neo.mjs 10.0.0-beta.3 → 10.0.0-beta.5

package/src/core/Effect.mjs

@@ -0,0 +1,127 @@
+import EffectManager     from './EffectManager.mjs';
+import EffectBatchManager from './EffectBatchManager.mjs';
+import IdGenerator        from './IdGenerator.mjs';
+
+/**
+ * Creates a reactive effect that automatically tracks its dependencies and re-runs when any of them change.
+ * This is a lightweight, plain JavaScript class for performance.
+ * It serves as a core reactive primitive, enabling automatic and dynamic dependency tracking.
+ * @class Neo.core.Effect
+ */
+class Effect {
+    /**
+     * A Map containing Config instances as keys and their cleanup functions as values.
+     * @member {Map} dependencies=new Map()
+     * @protected
+     */
+    dependencies = new Map()
+    /**
+     * The function to execute.
+     * @member {Function|null} _fn=null
+     */
+    _fn = null
+    /**
+     * The unique identifier for this effect instance.
+     * @member {String|null}
+     */
+    id = IdGenerator.getId('effect')
+    /**
+     * @member {Boolean}
+     * @protected
+     */
+    isDestroyed = false
+    /**
+     * @member {Boolean}
+     * @protected
+     */
+    isRunning = false
+
+    /**
+     * @member fn
+     */
+    get fn() {
+        return this._fn
+    }
+    set fn(value) {
+        this._fn = value;
+        // Assigning a new function to `fn` automatically triggers a re-run.
+        // This ensures that the effect immediately re-evaluates its dependencies
+        // based on the new function's logic, clearing old dependencies and establishing new ones.
+        this.run()
+    }
+
+    /**
+     * @param {Object} config
+     * @param {Function} config.fn The function to execute for the effect.
+     */
+    constructor({fn}) {
+        this.fn = fn
+    }
+
+    /**
+     * Cleans up all subscriptions and destroys the effect.
+     */
+    destroy() {
+        const me = this;
+
+        me.dependencies.forEach(cleanup => cleanup());
+        me.dependencies.clear();
+        me.isDestroyed = true
+    }
+
+    /**
+     * Executes the effect function, tracking its dependencies.
+     * This is called automatically on creation and whenever a dependency changes.
+     * The dynamic re-tracking ensures the effect always reflects its current dependencies,
+     * even if the logic within `fn` changes conditionally.
+     * @protected
+     */
+    run() {
+        const me = this;
+
+        if (me.isDestroyed || me.isRunning) return;
+
+        if (EffectBatchManager.isBatchActive()) {
+            EffectBatchManager.queueEffect(me);
+            return
+        }
+
+        me.isRunning = true;
+
+        me.dependencies.forEach(cleanup => cleanup());
+        me.dependencies.clear();
+
+        EffectManager.push(me);
+
+        try {
+            me.fn()
+        } finally {
+            EffectManager.pop();
+            me.isRunning = false;
+        }
+    }
+
+    /**
+     * Adds a `Neo.core.Config` instance as a dependency for this effect.
+     * @param {Neo.core.Config} config The config instance to subscribe to.
+     * @protected
+     */
+    addDependency(config) {
+        const me = this;
+
+        // Only add if not already a dependency. Map uses strict equality (===) for object keys.
+        if (!me.dependencies.has(config)) {
+            const cleanup = config.subscribe({
+                id: me.id,
+                fn: me.run.bind(me)
+            });
+
+            me.dependencies.set(config, cleanup)
+        }
+    }
+}
+
+const ns = Neo.ns('Neo.core', true);
+ns.Effect = Effect;
+
+export default Effect;

package/src/core/EffectBatchManager.mjs

@@ -0,0 +1,68 @@
+/**
+ * A singleton manager responsible for batching `Neo.core.Effect` executions.
+ * This ensures that effects triggered by multiple config changes within a single
+ * synchronous operation (e.g., `Neo.core.Base#set()`) are executed only once
+ * per batch, after all changes have been applied.
+ * @class Neo.core.EffectBatchManager
+ * @singleton
+ */
+const EffectBatchManager = {
+    /**
+     * The current count of active batch operations.
+     * Incremented by `startBatch()`, decremented by `endBatch()`.
+     * @member {Number} batchCount=0
+     */
+    batchCount: 0,
+    /**
+     * A Set of `Neo.core.Effect` instances that are pending execution within the current batch.
+     * @member {Set<Neo.core.Effect>} pendingEffects=new Set()
+     */
+    pendingEffects: new Set(),
+
+    /**
+     * Increments the batch counter. When `batchCount` is greater than 0,
+     * effects will be queued instead of running immediately.
+     */
+    startBatch() {
+        this.batchCount++
+    },
+
+    /**
+     * Decrements the batch counter. If `batchCount` reaches 0, all queued effects
+     * are executed and the `pendingEffects` Set is cleared.
+     */
+    endBatch() {
+        this.batchCount--;
+
+        if (this.batchCount === 0) {
+            this.pendingEffects.forEach(effect => {
+                effect.run();
+            });
+
+            this.pendingEffects.clear()
+        }
+    },
+
+    /**
+     * Checks if there is an active batch operation.
+     * @returns {Boolean}
+     */
+    isBatchActive() {
+        return this.batchCount > 0
+    },
+
+    /**
+     * Queues an effect for execution at the end of the current batch.
+     * If the effect is already queued, it will not be added again.
+     * @param {Neo.core.Effect} effect The effect to queue.
+     */
+    queueEffect(effect) {
+        this.pendingEffects.add(effect)
+    }
+};
+
+// Assign to Neo namespace
+const ns = Neo.ns('Neo.core', true);
+ns.EffectBatchManager = EffectBatchManager;
+
+export default EffectBatchManager;

package/src/core/EffectManager.mjs

@@ -0,0 +1,38 @@
+/**
+ * A singleton manager to track the currently running effect.
+ * This allows reactive properties to know which effect to subscribe to.
+ * @class Neo.core.EffectManager
+ * @singleton
+ */
+const EffectManager = {
+    effectStack: [],
+
+    /**
+     * Returns the effect currently at the top of the stack (i.e., the one currently running).
+     * @returns {Neo.core.Effect|null}
+     */
+    getActiveEffect() {
+        return this.effectStack[this.effectStack.length - 1]
+    },
+
+    /**
+     * Pops the current effect from the stack, returning to the previous effect (if any).
+     * @returns {Neo.core.Effect|null}
+     */
+    pop() {
+        return this.effectStack.pop()
+    },
+
+    /**
+     * Pushes an effect onto the stack, marking it as the currently running effect.
+     * @param {Neo.core.Effect} effect The effect to push.
+     */
+    push(effect) {
+        this.effectStack.push(effect)
+    }
+};
+
+const ns = Neo.ns('Neo.core', true);
+ns.EffectManager = EffectManager;
+
+export default EffectManager;

package/src/core/Util.mjs

@@ -1,10 +1,7 @@
-import Base from './Base.mjs';
-
 /**
  * @class Neo.core.Util
- * @extends Neo.core.Base
  */
-class Util extends Base {
+class Util {
     /**
      * A regex to remove camel case syntax
      * @member {RegExp} decamelRegEx=/([a-z])([A-Z])/g
@@ -13,19 +10,6 @@ class Util extends Base {
      */
     static decamelRegEx = /([a-z])([A-Z])/g
 
-    static config = {
-        /**
-         * @member {String} className='Neo.core.Util'
-         * @protected
-         */
-        className: 'Neo.core.Util',
-        /**
-         * @member {String} ntype='core-util'
-         * @protected
-         */
-        ntype: 'core-util'
-    }
-
     /**
      * @param {Object} scope
      * @param {String[]} values
@@ -229,7 +213,8 @@ class Util extends Base {
     }
 }
 
-Util = Neo.setupClass(Util);
+const ns = Neo.ns('Neo.core', true);
+ns.Util = Util;
 
 // aliases
 Neo.applyFromNs(Neo, Util, {

package/src/data/RecordFactory.mjs

@@ -81,7 +81,7 @@ class RecordFactory extends Base {
                         return this[dataSymbol][fieldName]
                     },
                     set(value) {
-                        instance.setRecordFields({
+                        this.notifyChange({
                             fields: {[fieldPath]: instance.parseRecordValue({record: this, field, value})},
                             model,
                             record: this
@@ -193,6 +193,25 @@ class RecordFactory extends Base {
                         return null
                     }
 
+                    /**
+                     * The single source of truth for record field changes.
+                     * Executes instance.setRecordFields(), and can get used via:
+                     * - Neo.util.Function:createSequence()
+                     * - Neo.util.Function:intercept(),
+                     * to "listen" to field changes
+                     * @param {Object}         data
+                     * @param {Object}         data.fields
+                     * @param {Neo.data.Model} data.model
+                     * @param {Object}         data.record
+                     * @param {Boolean}        silent=false
+                     * @returns {Object}
+                     */
+                    notifyChange(data, silent=false) {
+                        const param = {...data, silent}
+                        instance.setRecordFields(param);
+                        return param
+                    }
+
                     /**
                      * Bulk-update multiple record fields at once
                      * @param {Object} fields
@@ -207,7 +226,7 @@ class RecordFactory extends Base {
                      * @param {Object} fields
                      */
                     set(fields) {
-                        instance.setRecordFields({fields, model, record: this})
+                        this.notifyChange({fields, model, record: this})
                     }
 
                     /**
@@ -225,7 +244,7 @@ class RecordFactory extends Base {
                      * @param {Object} fields
                      */
                     setSilent(fields) {
-                        instance.setRecordFields({fields, model, record: this, silent: true})
+                        this.notifyChange({fields, model, record: this}, true)
                     }
 
                     /**

package/src/grid/Container.mjs

@@ -255,10 +255,13 @@ class GridContainer extends BaseContainer {
      * @protected
      */
     async afterSetColumns(value, oldValue) {
-        if (oldValue?.getCount?.() > 0) {
-            let me = this;
+        let me              = this,
+            {headerToolbar} = me;
 
-            me.headerToolbar?.createItems()
+        // - If columns changed at run-time OR
+        // - In case the `header.Toolbar#createItems()` method has run before columns where available
+        if (oldValue?.getCount?.() > 0 || (value?.count && headerToolbar?.isConstructed)) {
+            headerToolbar?.createItems()
 
             await me.timeout(50);
 
@@ -611,7 +614,8 @@ class GridContainer extends BaseContainer {
      */
     removeSortingCss(dataField) {
         this.headerToolbar?.items.forEach(column => {
-            if (column.dataField !== dataField) {
+            if (column.dataField !== dataField) {return;
+                console.log(column, dataField)
                 column.removeSortingCss()
             }
         })

package/src/grid/column/Component.mjs

@@ -118,7 +118,7 @@ class Component extends Column {
         }
 
         if (me.useBindings) {
-            body.getStateProvider()?.parseConfig(component)
+            body.getStateProvider()?.createBindings(component)
         }
 
         body.updateDepth = -1;