neo.mjs 4.0.44 → 4.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "neo.mjs",
-    "version": "4.0.44",
+    "version": "4.0.45",
     "description": "The webworkers driven UI framework",
     "type": "module",
     "repository": {

package/src/component/Carousel.mjs

@@ -1,6 +1,8 @@
 import ClassSystemUtil from '../util/ClassSystem.mjs';
 import Component       from './Base.mjs';
 import Store           from '../data/Store.mjs';
+import TaskManager     from '../manager/Task.mjs';
+
 
 /**
  * @class Neo.component.Carousel
@@ -31,6 +33,14 @@ class Carousel extends Component {
          * @protected
          */
         ntype: 'carousel',
+        /**
+         * autoRun allows to run through the all items timebased
+         * 0 means it is turned off. Other values are the timer in ms,
+         * which will hide the arrows.
+         *
+         * @member {int} autoRun=0
+         */
+        autoRun_: 0,
         /**
          * @member {String[]} cls=['neo-carousel']
          */
@@ -82,6 +92,8 @@ class Carousel extends Component {
         let me           = this,
             domListeners = me.domListeners;
 
+        if(me.autoRun) return;
+
         domListeners.push({
             click: {
                 fn      : me.onCarouselBtnClick,
@@ -93,6 +105,30 @@ class Carousel extends Component {
         me.domListeners = domListeners;
     }
 
+    /**
+     * Triggered after autoRun config got changed
+     * @param {boolean|integer} value
+     * @protected
+     */
+    afterSetAutoRun(value, oldValue) {
+        let me = this;
+
+        if(!value) return;
+
+        TaskManager.start({
+            id: this.id,
+            interval: value,
+            run: function() {
+                me.onCarouselBtnClick('forward');
+            }
+        });
+
+        let vdom = this._vdom;
+        vdom.cn[0].cn[0].removeDom = true;
+
+        this._vdom = vdom;
+    }
+
     /**
      * Triggered after the store config got changed
      * @param {Neo.data.Store|Object|null} value
@@ -188,7 +224,7 @@ class Carousel extends Component {
      */
     onCarouselBtnClick(event) {
         let me            = this,
-            action        = event.target.data.carouselaction,
+            action        = (typeof event === 'string') ? event : event.target.data.carouselaction,
             store         = me.store,
             countItems    = store.getCount(),
             vdom          = me.vdom,

package/src/controller/Component.mjs

@@ -182,18 +182,30 @@ class Component extends Base {
         if (listeners) {
             Object.entries(listeners).forEach(([key, value]) => {
                 if (key !== 'scope' && key !== 'delegate') {
-                    value.forEach(listener => {
-                        if (Neo.isObject(listener) && listener.hasOwnProperty('fn') && Neo.isString(listener.fn)) {
-                            eventHandler = listener.fn;
-                            handlerScope = me.getHandlerScope(eventHandler);
-
-                            if (!handlerScope) {
-                                Logger.logError('Unknown event handler for', eventHandler, component);
-                            } else {
-                                listener.fn = handlerScope[eventHandler].bind(handlerScope);
-                            }
+                    if (Neo.isString(value)) {
+                        eventHandler = value;
+                        handlerScope = me.getHandlerScope(eventHandler);
+
+                        if (!handlerScope) {
+                            Logger.logError('Unknown event handler for', eventHandler, component);
+                        } else {
+                            listeners[key] = {};
+                            listeners[key].fn = handlerScope[eventHandler].bind(handlerScope);
                         }
-                    });
+                    } else {
+                        value.forEach(listener => {
+                            if (Neo.isObject(listener) && listener.hasOwnProperty('fn') && Neo.isString(listener.fn)) {
+                                eventHandler = listener.fn;
+                                handlerScope = me.getHandlerScope(eventHandler);
+
+                                if (!handlerScope) {
+                                    Logger.logError('Unknown event handler for', eventHandler, component);
+                                } else {
+                                    listener.fn = handlerScope[eventHandler].bind(handlerScope);
+                                }
+                            }
+                        });
+                    }
                 }
             });
         }

package/src/manager/Task.mjs

@@ -0,0 +1,197 @@
+import Base from './Base.mjs';
+
+/**
+ * @class Neo.manager.Task
+ * @extends Neo.manager.Base
+ * @singleton
+ *
+ * @example
+ *     import TaskManager from '../../../node_modules/neo.mjs/src/manager/Task.mjs';
+ *
+ *     task = {
+ *         args: [clockDom],           // arguments passed into the run fn
+ *         addCountToArgs: true,       // adds the count to the arguments
+ *         fireOnStart: false          // run before the first interval
+ *         id: 'clockcounter',         // id for the task or autocreated
+ *         interval: 1000,             // in ms
+ *         onError: function(){},      // runs in case an error occurred
+ *         repeat: 10,                 // stopAfterTenTimes
+ *         run: function(clock) {      // function to run
+ *             clock.setHtml(new Date());
+ *         },
+ *         scope: this                 // scope of the function
+ *     };
+ *
+ *     TaskManager.start(task); // or taskId if exists
+ *     TaskManager.stop('clockcounter', remove); // false to not remove it from the TaskManager
+ *     TaskManager.stopAll(remove);
+ *
+ *     TaskManager.createTask(task);
+ *     TaskManager.remove(taskId);
+ *
+ *     TaskManager.run(taskId);
+ *     TaskManager.get(taskId).repeat = 20;
+ */
+class Task extends Base {
+    static getConfig() {return {
+        /**
+         * @member {String} className='Neo.manager.Task'
+         * @protected
+         */
+        className: 'Neo.manager.Task',
+        /**
+         * @member {Boolean} singleton=true
+         * @protected
+         */
+        singleton: true
+    }}
+
+    /**
+     * Adds a task to collection.
+     * Typically used via `start(task)`
+     * @param {Object} task
+     * @returns {Object}
+     */
+    createTask(task) {
+        let me = this;
+
+        if (!task.id) {
+            task.id = Neo.core.IdGenerator.getId('task');
+        }
+
+        task.scope          && task.run.bind(task.scope);
+        task.addCountToArgs && task.args.push(0);
+
+        task = {
+            args      : [],
+            isRunning : false,
+            onError   : Neo.emptyFn,
+            runCount  : 0,
+            runner    : null,
+            runOnStart: false,
+            ...task
+        };
+
+        me.register(task);
+
+        return task;
+    }
+
+    /**
+     * Removes a task from collection.
+     * @param {String} taskId
+     */
+    removeTask(taskId) {
+        this.unregister(taskId);
+    }
+
+    /**
+     * Runs a task from collection.
+     * @param {String} taskId
+     */
+    run(taskId) {
+        let me   = this,
+            task = me.get(taskId);
+
+        if (task.isRunning) {
+            Neo.logError('[Neo.util.TaskManager] Task is already running');
+            return task;
+        }
+
+        try {
+            let fn = function(task) {
+                task.runCount++;
+
+                if(task.addCountToArgs) {
+                    task.args[task.args.length - 1] = task.runCount;
+                }
+
+                if (task.repeat && task.runCount === task.repeat) {
+                    me.stop(task.id);
+                }
+
+                task.run(...task.args);
+            };
+
+            task.isRunning = true;
+            task.runner    = setInterval(fn, task.interval, task);
+        } catch (taskError) {
+            Neo.logError('[Neo.util.TaskManager] Error while running task ' + task.id);
+            task.onError(taskError);
+            task.isRunning = false;
+        }
+    }
+
+    /**
+     * Adds a task and runs it.
+     * @param {Object|String} task or taskId
+     * @returns {Object}
+     */
+    start(task) {
+        let me = this;
+
+        if (Neo.isString(task)) {
+            task = me.get(task);
+            !task && Neo.logError('[Neo.util.TaskManager] You passed a taskId which does not exits');
+        } else if (!task.id || !me.get(task.id)){
+            task = me.createTask(task);
+        }
+
+        if (task.isRunning) {
+            Neo.logError('[Neo.util.TaskManager] Task is already running');
+            return task;
+        }
+
+        if (task.runOnStart) {
+            task.runCount++;
+            task.run(...task.args);
+        }
+
+        me.run(task.id);
+
+        return task;
+    }
+
+    /**
+     * Stops a task and resets configs.
+     * If remove is true it will remove the task from the collection
+     * @param {String} taskId
+     * @param {Boolean} remove
+     */
+    stop(taskId, remove) {
+        let task = this.get(taskId);
+
+        task.isRunning && clearInterval(task.runner);
+
+        if (remove) {
+            this.removeTask(task);
+        } else {
+            task.isRunning = false;
+            task.runCount  = 0;
+            task.runner    = null;
+
+            if(task.addCountToArgs) {
+                task.args[task.args.length - 1] = 0;
+            }
+        }
+    }
+
+    /**
+     * Stops all running tasks from collection.
+     * If remove is true, it will remove all tasks from Manager
+     * @param {Boolean} remove
+     */
+    stopAll(remove) {
+        Object.keys(this.map).forEach(key => {
+            this.stop(key, remove);
+        });
+    }
+}
+
+Neo.applyClassConfig(Task);
+
+let instance = Neo.create(Task);
+
+Neo.applyToGlobalNs(instance);
+
+export default instance;

package/src/model/Component.mjs

@@ -124,7 +124,10 @@ class Component extends Base {
      * @protected
      */
     beforeSetStores(value, oldValue) {
+        let controller = this.component.getController();
+
         value && Object.entries(value).forEach(([key, storeValue]) => {
+            controller?.parseConfig(storeValue);
             value[key] = ClassSystemUtil.beforeSetInstance(storeValue);
         });
 

package/src/table/View.mjs

@@ -86,7 +86,7 @@ class View extends Component {
 
             data.push({
                 tag     : 'tr',
-                id      : id,
+                id,
                 cls     : trCls,
                 cn      : [],
                 tabIndex: '-1'
@@ -108,7 +108,7 @@ class View extends Component {
                 rendererOutput = column.renderer.call(column.rendererScope || container, {
                     dataField: column.dataField,
                     index    : i,
-                    record   : record,
+                    record,
                     value    : rendererValue
                 });
 

package/src/worker/App.mjs

@@ -118,10 +118,10 @@ class App extends Base {
         if (Neo.config.themes.length > 0) {
             className = className || proto.className;
 
-            let me        = this,
-                lAppName  = appName.toLowerCase(),
-                cssMap    = Neo.cssMap,
-                parent    = proto?.__proto__,
+            let me       = this,
+                lAppName = appName.toLowerCase(),
+                cssMap   = Neo.cssMap,
+                parent   = proto?.__proto__,
                 classPath, fileName, mapClassName, ns, themeFolders;
 
             if (!cssMap) {