sygnal 5.4.0 → 6.0.0

package/src/core/teardown.ts

@@ -0,0 +1,60 @@
+/**
+ * PLAN-4.6 core: teardown without timers (D165 / Q18). xstream stops a stream left without
+ * listeners in a setTimeout of its own (1-2k timers to unmount 1k components). While an instance
+ * unsubscribes (tearDown), Stream.prototype._remove queues such a stream instead (_stopID 0: an
+ * _add before the stop cancels it, as xstream's clearTimeout would), and stopQueued() stops the
+ * queue at the first macrotask after the drain / flush (G-302: xstream's timing; the runtime's
+ * setImmediate / MessageChannel ping, no setTimeout). The swap is scoped to the call (PLAN-4.5's
+ * tearDown, narrowed; R5 deleted the 5.x core's permanent one).
+ */
+import xs from '../extra/xstreamCompat'
+
+// G-315: probed on first use (a top-level probe would survive the D175 strip of production builds)
+let SP: any, NO: any, down: any[] | null = null, outer: any, owner: any
+// G-342/G-267: the instance a queued stream was left by (its stop() error is reported for it)
+const owners = new WeakMap<object, any>()
+const probe = () => { if (!SP) { const s: any = xs.create(); SP = Object.getPrototypeOf(s); NO = s._prod } }
+
+function removeQueued(this: any, il: any) {
+  if (this._target) return this._target._remove(il)
+  const a = this._ils, i = a.indexOf(il)
+  if (i < 0) return
+  a.splice(i, 1)
+  if (this._prod !== NO && !a.length) { this._err = NO; this._stopID = 0; down!.push(this); if (owner) owners.set(this, owner) }
+  else if (a.length == 1) this._pruneCycles()
+}
+
+/** run f with _remove queuing into q (nested calls share the outermost swap); `by`: the instance */
+export function tearDown(f: () => void, q: any[], by?: any) {
+  probe()
+  const prev = down, prevBy = owner
+  if (!prev) { outer = SP._remove; SP._remove = removeQueued }
+  down = q
+  if (by) owner = by
+  try { f() } finally { down = prev; owner = prevBy; if (!prev) SP._remove = outer }
+}
+
+/**
+ * stop the queued streams; a stop that leaves its upstream without listeners queues it here too.
+ * A throwing stop() (a producer's) stops nothing else from stopping; G-342/G-267: it is reported
+ * through `err` (with the instance that left the stream), not swallowed
+ */
+export function stopQueued(q: any[], err?: (e: any, by: any) => void) {
+  probe()
+  for (let i = 0; i < q.length; i++) {
+    const s = q[i]
+    if (s._stopID === 0 && !s._ils.length) {
+      s._stopID = NO
+      const by = owners.get(s)
+      tearDown(() => { if (s._prod !== NO) try { s._stopNow() } catch (e) { err?.(e, by) } }, q, by)
+    }
+  }
+  q.length = 0
+}
+
+/** the instance behind an intent's sources object (the source getters read it) */
+export const INST = /*#__PURE__*/ Symbol('sygnal.inst')
+/** the queue's action type for a state write (runtime setState, a child's seeded slice) */
+export const SET = /*#__PURE__*/ Symbol('setState')
+/** a child's seeded slice (D174), written even when it reads its initialState as the default */
+export const SEED = /*#__PURE__*/ Symbol('seed')

package/src/core/view.ts

@@ -0,0 +1,37 @@
+/**
+ * PLAN-4.6 core: the read-only InstanceView hooks and tools get (04 §2.3), never the raw
+ * instance. Made on the first hook call that needs it (an app without hooks makes none).
+ */
+import type {InstanceView} from './hooks'
+import type {Inst} from './instance'
+
+class View implements InstanceView {
+  constructor(private i: Inst) {}
+  get id() { return this.i.id }
+  get parentId() { return this.i.parent?.id }
+  get name() { return this.i.def.name }
+  get def() { return this.i.def }
+  get state() { return this.i.cell.get() }
+  get props() { return this.i.props }
+  get context() { return this.i.context() }
+  get isRoot() { return !this.i.parent }
+  get kind() { return this.i.kind }
+  /** false on a hidden Switchable page and below it */
+  get shown() {
+    for (let i: any = this.i; i; i = i.parent) if (!i.shown) return false
+    return true
+  }
+  get disposed() { return this.i.disposed }
+  get uid() { return this.i.uidBase }
+  get sources() { return this.i.sources() }
+  children(): InstanceView[] {
+    const out: InstanceView[] = []
+    this.i.kids.forEach((k: any) => {
+      if (k.def && k.app) out.push(viewOf(k))
+      else if (k.insts) for (const j of k.insts()) out.push(viewOf(j))
+    })
+    return out
+  }
+}
+
+export const viewOf = (i: Inst): InstanceView => (i.iv ||= new View(i))

package/src/cycle/dom/DocumentDOMSource.ts

@@ -12,20 +12,22 @@ export class DocumentDOMSource {
     this._selector = selector || null;
   }
 
+  // CT-1: a control works as is: querySelectorAll() and matches() stringify their argument,
+  // and a control stringifies to its selector
   public select(selector: string): DocumentDOMSource {
     return new DocumentDOMSource(this._name, selector);
   }
 
   public elements(): MemoryStream<Array<Document | Element>> {
     if (this._selector) {
-      const out: DevToolEnabledSource & MemoryStream<Array<Element>> = adapt(
-        xs.of(Array.from(document.querySelectorAll(this._selector)))
+      const out: DevToolEnabledSource & MemoryStream<Array<Document | Element>> = adapt(
+        xs.of<Array<Document | Element>>(Array.from(document.querySelectorAll(this._selector)))
       );
       out._isCycleSource = this._name;
       return out;
     }
-    const out: DevToolEnabledSource & MemoryStream<Array<Document>> = adapt(
-      xs.of([document])
+    const out: DevToolEnabledSource & MemoryStream<Array<Document | Element>> = adapt(
+      xs.of<Array<Document | Element>>([document])
     );
     out._isCycleSource = this._name;
     return out;
@@ -33,14 +35,14 @@ export class DocumentDOMSource {
 
   public element(): MemoryStream<Document | Element | null> {
     if (this._selector) {
-      const out: DevToolEnabledSource & MemoryStream<Element | null> = adapt(
-        xs.of(document.querySelector(this._selector))
+      const out: DevToolEnabledSource & MemoryStream<Document | Element | null> = adapt(
+        xs.of<Document | Element | null>(document.querySelector(this._selector))
       );
       out._isCycleSource = this._name;
       return out;
     }
-    const out: DevToolEnabledSource & MemoryStream<Document> = adapt(
-      xs.of(document)
+    const out: DevToolEnabledSource & MemoryStream<Document | Element | null> = adapt(
+      xs.of<Document | Element | null>(document)
     );
     out._isCycleSource = this._name;
     return out;
@@ -51,6 +53,9 @@ export class DocumentDOMSource {
     options?: EventsFnOptions,
     bubbles?: boolean
   ): EnrichedEventStream<DocumentEventMap[K]>;
+  // PLAN-5 0-S6: any other name (a custom element's 'wa-hover', a widget's or element's
+  // CustomEvent): the overload above only typed the built-in names (types only)
+  public events(eventType: string, options?: EventsFnOptions, bubbles?: boolean): EnrichedEventStream<Event>;
   public events(
     eventType: string,
     options: EventsFnOptions = {},

package/src/cycle/dom/ElementFinder.ts

@@ -18,20 +18,18 @@ export class ElementFinder {
     const selector = getSelectors(namespace);
 
     const scopeChecker = new ScopeChecker(namespace, this.isolateModule);
-    const topNode = this.isolateModule.getElement(
+    // G-144: every root element of the scope (a fragment-rooted component has several)
+    const topNodes = this.isolateModule.getElements(
       namespace.filter(n => n.type !== 'selector')
     );
 
-    if (topNode === undefined) {
-      return [];
-    }
-
     if (selector === '') {
-      return [topNode];
+      return topNodes;
     }
 
-    return toElArray(topNode.querySelectorAll(selector))
-      .filter(scopeChecker.isDirectlyInScope, scopeChecker)
-      .concat(topNode.matches(selector) ? [topNode] : []);
+    return topNodes.reduce((out: Array<Element>, topNode) => out.concat(
+      toElArray(topNode.querySelectorAll(selector)).filter(scopeChecker.isDirectlyInScope, scopeChecker),
+      topNode.matches(selector) ? [topNode] : []
+    ), []);
   }
 }