sibujs 4.14.0 → 4.15.0

package/dist/testing.d.cts

@@ -1,7 +1,9 @@
 import { w as AdoptMismatch, y as AdoptResult, R as RenderResult } from './ssr-JpGpHnpC.cjs';
-import { R as RenderRouteOptions, a as RouteRenderResult } from './renderRoute-DP20XwMS.cjs';
-import { a as RouteDef } from './routeHead-CE9SV-cH.cjs';
+import { R as RenderRouteOptions, a as RouteRenderResult } from './renderRoute-B84MONaO.cjs';
+import { a as RouteDef } from './routeHead-DLxlq15W.cjs';
 import './types-CJFViL6Q.cjs';
+import './track-core-DN5fYLWi.cjs';
+import './signal-BnWpq6WB.cjs';
 
 /**
  * Listener tracking for accessibility checks.

package/dist/testing.d.ts

@@ -1,7 +1,9 @@
 import { w as AdoptMismatch, y as AdoptResult, R as RenderResult } from './ssr-JpGpHnpC.js';
-import { R as RenderRouteOptions, a as RouteRenderResult } from './renderRoute-fxgsm2Ir.js';
-import { a as RouteDef } from './routeHead-DzVxPviY.js';
+import { R as RenderRouteOptions, a as RouteRenderResult } from './renderRoute-_yxPuEQY.js';
+import { a as RouteDef } from './routeHead-w8nANZ3M.js';
 import './types-CJFViL6Q.js';
+import './track-core-0edROAF5.js';
+import './signal-BnWpq6WB.js';
 
 /**
  * Listener tracking for accessibility checks.

package/dist/testing.js

@@ -1,36 +1,38 @@
 import {
   renderRoute
-} from "./chunk-GVAMIU6K.js";
-import "./chunk-VM2U5LEL.js";
-import "./chunk-52XFPGSN.js";
+} from "./chunk-75EAQH3U.js";
+import "./chunk-EHSJESRN.js";
+import "./chunk-HTPOIAAL.js";
+import "./chunk-DS5V2PRE.js";
 import {
   hydrate,
   renderToStringAsync
-} from "./chunk-BOYKGGVD.js";
-import "./chunk-CNPT6NKV.js";
-import "./chunk-LJMX4SQ7.js";
+} from "./chunk-DRWOD7RZ.js";
+import "./chunk-MINLMJUY.js";
+import "./chunk-BG4BP44S.js";
 import {
   __resetTransfer
 } from "./chunk-3HZOSMPX.js";
 import "./chunk-62BDYGAG.js";
-import "./chunk-CJ7KS3DF.js";
-import "./chunk-HQIAL7F2.js";
-import "./chunk-RVWJGWCL.js";
+import "./chunk-VSTX3XSX.js";
 import {
-  globalSingleton
-} from "./chunk-7ZHH77QA.js";
+  styleKeyToProperty
+} from "./chunk-DNCQDFJJ.js";
+import "./chunk-XPDZ2LDR.js";
+import "./chunk-RVWJGWCL.js";
 import {
   effect
-} from "./chunk-AE32RGWX.js";
+} from "./chunk-LGUXYHTZ.js";
 import "./chunk-B3HOT4TK.js";
 import "./chunk-UYTYNCMZ.js";
-import "./chunk-4FJSAUKB.js";
-import "./chunk-MIRKTVH4.js";
+import "./chunk-IUBV5WO5.js";
+import "./chunk-GFM5WWPU.js";
 import {
   dispose,
+  globalSingleton,
   replaceChildrenSafely,
   reportError
-} from "./chunk-S37PZD6I.js";
+} from "./chunk-BF3WBJJQ.js";
 import "./chunk-NT3ZYB5S.js";
 import "./chunk-R5U7XKVJ.js";
 
@@ -1204,8 +1206,7 @@ function createJestAdapter() {
       toHaveStyle(element, style) {
         const mismatches = [];
         for (const [prop, expected] of Object.entries(style)) {
-          const kebabProp = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-          const actual = element.style.getPropertyValue(kebabProp);
+          const actual = element.style.getPropertyValue(styleKeyToProperty(prop));
           if (actual !== expected) {
             mismatches.push(`${prop}: expected "${expected}" but got "${actual}"`);
           }

package/dist/track-core-0edROAF5.d.ts

@@ -0,0 +1,187 @@
+import { R as ReactiveSignal } from './signal-BnWpq6WB.js';
+
+type Subscriber = () => void;
+/**
+ * Stop recording dependency edges until the matching {@link resumeTracking}.
+ * Nestable — the depth is counted, so an inner pair does not resume early.
+ *
+ * Prefer {@link untracked}, which pairs the two calls for you even when the
+ * body throws. Reach for the raw pair only when the suspended region cannot be
+ * expressed as a single function.
+ *
+ * @returns Nothing.
+ */
+declare function suspendTracking(): void;
+/**
+ * Undo one {@link suspendTracking}. Dependency recording resumes only when the
+ * outermost pair closes.
+ *
+ * @returns Nothing.
+ */
+declare function resumeTracking(): void;
+/** Read the "tracking suspended" flag (used by derived's lazy path). */
+declare function isTrackingSuspended(): boolean;
+/**
+ * Run `fn` without recording anything it reads as a dependency.
+ *
+ * The suspension is released even if `fn` throws, which is the reason to prefer
+ * this over a manual suspend/resume pair.
+ *
+ * @param fn Function to run outside dependency tracking.
+ * @returns Whatever `fn` returns.
+ */
+declare function untracked<T>(fn: () => T): T;
+/** The owner scope in effect right now (`null` when there is none). @internal */
+declare function getOwnerScope(): unknown;
+/**
+ * Run `fn` with `scope` as the current owner scope, restoring the previous
+ * scope afterwards (even if `fn` throws). @internal
+ */
+declare function runWithOwnerScope<T>(scope: unknown, fn: () => T): T;
+/**
+ * Capture the current owner scope into `fn`, for work that runs later (a
+ * deferred first render, a lifecycle callback). Returns `fn` itself when there
+ * is no scope to carry. @internal
+ */
+declare function bindOwnerScope<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R;
+/** Lifecycle of a captured owner: 0 active, 1 paused, 2 ended. @internal */
+type OwnerState = 0 | 1 | 2;
+/**
+ * A check on the structural owner that was current when it was captured.
+ * `()` is true while that owner (or one above it) is paused or ended — the
+ * work it guards must not run. @internal
+ */
+interface HeldCheck {
+    (): boolean;
+    /** The owner's state now. */
+    state(): OwnerState;
+    /**
+     * Call `onActive` once the owner is active again, or `onEnd` once it has
+     * ended — whichever comes first, exactly once — without polling: both are
+     * driven by `thaw` and disposal. Returns a function that drops the wait.
+     */
+    wait(onActive: () => void, onEnd: () => void): () => void;
+    /**
+     * Call `onEnd` once the owner has ended (whatever its state now), exactly
+     * once. Returns a function that drops the watch. Unlike `wait`, it is called
+     * SYNCHRONOUSLY, inside the disposal that ended the owner: by the time any
+     * other subscriber can run, what it tears down is gone.
+     */
+    onEnd(onEnd: () => void): () => void;
+    /**
+     * Run `fn` with the captured owner as the structural owner, so what it
+     * creates (an effect, a binding) is owned by it: skipped while it is
+     * paused, re-run when it resumes.
+     */
+    run<T>(fn: () => T): T;
+    /**
+     * Call `listener` with the owner's new state whenever it switches between
+     * active and paused, a microtask after the switch (a pause and resume in
+     * the same task are coalesced: nothing is delivered). Never called once it
+     * ended; the listener is dropped then. Returns a function that drops it.
+     */
+    onChange(listener: (state: OwnerState) => void): () => void;
+    /** Whether the captured owner is `owner`, or lies below it. */
+    within(owner: StructuralBinding): boolean;
+}
+/**
+ * Capture the structural owner in effect now (see {@link HeldCheck}). Deferred
+ * work scheduled on a subtree's behalf — a first render queued in a microtask,
+ * an async continuation — which the drain's frozen check never sees, consults
+ * it before it reads state or builds DOM, and can wait for the owner to
+ * resume. @internal
+ */
+declare function captureFrozen(): HeldCheck;
+/**
+ * Hold a detached DOM subtree: bindings whose node lies inside it are skipped
+ * (and re-run once released), as for a paused owner. Returns the release.
+ * @internal
+ */
+declare function holdSubtree(root: {
+    contains(node: unknown): boolean;
+}): () => void;
+declare function retrack(effectFn: () => void, subscriber: Subscriber): void;
+declare function track(effectFn: () => void, subscriber?: Subscriber): () => void;
+declare function reactiveBinding(commit: () => void, ownerNode?: unknown, structural?: boolean): () => void;
+/**
+ * Handle returned by {@link structuralBinding}.
+ * @internal
+ */
+interface StructuralBinding {
+    /** Dispose the binding. Idempotent. */
+    stop: () => void;
+    /**
+     * Run `fn` with this binding as the structural owner, for a render that
+     * happens outside the binding's own run (a directive's deferred first
+     * render), so what it builds is owned exactly as a later rebuild would be.
+     */
+    run: <T>(fn: () => T) => T;
+    /**
+     * Stop every subscriber created under this binding (through `run`, or while
+     * it ran) from running again, without disposing anything. Their DOM stays
+     * as it is and their disposers stay registered, so a subtree can keep
+     * showing its last state, and keep its lifecycle alive, until it is removed.
+     * Disposing the binding lifts the freeze. Absent on a structural binding
+     * provided by an older copy of the runtime.
+     */
+    freeze?: () => void;
+    /**
+     * Resume a frozen binding (its branch was taken back before it finished
+     * leaving): the subscribers it skipped re-run, and deferred work waiting on
+     * it continues. Unlike `stop`, the subtree stays alive. Absent on an older
+     * runtime copy.
+     */
+    thaw?: () => void;
+}
+/**
+ * A {@link reactiveBinding} whose run may REPLACE the subtree it renders —
+ * the binding behind `when`, `match`, `each` and `KeepAlive`. Subscribers
+ * created while it runs are owned by it, and the drain runs it before any of
+ * them when both are pending (see "Structural ownership").
+ * @internal
+ */
+declare function structuralBinding(commit: () => void, ownerNode?: unknown): StructuralBinding;
+declare function recordDependency(signal: ReactiveSignal): void;
+declare function cleanup(subscriber: Subscriber): void;
+/**
+ * Cap how many times one subscriber may re-run within a single drain before it
+ * is quarantined as a runaway cycle. A safety valve, not a tuning knob.
+ *
+ * @param n New limit; ignored unless finite and positive.
+ * @returns The previous limit, so a caller can restore it.
+ */
+declare function setMaxSubscriberRepeats(n: number): number;
+/**
+ * Cap how many passes one notification drain may make before giving up on a
+ * self-refeeding update cycle.
+ *
+ * @param n New limit; ignored unless finite and positive.
+ * @returns The previous limit, so a caller can restore it.
+ */
+declare function setMaxDrainIterations(n: number): number;
+/**
+ * Flush queued signal notifications, running every dirty subscriber.
+ *
+ * Re-entrant calls are ignored: a write performed from inside a subscriber adds
+ * to the queue the current drain is already working through, rather than
+ * starting a nested one.
+ *
+ * @returns Nothing.
+ */
+declare function drainNotificationQueue(): void;
+declare function queueSignalNotification(signal: ReactiveSignal): void;
+/**
+ * Mark every subscriber of `signal` dirty and queue them for the next drain.
+ *
+ * @param signal The signal that changed.
+ * @returns Nothing.
+ */
+declare function notifySubscribers(signal: ReactiveSignal): void;
+/** O(1) subscriber count for devtools / introspection. */
+declare function getSubscriberCount(signal: ReactiveSignal): number;
+/** Return the signals a subscriber currently depends on, in record order. */
+declare function getSubscriberDeps(subscriber: Subscriber): ReactiveSignal[];
+/** Iterate subscribers of a signal (devtools graph walk). */
+declare function forEachSubscriber(signal: ReactiveSignal, visit: (sub: Subscriber) => void): void;
+
+export { type HeldCheck as H, type StructuralBinding as S, retrack as a, reactiveBinding as b, recordDependency as c, cleanup as d, setMaxSubscriberRepeats as e, setMaxDrainIterations as f, drainNotificationQueue as g, getSubscriberCount as h, isTrackingSuspended as i, getSubscriberDeps as j, forEachSubscriber as k, getOwnerScope as l, runWithOwnerScope as m, notifySubscribers as n, bindOwnerScope as o, structuralBinding as p, queueSignalNotification as q, resumeTracking as r, suspendTracking as s, track as t, untracked as u, captureFrozen as v, holdSubtree as w };

package/dist/track-core-DN5fYLWi.d.cts

@@ -0,0 +1,187 @@
+import { R as ReactiveSignal } from './signal-BnWpq6WB.cjs';
+
+type Subscriber = () => void;
+/**
+ * Stop recording dependency edges until the matching {@link resumeTracking}.
+ * Nestable — the depth is counted, so an inner pair does not resume early.
+ *
+ * Prefer {@link untracked}, which pairs the two calls for you even when the
+ * body throws. Reach for the raw pair only when the suspended region cannot be
+ * expressed as a single function.
+ *
+ * @returns Nothing.
+ */
+declare function suspendTracking(): void;
+/**
+ * Undo one {@link suspendTracking}. Dependency recording resumes only when the
+ * outermost pair closes.
+ *
+ * @returns Nothing.
+ */
+declare function resumeTracking(): void;
+/** Read the "tracking suspended" flag (used by derived's lazy path). */
+declare function isTrackingSuspended(): boolean;
+/**
+ * Run `fn` without recording anything it reads as a dependency.
+ *
+ * The suspension is released even if `fn` throws, which is the reason to prefer
+ * this over a manual suspend/resume pair.
+ *
+ * @param fn Function to run outside dependency tracking.
+ * @returns Whatever `fn` returns.
+ */
+declare function untracked<T>(fn: () => T): T;
+/** The owner scope in effect right now (`null` when there is none). @internal */
+declare function getOwnerScope(): unknown;
+/**
+ * Run `fn` with `scope` as the current owner scope, restoring the previous
+ * scope afterwards (even if `fn` throws). @internal
+ */
+declare function runWithOwnerScope<T>(scope: unknown, fn: () => T): T;
+/**
+ * Capture the current owner scope into `fn`, for work that runs later (a
+ * deferred first render, a lifecycle callback). Returns `fn` itself when there
+ * is no scope to carry. @internal
+ */
+declare function bindOwnerScope<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R;
+/** Lifecycle of a captured owner: 0 active, 1 paused, 2 ended. @internal */
+type OwnerState = 0 | 1 | 2;
+/**
+ * A check on the structural owner that was current when it was captured.
+ * `()` is true while that owner (or one above it) is paused or ended — the
+ * work it guards must not run. @internal
+ */
+interface HeldCheck {
+    (): boolean;
+    /** The owner's state now. */
+    state(): OwnerState;
+    /**
+     * Call `onActive` once the owner is active again, or `onEnd` once it has
+     * ended — whichever comes first, exactly once — without polling: both are
+     * driven by `thaw` and disposal. Returns a function that drops the wait.
+     */
+    wait(onActive: () => void, onEnd: () => void): () => void;
+    /**
+     * Call `onEnd` once the owner has ended (whatever its state now), exactly
+     * once. Returns a function that drops the watch. Unlike `wait`, it is called
+     * SYNCHRONOUSLY, inside the disposal that ended the owner: by the time any
+     * other subscriber can run, what it tears down is gone.
+     */
+    onEnd(onEnd: () => void): () => void;
+    /**
+     * Run `fn` with the captured owner as the structural owner, so what it
+     * creates (an effect, a binding) is owned by it: skipped while it is
+     * paused, re-run when it resumes.
+     */
+    run<T>(fn: () => T): T;
+    /**
+     * Call `listener` with the owner's new state whenever it switches between
+     * active and paused, a microtask after the switch (a pause and resume in
+     * the same task are coalesced: nothing is delivered). Never called once it
+     * ended; the listener is dropped then. Returns a function that drops it.
+     */
+    onChange(listener: (state: OwnerState) => void): () => void;
+    /** Whether the captured owner is `owner`, or lies below it. */
+    within(owner: StructuralBinding): boolean;
+}
+/**
+ * Capture the structural owner in effect now (see {@link HeldCheck}). Deferred
+ * work scheduled on a subtree's behalf — a first render queued in a microtask,
+ * an async continuation — which the drain's frozen check never sees, consults
+ * it before it reads state or builds DOM, and can wait for the owner to
+ * resume. @internal
+ */
+declare function captureFrozen(): HeldCheck;
+/**
+ * Hold a detached DOM subtree: bindings whose node lies inside it are skipped
+ * (and re-run once released), as for a paused owner. Returns the release.
+ * @internal
+ */
+declare function holdSubtree(root: {
+    contains(node: unknown): boolean;
+}): () => void;
+declare function retrack(effectFn: () => void, subscriber: Subscriber): void;
+declare function track(effectFn: () => void, subscriber?: Subscriber): () => void;
+declare function reactiveBinding(commit: () => void, ownerNode?: unknown, structural?: boolean): () => void;
+/**
+ * Handle returned by {@link structuralBinding}.
+ * @internal
+ */
+interface StructuralBinding {
+    /** Dispose the binding. Idempotent. */
+    stop: () => void;
+    /**
+     * Run `fn` with this binding as the structural owner, for a render that
+     * happens outside the binding's own run (a directive's deferred first
+     * render), so what it builds is owned exactly as a later rebuild would be.
+     */
+    run: <T>(fn: () => T) => T;
+    /**
+     * Stop every subscriber created under this binding (through `run`, or while
+     * it ran) from running again, without disposing anything. Their DOM stays
+     * as it is and their disposers stay registered, so a subtree can keep
+     * showing its last state, and keep its lifecycle alive, until it is removed.
+     * Disposing the binding lifts the freeze. Absent on a structural binding
+     * provided by an older copy of the runtime.
+     */
+    freeze?: () => void;
+    /**
+     * Resume a frozen binding (its branch was taken back before it finished
+     * leaving): the subscribers it skipped re-run, and deferred work waiting on
+     * it continues. Unlike `stop`, the subtree stays alive. Absent on an older
+     * runtime copy.
+     */
+    thaw?: () => void;
+}
+/**
+ * A {@link reactiveBinding} whose run may REPLACE the subtree it renders —
+ * the binding behind `when`, `match`, `each` and `KeepAlive`. Subscribers
+ * created while it runs are owned by it, and the drain runs it before any of
+ * them when both are pending (see "Structural ownership").
+ * @internal
+ */
+declare function structuralBinding(commit: () => void, ownerNode?: unknown): StructuralBinding;
+declare function recordDependency(signal: ReactiveSignal): void;
+declare function cleanup(subscriber: Subscriber): void;
+/**
+ * Cap how many times one subscriber may re-run within a single drain before it
+ * is quarantined as a runaway cycle. A safety valve, not a tuning knob.
+ *
+ * @param n New limit; ignored unless finite and positive.
+ * @returns The previous limit, so a caller can restore it.
+ */
+declare function setMaxSubscriberRepeats(n: number): number;
+/**
+ * Cap how many passes one notification drain may make before giving up on a
+ * self-refeeding update cycle.
+ *
+ * @param n New limit; ignored unless finite and positive.
+ * @returns The previous limit, so a caller can restore it.
+ */
+declare function setMaxDrainIterations(n: number): number;
+/**
+ * Flush queued signal notifications, running every dirty subscriber.
+ *
+ * Re-entrant calls are ignored: a write performed from inside a subscriber adds
+ * to the queue the current drain is already working through, rather than
+ * starting a nested one.
+ *
+ * @returns Nothing.
+ */
+declare function drainNotificationQueue(): void;
+declare function queueSignalNotification(signal: ReactiveSignal): void;
+/**
+ * Mark every subscriber of `signal` dirty and queue them for the next drain.
+ *
+ * @param signal The signal that changed.
+ * @returns Nothing.
+ */
+declare function notifySubscribers(signal: ReactiveSignal): void;
+/** O(1) subscriber count for devtools / introspection. */
+declare function getSubscriberCount(signal: ReactiveSignal): number;
+/** Return the signals a subscriber currently depends on, in record order. */
+declare function getSubscriberDeps(subscriber: Subscriber): ReactiveSignal[];
+/** Iterate subscribers of a signal (devtools graph walk). */
+declare function forEachSubscriber(signal: ReactiveSignal, visit: (sub: Subscriber) => void): void;
+
+export { type HeldCheck as H, type StructuralBinding as S, retrack as a, reactiveBinding as b, recordDependency as c, cleanup as d, setMaxSubscriberRepeats as e, setMaxDrainIterations as f, drainNotificationQueue as g, getSubscriberCount as h, isTrackingSuspended as i, getSubscriberDeps as j, forEachSubscriber as k, getOwnerScope as l, runWithOwnerScope as m, notifySubscribers as n, bindOwnerScope as o, structuralBinding as p, queueSignalNotification as q, resumeTracking as r, suspendTracking as s, track as t, untracked as u, captureFrozen as v, holdSubtree as w };