neo.mjs 8.0.0-beta.1 → 8.0.0

package/src/controller/Component.mjs

@@ -95,16 +95,6 @@ class Component extends Base {
             me : parent?.getHandlerScope(handlerName) || null
     }
 
-    /**
-     * sameLevelOnly=false will return the closest VM inside the component parent tree,
-     * in case there is none on the same level.
-     * @param {Boolean} [sameLevelOnly=false]
-     */
-    getModel(sameLevelOnly=false) {
-        let {component} = this;
-        return sameLevelOnly ? component.model : component.getModel()
-    }
-
     /**
      * Get the closest controller inside the components parent tree
      * @returns {Neo.controller.Component|null}
@@ -141,12 +131,31 @@ class Component extends Base {
     }
 
     /**
-     * Convenience shortcut for accessing model.Component based data.Stores
+     * Convenience shortcut
+     * @param args
+     * @returns {*}
+     */
+    getState(...args) {
+        return this.getStateProvider().getData(...args)
+    }
+
+    /**
+     * sameLevelOnly=false will return the closest stateProvider inside the component parent tree,
+     * in case there is none on the same level.
+     * @param {Boolean} [sameLevelOnly=false]
+     */
+    getStateProvider(sameLevelOnly=false) {
+        let {component} = this;
+        return sameLevelOnly ? component.stateProvider : component.getStateProvider()
+    }
+
+    /**
+     * Convenience shortcut for accessing state.Provider based data.Stores
      * @param {String} key
      * @returns {Neo.data.Store}
      */
     getStore(key) {
-        return this.getModel().getStore(key)
+        return this.getStateProvider().getStore(key)
     }
 
     /**
@@ -267,6 +276,14 @@ class Component extends Base {
 
         me.getParent()?.removeReference(component)
     }
+
+    /**
+     * Convenience shortcut
+     * @param args
+     */
+    setState(...args) {
+        this.getStateProvider().setData(...args)
+    }
 }
 
 export default Neo.setupClass(Component);

package/src/core/Base.mjs

@@ -55,7 +55,6 @@ class Base {
     /**
      * Configs will get merged throughout the class hierarchy
      * @returns {Object} config
-     * @tutorial 02_ClassSystem
      */
     static config = {
         /**
@@ -606,7 +605,7 @@ class Base {
     timeout(time) {
         return new Promise(resolve => {
             let timeoutIds = this.#timeoutIds,
-                timeoutId  = setTimeout(() => {timeoutIds.splice(timeoutIds.indexOf(timeoutId, 1)); resolve()}, time);
+                timeoutId  = setTimeout(() => {timeoutIds.splice(timeoutIds.indexOf(timeoutId), 1); resolve()}, time);
 
             timeoutIds.push(timeoutId)
         })

package/src/core/Compare.mjs

@@ -14,118 +14,163 @@ class Compare extends Base {
     }
 
     /**
-     * @param {*} item1
-     * @param {*} item2
+     * Storing the comparison method names by data type
+     * @member {Object} map
+     */
+    static map = {
+        Array      : 'compareArrays',
+        Date       : 'compareDates',
+        Function   : 'compareFunctions',
+        Map        : 'compareMaps',
+        NeoInstance: 'compareNeoInstances',
+        Object     : 'compareObjects',
+        RegExp     : 'compareRegExps',
+        Set        : 'compareSets'
+    }
+
+    /**
+     * @param {Array} item1
+     * @param {Array} item2
      * @returns {Boolean}
      */
-    static isEqual(item1, item2) {
-        if (item1 === item2) {
-            return true;
+    static compareArrays(item1, item2) {
+        if (item1.length !== item2.length) {
+            return false
         }
 
-        let type1 = Neo.typeOf(item1),
-            type2 = Neo.typeOf(item2),
-            key;
-
-        if (type1 !== type2) {
-            return false;
+        for (const [i, v] of item1.entries()) {
+            if (!Compare.isEqual(v, item2[i])) {
+                return false
+            }
         }
 
-        switch (type1) {
-            case 'Array': {
-                if (item1.length !== item2.length) {
-                    return false;
-                }
-
-                for (const [i, v] of item1.entries()) {
-                    if (!Compare.isEqual(v, item2[i])) {
-                        return false;
-                    }
-                }
+        return true
+    }
 
-                break;
-            }
+    /**
+     * @param {Date} item1
+     * @param {Date} item2
+     * @returns {Boolean}
+     */
+    static compareDates(item1, item2) {
+        return item1.valueOf() === item2.valueOf()
+    }
 
-            case 'Date': {
-                return item1.valueOf() === item2.valueOf();
-            }
+    /**
+     * @param {Function} item1
+     * @param {Function} item2
+     * @returns {Boolean}
+     */
+    static compareFunctions(item1, item2) {
+        if (item1.name !== item2.name) {
+            return false
+        }
 
-            case 'Function': {
-                if (item1.name !== item2.name) {
-                    return false;
-                }
+        return item1.toString() === item2.toString()
+    }
 
-                return item1.toString() === item2.toString();
-            }
+    /**
+     * @param {Map} item1
+     * @param {Map} item2
+     * @returns {Boolean}
+     */
+    static compareMaps(item1, item2) {
+        if (item1.size !== item2.size) {
+            return false
+        }
 
-            case 'Map': {
-                if (item1.size !== item2.size) {
-                    return false;
-                }
+        let val2;
 
-                let val2;
+        for (const [key, val] of item1) {
+            val2 = item2.get(key);
 
-                for (const [key, val] of item1) {
-                    val2 = item2.get(key);
+            if (val2 !== val || val2 === undefined && !item2.has(key)) {
+                return false
+            }
+        }
 
-                    if (val2 !== val || val2 === undefined && !item2.has(key)) {
-                        return false;
-                    }
-                }
+        return true
+    }
 
-                break;
-            }
+    /**
+     * @param {Neo.core.Base} item1
+     * @param {Neo.core.Base} item2
+     * @returns {Boolean}
+     */
+    static compareNeoInstances(item1, item2) {
+        return item1.id === item2.id
+    }
 
-            case 'NeoInstance': {
-                if (item1.id !== item2.id) {
-                    return false;
-                }
+    /**
+     * @param {Object} item1
+     * @param {Object} item2
+     * @returns {Boolean}
+     */
+    static compareObjects(item1, item2) {
+        if (Object.keys(item1).length !== Object.keys(item2).length) {
+            return false
+        }
 
-                break;
+        for (let key in item1) {
+            if (!Compare.isEqual(item1[key], item2[key])) {
+                return false
             }
+        }
 
-            case 'Object': {
-                if (Object.keys(item1).length !== Object.keys(item2).length) {
-                    return false;
-                }
-
-                for (key in item1) {
-                    if (!Compare.isEqual(item1[key], item2[key])) {
-                        return false;
-                    }
-                }
+        return true
+    }
 
-                break;
-            }
+    /**
+     * @param {RegExp} item1
+     * @param {RegExp} item2
+     * @returns {Boolean}
+     */
+    static compareRegExps(item1, item2) {
+        return item1.toString() === item2.toString()
+    }
 
-            case 'RegExp': {
-                if (item1.toString() !== item2.toString()) {
-                    return false;
-                }
+    /**
+     * @param {Set} item1
+     * @param {Set} item2
+     * @returns {Boolean}
+     */
+    static compareSets(item1, item2) {
+        if (item1.size !== item2.size) {
+            return false
+        }
 
-                break;
+        for (let key of item1) {
+            if (!item2.has(key)) {
+                return false
             }
+        }
 
-            case 'Set': {
-                if (item1.size !== item2.size) {
-                    return false;
-                }
+        return true
+    }
 
-                for (key of item1) {
-                    if (!item2.has(key)) {
-                        return false;
-                    }
-                }
+    /**
+     * @param {*} item1
+     * @param {*} item2
+     * @returns {Boolean}
+     */
+    static isEqual(item1, item2) {
+        if (item1 === item2) {
+            return true
+        }
 
-                break;
-            }
+        let type1 = Neo.typeOf(item1),
+            type2 = Neo.typeOf(item2);
 
-            default: {
-                return item1 === item2;
-            }
+        if (type1 !== type2) {
+            return false
+        }
+
+        if (Compare.map[type1]) {
+            return Compare[Compare.map[type1]](item1, item2)
         }
 
-        return true;
+        // all other types
+        return item1 === item2
     }
 }
 

package/src/date/SelectorContainer.mjs

@@ -1,11 +1,11 @@
-import ClassSystemUtil        from '../util/ClassSystem.mjs';
-import Container              from '../container/Base.mjs';
-import DateSelectorModel      from '../selection/DateSelectorModel.mjs';
-import DayViewComponent       from './DayViewComponent.mjs';
-import DateUtil               from '../util/Date.mjs';
-import NeoArray               from '../util/Array.mjs';
-import SelectorContainerModel from './SelectorContainerModel.mjs';
-import Toolbar                from '../toolbar/Base.mjs';
+import ClassSystemUtil                from '../util/ClassSystem.mjs';
+import Container                      from '../container/Base.mjs';
+import DateSelectorModel              from '../selection/DateSelectorModel.mjs';
+import DayViewComponent               from './DayViewComponent.mjs';
+import DateUtil                       from '../util/Date.mjs';
+import NeoArray                       from '../util/Array.mjs';
+import SelectorContainerStateProvider from './SelectorContainerStateProvider.mjs';
+import Toolbar                        from '../toolbar/Base.mjs';
 
 const todayDate = new Date();
 
@@ -114,10 +114,6 @@ class SelectorContainer extends Container {
          * @member {String|null} minValue_=null
          */
         minValue_: null,
-        /**
-         * @member {Neo.model.Component} model=SelectorContainerModel
-         */
-        model: SelectorContainerModel,
         /**
          * Used for wheel events. min value = 1.
          * A higher value means lesser sensitivity for wheel events
@@ -149,6 +145,10 @@ class SelectorContainer extends Container {
          * @member {Boolean} showWeekends_=true
          */
         showWeekends_: true,
+        /**
+         * @member {Neo.state.Provider} stateProvider=SelectorContainerStateProvider
+         */
+        stateProvider: SelectorContainerStateProvider,
         /**
          * True to use sliding animations
          * @member {Boolean} useAnimations=true

package/src/date/{SelectorContainerModel.mjs → SelectorContainerStateProvider.mjs}

@@ -1,16 +1,16 @@
-import Component from '../model/Component.mjs';
+import StateProvider from '../state/Provider.mjs';
 
 /**
- * @class Neo.date.SelectorContainerModel
- * @extends Neo.model.Component
+ * @class Neo.date.SelectorContainerStateProvider
+ * @extends Neo.state.Provider
  */
-class SelectorContainerModel extends Component {
+class SelectorContainerStateProvider extends StateProvider {
     static config = {
         /**
-         * @member {String} className='Neo.date.SelectorContainerModel'
+         * @member {String} className='Neo.date.SelectorContainerStateProvider'
          * @protected
          */
-        className: 'Neo.date.SelectorContainerModel',
+        className: 'Neo.date.SelectorContainerStateProvider',
         /**
          * @member {Object} data
          */
@@ -28,4 +28,4 @@ class SelectorContainerModel extends Component {
     }
 }
 
-export default Neo.setupClass(SelectorContainerModel);
+export default Neo.setupClass(SelectorContainerStateProvider);

package/src/layout/Base.mjs

@@ -101,18 +101,18 @@ class Base extends CoreBase {
     destroy() {
         let me = this;
 
-        me.bind && me.container.getModel()?.removeBindings(me.id);
+        me.bind && me.getStateProvider()?.removeBindings(me.id);
 
         super.destroy()
     }
 
     /**
-     * Returns the container model or its closest parent model
+     * Returns the container stateProvider or its closest parent stateProvider
      * @param {String} [ntype]
-     * @returns {Neo.model.Component|null}
+     * @returns {Neo.state.Provider|null}
      */
-    getModel(ntype) {
-        return this.container.getModel()
+    getStateProvider(ntype) {
+        return this.container.getStateProvider(ntype)
     }
 
     /**
@@ -125,7 +125,7 @@ class Base extends CoreBase {
 
         let me = this;
 
-        me.bind && me.container.getModel()?.parseConfig(me)
+        me.bind && me.container.getStateProvider()?.parseConfig(me)
     }
 
     /**