neo.mjs 10.0.0-beta.5 → 10.0.0

package/src/worker/Base.mjs

@@ -9,6 +9,8 @@ import RemoteMethodAccess    from './mixin/RemoteMethodAccess.mjs';
  * The abstract base class for e.g. the App, Data & VDom worker
  * @class Neo.worker.Base
  * @extends Neo.core.Base
+ * @mixes Neo.core.Observable
+ * @mixes Neo.worker.mixin.RemoteMethodAccess
  * @abstract
  */
 class Worker extends Base {

package/src/worker/Manager.mjs

@@ -18,6 +18,8 @@ navigator.serviceWorker?.addEventListener('controllerchange', function() {
  * Also, responsible for sending messages from the main thread to the different workers.
  * @class Neo.worker.Manager
  * @extends Neo.core.Base
+ * @mixes Neo.core.Observable
+ * @mixes Neo.worker.mixin.RemoteMethodAccess
  * @singleton
  */
 class Manager extends Base {

package/src/worker/ServiceBase.mjs

@@ -16,6 +16,7 @@ class ServiceBase extends Base {
         className: 'Neo.worker.ServiceBase',
         /**
          * @member {String} cacheName_='neo-runtime'
+         * @reactive
          */
         cacheName_: 'neo-runtime',
         /**
@@ -26,6 +27,7 @@ class ServiceBase extends Base {
          * Remote method access for other workers
          * @member {Object} remote={app: [//...]}
          * @protected
+         * @reactive
          */
         remote: {
             app: [
@@ -175,6 +177,8 @@ class ServiceBase extends Base {
      * @param {ExtendableMessageEvent} event
      */
     async onActivate(event) {
+        await globalThis.clients.claim();
+
         console.log('onActivate', event);
 
         let me   = this,
@@ -229,7 +233,8 @@ class ServiceBase extends Base {
      * @param {ExtendableMessageEvent} event
      */
     onInstall(event) {
-        console.log('onInstall', event)
+        console.log('onInstall', event);
+        globalThis.skipWaiting();
     }
 
     /**

package/src/worker/mixin/RemoteMethodAccess.mjs

@@ -10,12 +10,7 @@ class RemoteMethodAccess extends Base {
          * @member {String} className='Neo.worker.mixin.RemoteMethodAccess'
          * @protected
          */
-        className: 'Neo.worker.mixin.RemoteMethodAccess',
-        /**
-         * @member {Boolean} mixin=true
-         * @protected
-         */
-        mixin: true
+        className: 'Neo.worker.mixin.RemoteMethodAccess'
     }
 
     /**

package/test/siesta/siesta.js

@@ -48,7 +48,8 @@ project.plan(
         group: 'state',
         items: [
             'tests/state/createHierarchicalDataProxy.mjs',
-            'tests/state/Provider.mjs'
+            'tests/state/Provider.mjs',
+            'tests/state/ProviderNestedDataConfigs.mjs'
         ]
     },
     'tests/CollectionBase.mjs',
@@ -69,7 +70,21 @@ project.plan(
                 'tests/vdom/table/Container.mjs'
             ]
         },
-        'tests/vdom/Advanced.mjs']
+            'tests/vdom/Advanced.mjs',
+            'tests/vdom/VdomAsymmetricUpdates.mjs',
+            'tests/vdom/VdomRealWorldUpdates.mjs']
+    },
+    {
+        group: 'functional',
+        items: [
+            'tests/functional/Button.mjs'
+        ]
+    },
+    {
+        group: 'classic',
+        items: [
+            'tests/classic/Button.mjs'
+        ]
     }
 );
 

package/test/siesta/tests/VdomCalendar.mjs

@@ -1,12 +1,16 @@
-import Neo        from '../../../src/Neo.mjs';
-import * as core  from '../../../src/core/_export.mjs';
-import NeoArray   from '../../../src/util/Array.mjs';
-import Style      from '../../../src/util/Style.mjs';
-import VdomHelper from '../../../src/vdom/Helper.mjs';
-import VDomUtil   from '../../../src/util/VDom.mjs';
+import Neo             from '../../../src/Neo.mjs';
+import * as core       from '../../../src/core/_export.mjs';
+import NeoArray        from '../../../src/util/Array.mjs';
+import Style           from '../../../src/util/Style.mjs';
+import StringFromVnode from '../../../src/vdom/util/StringFromVnode.mjs';
+import VdomHelper      from '../../../src/vdom/Helper.mjs';
+import VDomUtil        from '../../../src/util/VDom.mjs';
 
 let deltas, output, vdom, vnode;
 
+// tests are designed for this rendering mode
+Neo.config.useDomApiRenderer = false;
+
 StartTest(t => {
     t.it('Week view: Infinite Scrolling', t => {
         vdom =
@@ -23,7 +27,7 @@ StartTest(t => {
             {id: 'col-15'}
         ]};
 
-        vnode = VdomHelper.create(vdom);
+        let vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {id: 'neo-vnode-1', cn: [
@@ -105,7 +109,7 @@ StartTest(t => {
             ]}
         ]};
 
-        vnode = VdomHelper.create(vdom);
+        let vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {id: 'neo-calendar-week', cn: [
@@ -165,7 +169,7 @@ StartTest(t => {
             ]}
         ]};
 
-        vnode = VdomHelper.create(vdom);
+        let vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {id: 'neo-calendar-week', cn: [
@@ -216,7 +220,7 @@ StartTest(t => {
             ]}
         ]};
 
-        vnode = VdomHelper.create(vdom);
+        let vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {id: 'neo-calendar-week', cn: [
@@ -268,7 +272,7 @@ StartTest(t => {
             {id: 'neo-column-3'}
         ]};
 
-        vnode = VdomHelper.create(vdom);
+        let vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {id: 'neo-calendar-week', cn: [
@@ -333,7 +337,7 @@ StartTest(t => {
         vdom =
         {id: 'neo-1'};
 
-        vnode = VdomHelper.create(vdom);
+        vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {id: 'neo-1', removeDom: true};
@@ -358,7 +362,7 @@ StartTest(t => {
             ]}
         ]};
 
-        vnode = VdomHelper.create(vdom);
+        vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {id: 'neo-calendar-week', cn: [
@@ -403,7 +407,7 @@ StartTest(t => {
             ]}
         ]};
 
-        vnode = VdomHelper.create(vdom);
+        vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {tag: 'ul', id: 'neo-calendar-calendars-list-1', cn: [
@@ -1696,7 +1700,7 @@ StartTest(t => {
             }], tag: 'div'
         }
 
-        vnode = VdomHelper.create(vdom);
+        let vnode = VdomHelper.create({vdom}).vnode;
 
         vdom =
         {cls: ['neo-c-m-scrollcontainer', 'neo-scroll-shadows', 'neo-is-scrolling'], id: 'neo-vnode-150', cn: [

package/test/siesta/tests/VdomHelper.mjs

@@ -1,13 +1,13 @@
-import Neo        from '../../../src/Neo.mjs';
-import * as core  from '../../../src/core/_export.mjs';
-import NeoArray   from '../../../src/util/Array.mjs';
-import Style      from '../../../src/util/Style.mjs';
-import VdomHelper from '../../../src/vdom/Helper.mjs';
-import VDomUtil   from '../../../src/util/VDom.mjs';
+import Neo             from '../../../src/Neo.mjs';
+import * as core       from '../../../src/core/_export.mjs';
+import NeoArray        from '../../../src/util/Array.mjs';
+import Style           from '../../../src/util/Style.mjs';
+import StringFromVnode from '../../../src/vdom/util/StringFromVnode.mjs';
+import VdomHelper      from '../../../src/vdom/Helper.mjs';
+import VDomUtil        from '../../../src/util/VDom.mjs';
 
 // tests are designed for this rendering mode
 Neo.config.useDomApiRenderer = false;
-VdomHelper.onNeoConfigChange({useDomApiRenderer: false})
 
 let deltas, output, tmp, vdom, vnode;
 

package/test/siesta/tests/classic/Button.mjs

@@ -0,0 +1,113 @@
+import Neo                from '../../../../src/Neo.mjs';
+import * as core          from '../../../../src/core/_export.mjs';
+import Button             from '../../../../src/button/Base.mjs';
+import DomApiVnodeCreator from '../../../../src/vdom/util/DomApiVnodeCreator.mjs';
+import VdomHelper         from '../../../../src/vdom/Helper.mjs';
+
+// IMPORTANT: This test file uses real components and expects them to render.
+// We need to enable unitTestMode for isolation, but also allow VDOM updates.
+Neo.config.unitTestMode = true;
+Neo.config.allowVdomUpdatesInTests = true;
+// This ensures that the VdomHelper uses the correct renderer for the assertions.
+Neo.config.useDomApiRenderer = true;
+
+// Create a mock application context, as the component lifecycle requires it for updates.
+const appName = 'ClassicButtonTest';
+Neo.apps = Neo.apps || {};
+Neo.apps[appName] = {
+    name     : appName,
+    fire     : Neo.emptyFn,
+    isMounted: () => true,
+    rendering: false
+};
+
+StartTest(t => {
+    let button, vnode;
+    let testRun = 0;
+
+    t.beforeEach(async t => {
+        testRun++;
+
+        button = Neo.create(Button, {
+            appName,
+            id     : 'my-button-' + testRun,
+            iconCls: 'fa fa-home',
+            text   : 'Click me'
+        });
+
+        ({vnode} = await button.render());
+        button.mounted = true; // Manually mount to enable updates in the test env
+    });
+
+    t.afterEach(t => {
+        button?.destroy();
+        button = null;
+        vnode  = null;
+    });
+
+    t.it('should create initial vnode correctly', async t => {
+        t.expect(vnode.nodeName).toBe('button');
+        t.expect(vnode.className).toEqual(['neo-button', 'icon-left']);
+        t.expect(vnode.childNodes.length).toBe(2); // icon & text. badge & ripple have removeDom:true
+
+        const iconNode = vnode.childNodes[0];
+        t.expect(iconNode.className).toEqual(['neo-button-glyph', 'fa', 'fa-home']);
+
+        const textNode = vnode.childNodes[1];
+        t.expect(textNode.className).toEqual(['neo-button-text']);
+        t.expect(textNode.textContent).toBe('Click me');
+    });
+
+    t.it('should update vnode and create delta for a single config change', async t => {
+        const textNodeId = vnode.childNodes[1].id;
+        const {deltas} = await button.set({text: 'New Text'});
+
+        t.is(deltas.length, 1, 'Should generate exactly one delta');
+        const delta = deltas[0];
+
+        t.is(delta.id, textNodeId, 'Delta should target the text node');
+        t.is(delta.textContent, 'New Text', 'Delta textContent is correct');
+    });
+
+    t.it('should update vnode and create delta for multiple config changes', async t => {
+        const iconNodeId = vnode.childNodes[0].id;
+        const textNodeId = vnode.childNodes[1].id;
+
+        const {deltas} = await button.set({
+            iconCls: 'fa fa-user',
+            text   : 'Submit'
+        });
+
+        t.is(deltas.length, 2, 'Should generate exactly two deltas');
+
+        const iconDelta = deltas.find(d => d.id === iconNodeId);
+        const textDelta = deltas.find(d => d.id === textNodeId);
+
+        t.ok(iconDelta, 'Should have a delta for the icon node');
+        t.isDeeply(iconDelta.cls.remove, ['fa-home'], 'Icon delta should remove old class');
+        t.isDeeply(iconDelta.cls.add, ['fa-user'], 'Icon delta should add new class');
+
+        t.ok(textDelta, 'Should have a delta for the text node');
+        t.is(textDelta.textContent, 'Submit', 'Text delta is correct');
+    });
+
+    t.it('should handle pressed state change', async t => {
+        t.notOk(vnode.className.includes('pressed'), 'Initial vnode should not have "pressed" class');
+
+        let updateData = await button.set({pressed: true});
+
+        t.is(updateData.deltas.length, 1, 'Should generate one delta for pressed: true');
+        let delta = updateData.deltas[0];
+        t.is(delta.id, button.id, 'Delta should target the button component root');
+        t.isDeeply(delta.cls.add, ['pressed'], 'Delta should add "pressed" class');
+        t.ok(updateData.vnode.className.includes('pressed'), 'Vnode should have "pressed" class');
+
+        updateData = await button.set({pressed: false});
+
+        t.is(updateData.deltas.length, 1, 'Should generate one delta for pressed: false');
+        delta = updateData.deltas[0];
+        t.is(delta.id, button.id, 'Delta should target the button component root');
+        t.isDeeply(delta.cls.remove, ['pressed'], 'Delta should remove "pressed" class');
+        t.notOk(updateData.vnode.className.includes('pressed'), 'Vnode should not have "pressed" class');
+    });
+});

package/test/siesta/tests/core/Effect.mjs

@@ -6,8 +6,8 @@ import Config        from '../../../../src/core/Config.mjs';
 
 StartTest(t => {
     t.it('EffectManager should manage active effects', t => {
-        const effect1 = new Effect({fn: () => {}});
-        const effect2 = new Effect({fn: () => {}});
+        const effect1 = new Effect(() => {});
+        const effect2 = new Effect(() => {});
 
         t.is(EffectManager.getActiveEffect(), null, 'No active effect initially');
 
@@ -38,13 +38,11 @@ StartTest(t => {
         t.is(configB,    configB, 'configB is strictly equal to itself');
         t.isNot(configA, configB, 'configA is not strictly equal to configB');
 
-        const effect = new Effect({
-            fn: () => {
-                runCount++;
-                // Access configs to register them as dependencies
-                sum = configA.get() + configB.get();
-                t.pass(`Effect ran. Sum: ${sum}`);
-            }
+        const effect = new Effect(() => {
+            runCount++;
+            // Access configs to register them as dependencies
+            sum = configA.get() + configB.get();
+            t.pass(`Effect ran. Sum: ${sum}`);
         });
 
         t.is(runCount,                  1, 'Effect function ran once on creation');
@@ -82,11 +80,9 @@ StartTest(t => {
         const configY = new Config('Y');
 
         // Initial effect: depends on configX
-        const effect = new Effect({
-            fn: () => {
-                runCount++;
-                t.is(configX.get(), 'X', 'Effect ran (1st): configX value');
-            }
+        const effect = new Effect(() => {
+            runCount++;
+            t.is(configX.get(), 'X', 'Effect ran (1st): configX value');
         });
 
         t.is(runCount,                 1, 'Effect ran once initially');

package/test/siesta/tests/core/EffectBatching.mjs

@@ -1,31 +1,30 @@
-import Neo                from '../../../../src/Neo.mjs';
-import * as core          from '../../../../src/core/_export.mjs';
-import Effect             from '../../../../src/core/Effect.mjs';
-import EffectBatchManager from '../../../../src/core/EffectBatchManager.mjs';
+import Neo           from '../../../../src/Neo.mjs';
+import * as core     from '../../../../src/core/_export.mjs';
+import Effect        from '../../../../src/core/Effect.mjs';
+import EffectManager from '../../../../src/core/EffectManager.mjs';
 
 class TestComponent extends core.Base {
     static config = {
         className: 'Neo.Test.EffectBatchingComponent',
-        configA_: 0,
-        configB_: 0,
-        configC_: 0
+        configA_ : 0,
+        configB_ : 0,
+        configC_ : 0
     }
 }
+
 Neo.setupClass(TestComponent);
 
 StartTest(t => {
     t.it('Effects should be batched during core.Base#set() operations', t => {
-        const instance = Neo.create(TestComponent);
+        const instance     = Neo.create(TestComponent);
         let effectRunCount = 0;
-        let sum = 0;
-
-        const effect = new Effect({
-            fn: () => {
-                effectRunCount++;
-                // Access all props to make them dependencies
-                sum = instance.configA + instance.configB + instance.configC;
-                t.pass(`Effect ran. Sum: ${sum}`);
-            }
+        let sum            = 0;
+
+        const effect = new Effect(() => {
+            effectRunCount++;
+            // Access all props to make them dependencies
+            sum = instance.configA + instance.configB + instance.configC;
+            t.pass(`Effect ran. Sum: ${sum}`);
         });
 
         t.is(effectRunCount, 1, 'Effect ran once on initial creation');
@@ -49,7 +48,7 @@ StartTest(t => {
         t.is(instance.configC, 3, 'configC should be updated');
 
         // Test individual property change outside a batch
-        effectRunCount = 0;
+        effectRunCount   = 0;
         instance.configA = 10;
         t.is(effectRunCount, 1, 'Effect should run immediately for individual property change outside a batch');
         t.is(sum, 10 + 2 + 3, 'Sum should be 10 + 2 + 3 = 15 after individual configA change');
@@ -60,8 +59,8 @@ StartTest(t => {
         // Update all configs to their previous values (no change)
         instance.set({
             configA: 10,
-            configB:  2,
-            configC:  3
+            configB: 2,
+            configC: 3
         });
 
         t.is(effectRunCount, 0, 'Effect should not run.');
@@ -70,28 +69,28 @@ StartTest(t => {
         instance.destroy();
     });
 
-    t.it('EffectBatchManager should correctly manage batch state', t => {
-        t.is(EffectBatchManager.isBatchActive(), false, 'Batch should not be active initially');
+    t.it('EffectManager should correctly manage batch state via pause() and resume()', t => {
+        t.is(EffectManager.isPaused(), false, 'Batch should not be active initially');
 
-        EffectBatchManager.startBatch();
-        t.is(EffectBatchManager.isBatchActive(), true, 'Batch should be active after startBatch()');
+        EffectManager.pause();
+        t.is(EffectManager.isPaused(), true, 'Batch should be active after pause()');
 
-        EffectBatchManager.startBatch(); // Nested batch
-        t.is(EffectBatchManager.isBatchActive(), true, 'Batch should still be active for nested batch');
+        EffectManager.pause(); // Nested batch
+        t.is(EffectManager.isPaused(), true, 'Batch should still be active for nested pause()');
 
-        EffectBatchManager.endBatch();
-        t.is(EffectBatchManager.isBatchActive(), true, 'Batch should still be active after inner endBatch()');
+        EffectManager.resume();
+        t.is(EffectManager.isPaused(), true, 'Batch should still be active after inner resume()');
 
-        EffectBatchManager.endBatch();
-        t.is(EffectBatchManager.isBatchActive(), false, 'Batch should not be active after all endBatch() calls');
+        EffectManager.resume();
+        t.is(EffectManager.isPaused(), false, 'Batch should not be active after all resume() calls');
     });
 
     t.it('Effect should run when a dependency is changed inside an afterSet hook', t => {
         class IndirectDependencyComponent extends core.Base {
             static config = {
                 className: 'Neo.Test.IndirectDependencyComponent',
-                configA_: 'initialA',
-                configB_: 'initialB'
+                configA_ : 'initialA',
+                configB_ : 'initialB'
             }
 
             afterSetConfigA(newValue, oldValue) {
@@ -101,19 +100,18 @@ StartTest(t => {
                 }
             }
         }
+
         Neo.setupClass(IndirectDependencyComponent);
 
-        const instance = Neo.create(IndirectDependencyComponent);
+        const instance     = Neo.create(IndirectDependencyComponent);
         let effectRunCount = 0;
-        let effectValue = '';
+        let effectValue    = '';
 
         // Effect depends only on configB
-        const effect = new Effect({
-            fn: () => {
-                effectRunCount++;
-                effectValue = instance.configB;
-                t.pass(`Effect ran. configB: ${effectValue}`);
-            }
+        const effect = new Effect(() => {
+            effectRunCount++;
+            effectValue = instance.configB;
+            t.pass(`Effect ran. configB: ${effectValue}`);
         });
 
         t.is(effectRunCount, 1, 'Effect ran once on initial creation');
@@ -139,8 +137,8 @@ StartTest(t => {
         class BeforeSetDependencyComponent extends core.Base {
             static config = {
                 className: 'Neo.Test.BeforeSetDependencyComponent',
-                configA_: 'initialA',
-                configC_: 'initialC' // configC will be changed by beforeSetConfigA
+                configA_ : 'initialA',
+                configC_ : 'initialC' // configC will be changed by beforeSetConfigA
             }
 
             beforeSetConfigA(newValue, oldValue) {
@@ -151,19 +149,18 @@ StartTest(t => {
                 return newValue; // Important: return newValue to allow configA to be set
             }
         }
+
         Neo.setupClass(BeforeSetDependencyComponent);
 
-        const instance = Neo.create(BeforeSetDependencyComponent);
+        const instance     = Neo.create(BeforeSetDependencyComponent);
         let effectRunCount = 0;
-        let effectValue = '';
+        let effectValue    = '';
 
         // Effect depends only on configC
-        const effect = new Effect({
-            fn: () => {
-                effectRunCount++;
-                effectValue = instance.configC;
-                t.pass(`Effect ran. configC: ${effectValue}`);
-            }
+        const effect = new Effect(() => {
+            effectRunCount++;
+            effectValue = instance.configC;
+            t.pass(`Effect ran. configC: ${effectValue}`);
         });
 
         t.is(effectRunCount, 1, 'Effect ran once on initial creation');
@@ -189,9 +186,9 @@ StartTest(t => {
         class CombinedDependencyComponent extends core.Base {
             static config = {
                 className: 'Neo.Test.CombinedDependencyComponent',
-                configA_: 'initialA',
-                configB_: 'initialB', // Changed by afterSet
-                configC_: 'initialC'  // Changed by beforeSet
+                configA_ : 'initialA',
+                configB_ : 'initialB', // Changed by afterSet
+                configC_ : 'initialC'  // Changed by beforeSet
             }
 
             beforeSetConfigA(newValue, oldValue) {
@@ -207,30 +204,27 @@ StartTest(t => {
                 }
             }
         }
+
         Neo.setupClass(CombinedDependencyComponent);
 
-        const instance = Neo.create(CombinedDependencyComponent);
+        const instance      = Neo.create(CombinedDependencyComponent);
         let effectBRunCount = 0;
         let effectCRunCount = 0;
-        let effectBValue = '';
-        let effectCValue = '';
+        let effectBValue    = '';
+        let effectCValue    = '';
 
         // Effect for configB (changed by afterSet)
-        const effectB = new Effect({
-            fn: () => {
-                effectBRunCount++;
-                effectBValue = instance.configB;
-                t.pass(`EffectB ran. configB: ${effectBValue}`);
-            }
+        const effectB = new Effect(() => {
+            effectBRunCount++;
+            effectBValue = instance.configB;
+            t.pass(`EffectB ran. configB: ${effectBValue}`);
         });
 
         // Effect for configC (changed by beforeSet)
-        const effectC = new Effect({
-            fn: () => {
-                effectCRunCount++;
-                effectCValue = instance.configC;
-                t.pass(`EffectC ran. configC: ${effectCValue}`);
-            }
+        const effectC = new Effect(() => {
+            effectCRunCount++;
+            effectCValue = instance.configC;
+            t.pass(`EffectC ran. configC: ${effectCValue}`);
         });
 
         t.is(effectBRunCount, 1, 'EffectB ran once on initial creation');
@@ -267,9 +261,9 @@ StartTest(t => {
         class SingleEffectCombinedDependencyComponent extends core.Base {
             static config = {
                 className: 'Neo.Test.SingleEffectCombinedDependencyComponent',
-                configA_: 'initialA',
-                configB_: 'initialB', // Changed by afterSet
-                configC_: 'initialC'  // Changed by beforeSet
+                configA_ : 'initialA',
+                configB_ : 'initialB', // Changed by afterSet
+                configC_ : 'initialC'  // Changed by beforeSet
             }
 
             beforeSetConfigA(newValue, oldValue) {
@@ -285,19 +279,18 @@ StartTest(t => {
                 }
             }
         }
+
         Neo.setupClass(SingleEffectCombinedDependencyComponent);
 
-        const instance = Neo.create(SingleEffectCombinedDependencyComponent);
+        const instance     = Neo.create(SingleEffectCombinedDependencyComponent);
         let effectRunCount = 0;
-        let effectValue = '';
+        let effectValue    = '';
 
         // Single Effect depends on both configB and configC
-        const effect = new Effect({
-            fn: () => {
-                effectRunCount++;
-                effectValue = `${instance.configB} | ${instance.configC}`;
-                t.pass(`Effect ran. Combined: ${effectValue}`);
-            }
+        const effect = new Effect(() => {
+            effectRunCount++;
+            effectValue = `${instance.configB} | ${instance.configC}`;
+            t.pass(`Effect ran. Combined: ${effectValue}`);
         });
 
         t.is(effectRunCount, 1, 'Effect ran once on initial creation');