slicejs-web-framework 3.3.7 → 3.3.8

package/Slice/tests/context-patch-use.test.js

@@ -1,95 +1,95 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-globalThis.alert = () => {};
-
-// Minimal global `slice` so ContextManager's slice.logger / slice.events work in
-// isolation (a tiny in-memory event bus drives the watch notifications).
-const subscribers = new Map(); // eventName -> Set<fn>
-let subId = 0;
-globalThis.slice = {
-   logger: { logError() {}, logInfo() {}, logWarning() {} },
-   events: {
-      subscribe(name, cb) {
-         if (!subscribers.has(name)) subscribers.set(name, new Set());
-         subscribers.get(name).add(cb);
-         return `sub-${++subId}`;
-      },
-      emit(name, ...args) {
-         for (const cb of subscribers.get(name) ?? []) cb(...args);
-      },
-   },
-};
-
-const { default: ContextManager } = await import(
-   '../Components/Structural/ContextManager/ContextManager.js'
-);
-
-function freshContext(name, initial) {
-   const ctx = new ContextManager();
-   ctx.create(name, initial);
-   return ctx;
-}
-
-test('patch merges into existing state (does not replace)', () => {
-   const ctx = freshContext('cart', { items: 2, total: 47, discount: 0 });
-   ctx.patch('cart', { discount: 0.1 });
-   assert.deepEqual(ctx.getState('cart'), { items: 2, total: 47, discount: 0.1 });
-});
-
-test('setState replaces, patch keeps the rest', () => {
-   const ctx = freshContext('s', { a: 1, b: 2 });
-   ctx.setState('s', { a: 9 }); // replace → drops b
-   assert.deepEqual(ctx.getState('s'), { a: 9 });
-   ctx.patch('s', { b: 5 }); // merge onto { a: 9 }
-   assert.deepEqual(ctx.getState('s'), { a: 9, b: 5 });
-});
-
-test('patch rejects non-object partials and missing contexts (no throw)', () => {
-   const ctx = freshContext('s', { a: 1 });
-   ctx.patch('s', null);
-   ctx.patch('s', [1, 2]);
-   ctx.patch('nope', { x: 1 });
-   assert.deepEqual(ctx.getState('s'), { a: 1 });
-   assert.equal(ctx.has('nope'), false);
-});
-
-test('use(name) returns a handle bound to that context', () => {
-   const ctx = freshContext('settings', { model: 'a' });
-   const settings = ctx.use('settings');
-
-   assert.equal(settings.get().model, 'a');
-   settings.set({ model: 'b' });
-   assert.equal(ctx.getState('settings').model, 'b');
-   settings.patch({ theme: 'dark' });
-   assert.deepEqual(ctx.getState('settings'), { model: 'b', theme: 'dark' });
-   assert.equal(settings.has(), true);
-   settings.destroy();
-   assert.equal(ctx.has('settings'), false);
-});
-
-test('use(name).bind calls back immediately and on every change', () => {
-   const ctx = freshContext('cart', { items: [], n: 0 });
-   const calls = [];
-   ctx.use('cart').bind({ sliceId: 'c1' }, (state) => calls.push(state.n));
-
-   assert.deepEqual(calls, [0]); // immediate initial call
-   ctx.patch('cart', { n: 1 });
-   assert.deepEqual(calls, [0, 1]); // fired on change
-});
-
-test('use(name).bind with a selector only fires when the selected value changes', () => {
-   const ctx = freshContext('cart', { items: ['x'], note: 'a' });
-   const counts = [];
-   ctx.use('cart').bind(
-      { sliceId: 'c2' },
-      (count) => counts.push(count),
-      (s) => s.items.length
-   );
-
-   assert.deepEqual(counts, [1]); // immediate, selected value = length
-   ctx.patch('cart', { note: 'b' }); // length unchanged → no fire
-   assert.deepEqual(counts, [1]);
-   ctx.patch('cart', { items: ['x', 'y'] }); // length changed → fire
-   assert.deepEqual(counts, [1, 2]);
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+globalThis.alert = () => {};
+
+// Minimal global `slice` so ContextManager's slice.logger / slice.events work in
+// isolation (a tiny in-memory event bus drives the watch notifications).
+const subscribers = new Map(); // eventName -> Set<fn>
+let subId = 0;
+globalThis.slice = {
+   logger: { logError() {}, logInfo() {}, logWarning() {} },
+   events: {
+      subscribe(name, cb) {
+         if (!subscribers.has(name)) subscribers.set(name, new Set());
+         subscribers.get(name).add(cb);
+         return `sub-${++subId}`;
+      },
+      emit(name, ...args) {
+         for (const cb of subscribers.get(name) ?? []) cb(...args);
+      },
+   },
+};
+
+const { default: ContextManager } = await import(
+   '../Components/Structural/ContextManager/ContextManager.js'
+);
+
+function freshContext(name, initial) {
+   const ctx = new ContextManager();
+   ctx.create(name, initial);
+   return ctx;
+}
+
+test('patch merges into existing state (does not replace)', () => {
+   const ctx = freshContext('cart', { items: 2, total: 47, discount: 0 });
+   ctx.patch('cart', { discount: 0.1 });
+   assert.deepEqual(ctx.getState('cart'), { items: 2, total: 47, discount: 0.1 });
+});
+
+test('setState replaces, patch keeps the rest', () => {
+   const ctx = freshContext('s', { a: 1, b: 2 });
+   ctx.setState('s', { a: 9 }); // replace → drops b
+   assert.deepEqual(ctx.getState('s'), { a: 9 });
+   ctx.patch('s', { b: 5 }); // merge onto { a: 9 }
+   assert.deepEqual(ctx.getState('s'), { a: 9, b: 5 });
+});
+
+test('patch rejects non-object partials and missing contexts (no throw)', () => {
+   const ctx = freshContext('s', { a: 1 });
+   ctx.patch('s', null);
+   ctx.patch('s', [1, 2]);
+   ctx.patch('nope', { x: 1 });
+   assert.deepEqual(ctx.getState('s'), { a: 1 });
+   assert.equal(ctx.has('nope'), false);
+});
+
+test('use(name) returns a handle bound to that context', () => {
+   const ctx = freshContext('settings', { model: 'a' });
+   const settings = ctx.use('settings');
+
+   assert.equal(settings.get().model, 'a');
+   settings.set({ model: 'b' });
+   assert.equal(ctx.getState('settings').model, 'b');
+   settings.patch({ theme: 'dark' });
+   assert.deepEqual(ctx.getState('settings'), { model: 'b', theme: 'dark' });
+   assert.equal(settings.has(), true);
+   settings.destroy();
+   assert.equal(ctx.has('settings'), false);
+});
+
+test('use(name).bind calls back immediately and on every change', () => {
+   const ctx = freshContext('cart', { items: [], n: 0 });
+   const calls = [];
+   ctx.use('cart').bind({ sliceId: 'c1' }, (state) => calls.push(state.n));
+
+   assert.deepEqual(calls, [0]); // immediate initial call
+   ctx.patch('cart', { n: 1 });
+   assert.deepEqual(calls, [0, 1]); // fired on change
+});
+
+test('use(name).bind with a selector only fires when the selected value changes', () => {
+   const ctx = freshContext('cart', { items: ['x'], note: 'a' });
+   const counts = [];
+   ctx.use('cart').bind(
+      { sliceId: 'c2' },
+      (count) => counts.push(count),
+      (s) => s.items.length
+   );
+
+   assert.deepEqual(counts, [1]); // immediate, selected value = length
+   ctx.patch('cart', { note: 'b' }); // length unchanged → no fire
+   assert.deepEqual(counts, [1]);
+   ctx.patch('cart', { items: ['x', 'y'] }); // length changed → fire
+   assert.deepEqual(counts, [1, 2]);
+});

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);
+}

package/Slice/tests/public-env-typed-accessors.test.js

@@ -1,66 +1,66 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-globalThis.alert = () => {};
-
-const { default: Slice } = await import('../Slice.js');
-
-function createSliceInstance() {
-  return new Slice({
-    paths: {},
-    themeManager: {},
-    stylesManager: {},
-    logger: {},
-    debugger: {},
-    loading: {},
-    events: {}
-  });
-}
-
-test('slice.env.get / has / all', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({ SLICE_PUBLIC_API_URL: 'https://api.example.com', INTERNAL: 'hidden' });
-
-  assert.equal(s.env.get('SLICE_PUBLIC_API_URL'), 'https://api.example.com');
-  assert.equal(s.env.get('SLICE_PUBLIC_MISSING', 'fb'), 'fb');
-  assert.equal(s.env.has('SLICE_PUBLIC_API_URL'), true);
-  assert.equal(s.env.has('SLICE_PUBLIC_MISSING'), false);
-  assert.deepEqual(s.env.all(), { SLICE_PUBLIC_API_URL: 'https://api.example.com' }); // only SLICE_PUBLIC_*
-});
-
-test('slice.env.bool parses truthy strings and falls back', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({
-    SLICE_PUBLIC_ON: 'true',
-    SLICE_PUBLIC_ON2: 'YES',
-    SLICE_PUBLIC_ON3: '1',
-    SLICE_PUBLIC_OFF: 'false',
-    SLICE_PUBLIC_EMPTY: ''
-  });
-
-  assert.equal(s.env.bool('SLICE_PUBLIC_ON'), true);
-  assert.equal(s.env.bool('SLICE_PUBLIC_ON2'), true);
-  assert.equal(s.env.bool('SLICE_PUBLIC_ON3'), true);
-  assert.equal(s.env.bool('SLICE_PUBLIC_OFF'), false);
-  assert.equal(s.env.bool('SLICE_PUBLIC_EMPTY', true), true);   // empty → fallback
-  assert.equal(s.env.bool('SLICE_PUBLIC_MISSING'), false);       // missing → default false
-  assert.equal(s.env.bool('SLICE_PUBLIC_MISSING', true), true);  // missing → custom fallback
-});
-
-test('slice.env.int parses integers and falls back', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({ SLICE_PUBLIC_TIMEOUT: '5000', SLICE_PUBLIC_BAD: 'nope' });
-
-  assert.equal(s.env.int('SLICE_PUBLIC_TIMEOUT'), 5000);
-  assert.equal(s.env.int('SLICE_PUBLIC_BAD', 10), 10);       // non-numeric → fallback
-  assert.equal(s.env.int('SLICE_PUBLIC_MISSING', 42), 42);   // missing → fallback
-});
-
-test('slice.env.list splits CSV, trims, drops empties', () => {
-  const s = createSliceInstance();
-  s.setPublicEnv({ SLICE_PUBLIC_MODELS: ' a , b ,, c ', SLICE_PUBLIC_EMPTY: '' });
-
-  assert.deepEqual(s.env.list('SLICE_PUBLIC_MODELS'), ['a', 'b', 'c']);
-  assert.deepEqual(s.env.list('SLICE_PUBLIC_EMPTY', ['x']), ['x']);     // empty → fallback
-  assert.deepEqual(s.env.list('SLICE_PUBLIC_MISSING'), []);             // missing → default []
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+globalThis.alert = () => {};
+
+const { default: Slice } = await import('../Slice.js');
+
+function createSliceInstance() {
+  return new Slice({
+    paths: {},
+    themeManager: {},
+    stylesManager: {},
+    logger: {},
+    debugger: {},
+    loading: {},
+    events: {}
+  });
+}
+
+test('slice.env.get / has / all', () => {
+  const s = createSliceInstance();
+  s.setPublicEnv({ SLICE_PUBLIC_API_URL: 'https://api.example.com', INTERNAL: 'hidden' });
+
+  assert.equal(s.env.get('SLICE_PUBLIC_API_URL'), 'https://api.example.com');
+  assert.equal(s.env.get('SLICE_PUBLIC_MISSING', 'fb'), 'fb');
+  assert.equal(s.env.has('SLICE_PUBLIC_API_URL'), true);
+  assert.equal(s.env.has('SLICE_PUBLIC_MISSING'), false);
+  assert.deepEqual(s.env.all(), { SLICE_PUBLIC_API_URL: 'https://api.example.com' }); // only SLICE_PUBLIC_*
+});
+
+test('slice.env.bool parses truthy strings and falls back', () => {
+  const s = createSliceInstance();
+  s.setPublicEnv({
+    SLICE_PUBLIC_ON: 'true',
+    SLICE_PUBLIC_ON2: 'YES',
+    SLICE_PUBLIC_ON3: '1',
+    SLICE_PUBLIC_OFF: 'false',
+    SLICE_PUBLIC_EMPTY: ''
+  });
+
+  assert.equal(s.env.bool('SLICE_PUBLIC_ON'), true);
+  assert.equal(s.env.bool('SLICE_PUBLIC_ON2'), true);
+  assert.equal(s.env.bool('SLICE_PUBLIC_ON3'), true);
+  assert.equal(s.env.bool('SLICE_PUBLIC_OFF'), false);
+  assert.equal(s.env.bool('SLICE_PUBLIC_EMPTY', true), true);   // empty → fallback
+  assert.equal(s.env.bool('SLICE_PUBLIC_MISSING'), false);       // missing → default false
+  assert.equal(s.env.bool('SLICE_PUBLIC_MISSING', true), true);  // missing → custom fallback
+});
+
+test('slice.env.int parses integers and falls back', () => {
+  const s = createSliceInstance();
+  s.setPublicEnv({ SLICE_PUBLIC_TIMEOUT: '5000', SLICE_PUBLIC_BAD: 'nope' });
+
+  assert.equal(s.env.int('SLICE_PUBLIC_TIMEOUT'), 5000);
+  assert.equal(s.env.int('SLICE_PUBLIC_BAD', 10), 10);       // non-numeric → fallback
+  assert.equal(s.env.int('SLICE_PUBLIC_MISSING', 42), 42);   // missing → fallback
+});
+
+test('slice.env.list splits CSV, trims, drops empties', () => {
+  const s = createSliceInstance();
+  s.setPublicEnv({ SLICE_PUBLIC_MODELS: ' a , b ,, c ', SLICE_PUBLIC_EMPTY: '' });
+
+  assert.deepEqual(s.env.list('SLICE_PUBLIC_MODELS'), ['a', 'b', 'c']);
+  assert.deepEqual(s.env.list('SLICE_PUBLIC_EMPTY', ['x']), ['x']);     // empty → fallback
+  assert.deepEqual(s.env.list('SLICE_PUBLIC_MISSING'), []);             // missing → default []
+});