sygnal 5.3.6 → 5.4.0

package/src/extra/flatten.ts

@@ -0,0 +1,75 @@
+/**
+ * ESM ports of xstream's `flattenConcurrently` and `flattenSequentially` extras
+ * (xstream, MIT, André Staltz), behaviour-identical.
+ *
+ * Why not re-export 'xstream/extra/*': those modules are CommonJS, and a bundler keeps a
+ * CJS module that an ESM module re-exports even when the app never uses it (G-055: +300 B
+ * gzip in the kanban bundle). ESM classes are tree-shaken when unused.
+ */
+import {Stream} from 'xstream'
+
+class Inner {
+  constructor(public out: any, public op: any) {}
+  _n(t: any) { this.out._n(t) }
+  _e(err: any) { this.out._e(err) }
+  _c() { this.op.less() }
+}
+
+class FlattenConcOperator {
+  type = 'flattenConcurrently'
+  active = 1 // outers and inners that have not yet ended
+  out: any = null
+  constructor(public ins: any) {}
+  _start(out: any) { this.out = out; this.ins._add(this) }
+  _stop() { this.ins._remove(this); this.active = 1; this.out = null }
+  less() { if (--this.active === 0 && this.out) this.out._c() }
+  _n(s: any) { if (this.out) { this.active++; s._add(new Inner(this.out, this)) } }
+  _e(err: any) { if (this.out) this.out._e(err) }
+  _c() { this.less() }
+}
+
+class FlattenSeqOperator {
+  type = 'flattenSequentially'
+  out: any = null
+  open = true
+  active: any = null
+  activeIL: any = null
+  seq: any[] = []
+  constructor(public ins: any) {}
+  _start(out: any) {
+    this.out = out; this.open = true; this.active = null
+    this.activeIL = new Inner(out, this); this.seq = []
+    this.ins._add(this)
+  }
+  _stop() {
+    this.ins._remove(this)
+    if (this.active && this.activeIL) this.active._remove(this.activeIL)
+    this.open = true; this.active = null; this.activeIL = null; this.seq = []; this.out = null
+  }
+  less() {
+    this.active = null
+    if (this.seq.length > 0) this._n(this.seq.shift())
+    if (!this.open && !this.active) this.out._c()
+  }
+  _n(s: any) {
+    if (!this.out) return
+    if (this.active) this.seq.push(s)
+    else { this.active = s; s._add(this.activeIL) }
+  }
+  _e(err: any) { if (this.out) this.out._e(err) }
+  _c() {
+    if (!this.out) return
+    this.open = false
+    if (!this.active && this.seq.length === 0) this.out._c()
+  }
+}
+
+/** Flattens a stream of streams, imitating every nested stream at once (RxJS mergeAll). */
+export function flattenConcurrently<T>(ins: Stream<Stream<T>>): Stream<T> {
+  return new Stream<T>(new FlattenConcOperator(ins) as any)
+}
+
+/** Flattens a stream of streams one at a time, buffering the rest in order (RxJS concatAll). */
+export function flattenSequentially<T>(ins: Stream<Stream<T>>): Stream<T> {
+  return new Stream<T>(new FlattenSeqOperator(ins) as any)
+}

package/src/extra/reducers.ts

@@ -39,6 +39,17 @@ export function toggle<S = any>(field: keyof S & string): (state: S) => S {
   return (state) => ({ ...state, [field]: !state[field] })
 }
 
+// event(type, payload?) → EVENTS sink fn for the object form:
+// `ACTION: { EVENTS: event('TYPE', (state, data) => payload) }` (static payloads allowed)
+export function event(
+  type: string,
+  payload?: any | ((state: any, data: any, next: Function, props: any) => any)
+): (state: any, data: any, next: Function, props: any) => { type: string; data: any } {
+  return typeof payload === 'function'
+    ? (state, data, next, props) => ({ type, data: payload(state, data, next, props) })
+    : () => ({ type, data: payload })
+}
+
 // ── emit() ─────────────────────────────────────────────────────────
 /**
  * Create a model entry that emits an EVENTS bus event.
@@ -56,9 +67,5 @@ export function emit(
   type: string,
   data?: any | ((state: any, actionData: any, next: Function, props: any) => any)
 ): { EVENTS: (state: any, actionData: any, next: Function, props: any) => { type: string; data: any } } {
-  return {
-    EVENTS: typeof data === 'function'
-      ? (state, actionData, next, props) => ({ type, data: data(state, actionData, next, props) })
-      : () => ({ type, data }),
-  }
+  return { EVENTS: event(type, data) }
 }

package/src/extra/run.ts

@@ -5,11 +5,15 @@ import eventBusDriver from './eventDriver';
 import logDriver from './logDriver';
 import component, {ABORT} from '../component';
 import {getDevTools} from './devtools';
+import {configureDiagnostics} from './diagnostics/index';
+import type {DiagnosticsMode, DiagnosticsOptions} from './diagnostics/index';
 
 interface RunOptions {
   mountPoint?: string;
   fragments?: boolean;
   useDefaultDrivers?: boolean;
+  /** Diagnostics mode (or mode + ignore list). Overrides globalThis.__SYGNAL_DEV__. */
+  diagnostics?: DiagnosticsMode | DiagnosticsOptions;
 }
 
 interface SygnalRunResult {
@@ -30,6 +34,13 @@ export default function run(
     dt.init();
   }
 
+  // Resolve diagnostics mode: explicit option > globalThis.__SYGNAL_DEV__ > 'off'.
+  // Each run() is authoritative: without the option, mode and ignore list
+  // reset to defaults (no leakage from an earlier run()/configureDiagnostics()).
+  const {diagnostics} = options;
+  const diagOptions: DiagnosticsOptions = typeof diagnostics === 'string' ? {mode: diagnostics} : diagnostics || {};
+  configureDiagnostics({mode: diagOptions.mode, ignore: diagOptions.ignore || []});
+
   const {mountPoint = '#root', fragments = true, useDefaultDrivers = true} = options;
   if (!app.isSygnalComponent) {
     const name = app.name || app.componentName || app.label || 'FUNCTIONAL_COMPONENT';