neo.mjs 4.3.15 → 4.3.17

package/package.json

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

package/src/component/Base.mjs

@@ -447,12 +447,16 @@ class Base extends CoreBase {
 
     /**
      * Registers the domListeners inside the Neo.manager.DomEvent
-     * @param {Array} value
-     * @param {Array} oldValue
+     * @param {Object[]} value
+     * @param {Object[]} oldValue
      * @protected
      */
     afterSetDomListeners(value, oldValue) {
-        DomEventManager.updateDomListeners(this, value, oldValue);
+        let me = this;
+
+        me.getController()?.parseDomListeners(me);
+
+        DomEventManager.updateDomListeners(me, value, oldValue);
     }
 
     /**

package/src/controller/Component.mjs

@@ -20,7 +20,7 @@ class Component extends Base {
          */
         ntype: 'component-controller',
         /**
-         * @member {Object} component=null
+         * @member {Neo.component.Base|null} component=null
          * @protected
          */
         component: null,
@@ -135,49 +135,13 @@ class Component extends Base {
     onComponentConstructed() {}
 
     /**
-     * @param {Neo.component.Base} [component=this.component]
+     * @param {Neo.component.Base} component=this.component
      */
     parseConfig(component=this.component) {
-        let me           = this,
-            domListeners = component.domListeners,
-            listeners    = component.listeners,
-            reference    = component.reference,
-            eventHandler, fn, handlerScope, parentController;
-
-        if (domListeners) {
-            domListeners.forEach(domListener => {
-                Object.entries(domListener).forEach(([key, value]) => {
-                    eventHandler = null;
-
-                    if (key !== 'scope' && key !== 'delegate') {
-                        if (Neo.isString(value)) {
-                            eventHandler = value;
-                        } else if (Neo.isObject(value) && value.hasOwnProperty('fn') && Neo.isString(value.fn)) {
-                            eventHandler = value.fn;
-                        }
-
-                        if (eventHandler) {
-                            handlerScope = me.getHandlerScope(eventHandler);
-
-                            if (!handlerScope) {
-                                Logger.logError('Unknown domEvent handler for', eventHandler, component);
-                            } else {
-                                fn               = handlerScope[eventHandler].bind(handlerScope);
-                                domListener[key] = fn;
-
-                                DomEventManager.updateListenerPlaceholder({
-                                    componentId       : component.id,
-                                    eventHandlerMethod: fn,
-                                    eventHandlerName  : eventHandler,
-                                    eventName         : key,
-                                    scope             : parentController
-                                });
-                            }
-                        }
-                    }
-                });
-            });
-        }
+        let me        = this,
+            listeners = component.listeners,
+            reference = component.reference,
+            eventHandler, handlerScope;
 
         if (listeners) {
             Object.entries(listeners).forEach(([key, value]) => {
@@ -215,6 +179,41 @@ class Component extends Base {
         }
     }
 
+    /**
+     * @param {Neo.component.Base} component=this.component
+     */
+    parseDomListeners(component=this.component) {
+        let me           = this,
+            domListeners = component.domListeners,
+            eventHandler, scope;
+
+        if (domListeners) {
+            domListeners.forEach(domListener => {
+                Object.entries(domListener).forEach(([key, value]) => {
+                    eventHandler = null;
+
+                    if (key !== 'scope' && key !== 'delegate') {
+                        if (Neo.isString(value)) {
+                            eventHandler = value;
+                        } else if (Neo.isObject(value) && value.hasOwnProperty('fn') && Neo.isString(value.fn)) {
+                            eventHandler = value.fn;
+                        }
+
+                        if (eventHandler) {
+                            scope = me.getHandlerScope(eventHandler);
+
+                            if (!scope) {
+                                Logger.logError('Unknown domEvent handler for', eventHandler, component);
+                            } else {
+                                domListener[key] = scope[eventHandler].bind(scope);
+                            }
+                        }
+                    }
+                });
+            });
+        }
+    }
+
     /**
      * Will get called by component.Base: destroy() in case the component has a reference config
      * @param {Neo.component.Base} component

package/src/grid/Container.mjs

@@ -184,19 +184,26 @@ class Container extends BaseContainer {
     createColumns(columns) {
         let me             = this,
             columnDefaults = me.columnDefaults,
-            sorters        = me.store?.sorters;
+            sorters        = me.store?.sorters,
+            renderer;
 
         if (!columns || !columns.length) {
             Neo.logError('Attempting to create a grid.Container without defined columns', me.id);
         }
 
         columns.forEach(column => {
+            renderer = column.renderer;
+
             columnDefaults && Neo.assignDefaults(column, columnDefaults);
 
             if (column.dock && !column.width) {
                 Neo.logError('Attempting to create a docked column without a defined width', column, me.id);
             }
 
+            if (renderer && Neo.isString(renderer) && me[renderer]) {
+                column.renderer = me[renderer];
+            }
+
             if (sorters?.[0]) {
                 if (column.field === sorters[0].property) {
                     column.isSorted = sorters[0].direction;

package/src/manager/DomEvent.mjs

@@ -405,34 +405,6 @@ class DomEvent extends Base {
         }
     }
 
-    /**
-     * Intended for Neo.controller.Component to replace listener placeholders provided as a string
-     * @param {Object} config
-     * @param {String} config.componentId
-     * @param {Function} config.eventHandlerMethod
-     * @param {String} config.eventHandlerName
-     * @param {String} config.eventName
-     * @param {Neo.core.Base} config.scope
-     */
-    updateListenerPlaceholder(config) {
-        let me             = this,
-            items          = me.items[config.componentId] || {},
-            eventListeners = items[config.eventName] || [],
-            i              = 0,
-            len            = eventListeners.length,
-            listener;
-
-        for (; i < len; i++) {
-            listener = eventListeners[i];
-
-            if (listener.fn === config.eventHandlerName) {
-                listener.fn    = config.eventHandlerMethod;
-                listener.scope = config.scope;
-                break;
-            }
-        }
-    }
-
     /**
      * @param {Object} listener
      * @param {Array} path

package/src/table/Container.mjs

@@ -286,19 +286,26 @@ class Container extends BaseContainer {
     createColumns(columns) {
         let me             = this,
             columnDefaults = me.columnDefaults,
-            sorters        = me.store?.sorters;
+            sorters        = me.store?.sorters,
+            renderer;
 
         if (!columns || !columns.length) {
             Neo.logError('Attempting to create a table.Container without defined columns', me.id);
         }
 
         columns.forEach(column => {
+            renderer = column.renderer;
+
             columnDefaults && Neo.assignDefaults(column, columnDefaults);
 
             if (column.dock && !column.width) {
                 Neo.logError('Attempting to create a docked column without a defined width', column, me.id);
             }
 
+            if (renderer && Neo.isString(renderer) && me[renderer]) {
+                column.renderer = me[renderer];
+            }
+
             if (sorters?.[0]) {
                 if (column.dataField === sorters[0].property) {
                     column.isSorted = sorters[0].direction;