sygnal 6.2.0 → 6.4.0

package/src/ai.ts

@@ -21,3 +21,9 @@ export {anthropicMessages, agui, fromAISDK, strictSchemas} from './index'
 export {makeMcpAppDriver} from './index'
 // A-3 (3-A3, experimental, D291)
 export {formTool} from './index'
+// PLAN-9 (A)
+export {defineCatalog, compose, composeWith, fromTree, toTree, removeNode} from './index'
+// PLAN-9 H: chat client tools and cards
+export {openToolCalls, askCard} from './index'
+// PLAN-9 M-1
+export {Composed} from './index'

package/src/collection.ts

@@ -1,5 +1,6 @@
 import {h} from './cycle/dom/snabbdom';
-// the core's handler for this marker, registered on import (D157)
+// the core's host for this marker, registered on import (D157): unlike Portal, Transition and
+// Suspense (G-751), not on first use, because the lowercase tag works without an import (docs)
 import './core/hosts/collection';
 
 /** `<Collection of={Item} from="items" />`: a marker vnode the core's Collection host renders */

package/src/core/instance.ts

@@ -52,12 +52,15 @@ function extractSlots(children: any[]): [any[], Record<string, any[]>] {
   return [slots.default || [], slots]
 }
 
-/** an instance's id among its parent's children: its `id` prop, else its path in the view */
+/**
+ * an instance's id among its parent's children (D456): its vnode `key`, else its `id` prop, else
+ * its path in the view
+ */
 const idOf = (n: any, path: string) => {
-  const id = n.data?.props?.id
+  const id = n.key ?? n.data?.props?.id
   let s: any
   // (G-298: an id JSON can't encode, a BigInt, is used as its string)
-  if (id) try { s = JSON.stringify(id) } catch (_) { s = String(id) }
+  if (id != null) try { s = JSON.stringify(id) } catch (_) { s = String(id) }
   return `${n.sel}::${(s && s.replace(/"/g, '')) || path}`
 }
 

package/src/core/markers/lazy.ts

@@ -1,5 +1,5 @@
 /**
- * PLAN-4.6 core: lazy() components (R2), registered on import by the public `lazy` module.
+ * PLAN-4.6 core: lazy() components (R2), registered by the first `lazy()` call (G-751).
  * A view resolver (registry `resolvers`): until the import resolves, the LazyWrapper itself is
  * the component (it renders the data-sygnal-lazy="loading" placeholder Suspense waits for, or
  * the error placeholder); once it has, the loaded component replaces it under the same id (a
@@ -15,7 +15,7 @@ import {resolvers} from '../registry'
 /** wrapper -> the owners waiting for it (`done`: settled, nobody waits any more) */
 export const waiting = new WeakMap<any, Set<any> & {done?: boolean}>()
 
-resolvers.push((view, owner) => {
+const resolve = (view: any, owner: any) => {
   if (!view.__sygnalLazy) return
   if (view.__sygnalLazyLoaded()) return view.__sygnalLazyLoadedComponent || undefined
   let w = waiting.get(view)
@@ -37,4 +37,8 @@ resolvers.push((view, owner) => {
     set.add(owner)
     owner.dispose$?.().addListener({next: () => set.delete(owner)})
   }
-})
+}
+
+let on: any
+/** G-751: registers the resolver once; `lazy()` calls it, not the module's import */
+export const enableLazy = () => { on ||= resolvers.push(resolve) }

package/src/core/markers/portal.ts

@@ -1,5 +1,5 @@
 /**
- * PLAN-4.6 core: the Portal marker (R2), registered on import by the public `Portal` module.
+ * PLAN-4.6 core: the Portal marker (R2), registered by the public `Portal` when used (G-751).
  * A template rewrite (registry `pres`): the `portal` marker becomes a hidden placeholder whose
  * hooks patch its children into the target with a separate snabbdom patch function. As today
  * (the 5.x core's createPortalPlaceholder):
@@ -93,4 +93,7 @@ export function portalPlaceholder(target: string, children: any[]): any {
   }
 }
 
-pres.portal = (n) => portalPlaceholder(n.data?.props?.target, n.children || [])
+// (widgets among its children: `pres.widget.$k` rewrites them, extra/widget.ts; the core doesn't walk them)
+const pre = (n: any, o: any, x: string) => portalPlaceholder(n.data?.props?.target, (pres.widget as any)?.$k(n.children || [], o, x) || n.children || [])
+/** G-751: registers the rewrite; the public `Portal` calls it when used (its `$reg`), not on import */
+export const enablePortal = () => { pres.portal = pre }

package/src/core/markers/suspense.ts

@@ -1,5 +1,5 @@
 /**
- * PLAN-4.6 core: Suspense (R2), registered on import by the public `Suspense` module. A
+ * PLAN-4.6 core: Suspense (R2), registered by the public `Suspense` when used (G-751). A
  * post-processor (registry `posts`) of the injected vnode of an instance whose template has a
  * `suspense` marker (the 5.x core's processSuspensePost):
  * - the core injects a child whose READY is false with data-sygnal-ready="false", and a lazy
@@ -38,4 +38,5 @@ export function suspensePost(v: any): any {
   return out ? {...v, children: out} : v
 }
 
-posts.suspense = suspensePost
+/** G-751: registers the post-processor; the public `Suspense` calls it when used (its `$reg`) */
+export const enableSuspense = () => { posts.suspense = suspensePost }

package/src/core/markers/transition.ts

@@ -1,6 +1,6 @@
 /**
- * PLAN-4.6 core: the Transition marker (R2), registered on import by the public `Transition`
- * module. A template rewrite (registry `pres`): the `transition` marker is replaced by its first
+ * PLAN-4.6 core: the Transition marker (R2), registered by the public `Transition`
+ * when used (G-751). A template rewrite (registry `pres`): the `transition` marker is replaced by its first
  * child (walked on, at the marker's path), with snabbdom hooks that add the classes as today
  * (the 5.x core's applyTransitionHooks):
  * `${name}-enter|leave-from` + `-active`, two frames later `-from` becomes `-to`, and at the end
@@ -57,7 +57,7 @@ export function transitionHooks(vnode: any, p: {name?: string, duration?: number
 // (no global symbol registry entry per name)
 const T = Symbol()
 
-pres.transition = (n) => {
+const pre = (n: any) => {
   const child = n.children?.[0], p = n.data?.props || {}, k = p.name + ' ' + p.duration
   // no element child: the text child (or the marker itself, left as it is: today's behaviour)
   if (!child?.sel) return child || n
@@ -68,3 +68,6 @@ pres.transition = (n) => {
   // fragment or text has no element to animate: nothing happens
   return child.sel == 'collection' ? {...child, data: {...child.data, tr: (v: any) => (v[T] ||= {})[k] ||= transitionHooks(v, p)}} : transitionHooks(child, p)
 }
+
+/** G-751: registers the rewrite; the public `Transition` calls it when used (its `$reg`) */
+export const enableTransition = () => { pres.transition = pre }

package/src/core/registry.ts

@@ -1,9 +1,13 @@
 /**
- * PLAN-4.6 core: the module registries (04-hooks-contract §2.1). A feature module fills them
- * when it is imported; the core only looks them up, so an app that never imports the module pays
- * nothing (D157). R2 fills hosts (core/hosts: Collection, Switchable) and the markers
- * (core/markers: Portal, Transition, ClientOnly, Suspense, lazy), each imported by its public
- * module; R3 adds the definition hooks (behaviors, undo, selection, pager, persist, resources).
+ * PLAN-4.6 core: the module registries (04-hooks-contract §2.1). A feature fills them when it is
+ * used; the core only looks them up, so an app that never uses the feature pays nothing (D157).
+ * R2 fills hosts (core/hosts: Collection, Switchable) and the markers (core/markers: Portal,
+ * Transition, ClientOnly, Suspense, lazy). G-751: Portal, Transition and Suspense register their
+ * handler when a tag uses them (the pragma calls the marker's `$reg`) and `lazy()` its resolver,
+ * not on import: a module-level registration is kept by every bundle of the single-file build.
+ * Collection and Switchable register on import (the lowercase `<collection>` / `<switchable>`
+ * work without one); ClientOnly's is in runtime.ts (sygnal/vike can't reach the registry). R3
+ * adds the definition hooks (behaviors, undo, selection, pager, persist, resources).
  *
  * The entries are core modules: they get the owner's raw instance (hooks get InstanceViews).
  */

package/src/cycle/dom/IsolateModule.ts

@@ -81,25 +81,25 @@ export class IsolateModule {
 
   public createModule() {
     const self = this;
-    // G-564: a vnode can be in the old tree and the new one (a component's cached vnode, a
-    // Collection item's copy, a hoisted vnode). When an ancestor is recreated (`alt ? <ol>{c}</ol>
-    // : <ul>{c}</ul>`, a new key), snabbdom creates it again and gives it the new element before it
-    // destroys the old subtree, so destroy hooks saw the new element (a widget inside wasn't
-    // unmounted, its scope lost the new element). A created element notes its children's elements
-    // (M: a child with one is mounted, or was), before they are created; a destroyed vnode gives
-    // its noted children their old elements back for their destroy hooks (and theirs, down the
-    // subtree), and they get the new ones again when the removal starts (S), before the insert
-    // hooks. (A vnode that moves to another parent still gives its own destroy hook the new one)
-    const M = new Map<any, any>(), S: any[] = [];
-    // G-573: a vnode in the new tree twice: its first note (its element before the patch) wins.
-    // A destroy hook that throws ends the patch before remove / post: the next patch first gives
-    // the vnodes their new elements back and forgets the notes (pre)
-    const back = (c: any) => M.has(c) && (S.push(c, c.elm), c.elm = M.get(c));
-    const ret = () => { for (let e; S.length; ) e = S.pop(), S.pop().elm = e; };
+    // G-564, G-750, G-753: a vnode can be in the old tree and the new one (a component's cached
+    // vnode, a Collection item's copy, a hoisted vnode). Under another parent element (a recreated
+    // ancestor: `alt ? <ol>{c}</ol> : <ul>{c}</ul>`; a keyed instance moved to another column, or
+    // into a new row that takes its old place among its siblings) snabbdom created it again and
+    // gave it the new element while the old tree still had it: its destroy hooks saw the new
+    // element (a widget inside wasn't unmounted, its scope lost the new element), its old parent
+    // removed the new element and left the old one (G-750), or inserted a new sibling before it,
+    // inside that sibling (NotFoundError, the patch stopped: G-753). Now an element that is
+    // created or patched takes a copy of each child that has an element and isn't one of its old
+    // children (only a mounted vnode has one), before it is created: the old tree keeps the vnode
+    // and its element. The copy's children array is its own, so its children are copied when it
+    // is created. After the patch (post) each vnode takes its copy's fields (its element) and its
+    // place again, so the next patch sees the same vnode (snabbdom's shortcut). A patch that
+    // throws keeps the copies (pre forgets them): they still work, as copies
+    const R: any[] = [];
+    const copy = (a: any[], i: number) => { R.push(a, i, a[i]); a[i] = {...a[i], children: a[i].children?.slice()} };
     return {
       pre() {
-        ret();
-        M.clear();
+        R.length = 0;
       },
 
       create(emptyVNode: VNode, vNode: VNode) {
@@ -109,7 +109,7 @@ export class IsolateModule {
         if (Array.isArray(namespace)) {
           self.insertElement(namespace, elm as Element);
         }
-        children?.forEach((c: any) => c?.elm && M.set(c, M.get(c) || c.elm));
+        children?.forEach((c: any, i: number) => c?.elm && copy(children, i));
       },
 
       update(oldVNode: VNode, vNode: VNode) {
@@ -126,21 +126,25 @@ export class IsolateModule {
         if (Array.isArray(namespace)) {
           self.insertElement(namespace, elm as Element);
         }
+        // (oldVNode !== vNode here: snabbdom returns early for the same vnode; the Set only when a
+        // child isn't at its old index)
+        const oc = oldVNode.children, nc: any = vNode.children
+        let o: any
+        nc?.forEach((c: any, i: number) => c?.elm && c !== oc?.[i] && !(o ||= new Set(oc)).has(c) && copy(nc, i));
       },
 
-      // (the elements as they are now: post runs after the vnodes got their new ones back)
       destroy(vNode: VNode) {
-        vNode.children?.forEach(back);
         self.vnodesBeingRemoved.push(vNode.elm as Element);
       },
 
       remove(vNode: VNode, cb: Function) {
         self.vnodesBeingRemoved.push(vNode.elm as Element);
-        ret();
         cb();
       },
 
       post() {
+        for (let i = 0; i < R.length; i += 3) R[i][R[i + 1]] = Object.assign(R[i + 2], R[i][R[i + 1]]);
+        R.length = 0;
         // G-144: a removed root element is no longer one of its scope's roots (an element no
         // scope has as a root isn't in any set: removing it does nothing)
         for (const elm of self.vnodesBeingRemoved) {
@@ -148,7 +152,6 @@ export class IsolateModule {
           (self.eventDelegator as EventDelegator).removeElement(elm);
         }
         self.vnodesBeingRemoved = [];
-        M.clear();
       },
     };
   }