store.js

import { storeChannel, dispatcherChannel } from "./bus";
import { entries } from "./utils";
import dispatcher from "./dispatcher";
import _ from "lodash";
import { mixin } from "./mixins";

export const stores = {};

function buildActionList( handlers ) {
	const actionList = [];
	for ( const [ key, handler ] of entries( handlers ) ) {
		actionList.push( {
			actionType: key,
			waitFor: handler.waitFor || []
		} );
	}
	return actionList;
}

function ensureStoreOptions( options, handlers, store ) {
	const namespace = ( options && options.namespace ) || store.namespace;
	if ( namespace in stores ) {
		throw new Error( `The store namespace "${ namespace }" already exists.` );
	}
	if ( !namespace ) {
		throw new Error( "A lux store must have a namespace value provided" );
	}
	if ( !handlers || !Object.keys( handlers ).length ) {
		throw new Error( "A lux store must have action handler methods provided" );
	}
}

function getHandlerObject( key, listeners ) {
	return {
		waitFor: [],
		handler() {
			let changed = 0;
			const args = Array.from( arguments );
			listeners[ key ].forEach( function( listener ) {
				changed += ( listener.apply( this, args ) === false ? 0 : 1 );
			}.bind( this ) );
			return changed > 0;
		}
	};
}

function updateWaitFor( source, handlerObject ) {
	if ( source.waitFor ) {
		source.waitFor.forEach( function( dep ) {
			if ( handlerObject.waitFor.indexOf( dep ) === -1 ) {
				handlerObject.waitFor.push( dep );
			}
		} );
	}
}

function addListeners( listeners, key, handler ) {
	listeners[ key ] = listeners[ key ] || [];
	listeners[ key ].push( handler.handler || handler );
}

function processStoreArgs( ...options ) {
	const listeners = {};
	const handlers = {};
	const state = {};
	const otherOpts = {};
	options.forEach( function( o ) {
		let opt;
		if ( o ) {
			opt = _.clone( o );
			_.merge( state, opt.state );
			if ( opt.handlers ) {
				Object.keys( opt.handlers ).forEach( function( key ) {
					const handler = opt.handlers[ key ];
					// set up the actual handler method that will be executed
					// as the store handles a dispatched action
					handlers[ key ] = handlers[ key ] || getHandlerObject( key, listeners );
					// ensure that the handler definition has a list of all stores
					// being waited upon
					updateWaitFor( handler, handlers[ key ] );
					// Add the original handler method(s) to the listeners queue
					addListeners( listeners, key, handler );
				} );
			}
			delete opt.handlers;
			delete opt.state;
			_.merge( otherOpts, opt );
		}
	} );
	return [ state, handlers, otherOpts ];
}

export class Store {
	constructor( ...opt ) {
		let [ state, handlers, options ] = processStoreArgs( ...opt ); // eslint-disable-line prefer-const
		ensureStoreOptions( options, handlers, this );
		const namespace = options.namespace;
		Object.assign( this, options );
		stores[ namespace ] = this;
		let inDispatch = false;
		this.hasChanged = false;

		this.getState = function() {
			return state;
		};

		this.setState = function( newState ) {
			if ( !inDispatch ) {
				throw new Error( "setState can only be called during a dispatch cycle from a store action handler." );
			}
			state = Object.assign( state, newState );
		};

		this.replaceState = function( newState ) {
			if ( !inDispatch ) {
				throw new Error( "replaceState can only be called during a dispatch cycle from a store action handler." );
			}
			// we preserve the underlying state ref, but clear it
			Object.keys( state ).forEach( function( key ) {
				delete state[ key ];
			} );
			state = Object.assign( state, newState );
		};

		this.flush = function flush() {
			inDispatch = false;
			if ( this.hasChanged ) {
				this.hasChanged = false;
				storeChannel.publish( `${ this.namespace }.changed` );
			}
		};

		mixin( this, mixin.actionListener( {
			context: this,
			channel: dispatcherChannel,
			topic: `${ namespace }.handle.*`,
			handlers,
			handlerFn: function( data ) {
				if ( handlers.hasOwnProperty( data.actionType ) ) {
					inDispatch = true;
					const res = handlers[ data.actionType ].handler.apply( this, data.actionArgs.concat( data.deps ) );
					this.hasChanged = !( res === false );
					dispatcherChannel.publish(
						`${ this.namespace }.handled.${ data.actionType }`,
						{ hasChanged: this.hasChanged, namespace: this.namespace }
					);
				}
			}.bind( this )
		} ) );

		this.__subscription = {
			notify: dispatcherChannel.subscribe( "notify", () => this.flush() )
				.constraint( () => inDispatch )
		};

		dispatcher.registerStore(
			{
				namespace,
				actions: buildActionList( handlers )
			}
		);
	}

	// Need to build in behavior to remove this store
	// from the dispatcher's actionMap as well!
	dispose() {
		/*eslint-disable */
		for ( let [ k, subscription ] of entries( this.__subscription ) ) {
			subscription.unsubscribe();
		}
		/* eslint-enable */
		delete stores[ this.namespace ];
		dispatcher.removeStore( this.namespace );
		this.luxCleanup();
	}
}

export function removeStore( namespace ) {
	stores[ namespace ].dispose();
}