sygnal 6.4.0 → 6.6.0

package/dist/diagnostics.cjs.js

@@ -143,6 +143,9 @@ const CODE_TITLES = {
     SYG127: 'Behavior collision or unresolvable uses entry',
     SYG128: 'Duplicate control key',
     SYG129: "CHILD.select() of a component this one doesn't render",
+    // PLAN-10 X-1 (D512): graph-wide checks, static only (sygnal-check)
+    SYG170: 'Context field read with no provider',
+    SYG171: 'PARENT sink no parent reads',
     SYG112: 'Reply action has no model entry',
     SYG130: 'href() names no route or leaves out a param',
     SYG131: 'Route params the pattern does not use',
@@ -272,6 +275,8 @@ const CODE_TITLES = {
     // checks/next.ts and sygnal-check: a component reference that is not a function (an import of
     // a name the module doesn't export is undefined under Vitest)
     SYG427: 'CHILD.select() of something that is not a component',
+    // 6.5.0 (checks/next.ts): state="a.b" / from="a.b" is a path; the parent state has a literal "a.b" key
+    SYG428: 'A state path that names a key containing a dot',
     // PLAN-9 (D470): checks/next.ts; dev entry
     SYG453: 'Two children with the same identity share one instance',
     SYG601: "Retired in 6.0: Missing or invalid sources",
@@ -414,6 +419,9 @@ const DEV_CODE_SEVERITY = {
     SYG128: 'error',
     // PLAN-4 4-G2: static only (sygnal-check); listed so the entry knows its title
     SYG129: 'warn',
+    // PLAN-10 X-1: static only (sygnal-check)
+    SYG170: 'warn',
+    SYG171: 'warn',
     SYG221: 'error',
     // PLAN-4 GS-4 (state.ts)
     SYG222: 'warn',
@@ -480,6 +488,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',
@@ -1153,25 +1163,44 @@ function checkCollection(component, el) {
             state = component.addCalculated(state);
     }
     catch (_) { }
-    let problem;
-    let fix = `Pass the name of an array field in ${name}'s state, e.g. <Collection of={${ofName}} from="items" />, and initialize that field to [] in initialState`;
-    // Every defined `from` (string field, lens object, or an invalid value) is reported by
-    // the core itself (SYG401/SYG412, retrofitted in 1E) in every diagnostics mode (D22), so
-    // this check only covers a missing `from`.
+    if (typeof from === 'string')
+        return checkFrom(component, name, from, ofName, state);
+    // a lens or an invalid value: the core's (SYG401 / SYG412)
     if (from !== undefined)
         return;
-    if (!Array.isArray(state) && !(state && Array.isArray(state.value))) {
-        problem = `has no 'from' prop, so it uses ${name}'s whole state, which is ${describe$1(state)}, not an array`;
-    }
-    if (!problem || !once(`SYG401:${name}:undefined`))
+    if (Array.isArray(state) || (state && Array.isArray(state.value)))
+        return;
+    if (!once(`SYG401:${name}:undefined`))
         return;
     reportSafely('SYG401', {
         component,
-        message: `<Collection of={${ofName}}> ${problem}, so it renders no items`,
-        fix,
+        message: `<Collection of={${ofName}}> has no 'from' prop, so it uses ${name}'s whole state, which is ${describe$1(state)}, not an array, so it renders no items`,
+        fix: `Pass the name of an array field in ${name}'s state, e.g. <Collection of={${ofName}} from="items" />, and initialize that field to [] in initialState`,
         data: { from: 'undefined', of: ofName },
     });
 }
+/** `from` a key or a path ('board.cards', 'boards[0].cards'), as the core reads it (cell.ts pathOf) */
+function checkFrom(component, name, from, ofName, state) {
+    const ks = from.replace(/\[(\d+)\]/g, '.$1').split('.');
+    const calc = component._calculatedFieldNames;
+    if (calc?.has?.(ks[0]))
+        return;
+    const at = ks.slice(0, -1).reduce((o, k) => (o == null ? o : o[k]), state), last = ks[ks.length - 1];
+    if (!isPlainObject(at) && !Array.isArray(at))
+        return; // a level still missing: renders once it appears (D178)
+    let message;
+    if (!(last in at)) {
+        const arrays = Object.keys(at).filter(k => Array.isArray(at[k]));
+        message = `Collection from="${from}" is not in state${arrays.length ? ` (array fields: '${arrays.join("', '")}')` : ''}; it renders nothing until it exists`;
+    }
+    else if (!Array.isArray(at[last]))
+        message = `Collection 'from' field '${from}' is not an array; it renders nothing`;
+    else
+        return;
+    if (!once(`SYG401:${name}:${from}`))
+        return;
+    reportSafely('SYG401', { component, message, fix: 'Set it to an array in initialState', data: { from, of: ofName } });
+}
 const WRAPPED = '__sygnalDiagWrapped';
 const collectionsCheck = {
     id: 'collections',
@@ -1244,7 +1273,7 @@ onReset(() => {
 });
 /** the control that rendered a vnode (only while the dev entry is installed) */
 const controlOfVnode = (vnode) => vnode && typeof vnode == 'object' ? vnodeControls.get(vnode) : undefined;
-const STATICS$1 = ['intent', 'model', 'initialState'];
+const STATICS$2 = ['intent', 'model', 'initialState'];
 const describe = (v) => v === undefined || v === null ? String(v)
     : Array.isArray(v) ? `an array of ${v.length}`
         : typeof v != 'object' ? `a ${typeof v} (${JSON.stringify(v)})`
@@ -1258,7 +1287,7 @@ function onControl(control, vnode) {
         vnodeControls.set(vnode, control);
     if (!staticsSeen.has(control)) {
         staticsSeen.add(control);
-        const given = STATICS$1.filter(s => control[s] != null);
+        const given = STATICS$2.filter(s => control[s] != null);
         if (given.length) {
             devReport('SYG125', {
                 message: `The control ${key} has ${given.map(s => '.' + s).join(', ')}, but controls are elements, not components: ${given.length > 1 ? 'these statics are' : 'it is'} never used`,
@@ -3455,6 +3484,9 @@ const slim = (d) => {
         out.fix = d.fix;
     if (d.docsUrl)
         out.docsUrl = d.docsUrl;
+    // PLAN-10 P-1: when it was reported (runtime diagnostics are reported once per process)
+    if (typeof d.timestamp === 'number')
+        out.timestamp = d.timestamp;
     if (d.data !== undefined) {
         // keep it JSON-safe (data can hold errors, vnodes, ...)
         try {
@@ -3558,12 +3590,61 @@ function childrenOf(r, all) {
         const key = `${c.name}\u0000${via[c.kind]}`;
         const entry = out.get(key);
         if (entry)
-            entry.count = (entry.count || 1) + 1;
+            entry.count = entry.ids.push(c.id);
         else
-            out.set(key, { name: c.name, via: via[c.kind], count: 1 });
+            out.set(key, { name: c.name, via: via[c.kind], count: 1, ids: [c.id] });
     }
     return [...out.values()];
 }
+/** the statics sygnal-check reads (its STATIC_PROPS): a component function with none is view-only */
+const STATICS$1 = ['intent', 'model', 'initialState', 'isolatedState', 'context', 'calculated', 'connections', 'resources', 'route', 'head', 'uses', 'timers', 'persist', 'viewTransitions', 'browser', 'agent'];
+/** PLAN-10 D522: no statics and nothing the core added (renderComponent's test intent, a behavior's model) */
+function isViewOnly(c) {
+    const def = c && c.__next && c.__next.def;
+    if (!def || def.intent || (def.handlers && def.handlers.size) || def.initialState !== undefined)
+        return false;
+    const fn = def.view;
+    return !!fn && STATICS$1.every(k => fn[k] === undefined);
+}
+/** PLAN-10 P-2 (D544): the static key sygnal/vite's dev transform stamped on the component function */
+function stampedKey(c) {
+    const fn = c && c.__next && c.__next.def && c.__next.def.view;
+    const k = fn && fn.__sygnalKey;
+    return typeof k === 'string' ? k : undefined;
+}
+/** PLAN-10 D530: the context keys the instance's latest render read (InstanceView.reads); every key when it read them all */
+function contextReadsOf(c) {
+    const v = c && c.__next;
+    const reads = v && v.reads;
+    if (!reads)
+        return [];
+    const out = [...reads].filter(k => k !== '\u0000all');
+    if (reads.has('\u0000all')) {
+        try {
+            for (const k of Object.keys(v.context || {}))
+                if (!out.includes(k))
+                    out.push(k);
+        }
+        catch (_) { /* no context */ }
+    }
+    return out;
+}
+/** PLAN-10 D522: the app (run()) of each instance: the index of its root among the live roots, oldest first */
+function appsOf(all) {
+    const byId = new Map(all.map(r => [r.id, r]));
+    const roots = all.filter(r => r.parentId === null).sort((a, b) => Number(a.id) - Number(b.id));
+    const index = new Map(roots.map((r, i) => [r, i]));
+    const out = new Map();
+    for (const r of all) {
+        let top = r;
+        for (let n = 0; top && top.parentId !== null && n < 10000; n++)
+            top = byId.get(top.parentId);
+        const i = top && index.get(top);
+        if (i !== undefined)
+            out.set(r, i);
+    }
+    return out;
+}
 /** The app graph of the live component instances (see ./public.d.ts). */
 function inspect(options = {}) {
     // report SYG105 (info) for EVENTS types selected but never emitted so far
@@ -3588,21 +3669,28 @@ function inspect(options = {}) {
     const ids = options.ids && new Set(options.ids.map(String));
     const recs = ids ? all.filter(r => ids.has(r.id)) : all;
     const names = new Set(recs.map(r => r.name));
+    const apps = appsOf(all);
     const components = recs.map(r => {
         const c = r.instance;
         const calculated = c && c.calculated && typeof c.calculated === 'object' ? Object.keys(c.calculated) : [];
         const selectors = selectorsOf(r, options, diags);
         const controls = controlsOf(r, selectors);
+        const key = stampedKey(c);
         return {
             name: r.name,
             id: r.id,
+            ...(key ? { key } : {}),
             parentId: r.parentId,
             kind: r.kind,
+            ...(isViewOnly(c) ? { viewOnly: true } : {}),
+            ...(r.parentId === null ? { entry: true } : {}),
+            ...(apps.has(r) ? { app: apps.get(r) } : {}),
+            ...(c && c.__next && c.__next.shown === false ? { shown: false } : {}),
             actions: actionsOf(r),
             stateKeys: stateKeysOf(c, calculated),
             calculated,
             contextProvides: c && isPlainObject(c.context) ? Object.keys(c.context) : [],
-            contextConsumes: null,
+            contextConsumes: contextReadsOf(c),
             eventsEmitted: [...r.eventsEmitted],
             eventsSelected: [...r.eventsSelected],
             children: childrenOf(r, all),
@@ -3614,14 +3702,21 @@ function inspect(options = {}) {
     });
     const cache = cacheOf(recs) || {};
     const events = {};
-    const ev = (type) => events[type] || (events[type] = { emitters: [], selectors: [] });
+    // names once each (as before); PLAN-10 D522: every instance's id in emitterIds / selectorIds
+    const ev = (type) => events[type] || (events[type] = { emitters: [], selectors: [], emitterIds: [], selectorIds: [] });
     const add = (list, name) => { if (!list.includes(name))
         list.push(name); };
     for (const c of components) {
-        for (const t of c.eventsEmitted)
-            add(ev(t).emitters, c.name);
-        for (const t of c.eventsSelected)
-            add(ev(t).selectors, c.name);
+        for (const t of c.eventsEmitted) {
+            const e = ev(t);
+            add(e.emitters, c.name);
+            e.emitterIds.push(c.id);
+        }
+        for (const t of c.eventsSelected) {
+            const e = ev(t);
+            add(e.selectors, c.name);
+            e.selectorIds.push(c.id);
+        }
     }
     // emitted on the bus by something that isn't a listed component (e.g. a driver, a pruned component)
     if (!ids)
@@ -3736,6 +3831,22 @@ function removed(component, name, anchor, detail) {
         data: { form: anchor, guide: `${MIGRATE}#${anchor}`, ...(detail ? { detail } : {}) },
     });
 }
+/**
+ * SYG428 (6.5.0): `state="a.b"` / `from="a.b"` is a path, read as `state.a.b`. Before 6.5.0 it was
+ * one key named "a.b"; when the owner's state still has such a key, the designator now misses it.
+ */
+function dottedKey(f, what, designator, ownerState) {
+    if (typeof designator != 'string' || !/[.[]/.test(designator) || !isPlainObject(ownerState))
+        return;
+    if (!Object.prototype.hasOwnProperty.call(ownerState, designator) || !once(`SYG428:${f.name}:${designator}`))
+        return;
+    devReport('SYG428', {
+        component: f.name,
+        message: `${what}="${designator}" is a path (since 6.5.0), read as ${designator.replace(/\[(\d+)\]/g, '.$1').split('.').map((k) => `[${JSON.stringify(k)}]`).join('')}, but the state has a key named "${designator}"`,
+        fix: `Rename the key so it has no dot (and point ${what} at it), or use a lens: ${what}={{ get: (s) => s['${designator}'], set: (s, v) => ({ ...s, '${designator}': v }) }}`,
+        data: { designator, what },
+    });
+}
 /** SYG427: CHILD.select(x) with no component (an import of a name the module doesn't export) */
 function notComponent(f, x) {
     if (!once(`SYG427:${f.name}`))
@@ -4102,12 +4213,18 @@ function nextHooks(_api) {
     // G-527: one chain of SYG149 checks over the latest patches (G-501: it stops once every instance
     // that renders a named Collection is disposed, the app's dispose included)
     const vtCheck = vtChecker(() => vtp.size && on());
+    // SYG428: the live instances by id, to read a child's parent state
+    const live = new Map();
     return {
         onCreate(iv) {
+            live.set(iv.id, iv);
             if (!on())
                 return;
             log.onCreate(iv);
             const f = fac(iv);
+            const parent = live.get(iv.parentId);
+            if (parent)
+                dottedKey(f, `<${f.name} state`, iv.props?.state, parent.state);
             removedStatics(f);
             if (!iv.def.intent)
                 wire(iv, []);
@@ -4166,6 +4283,7 @@ function nextHooks(_api) {
         },
         onDispose(iv) {
             vtp.delete(iv);
+            live.delete(iv.id);
             H.onDispose(fac(iv));
         },
         onAction(iv, a) { log.onAction(iv, a); },
@@ -4213,6 +4331,7 @@ function nextHooks(_api) {
                 checkCollection(f, { data: { props } });
             }
             catch (_) { /* ignore */ }
+            dottedKey(f, `<${sel == 'collection' ? 'Collection' : 'VirtualCollection'} from`, props.from, owner.state);
             // G-419: SYG148 for a prefix that isn't an identifier; a valid one is checked for
             // duplicate names after each patch (SYG149). G-460: a falsy one names nothing (as the host)
             const p = props.viewTransitionName;