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

package/dist/solid/variant-tree.d.ts

@@ -0,0 +1,349 @@
+/**
+ * The rules of an element's place in variant orchestration (ADR-0007, #50), Solid-free (#209): the
+ * names an element hands its children and inherits from its parent, the values it starts from, and
+ * what a server render builds. Each binding's variant node (`variant-node.ts` for Solid 1,
+ * `unstable/v2/variant-node.ts` for Solid 2) runs the orchestration over them, with its own Solid.
+ *
+ * Motion's rule (CONTEXT.md, **Variant child**):
+ * - An element that names its own variants, a name on any variant prop (`initial`, `animate`, the
+ *   `while*` gestures, `exit`; #618), hands its children its `initial` and `animate` names, and an
+ *   `initial={false}` with them (#134). Any other passes its parent's through, unless it sets
+ *   `inherit={false}`, which passes none.
+ * - A **Variant child** (`variants`, no names of its own, `inherit` not `false`) inherits its
+ *   ancestor's names and default transition, takes a stagger slot among the ancestor's variant
+ *   children, and counts for the ancestor's `when`.
+ * - An element with variants of its own (`variants`, or a name) is what its Variant children
+ *   join: it owns their registry, their stagger and their `when`. Any other element passes its
+ *   parent's context through, so a Variant child joins its nearest such ancestor; it renders no
+ *   Provider unless it sets `inherit={false}` ({@link changesContext}).
+ *
+ * @module
+ */
+import * as Stagger from "@wardic/core/Stagger";
+import type * as Values from "@wardic/core/Values";
+import { type ControlsChange } from "./animation-controls.ts";
+import type { AppearGroup } from "./appear.ts";
+import type { WardicStagger, WardicTransition, WardicVariantLabels } from "./config.ts";
+import type { Accessor, Reactivity } from "./reactivity.ts";
+/**
+ * The handle a child receives from {@link WardicVariantContextValue.register}
+ * when it mounts under a `ward.Provider` (ADR-0007, step 21b).
+ *
+ * - `index` / `total` — the child's SNAPSHOT position + sibling count for the
+ *   CURRENT transition. The Provider rewrites these only at the trigger (the
+ *   parent variant changing), never mid-transition; the child reads them to feed
+ *   core `stagger(amount, { from })(index, total)`.
+ * - `setSettled` — the child reports its own settle state (true when its spine
+ *   settles, false while animating), feeding the parent's `allChildrenSettled`.
+ * - `dispose` — removes this record from the registry on unmount.
+ */
+export interface WardicChildRegistration {
+    readonly index: Accessor<number>;
+    readonly total: Accessor<number>;
+    readonly setSettled: (settled: boolean) => void;
+    /**
+     * The child's keys of one of a list's names settled, or moving again (#297's PR 2): for that name's
+     * own `afterChildren`. Optional: left out, nothing per name.
+     */
+    readonly setSettledFor?: (name: string, settled: boolean) => void;
+    readonly dispose: () => void;
+}
+/**
+ * A list's names orchestrated each on their own (#297's PR 2, Motion's `animateVariant` a name): whether
+ * a name's keys may start (its provider's `beforeChildren` for that name, and its own `afterChildren`),
+ * and what a spine tells as a list's names start moving and settle. Read by polling: a group waiting
+ * on a name's gate reads it each tick.
+ */
+export interface NameOrchestration {
+    readonly mayStart: (name: string) => boolean;
+    readonly moving: (names: ReadonlyArray<string>) => void;
+    readonly settled: (names: ReadonlyArray<string>) => void;
+}
+/** The resolved stagger config the Provider exposes to its children. */
+export interface WardicStaggerConfig {
+    /** Seconds between siblings (core `stagger` amount). */
+    readonly amount: number;
+    /** Fixed offset added to every child's computed delay, or a function that decides it whole (#436). */
+    readonly delayChildren: number | WardicStagger;
+    /** Origin the stagger distance grows outward from (core option). */
+    readonly from: Stagger.Origin;
+    /** `1` forward (index = position), `-1` reverses the effective index. */
+    readonly direction: 1 | -1;
+}
+/**
+ * The value carried down the tree by {@link WardicVariantContext}.
+ *
+ * - `variant` — the parent instance's CURRENT variant NAME (reactive). It is
+ *   `undefined` when the parent's resolved `animate` is a `Values` map rather
+ *   than a name (propagation is by name only — a values map has no name to
+ *   inherit).
+ * - `initial` — the parent's `initial` NAME, or `false`, read once (#50, #134).
+ *
+ * Every Wardic element provides one (#50): its own if it has variants of its own, else its
+ * parent's, passed through (`variant-node.ts`).
+ * - `transition` — the parent's transition, inherited as the DEFAULT for
+ *   children that supply no local `transition`.
+ *
+ * Designed to extend without breaking: 21b adds optional `registry` / `stagger`
+ * / `when` members; readers consume only the fields they know.
+ */
+/** A gesture layer, in Motion's priority, lowest first (#291): `whileInView` … `whileDrag`. */
+export type GestureLayer = "inView" | "focused" | "hovered" | "pressed" | "dragged";
+/** The gesture layers in Motion's priority, lowest first. */
+export declare const GESTURE_LAYERS: ReadonlyArray<GestureLayer>;
+/** The variant names an element hands its Variant children for its active gestures (#291): a name or a list each (#297). */
+export type GestureNames = Readonly<Partial<Record<GestureLayer, WardicVariantLabels | undefined>>>;
+/** No gesture on: what an element with none active hands down. */
+export declare const NO_GESTURE_NAMES: GestureNames;
+/** Two {@link GestureNames} the same: the same names for each gesture, a list name by name (#297). */
+export declare const sameGestureNames: (a: GestureNames, b: GestureNames) => boolean;
+/** Whether each gesture is on (#291): a spine's, bound to its variant node. */
+export type GestureStates = Readonly<Record<GestureLayer, boolean>>;
+/** No gesture on. */
+export declare const NO_GESTURE_STATES: GestureStates;
+/**
+ * What an element hands its Variant children for its gestures (#291, Motion's `setActive` and variant
+ * context): whether each is on (its own, or its own provider's), and each one's label (its own
+ * `while*`, if a name, else the one it took). A Variant child's gesture is on while its provider's is.
+ */
+export interface GestureHandDown {
+    readonly on: GestureStates;
+    readonly names: GestureNames;
+}
+/** Nothing on, no labels: what an element hands down with no provider and no gesture. */
+export declare const NO_HAND_DOWN: GestureHandDown;
+/** Two hand-downs the same: each gesture on alike, with the same label. */
+export declare const sameHandDown: (a: GestureHandDown, b: GestureHandDown) => boolean;
+/** What a context hands down, nothing without a context or its gestures. */
+export declare const handDownFrom: (context: WardicVariantContextValue | undefined) => GestureHandDown;
+/** The gesture props a variant node reads (#291). */
+export interface GestureConfig {
+    readonly whileInView?: object | WardicVariantLabels | undefined;
+    readonly whileFocus?: object | WardicVariantLabels | undefined;
+    readonly whileHover?: object | WardicVariantLabels | undefined;
+    readonly whileTap?: object | WardicVariantLabels | undefined;
+    readonly whileDrag?: object | WardicVariantLabels | undefined;
+}
+/** Each gesture on: its own, or its provider's. */
+export declare const gesturesOn: (own: GestureStates, above: GestureStates) => GestureStates;
+/** What an element hands down (#291), from its config, its own states, and what it takes. */
+export declare const handDownOf: (config: GestureConfig, own: GestureStates, above: GestureHandDown) => GestureHandDown;
+/** The name each gesture's layer resolves while it's on (#291): its label then; off, none. */
+export declare const activeNamesOf: (handDown: GestureHandDown) => GestureNames;
+/**
+ * A key for a variant name and the active gestures' names: what a provider's orchestration snapshots
+ * at (#291), a list's names each (#297). A **Controls change** (#433) is one too, to the same name.
+ */
+export declare const triggerKeyOf: (variant: WardicVariantLabels | undefined, handDown: GestureHandDown, change: ControlsChange | undefined) => string;
+/**
+ * The **Controls change** a provider's latest trigger came with (#433): its orchestration is that
+ * change's override until a trigger without one. `previous` is the last answer.
+ */
+export interface ChangeAtTrigger {
+    readonly change: ControlsChange | undefined;
+    readonly key: string;
+    /** The change that orchestrates now: the one the latest trigger came with, or none. */
+    readonly by: ControlsChange | undefined;
+}
+/** {@link ChangeAtTrigger} after a trigger `key` with `change` in effect. */
+export declare const changeAtTrigger: (change: ControlsChange | undefined, key: string, previous: ChangeAtTrigger | undefined) => ChangeAtTrigger;
+/**
+ * The orchestration every name of a list takes at a trigger a Controls change came with (#433): its
+ * override's, or `undefined` for none (each name its own).
+ */
+export declare const changeConfigOf: (at: ChangeAtTrigger) => NameConfig | undefined;
+/** A provider's orchestration at a trigger (#433): the override of the change it came with, else its own. */
+export declare const orchestrationAt: (at: ChangeAtTrigger, own: () => WardicTransition | undefined) => WardicTransition | undefined;
+/** The highest-priority active gesture's name, or list (#297), if any hands one down. */
+export declare const topGestureName: (names: GestureNames) => WardicVariantLabels | undefined;
+/**
+ * What a variant parent hands its children: `variant()`, its current name or names; `initial`;
+ * `transition()`; `when()` and its stagger; and the registration its children make, in mount order,
+ * for that orchestration.
+ *
+ * @see https://wardic.dev/reference/solid/advanced/variant-context
+ */
+export interface WardicVariantContextValue {
+    /** The parent's current variant NAME, or list of names, reactive (undefined if it's a values map). */
+    readonly variant: Accessor<WardicVariantLabels | undefined>;
+    /**
+     * The parent's `initial` variant NAME, or `false`, read once (undefined if it's a values map or
+     * absent): a Variant child with no `initial` of its own starts from it, or, for `false`,
+     * at its `animate` (Motion's `getCurrentTreeVariants`).
+     */
+    readonly initial: WardicVariantLabels | false | undefined;
+    /** The parent's transition, inherited as the default for children. */
+    readonly transition: Accessor<WardicTransition | undefined>;
+    /**
+     * What the parent hands down for its gestures (Motion's): whether each is on, and its label.
+     * A Variant child's gesture is on while the parent's is, on its own `while*`, else that label.
+     * Optional: left out, nothing.
+     */
+    readonly gestures?: Accessor<GestureHandDown>;
+    /**
+     * Register this child with the parent's ordered registry (call on mount).
+     * Returns the child's reactive snapshot index/total + a settle reporter +
+     * a disposer. Children register in mount order; the parent snapshots that
+     * order at each change it hands down.
+     */
+    readonly register: () => WardicChildRegistration;
+    /**
+     * The parent's resolved stagger config (from `config.transition`): amount =
+     * `staggerChildren`, plus `delayChildren` / `from` / `direction`.
+     */
+    readonly stagger: Accessor<WardicStaggerConfig>;
+    /**
+     * The parent's stagger config for one of its names (Motion's `animateVariant` a name): that
+     * name's own transition's, else the parent's `transition`. A Variant child's keys of that name take
+     * their delay from it. `undefined` asks for {@link stagger}. Optional: left out, `stagger` for all.
+     */
+    readonly staggerFor?: (name: string | undefined) => WardicStaggerConfig;
+    /**
+     * For a list: whether a Variant child's keys of `name` may start, that name's own
+     * `beforeChildren`: true unless it has one and this element's keys of that name haven't settled
+     * since its list last changed. Optional: left out, always.
+     */
+    readonly mayStartFor?: (name: string) => boolean;
+    /** The parent's `when` mode, or `undefined` (default concurrent); a list's names have each their own. */
+    readonly when: Accessor<"beforeChildren" | "afterChildren" | undefined>;
+    /**
+     * Whether children may START their inherited-variant Retarget yet. True
+     * immediately UNLESS `when === "beforeChildren"`, in which case it flips true
+     * once the parent's own variant animation settles.
+     */
+    readonly childrenMayStart: Accessor<boolean>;
+    /** Whether EVERY Variant child has reported its spine as settled. */
+    readonly allChildrenSettled: Accessor<boolean>;
+    /**
+     * The **Controls change** in effect: its own controls' latest, else the one it inherits. A
+     * Variant child joins it, and runs its first Retarget for it on its override. Optional: none.
+     */
+    readonly change?: Accessor<ControlsChange | undefined>;
+    /**
+     * During a server render, the parent's Appear group: its Variant
+     * children join it in render order, for their stagger and `when` before hydration.
+     */
+    readonly appearGroup?: AppearGroup | undefined;
+}
+/** The part of an element's config its place in variant orchestration reads. */
+export interface VariantConfig extends GestureConfig {
+    readonly initial?: object | WardicVariantLabels | false | undefined;
+    readonly animate?: object | WardicVariantLabels | undefined;
+    readonly exit?: object | WardicVariantLabels | undefined;
+    readonly variants?: object | undefined;
+    readonly inherit?: boolean | undefined;
+    readonly transition?: WardicTransition | undefined;
+    /** What its dynamic variants resolve with (#277). */
+    readonly custom?: unknown;
+    /**
+     * Whether its `animate` is **Animation controls**' (#433): it names its own variants whatever its
+     * entry is, as Motion's `isControllingVariants`, so it hands down the names its controls set.
+     */
+    readonly controlled?: boolean | undefined;
+}
+/** An `initial` an element hands its children: a variant name or list (#297), `false` (#134), or `undefined` for a values map or nothing. */
+export declare const initialNameOf: (entry: object | WardicVariantLabels | false | undefined) => WardicVariantLabels | false | undefined;
+/** A variant name or a list of names (#297), or `undefined` for a values map or nothing. */
+export declare const nameOf: (entry: object | WardicVariantLabels | undefined) => WardicVariantLabels | undefined;
+/**
+ * Whether `config` names its own variants: any of its variant props, `initial`, `animate`, the five
+ * `while*` and `exit`, is a name or a list, or its `animate` is **Animation controls** (#433), as given
+ * or as its binding marks the config it reads (Motion's `isControllingVariants`, `isVariantLabel`).
+ */
+export declare const namesOwnVariants: (config: VariantConfig) => boolean;
+/** Whether an element has variants of its own, so Variant children join it (Motion's `isVariantNode`). */
+export declare const hasOwnVariants: (config: VariantConfig) => boolean;
+/**
+ * Whether an element changes what its children read, so it renders its variant context's
+ * Provider (#50): it has variants of its own, or it sets `inherit={false}`. Any other element hands
+ * its children its parent's context as it is, so it renders none. Decided once, at setup, from the
+ * same props on a server and on the client, so the nesting never changes after mount.
+ */
+export declare const changesContext: (config: VariantConfig) => boolean;
+/**
+ * The **Controls change** in effect for an element (#433): its own controls', else the one the context
+ * it inherits from is in, else none. Per mount, for every element (#460): guards, nothing built.
+ */
+export declare const controlsChangeOf: (controls: Accessor<ControlsChange | undefined> | undefined, inherited: WardicVariantContextValue | undefined) => Accessor<ControlsChange | undefined>;
+/** Whether an element is a **Variant child** (CONTEXT.md). */
+export declare const isVariantChild: (config: VariantConfig) => boolean;
+/** The context an element inherits names and its default transition from: its parent's, for a Variant child. */
+export declare const inheritedContext: (config: VariantConfig, parent: WardicVariantContextValue | undefined) => WardicVariantContextValue | undefined;
+/**
+ * The `initial` an element's Starting style resolves: its own, else the `initial` name (or `false`) of
+ * the context it inherits from (#50, #134). Read once, as every `initial` is.
+ */
+export declare const initialOf: (config: VariantConfig, inherited: WardicVariantContextValue | undefined) => object | WardicVariantLabels | false | undefined;
+/**
+ * Whether an element starts at its `animate`, with nothing animating at mount (#134, Motion's
+ * `isInitialAnimationBlocked`): its `initial` (own or inherited) is `false`, or it renders with an
+ * `<AnimatePresence initial={false}>`'s first render (`presenceBlocks`).
+ */
+export declare const startsAtAnimate: (config: VariantConfig, inherited: WardicVariantContextValue | undefined, presenceBlocks: boolean) => boolean;
+/**
+ * Whether an element's mount tells nothing (#448, Motion's `animation-state.ts`): it
+ * {@link startsAtAnimate}, or its `initial` (own, else inherited) is the same name, list or values map
+ * as its `animate` (own, else inherited). Its first Retarget, landing with nothing to animate, is told
+ * to no one. Read once, untracked.
+ */
+export declare const startsQuiet: (config: VariantConfig, inherited: WardicVariantContextValue | undefined, presenceBlocks: boolean, untrack: Reactivity["untrack"]) => boolean;
+/**
+ * The values an element starts from, its Starting style's input (ADR-0003): its `initial` (own, else
+ * inherited, #50), or, when it {@link startsAtAnimate}, its `animate` (own, else inherited), as
+ * Motion's `initial={false}` (#134). Read once: an inherited name is read through `untrack`.
+ */
+export declare const startingValuesOf: (config: VariantConfig, inherited: WardicVariantContextValue | undefined, presenceBlocks: boolean, untrack: Reactivity["untrack"]) => Values.Values;
+/**
+ * A name an element hands its children (Motion's `getCurrentTreeVariants`): `own` if it names its own
+ * variants, else `fromParent` unless it sets `inherit={false}`.
+ */
+export declare const handedDown: <A extends WardicVariantLabels | false>(config: VariantConfig, own: () => A | undefined, fromParent: () => A | undefined) => A | undefined;
+/** An element's own transition, else the one it inherits. */
+export declare const ownOrInherited: (own: WardicTransition | undefined, inherited: WardicVariantContextValue | undefined) => WardicTransition | undefined;
+/** The stagger config an element's `transition` gives its Variant children. */
+export declare const staggerOf: (transition: WardicTransition | undefined) => WardicStaggerConfig;
+/** A context's stagger config for one of its names (#297): its `staggerFor`'s, else its whole orchestration's. */
+export declare const staggerOfName: (context: WardicVariantContextValue, name: string | undefined) => WardicStaggerConfig;
+/** Whether a context lets a Variant child's keys of a list's name start (#297's PR 2): its `mayStartFor`, else always. */
+export declare const mayStartOf: (context: WardicVariantContextValue, name: string) => boolean;
+/** A child's place in a stagger, turned by its `staggerDirection`: `-1` counts from the last. */
+export declare const directed: (index: number, total: number, direction: 1 | -1) => number;
+/**
+ * A child's delay in a stagger (ADR-0007): its `delayChildren` plus its place from the origin, turned
+ * by its `staggerDirection`. A function `delayChildren` (#436, Motion's `calcChildStagger`) decides it
+ * whole, from the child's index and the count. Every stagger, a Variant child's, a presence's exit's
+ * and a server's Appear timing, is placed by it.
+ */
+export declare const childDelayOf: (s: WardicStaggerConfig, index: number, total: number) => number;
+/** A name's orchestration (#297): its stagger config, and its own `when`, from its own transition, else the element's. */
+export interface NameConfig {
+    readonly stagger: WardicStaggerConfig;
+    readonly when: "beforeChildren" | "afterChildren" | undefined;
+}
+/** A {@link NameConfig} from the transition a name orchestrates on. */
+export declare const nameConfigOf: (transition: WardicTransition | undefined) => NameConfig;
+/** The stagger config of a transition's stagger keys, each defaulted. */
+export declare const staggerWith: ({ staggerChildren, delayChildren, from, staggerDirection }: WardicTransition) => WardicStaggerConfig;
+/**
+ * Two stagger configs the same field by field: a memo of one holds while its orchestration changes to
+ * a transition with the same stagger (#460: a Variant child with no `press` variant, its parent
+ * pressed, made a new, equal config at each press and release, `UNSTABLE_MEMO_OUTPUT`).
+ */
+export declare const sameStagger: (a: WardicStaggerConfig, b: WardicStaggerConfig) => boolean;
+/** What an element provides when it has no variants of its own: its parent's context, unless `inherit={false}`. */
+export declare const passedThrough: (config: VariantConfig, parent: WardicVariantContextValue | undefined) => WardicVariantContextValue | undefined;
+/** A registration that does nothing: a server render has no orchestration to join. */
+export declare const INERT_REGISTRATION: WardicChildRegistration;
+/** An element's place in variant orchestration during a server render (ADR-0021). */
+export interface ServerVariantNode {
+    /** What its children read: the same context the client builds, with inert orchestration. */
+    readonly provided: WardicVariantContextValue | undefined;
+    /** The context it inherits from: its parent's, for a Variant child. */
+    readonly inherited: WardicVariantContextValue | undefined;
+}
+/**
+ * {@link createVariantNode} during a server render: the same names, read once, and orchestration
+ * that does nothing. No runtime, no signals.
+ */
+export declare const serverVariantNode: (config: VariantConfig, parent: WardicVariantContextValue | undefined) => ServerVariantNode;
+//# sourceMappingURL=variant-tree.d.ts.map

package/dist/solid/variant-tree.d.ts.map

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