sygnal 6.4.0 → 6.5.0

package/dist/index.cjs.js

@@ -787,6 +787,8 @@ const DEV_CODE_SEVERITY = {
     SYG426: 'warn',
     // checks/next.ts: CHILD.select(undefined), usually a missing export
     SYG427: 'error',
+    // checks/next.ts: a path designator that 6.4 read as one key with a dot
+    SYG428: 'warn',
     // PLAN-9 (checks/next.ts): D470 key identity, two children with one identity
     SYG453: 'warn',
     SYG612: 'error',
@@ -1413,18 +1415,45 @@ function localCell(app, parent) {
     return { local: true, get: () => (own ? v : parent.get()), set: (n) => { v = n; own = true; app.commit(); } };
 }
 /**
- * state="key". `owner`: the parent's name when `k` is one of its calculated fields (SYG409:
- * writes ignored; `what` names the writer in the message). `dflt`: an isolated child's
- * initialState, read while the slice is undefined. `has()`: the slice itself is defined (D174).
+ * SPIKE (state paths): a state designator as segments. A plain key is one segment; 'a.b.0' and
+ * 'a[0].b' are paths into nested objects and arrays. No array form: an array `from` / `state` is
+ * the data passed by mistake (SYG410 / SYG412), and ['x', 'y'] would be ambiguous.
+ */
+const pathOf$1 = (p) => p.replace(/\[(\d+)\]/g, '.$1').split('.');
+const getIn$1 = (o, ks) => { for (const k of ks) {
+    if (o == null)
+        return undefined;
+    o = o[k];
+} return o; };
+/** `o` with the value at `ks` replaced; only the levels on the path are copied (a missing level becomes {}) */
+function setIn$1(o, ks, i, v) {
+    if (i == ks.length)
+        return v;
+    const k = ks[i], cur = o?.[k], n = setIn$1(cur, ks, i + 1, v);
+    if (n === cur && o != null)
+        return o;
+    if (Array.isArray(o)) {
+        const c = o.slice();
+        c[k] = n;
+        return c;
+    }
+    return { ...o, [k]: n };
+}
+/**
+ * state="key" (SPIKE: or a path, 'a.b' / 'a[0].b'). `owner`: the parent's name when the first
+ * segment is one of its calculated fields (SYG409: writes ignored; `what` names the writer in
+ * the message). `dflt`: an isolated child's initialState, read while the slice is undefined.
+ * `has()`: the slice itself is defined (D174).
  */
 function keyCell(parent, k, owner, dflt, what = 'Sub-component') {
+    const ks = pathOf$1(k);
     let lp = {}, lv;
     return {
         get() {
             const p = parent.get();
             if (p !== lp) {
                 lp = p;
-                lv = p == null ? undefined : p[k];
+                lv = getIn$1(p, ks);
                 if (lv === undefined)
                     lv = dflt;
             }
@@ -1432,12 +1461,12 @@ function keyCell(parent, k, owner, dflt, what = 'Sub-component') {
         },
         set(v) {
             if (owner)
-                return warn('SYG409', owner, `${what} tried to update calculated field '${k}'; ignored`, 'Bind it to a non-calculated field');
+                return warn('SYG409', owner, `${what} tried to update calculated field '${ks[0]}'; ignored`, 'Bind it to a non-calculated field');
             const p = parent.get();
-            if (p?.[k] !== v)
-                parent.set({ ...p, [k]: v });
+            if (getIn$1(p, ks) !== v)
+                parent.set(setIn$1(p, ks, 0, v));
         },
-        has: () => parent.get()?.[k] !== undefined,
+        has: () => getIn$1(parent.get(), ks) !== undefined,
     };
 }
 /**
@@ -2783,7 +2812,7 @@ class Inst {
                 fail$2('SYG405', def.name, 'Sub-component initialState replaces the state its parent passes in', 'Remove initialState, or set isolatedState = true');
             }
             const dflt = def.isolated ? def.initialState : undefined;
-            const cell = typeof st == 'string' ? keyCell(this.cell, st, calcOf?.has(st) && this.def.name, dflt)
+            const cell = typeof st == 'string' ? keyCell(this.cell, st, calcOf?.has(pathOf$1(st)[0]) && this.def.name, dflt)
                 : st !== undefined ? lensCell(this.cell, st, this.def.name, (e) => app.appError(this, e, 'view'), dflt)
                     : def.isolated ? localCell(app, this.cell) : this.cell;
             const scope = app.scope();
@@ -2865,8 +2894,9 @@ class Inst {
  *
  * It stands where the `<Collection>` marker was in its owner's template and renders the items
  * inside the owner's render: no stream of its own, no pickCombine.
- * - `of`: a component function (D163: no names). `from`: a state key (SYG409 on a calculated
- *   one), a `{ get, set }` lens (SYG412 without get(); SYG401 for a non-array) or none (the
+ * - `of`: a component function (D163: no names). `from`: a state key or path ('board.cards';
+ *   SYG409 on a calculated first segment; SYG401 when it isn't an array: the dev entry's), a
+ *   `{ get, set }` lens (SYG412 without get(); SYG401 for a non-array) or none (the
  *   owner's state is the array).
  * - Items are keyed by `id`, an id-less item by its raw index (D169); one key -> index map per
  *   array identity serves every item (cell.ts indexer). A duplicate key renders its first element
@@ -2948,16 +2978,9 @@ function arrayCell(owner, from) {
             set: (v) => oc.set(v),
         };
     }
-    if (typeof from == 'string') {
-        const cs = oc.get(), calc = owner.def.calcNames?.has(from);
-        if (isObj$2(cs) && !(from in cs) && !calc) {
-            const arrays = Object.keys(cs).filter(k => Array.isArray(cs[k]));
-            warn('SYG401', name, `Collection from="${from}" is not in state${arrays.length ? ` (array fields: '${arrays.join("', '")}')` : ''}; it renders nothing until it exists`, 'Set it to an array in initialState');
-        }
-        else if (isObj$2(cs) && !Array.isArray(cs[from]))
-            warn('SYG401', name, `Collection 'from' field '${from}' is not an array; it renders nothing`, 'Set it to an array in initialState');
-        return keyCell(oc, from, calc && name, undefined, 'Collection');
-    }
+    // a key or a path ('board.cards'); SYG401 for one that isn't an array is the dev entry's (checks/collections.ts)
+    if (typeof from == 'string')
+        return keyCell(oc, from, owner.def.calcNames?.has(pathOf$1(from)[0]) && name, undefined, 'Collection');
     if (isObj$2(from) && typeof from.get == 'function') {
         let lp = {}, lv;
         return {
@@ -4166,7 +4189,7 @@ class SwitchableHost {
         this.lr = true;
         this.kids = [];
         check$3(owner, props);
-        const st = props.state, calc = typeof st == 'string' && owner.def.calcNames?.has(st);
+        const st = props.state, calc = typeof st == 'string' && owner.def.calcNames?.has(pathOf$1(st)[0]);
         this.cell = typeof st == 'string' ? keyCell(owner.cell, st, calc && owner.def.name, undefined, 'Switchable sub-component')
             : st !== undefined ? lensCell(owner.cell, st, owner.def.name, (e) => owner.app.appError(owner, e, 'view'))
                 : owner.cell;