@base-framework/base 2.6.0 → 2.6.1

package/es5/modules/state.js

@@ -0,0 +1,274 @@
+/* base framework module */
+/*
+	this will create a layout builder object
+	and shortcut functions.
+*/
+(function()
+{
+	"use strict";
+
+	/**
+	 * StateTarget
+	 *
+	 * This will create a state target to track the state
+	 * of an object.
+	 * @class
+	 * @augments base.SimpleData
+	 */
+	var StateTarget = base.SimpleData.extend(
+	{
+		/**
+		 * @constructor
+		 * @param {string} id
+		 */
+		constructor: function(id)
+		{
+			this._init();
+
+			/* this will setup the event sub for
+			one way binding */
+			this.eventSub = new base.DataPubSub();
+
+			this.links = {};
+			this.stage = {};
+			this.id = id;
+		},
+
+		/**
+		 * This will restore a state to the controller.
+		 */
+		restore: function()
+		{
+			base.state.restore(this.id, this);
+		},
+
+		/**
+		 * This will remove the target from the controller.
+		 */
+		remove: function()
+		{
+			base.state.remove(this.id);
+		},
+
+		/**
+		 * This will add an action to the target.
+		 *
+		 * @param {string} action
+		 * @param {*} state
+		 */
+		addAction: function(action, state)
+		{
+			if(typeof state !== 'undefined')
+			{
+				this.set(action, state);
+			}
+		},
+
+		/**
+		 * This will get the state of an action.
+		 *
+		 * @param {string} action
+		 * @return {*}
+		 */
+		getState: function(action)
+		{
+			return this.get(action);
+		},
+
+		/**
+		 * This will remove an action or a callBack
+		 * from an action. if no token is passed the
+		 * whole action is removed.
+		 *
+		 * @param {string} action
+		 * @param {string} [token]
+		 */
+		removeAction: function(action, token)
+		{
+			/* if we have a token then the token will be
+			the only item removed */
+			if(token)
+			{
+				this.off(action, token);
+			}
+			else
+			{
+				var actions = this.stage;
+				if(typeof actions[action] !== 'undefined')
+				{
+					delete actions[action];
+				}
+			}
+		}
+	});
+
+	/**
+	 * StateController
+	 *
+	 * This will create a state controller that can
+	 * add and remove targets, actions, and action
+	 * subscriber callBack functions.
+	 *
+	 * @class
+	 */
+	var StateController = base.Class.extend(
+	{
+		/**
+		 * @constructor
+		 */
+		constructor: function()
+		{
+			this.targets = {};
+		},
+
+		/**
+		 * This will restore a state target.
+		 *
+		 * @param {string} id
+		 * @param {object} target
+		 */
+		restore: function(id, target)
+		{
+			this.targets[id] = target;
+		},
+
+		/**
+		 * This will get the state target.
+		 *
+		 * @param {string} id
+		 * @return {object}
+		 */
+		getTarget: function(id)
+		{
+			var targets = this.targets;
+			return (targets[id] || (targets[id] = new StateTarget(id)));
+		},
+
+		/**
+		 * This will get the state of an action.
+		 *
+		 * @param {string} targetId
+		 * @param {string} action
+		 */
+		getActionState: function(targetId, action)
+		{
+			var target = this.getTarget(targetId);
+			return target.get(action);
+		},
+
+		/**
+		 * This will add a new target.
+		 *
+		 * @param {string} targetId
+		 * @param {string} [action]
+		 * @param {*} [state] the primary action state
+		 * @return {object}
+		 */
+		add: function(targetId, action, state)
+		{
+			var target = this.getTarget(targetId);
+			if(action)
+			{
+				target.addAction(action, state);
+			}
+			return target;
+		},
+
+		/**
+		 * This will add a new action to a target.
+		 *
+		 * @param {string} targetId
+		 * @param {string} action
+		 * @param {string} [state]
+		 * @return {object}
+		 */
+		addAction: function(targetId, action, state)
+		{
+			return this.add(targetId, action, state);
+		},
+
+		/**
+		 * This will remove the action from a target.
+		 *
+		 * @param {string} targetId
+		 * @param {string} action
+		 * @param {string} [token]
+		 */
+		removeAction: function(targetId, action, token)
+		{
+			this.off(targetId, action, token);
+		},
+
+		/**
+		 * This will add a new subscriber to the action.
+		 *
+		 * @param {string} targetId
+		 * @param {string} action
+		 * @param {function} callBack
+		 * @return {string}
+		 */
+		on: function(targetId, action, callBack)
+		{
+			var target = this.getTarget(targetId);
+			if(action)
+			{
+				return target.on(action, callBack);
+			}
+			return false;
+		},
+
+		/**
+		 * This will remove a subscriber from an action.
+		 *
+		 * @param {string} targetId
+		 * @param {string} action
+		 * @param {string} token
+		 */
+		off: function(targetId, action, token)
+		{
+			this.remove(targetId, action, token);
+		},
+
+		/**
+		 * This will remove a target or action or callBack.
+		 *
+		 * @param {string} targetId
+		 * @param {string} [action]
+		 * @param {string} [token]
+		 */
+		remove: function(targetId, action, token)
+		{
+			var targets = this.targets;
+			var target = targets[targetId];
+			if(!target)
+			{
+				return false;
+			}
+
+			if(action)
+			{
+				target.off(action, token);
+			}
+			else
+			{
+				delete targets[targetId];
+			}
+		},
+
+		/**
+		 * This will set the action state.
+		 *
+		 * @param {string} targetId
+		 * @param {string} action
+		 * @param {*} state
+		 */
+		set: function(targetId, action, state)
+		{
+			var target = this.getTarget(targetId);
+			target.set(action, state);
+		}
+	});
+
+	base.extend.StateController = StateController;
+	base.extend.state = new StateController();
+})();

package/es6/.jshintrc

@@ -0,0 +1,3 @@
+{
+  "esversion": 6
+}

package/es6/base.js

@@ -0,0 +1,41 @@
+import {base} from './core.js';
+import {ajax} from './modules/ajax/ajax.js';
+import {dataBinder} from './modules/data-binder/data-binder.js';
+import {Data, SimpleData, Model} from './modules/data/data.js';
+import {state} from './modules/state/state.js';
+import {router, NavLink} from './modules/router/router.js';
+import {builder} from './modules/layout/layout-builder.js';
+import {Unit, Component, Jot, Watch} from './modules/component/component.js';
+import {Atom} from './modules/atom/atom.js';
+
+base.augment(
+{
+    ajax,
+    dataBinder,
+    Data,
+    SimpleData,
+    Model,
+    state,
+    builder,
+    router,
+    Component
+});
+
+export {
+    base,
+    ajax,
+    dataBinder,
+    Data,
+    SimpleData,
+    Model,
+    state,
+    builder,
+    router,
+    Unit,
+    Component,
+    Jot,
+    Watch,
+    NavLink,
+    Atom
+};
+

package/es6/core.js

@@ -0,0 +1 @@
+export {base} from './events.js';

package/es6/data-tracker.js

@@ -0,0 +1,351 @@
+/**
+ * TrackerTypes
+ *
+ * This will add and remove tracker types to the data tracker.
+ *
+ */
+const TrackerTypes =
+{
+    /**
+     * @member {object} The Type and callBack that is called
+     * when the type is removed from the object.
+     */
+    types: {},
+
+    /**
+     * This will add a type.
+     * @param {string} type
+     * @param {function} callBack The function to call when an object
+     * is having the type removed.
+     */
+    add(type, callBack)
+    {
+        this.types[type] = callBack;
+    },
+
+    /**
+     * This will get a type or return false.
+     * @param {string} type
+     * @return {(function|boolean)} The callBack or false.
+     */
+    get(type)
+    {
+        return this.types[type] || false;
+    },
+
+    /**
+     * This will remove a type.
+     * @param {string} type
+     */
+    remove(type)
+    {
+        delete this.types[type];
+    }
+};
+
+/**
+ * Tracker
+ *
+ * This will create a tracker for an object that will
+ * store each type added and the data stored to
+ * each type.
+ *
+ * @class
+ */
+class Tracker
+{
+    /**
+     * @constructor
+     */
+    constructor()
+    {
+        /**
+         * @member {object} types
+         */
+        this.types = {};
+    }
+
+    /**
+     * This will add data to a type.
+     *
+     * @public
+     * @param {string} addingType The type of data.
+     * @param {*} data The data to store
+     */
+    add(addingType, data)
+    {
+        let type = this.types[addingType] || (this.types[addingType] = []);
+        type.push(data);
+    }
+
+    /**
+     * This will get all the data stored to a data type.
+     * @param {string} type
+     * @return {*|boolean} the data or false.
+     */
+    get(type)
+    {
+        return this.types[type] || false;
+    }
+
+    /**
+     * This will call the callBack with the data.
+     *
+     * @private
+     * @param {function} callBack
+     * @param {*} data
+     */
+    removeByCallBack(callBack, data)
+    {
+        if(typeof callBack === 'function')
+        {
+            callBack(data);
+        }
+    }
+
+    /**
+     * This will remove the data by type.
+     *
+     * @private
+     * @param {string} removingType
+     */
+    removeType(removingType)
+    {
+        let types = this.types;
+        if(types)
+        {
+            let type = types[removingType];
+            if(type.length)
+            {
+                let data,
+                callBack = TrackerTypes.get(removingType);
+                for(var i = 0, length = type.length; i < length; i++)
+                {
+                    data = type[i];
+                    if(data)
+                    {
+                        // this will stop any circular referrences
+                        type[i] = null;
+
+                        this.removeByCallBack(callBack, data);
+                    }
+                }
+                delete types[type];
+            }
+        }
+    }
+
+    /**
+     * This will remove the data by type or all if no type is
+     * set.
+     *
+     * @public
+     * @param {string} [type]
+     */
+    remove(type)
+    {
+        if(type)
+        {
+            this.removeType(type);
+        }
+        else
+        {
+            let types = this.types;
+            for(var prop in types)
+            {
+                if(types.hasOwnProperty(prop))
+                {
+                    type = types[prop];
+                    if(!type)
+                    {
+                        continue;
+                    }
+
+                    this.removeType(prop);
+                }
+            }
+
+            delete this.types;
+        }
+    }
+}
+
+/**
+ * DataTracker
+ *
+ * This will add data tracking for objects. The DataTracker is
+ * a single point where any data can be tracked to an object
+ * or element. Modules can register types to store their own
+ * data that can allow the data to be removed when the element
+ * is removed.
+ *
+ * @class
+ */
+export class DataTracker
+{
+    /**
+     * @constructor
+     */
+    constructor()
+    {
+        /**
+         * @private
+         * @member trackers This is an object that stores all tracker
+         * objects by tracking id.
+         */
+        this.trackers = {};
+
+        /**
+         * @private
+         * @member {int} trackingCount
+         */
+        this.trackingCount = 0;
+    }
+
+    /**
+     * This will add a new type to the data tracker.
+     *
+     * @public
+     * @param {string} type The new type.
+     * @param {function} callBack The callBack to help clean
+     * up data when removed.
+     */
+    addType(type, callBack)
+    {
+        TrackerTypes.add(type, callBack);
+    }
+
+    /**
+     * This will remove a type from the data tracker.
+     * @param {string} type
+     */
+    removeType(type)
+    {
+        TrackerTypes.remove(type);
+    }
+
+    /**
+     * This will get the object tracking id or set it if
+     * not set.
+     *
+     * @param {object} obj
+     * @return {string}
+     */
+    getTrackingId(obj)
+    {
+        return obj.trackingId || (obj.trackingId = 'dt' + this.trackingCount++);
+    }
+
+    /**
+     * This will add data to an object.
+     *
+     * @param {object} obj
+     * @param {string} type The type name.
+     * @param {*} data The data to track.
+     */
+    add(obj, type, data)
+    {
+        const id = this.getTrackingId(obj),
+        tracker = this.find(id);
+
+        tracker.add(type, data);
+    }
+
+    /**
+     * This will get the data from a type or the tracker object
+     * if type is not set.
+     *
+     * @param {object} obj
+     * @param {string} [type]
+     * @return {*}
+     */
+    get(obj, type)
+    {
+        const id = obj.trackingId;
+        let tracker = this.trackers[id];
+        if(!tracker)
+        {
+            return false;
+        }
+
+        return (type)? tracker.get(type) : tracker;
+    }
+
+    /**
+     * This will get the tracker or create a new tracker
+     * if no tracker is set.
+     *
+     * @param {string} id
+     * @return {object} The tracker.
+     */
+    find(id)
+    {
+        let trackers = this.trackers;
+        return (trackers[id] || (trackers[id] = new Tracker()));
+    }
+
+    /**
+	 * This will check if an object is empty.
+	 *
+	 * @param {object} obj
+	 * @return {boolean}
+	 */
+	isEmpty(obj)
+	{
+		if(!obj || typeof obj !== 'object')
+		{
+			return true;
+		}
+
+		/* we want to loop through each property and
+		check if it belongs to the object directly */
+		for(var key in obj)
+		{
+			if(obj.hasOwnProperty(key))
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+    /**
+     * This will remove a type or all data for an object if
+     * no type is set.
+     *
+     * @param {object} obj
+     * @param {stirng} [type]
+     */
+    remove(obj, type)
+    {
+        const id = obj.trackingId;
+        if(!id)
+        {
+            return true;
+        }
+
+        let tracker = this.trackers[id];
+        if(!tracker)
+        {
+            return false;
+        }
+
+        if(type)
+        {
+            tracker.remove(type);
+
+            /* this will remove the msg from the elements
+            if no elements are listed under the msg */
+            if(this.isEmpty(tracker.types))
+            {
+                delete this.trackers[id];
+            }
+        }
+        else
+        {
+            tracker.remove();
+
+            delete this.trackers[id];
+        }
+    }
+}