slicejs-web-framework 4.0.0 → 4.0.1

package/Slice/tests/event-emitters.test.js

@@ -1,79 +1,79 @@
-// Tests for emitter tracing: who emits each event (bind attribution + dev
-// stack-trace fallback), recorded only while a debugger is "open" (recording).
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-globalThis.slice = {
-   isProduction: () => false,
-   controller: { activeComponents: new Map() },
-   logger: { logError() {}, logInfo() {}, logWarning() {}, info() {}, error() {} },
-};
-
-const { default: EventManager } = await import('../Components/Structural/EventManager/EventManager.js');
-
-test('bound emit is attributed to its component', () => {
-   const em = new EventManager();
-   em.startRecording();
-   const comp = { sliceId: 'card-1', constructor: { name: 'Card' } };
-   em.bind(comp).emit('user:login', { id: 1 });
-
-   const bucket = em.emitters.get('user:login');
-   assert.ok(bucket, 'event has emitters bucket');
-   const entry = bucket.get('card-1');
-   assert.equal(entry.name, 'Card');
-   assert.equal(entry.sliceId, 'card-1');
-   assert.equal(entry.count, 1);
-
-   const hist = em.emitHistory.find((e) => e.eventName === 'user:login');
-   assert.equal(hist.emitter.sliceId, 'card-1', 'history entry carries the emitter');
-});
-
-test('global emit falls back to a dev stack-trace source', () => {
-   const em = new EventManager();
-   em.startRecording();
-   em.emit('router:change');
-
-   const hist = em.emitHistory.find((e) => e.eventName === 'router:change');
-   assert.ok(hist.emitter, 'emitter captured for global emit');
-   assert.ok(hist.emitter.source && hist.emitter.source.includes('.js'), 'source is file:line');
-   assert.ok(!hist.emitter.source.includes('EventManager.js'), 'attributes the caller, not the manager');
-});
-
-test('emitter counts accumulate per distinct source', () => {
-   const em = new EventManager();
-   em.startRecording();
-   em.bind({ sliceId: 'a-1', constructor: { name: 'A' } }).emit('x:y');
-   em.bind({ sliceId: 'a-1', constructor: { name: 'A' } }).emit('x:y');
-   em.bind({ sliceId: 'b-2', constructor: { name: 'B' } }).emit('x:y');
-
-   const bucket = em.emitters.get('x:y');
-   assert.equal(bucket.get('a-1').count, 2);
-   assert.equal(bucket.get('b-2').count, 1);
-});
-
-test('no recording (debugger closed) => no emitter tracking, zero overhead', () => {
-   const em = new EventManager();
-   em.emit('a:b');
-   em.bind({ sliceId: 'z-1', constructor: { name: 'Z' } }).emit('a:b');
-   assert.equal(em.emitters.size, 0);
-   assert.equal(em.emitHistory.length, 0);
-});
-
-test('production: no stack-trace source captured', () => {
-   globalThis.slice.isProduction = () => true;
-   const em = new EventManager();
-   em.startRecording();
-   em.emit('p:q');
-   const hist = em.emitHistory.find((e) => e.eventName === 'p:q');
-   assert.equal(hist.emitter, null, 'no source attribution in production');
-   globalThis.slice.isProduction = () => false;
-});
-
-test('startRecording resets the emitters map', () => {
-   const em = new EventManager();
-   em.startRecording();
-   em.bind({ sliceId: 'a-1', constructor: { name: 'A' } }).emit('x:y');
-   assert.equal(em.emitters.size, 1);
-   em.startRecording();
-   assert.equal(em.emitters.size, 0, 'fresh session clears prior emitters');
-});
+// Tests for emitter tracing: who emits each event (bind attribution + dev
+// stack-trace fallback), recorded only while a debugger is "open" (recording).
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+globalThis.slice = {
+   isProduction: () => false,
+   controller: { activeComponents: new Map() },
+   logger: { logError() {}, logInfo() {}, logWarning() {}, info() {}, error() {} },
+};
+
+const { default: EventManager } = await import('../Components/Structural/EventManager/EventManager.js');
+
+test('bound emit is attributed to its component', () => {
+   const em = new EventManager();
+   em.startRecording();
+   const comp = { sliceId: 'card-1', constructor: { name: 'Card' } };
+   em.bind(comp).emit('user:login', { id: 1 });
+
+   const bucket = em.emitters.get('user:login');
+   assert.ok(bucket, 'event has emitters bucket');
+   const entry = bucket.get('card-1');
+   assert.equal(entry.name, 'Card');
+   assert.equal(entry.sliceId, 'card-1');
+   assert.equal(entry.count, 1);
+
+   const hist = em.emitHistory.find((e) => e.eventName === 'user:login');
+   assert.equal(hist.emitter.sliceId, 'card-1', 'history entry carries the emitter');
+});
+
+test('global emit falls back to a dev stack-trace source', () => {
+   const em = new EventManager();
+   em.startRecording();
+   em.emit('router:change');
+
+   const hist = em.emitHistory.find((e) => e.eventName === 'router:change');
+   assert.ok(hist.emitter, 'emitter captured for global emit');
+   assert.ok(hist.emitter.source && hist.emitter.source.includes('.js'), 'source is file:line');
+   assert.ok(!hist.emitter.source.includes('EventManager.js'), 'attributes the caller, not the manager');
+});
+
+test('emitter counts accumulate per distinct source', () => {
+   const em = new EventManager();
+   em.startRecording();
+   em.bind({ sliceId: 'a-1', constructor: { name: 'A' } }).emit('x:y');
+   em.bind({ sliceId: 'a-1', constructor: { name: 'A' } }).emit('x:y');
+   em.bind({ sliceId: 'b-2', constructor: { name: 'B' } }).emit('x:y');
+
+   const bucket = em.emitters.get('x:y');
+   assert.equal(bucket.get('a-1').count, 2);
+   assert.equal(bucket.get('b-2').count, 1);
+});
+
+test('no recording (debugger closed) => no emitter tracking, zero overhead', () => {
+   const em = new EventManager();
+   em.emit('a:b');
+   em.bind({ sliceId: 'z-1', constructor: { name: 'Z' } }).emit('a:b');
+   assert.equal(em.emitters.size, 0);
+   assert.equal(em.emitHistory.length, 0);
+});
+
+test('production: no stack-trace source captured', () => {
+   globalThis.slice.isProduction = () => true;
+   const em = new EventManager();
+   em.startRecording();
+   em.emit('p:q');
+   const hist = em.emitHistory.find((e) => e.eventName === 'p:q');
+   assert.equal(hist.emitter, null, 'no source attribution in production');
+   globalThis.slice.isProduction = () => false;
+});
+
+test('startRecording resets the emitters map', () => {
+   const em = new EventManager();
+   em.startRecording();
+   em.bind({ sliceId: 'a-1', constructor: { name: 'A' } }).emit('x:y');
+   assert.equal(em.emitters.size, 1);
+   em.startRecording();
+   assert.equal(em.emitters.size, 0, 'fresh session clears prior emitters');
+});

package/Slice/tests/event-registry.test.js

@@ -1,141 +1,141 @@
-// Unit tests for the EventManager typed-event registry (register/validate/warn).
-// EventManager only depends on the `slice` global for logging + isProduction +
-// controller.activeComponents, so we stub a minimal one and drive the real class.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-const warnings = [];
-globalThis.slice = {
-   isProduction: () => false,
-   controller: { activeComponents: new Map() },
-   logger: {
-      logError() {},
-      logInfo() {},
-      logWarning(_c, message) { warnings.push(message); },
-      info() {}, error() {}, warn() {},
-   },
-};
-
-const { default: EventManager } = await import('../Components/Structural/EventManager/EventManager.js');
-
-const undeclaredWarns = (name) => warnings.filter((w) => w.includes('Undeclared') && (!name || w.includes(name)));
-
-test('loose mode: with no registry, nothing warns', () => {
-   warnings.length = 0;
-   const em = new EventManager();
-   em.emit('anything:happens');
-   em.subscribe('whatever:event', () => {});
-   assert.equal(undeclaredWarns().length, 0);
-});
-
-test('declared event emits and subscribes without warning', () => {
-   warnings.length = 0;
-   const em = new EventManager();
-   em.register({ 'user:login': { payload: { id: 'number' } } });
-   em.subscribe('user:login', () => {});
-   em.emit('user:login', { id: 1 });
-   assert.equal(undeclaredWarns().length, 0);
-});
-
-test('undeclared event warns exactly once but still delivers', () => {
-   warnings.length = 0;
-   const em = new EventManager();
-   em.register({ 'user:login': { payload: null } });
-
-   let calls = 0;
-   em.subscribe('ghost:event', () => { calls += 1; });   // subscribe (undeclared) -> warns
-   em.emit('ghost:event');                                 // emit (undeclared, already warned)
-   em.emit('ghost:event');
-
-   assert.equal(undeclaredWarns('ghost:event').length, 1, 'warned exactly once');
-   assert.equal(calls, 2, 'delivery still happened both emits');
-});
-
-test('framework events (router:*/context:*) never warn', () => {
-   warnings.length = 0;
-   const em = new EventManager();
-   em.register({ 'user:login': { payload: null } });
-   em.emit('router:change');
-   em.emit('context:user', {});
-   em.subscribe('context:cart', () => {});
-   assert.equal(undeclaredWarns().length, 0);
-});
-
-test('production: undeclared events do not warn', () => {
-   warnings.length = 0;
-   globalThis.slice.isProduction = () => true;
-   const em = new EventManager();
-   em.register({ 'a:b': { payload: null } });
-   em.emit('zzz:undeclared');
-   assert.equal(undeclaredWarns().length, 0);
-   globalThis.slice.isProduction = () => false;
-});
-
-test('register() merges catalogs and is chainable', () => {
-   const em = new EventManager();
-   const ret = em.register({ 'a:1': { payload: null } }).register({ 'b:2': { payload: { x: 'string' } } });
-   assert.equal(ret, em, 'returns the manager for chaining');
-   assert.ok(em.registry.has('a:1') && em.registry.has('b:2'), 'both catalogs merged');
-   assert.equal(em.isDeclared('a:1'), true);
-   assert.equal(em.isDeclared('nope:nope'), false);
-});
-
-test('register(namespace, catalog) prefixes keys', () => {
-   const em = new EventManager();
-   em.register('user', { login: { payload: { id: 'number' } }, logout: { payload: null } });
-   assert.ok(em.registry.has('user:login'), 'user:login declared');
-   assert.ok(em.registry.has('user:logout'), 'user:logout declared');
-   assert.equal(em.namespaceOf('user:login'), 'user');
-   assert.equal(em.namespaceOf('ready'), null);
-});
-
-test('event without namespace warns once in dev', () => {
-   warnings.length = 0;
-   const em = new EventManager();
-   em.register({ 'ready': { payload: null } });       // declared but no namespace -> warns
-   em.emit('ready');
-   em.emit('ready');
-   const nsWarns = warnings.filter((w) => w.includes('no namespace'));
-   assert.equal(nsWarns.length, 1, 'namespace warning fired exactly once');
-});
-
-test('no-namespace warning is silent in loose mode (no registry)', () => {
-   warnings.length = 0;
-   const em = new EventManager();
-   em.emit('ready'); // nobody registered -> loose mode, no warnings at all
-   assert.equal(warnings.length, 0);
-});
-
-test('loadGraph stores the static graph and exposes emitters/listeners', () => {
-   const em = new EventManager();
-   assert.deepEqual(em.staticEmittersOf('user:login'), [], 'empty before loadGraph');
-   em.loadGraph({
-      events: {
-         'user:login': {
-            payload: { id: 'number' },
-            emitters: [{ file: 'src/Login.js', line: 12, component: 'Login' }],
-            listeners: [{ file: 'src/Header.js', line: 5, component: 'Header' }],
-         },
-      },
-      dynamic: { emitters: [], listeners: [] },
-   });
-   assert.equal(em.staticEmittersOf('user:login')[0].component, 'Login');
-   assert.equal(em.staticListenersOf('user:login')[0].component, 'Header');
-   assert.deepEqual(em.staticEmittersOf('unknown:event'), []);
-});
-
-test('loadGraph ignores malformed input', () => {
-   const em = new EventManager();
-   em.loadGraph(null);
-   em.loadGraph({ nope: true });
-   assert.equal(em.graph, null);
-});
-
-test('undeclared usage is tracked for the debugger drift view', () => {
-   warnings.length = 0;
-   const em = new EventManager();
-   em.register({ 'declared:ok': { payload: null } });
-   em.emit('drifted:event');
-   assert.ok(em.undeclared.has('drifted:event'), 'drift set records undeclared usage');
-   assert.ok(!em.undeclared.has('declared:ok'), 'declared events are not drift');
-});
+// Unit tests for the EventManager typed-event registry (register/validate/warn).
+// EventManager only depends on the `slice` global for logging + isProduction +
+// controller.activeComponents, so we stub a minimal one and drive the real class.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+const warnings = [];
+globalThis.slice = {
+   isProduction: () => false,
+   controller: { activeComponents: new Map() },
+   logger: {
+      logError() {},
+      logInfo() {},
+      logWarning(_c, message) { warnings.push(message); },
+      info() {}, error() {}, warn() {},
+   },
+};
+
+const { default: EventManager } = await import('../Components/Structural/EventManager/EventManager.js');
+
+const undeclaredWarns = (name) => warnings.filter((w) => w.includes('Undeclared') && (!name || w.includes(name)));
+
+test('loose mode: with no registry, nothing warns', () => {
+   warnings.length = 0;
+   const em = new EventManager();
+   em.emit('anything:happens');
+   em.subscribe('whatever:event', () => {});
+   assert.equal(undeclaredWarns().length, 0);
+});
+
+test('declared event emits and subscribes without warning', () => {
+   warnings.length = 0;
+   const em = new EventManager();
+   em.register({ 'user:login': { payload: { id: 'number' } } });
+   em.subscribe('user:login', () => {});
+   em.emit('user:login', { id: 1 });
+   assert.equal(undeclaredWarns().length, 0);
+});
+
+test('undeclared event warns exactly once but still delivers', () => {
+   warnings.length = 0;
+   const em = new EventManager();
+   em.register({ 'user:login': { payload: null } });
+
+   let calls = 0;
+   em.subscribe('ghost:event', () => { calls += 1; });   // subscribe (undeclared) -> warns
+   em.emit('ghost:event');                                 // emit (undeclared, already warned)
+   em.emit('ghost:event');
+
+   assert.equal(undeclaredWarns('ghost:event').length, 1, 'warned exactly once');
+   assert.equal(calls, 2, 'delivery still happened both emits');
+});
+
+test('framework events (router:*/context:*) never warn', () => {
+   warnings.length = 0;
+   const em = new EventManager();
+   em.register({ 'user:login': { payload: null } });
+   em.emit('router:change');
+   em.emit('context:user', {});
+   em.subscribe('context:cart', () => {});
+   assert.equal(undeclaredWarns().length, 0);
+});
+
+test('production: undeclared events do not warn', () => {
+   warnings.length = 0;
+   globalThis.slice.isProduction = () => true;
+   const em = new EventManager();
+   em.register({ 'a:b': { payload: null } });
+   em.emit('zzz:undeclared');
+   assert.equal(undeclaredWarns().length, 0);
+   globalThis.slice.isProduction = () => false;
+});
+
+test('register() merges catalogs and is chainable', () => {
+   const em = new EventManager();
+   const ret = em.register({ 'a:1': { payload: null } }).register({ 'b:2': { payload: { x: 'string' } } });
+   assert.equal(ret, em, 'returns the manager for chaining');
+   assert.ok(em.registry.has('a:1') && em.registry.has('b:2'), 'both catalogs merged');
+   assert.equal(em.isDeclared('a:1'), true);
+   assert.equal(em.isDeclared('nope:nope'), false);
+});
+
+test('register(namespace, catalog) prefixes keys', () => {
+   const em = new EventManager();
+   em.register('user', { login: { payload: { id: 'number' } }, logout: { payload: null } });
+   assert.ok(em.registry.has('user:login'), 'user:login declared');
+   assert.ok(em.registry.has('user:logout'), 'user:logout declared');
+   assert.equal(em.namespaceOf('user:login'), 'user');
+   assert.equal(em.namespaceOf('ready'), null);
+});
+
+test('event without namespace warns once in dev', () => {
+   warnings.length = 0;
+   const em = new EventManager();
+   em.register({ 'ready': { payload: null } });       // declared but no namespace -> warns
+   em.emit('ready');
+   em.emit('ready');
+   const nsWarns = warnings.filter((w) => w.includes('no namespace'));
+   assert.equal(nsWarns.length, 1, 'namespace warning fired exactly once');
+});
+
+test('no-namespace warning is silent in loose mode (no registry)', () => {
+   warnings.length = 0;
+   const em = new EventManager();
+   em.emit('ready'); // nobody registered -> loose mode, no warnings at all
+   assert.equal(warnings.length, 0);
+});
+
+test('loadGraph stores the static graph and exposes emitters/listeners', () => {
+   const em = new EventManager();
+   assert.deepEqual(em.staticEmittersOf('user:login'), [], 'empty before loadGraph');
+   em.loadGraph({
+      events: {
+         'user:login': {
+            payload: { id: 'number' },
+            emitters: [{ file: 'src/Login.js', line: 12, component: 'Login' }],
+            listeners: [{ file: 'src/Header.js', line: 5, component: 'Header' }],
+         },
+      },
+      dynamic: { emitters: [], listeners: [] },
+   });
+   assert.equal(em.staticEmittersOf('user:login')[0].component, 'Login');
+   assert.equal(em.staticListenersOf('user:login')[0].component, 'Header');
+   assert.deepEqual(em.staticEmittersOf('unknown:event'), []);
+});
+
+test('loadGraph ignores malformed input', () => {
+   const em = new EventManager();
+   em.loadGraph(null);
+   em.loadGraph({ nope: true });
+   assert.equal(em.graph, null);
+});
+
+test('undeclared usage is tracked for the debugger drift view', () => {
+   warnings.length = 0;
+   const em = new EventManager();
+   em.register({ 'declared:ok': { payload: null } });
+   em.emit('drifted:event');
+   assert.ok(em.undeclared.has('drifted:event'), 'drift set records undeclared usage');
+   assert.ok(!em.undeclared.has('declared:ok'), 'declared events are not drift');
+});

package/Slice/tests/fixtures/real-runtime-loader.mjs

@@ -1,21 +1,21 @@
-// Node ESM resolve hook so the REAL Controller can load under `node --test`.
-//
-// Controller.js does `import components from '/Components/components.js'` — a
-// browser-absolute path that the dev server serves but node can't resolve. We
-// map only that exact specifier to a small fixture components map (just data,
-// the same shape the real components.js exports). Everything else resolves
-// normally, so the tests exercise the real Slice + Controller code, not mocks.
-// AppProbe lives in a CUSTOM category ('AppServices') whose type is 'Service' —
-// it must be allowed as a singleton (the type, not the category name, decides).
-const COMPONENTS = { Probe: 'Service', ModalProbe: 'Visual', AppProbe: 'AppServices' };
-const STUB = `export default ${JSON.stringify(COMPONENTS)};`;
-
-export async function resolve(specifier, context, nextResolve) {
-   if (specifier === '/Components/components.js') {
-      return {
-         url: `data:text/javascript,${encodeURIComponent(STUB)}`,
-         shortCircuit: true
-      };
-   }
-   return nextResolve(specifier, context);
-}
+// Node ESM resolve hook so the REAL Controller can load under `node --test`.
+//
+// Controller.js does `import components from '/Components/components.js'` — a
+// browser-absolute path that the dev server serves but node can't resolve. We
+// map only that exact specifier to a small fixture components map (just data,
+// the same shape the real components.js exports). Everything else resolves
+// normally, so the tests exercise the real Slice + Controller code, not mocks.
+// AppProbe lives in a CUSTOM category ('AppServices') whose type is 'Service' —
+// it must be allowed as a singleton (the type, not the category name, decides).
+const COMPONENTS = { Probe: 'Service', ModalProbe: 'Visual', AppProbe: 'AppServices' };
+const STUB = `export default ${JSON.stringify(COMPONENTS)};`;
+
+export async function resolve(specifier, context, nextResolve) {
+   if (specifier === '/Components/components.js') {
+      return {
+         url: `data:text/javascript,${encodeURIComponent(STUB)}`,
+         shortCircuit: true
+      };
+   }
+   return nextResolve(specifier, context);
+}