neo.mjs 10.0.0-beta.4 → 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/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;