@wardic/solid 0.0.0-stage → 1.0.0-rc.2

package/dist/solid/unstable/v2/sensors.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Sensors on Solid 2 (#209 PR 3's Q1): each is a ref that's also its reading, as a ward is a ref
+ * carrying its props. Give it to an element's `ref` (alone, or in an array beside a ward); call it
+ * with nothing to read it, tracked as any signal:
+ *
+ * ```tsx
+ * const hovered = createHover()
+ * <div ref={hovered}>{hovered() ? "in" : "out"}</div>
+ * ```
+ *
+ * Each wraps a core recognizer (ADR-0006): attached, it runs on the provider's runtime until the
+ * sensor's owner is disposed or it's given another element. Each is a watch (#318, #379, ADR-0055),
+ * in a Scope of its own with no fiber. Its value starts at its rest (`false`,
+ * or `null` for a drag) and stays there on a server, where no ref is called. `createReducedMotion`,
+ * `createReducedMotionConfig` and `createPageInView` take no element: they follow the Probe's
+ * preference, the nearest config's setting over it, and the page's visibility (#443).
+ *
+ * @module
+ */
+import type * as InputFeed from "@wardic/core/InputFeed";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import { type Accessor } from "solid-js";
+import type { WardicViewport } from "../../config.ts";
+import type { WardicServices } from "../../runtime.ts";
+export type { CreateDragOptions } from "../../drag-samples.ts";
+/**
+ * A sensor: give it to an element's `ref` (alone, or in an array beside a ward), and call it with
+ * nothing to read it, tracked as any signal. Given another element, it follows that one.
+ */
+export interface Sensor<A> {
+    /** Its reading, tracked. */
+    (): A;
+    /** Attach it to `element`: Solid calls it as a ref. */
+    (element: Element): void;
+}
+/**
+ * A sensor of a watch's values (#318, ADR-0055), at `initial` until its first: attached, the watch
+ * runs in a Scope of its own, closed when the sensor is given another element or its owner is
+ * disposed. Call within an owner.
+ */
+export declare const watchSensorOf: <A>(watchOf: (target: Element, handlers: InputFeed.Handlers<A>) => Effect.Effect<void, never, Scope.Scope | WardicServices>, initial: A) => Sensor<A>;
+/**
+ * `true` while the element it's given to as a `ref` is in view, `false` otherwise. What "in view"
+ * means is a `viewport`'s, as on a Wardic element: `root`, a scrolling container (the window if none);
+ * `margin`, grown around it, as CSS `rootMargin`; `amount` of the element that must show, `"some"`,
+ * `"all"` or 0 to 1; and `once`, to stay `true` after the first entry. `root` is read as it's
+ * attached: an ancestor's `ref`, which Solid applies before its children's, has it by then. Motion's
+ * `useInView`.
+ *
+ * @example
+ * const visible = createInView({ amount: "all", once: true })
+ * <section ref={visible}>{visible() ? "Seen" : "Not yet"}</section>
+ * @see https://wardic.dev/reference/solid/gestures/create-in-view
+ */
+export declare const createInView: (viewport?: WardicViewport) => Sensor<boolean>;
+/**
+ * Whether the visitor's system asks for reduced motion, as an accessor. A server renders `false`, and a
+ * hydrating page keeps it until it has mounted, so markup that depends on it hydrates. Wardic's
+ * animations honour the setting either way. Motion's `useReducedMotion`, which gives `null` on a server.
+ *
+ * @example
+ * const reduced = createReducedMotion()
+ * <Show when={!reduced()} fallback={<img src={still} />}><video autoplay src={clip} /></Show>
+ * @see https://wardic.dev/reference/solid/utilities/create-reduced-motion
+ */
+export declare const createReducedMotion: () => Accessor<boolean>;
+/**
+ * Whether reduced motion applies here, as Wardic's animations here honour it: the nearest
+ * `WardicConfig`'s `reducedMotion`, else the provider's, over the visitor's setting. `"always"` is
+ * `true`, `"never"` `false`, and `"user"` follows the system. A server renders `"always"` as `true` and
+ * the rest as `false`, kept until the page has mounted. Motion's `useReducedMotionConfig`.
+ *
+ * @example
+ * const reduced = createReducedMotionConfig()
+ * const path = () => (reduced() ? undefined : arc())
+ * @see https://wardic.dev/reference/solid/utilities/create-reduced-motion
+ */
+export declare const createReducedMotionConfig: () => Accessor<boolean>;
+/**
+ * Whether the page is shown: `false` while it's hidden, in a tab in the background or a minimised
+ * window. Pause what nobody can see, such as a carousel's autoplay. A server renders `true`, and a
+ * hydrating page keeps it until it has settled. Motion's `usePageInView`.
+ *
+ * @example
+ * const visible = createPageInView()
+ * createEffect(visible, (shown) => (shown ? player.play() : player.pause()))
+ * @see https://wardic.dev/reference/solid/gestures/create-page-in-view
+ */
+export declare const createPageInView: () => Accessor<boolean>;
+//# sourceMappingURL=sensors.d.ts.map

package/dist/solid/unstable/v2/sensors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sensors.d.ts","sourceRoot":"","sources":["../../../../src/unstable/v2/sensors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,KAAK,SAAS,MAAM,wBAAwB,CAAA;AAMxD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAIrC,OAAO,EAAE,KAAK,QAAQ,EAA2B,MAAM,UAAU,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAGrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAItD,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,4BAA4B;IAC5B,IAAI,CAAC,CAAA;IACL,uDAAuD;IACvD,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;CACzB;AAMD;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,WACpB,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,cAAc,CAAC,WAC9G,CAAC,KACT,MAAM,CAAC,CAAC,CA+BV,CAAA;AAED;;;;;;;;;;;;GAYG;AAGH,eAAO,MAAM,YAAY,cAAe,cAAc,KAAG,MAAM,CAAC,OAAO,CAIpE,CAAA;AAEH;;;;;;;;;GASG;AAGH,eAAO,MAAM,mBAAmB,QAAO,QAAQ,CAAC,OAAO,CAItD,CAAA;AAED;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,QAAO,QAAQ,CAAC,OAAO,CAI5D,CAAA;AAED;;;;;;;;;GASG;AAEH,eAAO,MAAM,gBAAgB,QAAO,QAAQ,CAAC,OAAO,CAInD,CAAA"}

package/dist/solid/unstable/v2/sensors.js

@@ -0,0 +1,124 @@
+import * as Probe from "@wardic/core/Probe";
+import * as Recognizer from "@wardic/core/Recognizer";
+import * as ReducedMotion from "@wardic/core/ReducedMotion";
+import * as Report from "@wardic/dom/Report";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import * as Predicate from "effect/Predicate";
+import * as UndefinedOr from "effect/UndefinedOr";
+import { isServer } from "@solidjs/web";
+import { createSignal, onCleanup } from "solid-js";
+import { inViewOptionsOf } from "../../gesture-callbacks.js";
+import * as OwnerScope from "../../owner-scope.js";
+import { fromAtom } from "./bridge.js";
+import { useWardicReducedMotionSetting, useWardicRuntime } from "./provider.jsx";
+/** Whether a sensor's call is Solid applying it as a ref. */
+const isElement = (value) => Predicate.hasProperty(value, "nodeType");
+/**
+ * A sensor of a watch's values (#318, ADR-0055), at `initial` until its first: attached, the watch
+ * runs in a Scope of its own, closed when the sensor is given another element or its owner is
+ * disposed. Call within an owner.
+ */
+export const watchSensorOf = (watchOf, initial) => {
+    // A server never calls a ref: the sensor rests where it starts.
+    if (isServer)
+        return (() => initial);
+    const runtime = useWardicRuntime();
+    const [value, setValue] = createSignal(initial);
+    // The element it's attached to, and its watch's Scope there.
+    let attached;
+    const detach = () => {
+        UndefinedOr.map(attached, ({ scope }) => OwnerScope.close(runtime, scope, "wardic.sensor: a finalizer failed"));
+        attached = undefined;
+    };
+    onCleanup(detach);
+    const onDefect = (cause) => {
+        runtime.runFork(Report.failure("wardic.sensor: a gesture handler failed", cause));
+    };
+    const attach = (element) => {
+        if (Predicate.isNotUndefined(attached) && attached.element === element)
+            return;
+        detach();
+        // Attached before its watch starts, so one that throws as it subscribes is closed all the same (#618).
+        const scope = OwnerScope.open(runtime);
+        attached = { element, scope };
+        runtime.runSync(watchOf(element, { on: (next) => setValue(() => next), onDefect }).pipe(Scope.provide(scope)));
+    };
+    // eslint-disable-next-line solid/reactivity -- the sensor: a ref Solid calls with its element, and an accessor its caller reads where it tracks
+    return ((element) => {
+        if (isElement(element)) {
+            attach(element);
+            return undefined;
+        }
+        return value();
+    });
+};
+/**
+ * `true` while the element it's given to as a `ref` is in view, `false` otherwise. What "in view"
+ * means is a `viewport`'s, as on a Wardic element: `root`, a scrolling container (the window if none);
+ * `margin`, grown around it, as CSS `rootMargin`; `amount` of the element that must show, `"some"`,
+ * `"all"` or 0 to 1; and `once`, to stay `true` after the first entry. `root` is read as it's
+ * attached: an ancestor's `ref`, which Solid applies before its children's, has it by then. Motion's
+ * `useInView`.
+ *
+ * @example
+ * const visible = createInView({ amount: "all", once: true })
+ * <section ref={visible}>{visible() ? "Seen" : "Not yet"}</section>
+ * @see https://wardic.dev/reference/solid/gestures/create-in-view
+ */
+// The core in-view watch, its options mapped as the element's `viewport` is (#273): `root` read as
+// it's attached.
+export const createInView = (viewport) => watchSensorOf((target, { on, onDefect }) => Recognizer.watchInView(target, inViewOptionsOf(viewport), { on: (transition) => on(transition.active), onDefect }), false);
+/**
+ * Whether the visitor's system asks for reduced motion, as an accessor. A server renders `false`, and a
+ * hydrating page keeps it until it has mounted, so markup that depends on it hydrates. Wardic's
+ * animations honour the setting either way. Motion's `useReducedMotion`, which gives `null` on a server.
+ *
+ * @example
+ * const reduced = createReducedMotion()
+ * <Show when={!reduced()} fallback={<img src={still} />}><video autoplay src={clip} /></Show>
+ * @see https://wardic.dev/reference/solid/utilities/create-reduced-motion
+ */
+// The Probe's `prefersReducedMotion` Atom, held until mount (the Hydration hold, ADR-0021 decision 8).
+// The engine reads the preference as each animation starts, and snaps its positional keys (ADR-0029).
+export const createReducedMotion = () => {
+    if (isServer)
+        return () => false;
+    const probe = useWardicRuntime().runSync(Probe.Probe);
+    return fromAtom(probe.prefersReducedMotion, { serverValue: false });
+};
+/**
+ * Whether reduced motion applies here, as Wardic's animations here honour it: the nearest
+ * `WardicConfig`'s `reducedMotion`, else the provider's, over the visitor's setting. `"always"` is
+ * `true`, `"never"` `false`, and `"user"` follows the system. A server renders `"always"` as `true` and
+ * the rest as `false`, kept until the page has mounted. Motion's `useReducedMotionConfig`.
+ *
+ * @example
+ * const reduced = createReducedMotionConfig()
+ * const path = () => (reduced() ? undefined : arc())
+ * @see https://wardic.dev/reference/solid/utilities/create-reduced-motion
+ */
+// #443; tracked since #584.
+export const createReducedMotionConfig = () => {
+    const setting = useWardicReducedMotionSetting();
+    const prefers = createReducedMotion();
+    return () => ReducedMotion.applies(setting(), prefers());
+};
+/**
+ * Whether the page is shown: `false` while it's hidden, in a tab in the background or a minimised
+ * window. Pause what nobody can see, such as a carousel's autoplay. A server renders `true`, and a
+ * hydrating page keeps it until it has settled. Motion's `usePageInView`.
+ *
+ * @example
+ * const visible = createPageInView()
+ * createEffect(visible, (shown) => (shown ? player.play() : player.pause()))
+ * @see https://wardic.dev/reference/solid/gestures/create-page-in-view
+ */
+// #443, the Probe's `pageVisible`, held until settled (the Hydration hold).
+export const createPageInView = () => {
+    if (isServer)
+        return () => true;
+    const probe = useWardicRuntime().runSync(Probe.Probe);
+    return fromAtom(probe.pageVisible, { serverValue: true });
+};
+//# sourceMappingURL=sensors.js.map

package/dist/solid/unstable/v2/sensors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sensors.js","sourceRoot":"","sources":["../../../../src/unstable/v2/sensors.ts"],"names":[],"mappings":"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"}

package/dist/solid/unstable/v2/solid-reactivity.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Solid 2's {@link Reactivity}, for the Solid-free modules the Solid 2 binding runs (#209), made
+ * per ward under its owner.
+ *
+ * - A trigger's signal is written where Solid 2 allows a write: the flush gate's hooks, an effect's
+ *   apply, an event. No internal signal is written in an owned scope but four, which say why
+ *   (`ownedWrite`, #257's audit; checked again in #618): a Variant child's registration, the gesture
+ *   states a ward binds to its variant node at setup, a ward given its element in a component's body,
+ *   and a ward given its `.with()` props in a spread's run (#264).
+ * - A watch is an effect in a root of its own under the ward's owner, so it ends with the ward, or
+ *   at its stop. Not under the computation it's made in: Solid 2 disposes a root with the
+ *   computation it's made in (a 1.x root outlived it), and a `style` re-run must not end a Live
+ *   value's watch. Nor detached: Solid 2 refuses a root with no owner inside an effect's apply,
+ *   where a ward mounts.
+ *
+ * @module
+ */
+import { type Owner } from "solid-js";
+import type { Reactivity } from "../../reactivity.ts";
+/**
+ * The options of every computation the binding makes (#209 PR 4a): transparent to Solid 2's
+ * hydration ids. A memo or an effect otherwise takes its owner's next child id, and adopts the
+ * server's serialized value while hydrating; the binding makes them on the client only (a server
+ * ward is lean, ADR-0021), so the client's later ids would miss the server's markup.
+ */
+export declare const CLIENT_ONLY: {
+    readonly transparent: true;
+};
+/** {@link CLIENT_ONLY}, deferred: an effect that skips its first run. */
+export declare const CLIENT_ONLY_DEFERRED: {
+    readonly transparent: true;
+    readonly defer: true;
+};
+/**
+ * {@link CLIENT_ONLY} for a computation whose compute builds the value it returns, so it never
+ * returns a promise: Solid 2 skips its check of each result's shape (`sync`, which it documents for
+ * library code that returns sync values). Never for one that returns a value it was given, which an
+ * app may make a promise of, and never for a waiter (`lifecycle.ts`), which returns one by design.
+ */
+export declare const CLIENT_ONLY_SYNC: {
+    readonly transparent: true;
+    readonly sync: true;
+};
+/** {@link CLIENT_ONLY_SYNC}, deferred: an effect that skips its first run. */
+export declare const CLIENT_ONLY_SYNC_DEFERRED: {
+    readonly transparent: true;
+    readonly sync: true;
+    readonly defer: true;
+};
+/**
+ * `onSettled` for client-only code (#209 PR 4b): Solid 2's own, a tracked effect running `callback`
+ * untracked once the render has settled, made {@link CLIENT_ONLY}. Solid's takes a hydration id,
+ * and a server's `onSettled` takes the same one, but code that runs on the client only has no server
+ * call to take it: the keys after it would miss the server's markup. A tracked effect's declared
+ * options are only `name`; it passes them to its node, as every computation does, which reads
+ * `transparent` (`@solidjs/signals` rc.15 to rc.18, dev and prod builds).
+ */
+export declare const onSettledClientOnly: (callback: () => void | (() => void)) => void;
+/** Solid 2's reactive primitives, a watch made under `owner`. */
+export declare const reactivityIn: (owner: Owner | null) => Reactivity;
+//# sourceMappingURL=solid-reactivity.d.ts.map

package/dist/solid/unstable/v2/solid-reactivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-reactivity.d.ts","sourceRoot":"","sources":["../../../../src/unstable/v2/solid-reactivity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAA+D,KAAK,KAAK,EAAyB,MAAM,UAAU,CAAA;AACzH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,WAAW;aAAK,WAAW;CAAiB,CAAA;AACzD,yEAAyE;AACzE,eAAO,MAAM,oBAAoB;aAAK,WAAW;aAAQ,KAAK;CAAiB,CAAA;AAE/E;;;;;GAKG;AAEH,eAAO,MAAM,gBAAgB;aAAK,WAAW;aAAQ,IAAI;CAAiB,CAAA;AAC1E,8EAA8E;AAC9E,eAAO,MAAM,yBAAyB;aAAK,WAAW;aAAQ,IAAI;aAAQ,KAAK;CAAiB,CAAA;AAIhG;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,aAAc,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,KAAG,IAA6D,CAAA;AAEvI,iEAAiE;AACjE,eAAO,MAAM,YAAY,UAAW,KAAK,GAAG,IAAI,KAAG,UAcjD,CAAA"}

package/dist/solid/unstable/v2/solid-reactivity.js

@@ -0,0 +1,62 @@
+/**
+ * Solid 2's {@link Reactivity}, for the Solid-free modules the Solid 2 binding runs (#209), made
+ * per ward under its owner.
+ *
+ * - A trigger's signal is written where Solid 2 allows a write: the flush gate's hooks, an effect's
+ *   apply, an event. No internal signal is written in an owned scope but four, which say why
+ *   (`ownedWrite`, #257's audit; checked again in #618): a Variant child's registration, the gesture
+ *   states a ward binds to its variant node at setup, a ward given its element in a component's body,
+ *   and a ward given its `.with()` props in a spread's run (#264).
+ * - A watch is an effect in a root of its own under the ward's owner, so it ends with the ward, or
+ *   at its stop. Not under the computation it's made in: Solid 2 disposes a root with the
+ *   computation it's made in (a 1.x root outlived it), and a `style` re-run must not end a Live
+ *   value's watch. Nor detached: Solid 2 refuses a root with no owner inside an effect's apply,
+ *   where a ward mounts.
+ *
+ * @module
+ */
+import { createEffect, createRoot, createSignal, createTrackedEffect, runWithOwner, untrack } from "solid-js";
+/**
+ * The options of every computation the binding makes (#209 PR 4a): transparent to Solid 2's
+ * hydration ids. A memo or an effect otherwise takes its owner's next child id, and adopts the
+ * server's serialized value while hydrating; the binding makes them on the client only (a server
+ * ward is lean, ADR-0021), so the client's later ids would miss the server's markup.
+ */
+export const CLIENT_ONLY = { transparent: true };
+/** {@link CLIENT_ONLY}, deferred: an effect that skips its first run. */
+export const CLIENT_ONLY_DEFERRED = { transparent: true, defer: true };
+/**
+ * {@link CLIENT_ONLY} for a computation whose compute builds the value it returns, so it never
+ * returns a promise: Solid 2 skips its check of each result's shape (`sync`, which it documents for
+ * library code that returns sync values). Never for one that returns a value it was given, which an
+ * app may make a promise of, and never for a waiter (`lifecycle.ts`), which returns one by design.
+ */
+// #618 (M2): a computation returning an object paid `handleAsync`'s probe each run (rc.20), 15-55 ns.
+export const CLIENT_ONLY_SYNC = { transparent: true, sync: true };
+/** {@link CLIENT_ONLY_SYNC}, deferred: an effect that skips its first run. */
+export const CLIENT_ONLY_SYNC_DEFERRED = { transparent: true, sync: true, defer: true };
+const SETTLED = { name: "onSettled", ...CLIENT_ONLY };
+/**
+ * `onSettled` for client-only code (#209 PR 4b): Solid 2's own, a tracked effect running `callback`
+ * untracked once the render has settled, made {@link CLIENT_ONLY}. Solid's takes a hydration id,
+ * and a server's `onSettled` takes the same one, but code that runs on the client only has no server
+ * call to take it: the keys after it would miss the server's markup. A tracked effect's declared
+ * options are only `name`; it passes them to its node, as every computation does, which reads
+ * `transparent` (`@solidjs/signals` rc.15 to rc.18, dev and prod builds).
+ */
+export const onSettledClientOnly = (callback) => createTrackedEffect(() => untrack(callback), SETTLED);
+/** Solid 2's reactive primitives, a watch made under `owner`. */
+export const reactivityIn = (owner) => ({
+    untrack,
+    trigger: () => {
+        const [track, notify] = createSignal(undefined, { equals: false });
+        return { track, notify: () => void notify(undefined) };
+    },
+    watch: (accessor, onChange) => runWithOwner(owner, () => createRoot((dispose) => {
+        createEffect(accessor, (value) => {
+            onChange(value);
+        }, CLIENT_ONLY_DEFERRED);
+        return dispose;
+    }, CLIENT_ONLY)),
+});
+//# sourceMappingURL=solid-reactivity.js.map

package/dist/solid/unstable/v2/solid-reactivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-reactivity.js","sourceRoot":"","sources":["../../../../src/unstable/v2/solid-reactivity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,mBAAmB,EAAc,YAAY,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGzH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,WAAW,EAAE,IAAI,EAAW,CAAA;AACzD,yEAAyE;AACzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAW,CAAA;AAE/E;;;;;GAKG;AACH,sGAAsG;AACtG,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAW,CAAA;AAC1E,8EAA8E;AAC9E,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAW,CAAA;AAEhG,MAAM,OAAO,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAAA;AAErD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,QAAmC,EAAQ,EAAE,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAA;AAEvI,iEAAiE;AACjE,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAmB,EAAc,EAAE,CAAC,CAAC;IAChE,OAAO;IACP,OAAO,EAAE,GAAG,EAAE;QACZ,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,YAAY,CAAY,SAAS,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;QAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC,SAAS,CAAC,EAAE,CAAA;IACxD,CAAC;IACD,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAC5B,YAAY,CAAC,KAAK,EAAE,GAAG,EAAE,CACvB,UAAU,CAAC,CAAC,OAAO,EAAE,EAAE;QACrB,YAAY,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;YAC/B,QAAQ,CAAC,KAAK,CAAC,CAAA;QACjB,CAAC,EAAE,oBAAoB,CAAC,CAAA;QACxB,OAAO,OAAO,CAAA;IAChB,CAAC,EAAE,WAAW,CAAC,CAAC;CACrB,CAAC,CAAA"}

package/dist/solid/unstable/v2/variant-node.d.ts

@@ -0,0 +1,51 @@
+import { type Accessor } from "solid-js";
+import type { ControlsChange } from "../../animation-controls.ts";
+import { type GestureStates, type NameOrchestration, type VariantConfig, type WardicVariantContextValue } from "../../variant-tree.ts";
+/**
+ * The variant context: what the nearest variant parent hands its children, its names, transition and
+ * orchestration. Wardic's elements read it to follow their parent's variants; a binding of your own
+ * provides or reads it the same way. `null` outside a parent.
+ *
+ * @see https://wardic.dev/reference/solid/advanced/variant-context
+ */
+export declare const WardicVariantContext: import("solid-js").Context<WardicVariantContextValue | null>;
+/**
+ * The nearest variant parent's context, or `undefined` outside one: its current variant name,
+ * `initial`, transition and orchestration, for an element of your own that follows a parent's variants.
+ *
+ * @example
+ * const parent = useVariantContext()
+ * const name = () => parent?.variant()
+ * @see https://wardic.dev/reference/solid/advanced/variant-context
+ */
+export declare const useVariantContext: () => WardicVariantContextValue | undefined;
+/** An element's place in variant orchestration, on the client. */
+export interface VariantNode {
+    /** What its children read: its own context, its parent's passed through, or none. */
+    readonly provided: WardicVariantContextValue | undefined;
+    /** The context its spine inherits names and its default transition from: its parent's, for a Variant child. */
+    readonly inherited: WardicVariantContextValue | undefined;
+    /** Its stagger delay in seconds, as a Variant child; `undefined` for any other element. */
+    readonly extraDelay: ((name: string | undefined) => number) | undefined;
+    /** Whether its spine may start a Retarget: its ancestor's `beforeChildren` and its own `afterChildren` allow it. */
+    readonly canStart: () => boolean;
+    /** Its spine's settle report on each frame: to its ancestor's registry, and to its own `beforeChildren`. */
+    readonly onFrame: (done: boolean) => void;
+    /**
+     * Bind its spine's gesture states (#291), at its ward's setup: the names it hands its Variant
+     * children follow them. Only an element whose Variant children join it has one.
+     */
+    readonly bindGestures: ((states: Accessor<GestureStates>) => void) | undefined;
+    /**
+     * A list's names orchestrated each on their own (#297's PR 2): its spine's gates and per-name
+     * settles. Only an element that joins a provider or provides has one.
+     */
+    readonly names: NameOrchestration | undefined;
+}
+/**
+ * An element's place in variant orchestration on the client, from its config (`cfg`, read where it
+ * tracks; `config`, the ward's plain copy at setup, #259) and the nearest context
+ * (`useVariantContext()`). Call within a Solid owner.
+ */
+export declare const createVariantNode: (cfg: Accessor<VariantConfig>, config: VariantConfig, parent: WardicVariantContextValue | undefined, controls?: Accessor<ControlsChange | undefined>) => VariantNode;
+//# sourceMappingURL=variant-node.d.ts.map

package/dist/solid/unstable/v2/variant-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variant-node.d.ts","sourceRoot":"","sources":["../../../../src/unstable/v2/variant-node.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,KAAK,QAAQ,EAA2E,MAAM,UAAU,CAAA;AACjH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAEjE,OAAO,EAUL,KAAK,aAAa,EAgBlB,KAAK,iBAAiB,EAKtB,KAAK,aAAa,EAGlB,KAAK,yBAAyB,EAC/B,MAAM,uBAAuB,CAAA;AAI9B;;;;;;GAMG;AAGH,eAAO,MAAM,oBAAoB,8DAAwD,CAAA;AAEzF;;;;;;;;GAQG;AAEH,eAAO,MAAM,iBAAiB,QAAO,yBAAyB,GAAG,SACc,CAAA;AAE/E,kEAAkE;AAClE,MAAM,WAAW,WAAW;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,GAAG,SAAS,CAAA;IACxD,+GAA+G;IAC/G,QAAQ,CAAC,SAAS,EAAE,yBAAyB,GAAG,SAAS,CAAA;IACzD,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,CAAC,GAAG,SAAS,CAAA;IACvE,oHAAoH;IACpH,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAA;IAChC,4GAA4G;IAC5G,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IACzC;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAC9E;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAC9C;AAiPD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,QACvB,QAAQ,CAAC,aAAa,CAAC,UACpB,aAAa,UACb,yBAAyB,GAAG,SAAS,aAClC,QAAQ,CAAC,cAAc,GAAG,SAAS,CAAC,KAC9C,WAqCF,CAAA"}