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

package/dist/solid/drag-sensor.js

@@ -0,0 +1,33 @@
+import * as InputSource from "@wardic/core/InputSource";
+import * as Effect from "effect/Effect";
+import { watchToSignal } from "./bridge.js";
+import { watchDragSamples } from "./drag-samples.js";
+import { drag } from "./features/drag.js";
+import { inputIn } from "./gesture-features.js";
+import { useBrought } from "./provider.jsx";
+import { useWardicConfig } from "./wardic-config.jsx";
+import { transformPagePointOf } from "./wardic-config-value.js";
+/** What it brings (ADR-0067 decision 12): its gesture's Feature, whatever its section has (#511). */
+const DRAG = [drag];
+/**
+ * The latest sample of a drag on `target`, `null` before the first: where the pointer is, how far it
+ * has come, its velocity, and the gesture's `phase`. It moves nothing: it reports, for a drag that
+ * drives something else, such as a slider's value. `target` is the element itself, so call it where
+ * it exists. Like an element's own drag, it takes the element's drag while a gesture is on, unless
+ * `claim: false`.
+ *
+ * @example
+ * const drag = createDrag(props.track, { axis: "x" })
+ * const value = () => (drag()?.offset.x ?? 0) / 2
+ * @see https://wardic.dev/reference/solid/gestures/create-drag
+ */
+// The core drag watch (#379), each sample kept within `bounds` when given. It holds `target`'s Drag
+// claim while a gesture is on, shared with every other drag on it; refused one, it gets no samples for
+// that gesture.
+export const createDrag = (target, options) => {
+    // Its points through the nearest WardicConfig's `transformPagePoint` (#443), read at each down.
+    const pagePoint = transformPagePointOf(useWardicConfig());
+    const services = useBrought(DRAG);
+    return watchToSignal((handlers) => Effect.provideService(watchDragSamples(target, { ...options }, handlers, pagePoint), InputSource.InputSource, inputIn(services())), null);
+};
+//# sourceMappingURL=drag-sensor.js.map

package/dist/solid/drag-sensor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drag-sensor.js","sourceRoot":"","sources":["../../src/drag-sensor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,0BAA0B,CAAA;AACvD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAA0B,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAE5E,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAE/D,qGAAqG;AACrG,MAAM,IAAI,GAA2B,CAAC,IAAI,CAAC,CAAA;AAE3C;;;;;;;;;;;GAWG;AACH,oGAAoG;AACpG,uGAAuG;AACvG,gBAAgB;AAChB,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAe,EAAE,OAA2B,EAAgC,EAAE;IACvG,gGAAgG;IAChG,MAAM,SAAS,GAAG,oBAAoB,CAAC,eAAe,EAAE,CAAC,CAAA;IACzD,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,CAAA;IACjC,OAAO,aAAa,CAClB,CAAC,QAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,gBAAgB,CAAC,MAAM,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAChJ,IAAI,CACL,CAAA;AACH,CAAC,CAAA"}

package/dist/solid/drag-track.d.ts

@@ -0,0 +1,227 @@
+/**
+ * The binding-orchestrated drag track (ADR-0004 response half), Solid-free (#209): each binding
+ * runs it through `driveDragTrack`, handing it a `watch` for its element's watch Scope, a `fork` for
+ * its responses and a `setDragging` for its `dragging` signal. The Solid 1 binding's `runDragTrack`
+ * (`drag.ts`) wraps it.
+ *
+ * DESIGN (locked via grilling, subtask 22c): on a drag-enabled element `x`/`y`
+ * are DIRECT-SET by the pointer (1:1, NOT sprung) while the spring spine keeps
+ * driving every OTHER key + `whileDrag`. Ownership of `x`/`y` is DYNAMIC: the
+ * drag owns them while held AND during the release tail; once the release
+ * settles, ownership returns to the spring (so a later `animate.x`/`y` or a
+ * layout/Reorder FLIP can take over from the rested position). A Retarget that
+ * changes `x` or `y` during the release takes them over sooner (#340, ADR-0016
+ * *Amendment (#340)*), as a newer animation of Motion's value does: the release
+ * stops where it is, tells no end, and the spring goes on from there, at the
+ * release's velocity ({@link DragTrack.takeRelease}).
+ *
+ * This module is the RESPONSE half (binding orchestration). Core ships the
+ * RECOGNITION (`drag()`, kept to its axis and holding its **Drag claim**), the
+ * constraint (`Drag.constrain`) and the inertia PRIMITIVE (`inertia`, `inertiaVec`); the
+ * constraints on the element's x/y, the release driver, the gate writes, and the
+ * snapshot sync are response concerns and live here (ADR-0004, ADR-0016 *Amendment (#140)*).
+ *
+ * STRUCTURE (ADR-0032, ADR-0055 *Amendment (#379)*): input is handled inside its event, by two
+ * watches in the element's watch Scope, with no fiber of the track's own at rest:
+ *   - the drag's samples (`DragRecognizer.watchDrag`): a gesture's bookkeeping, then the direct-set,
+ *     or at the "end" the release;
+ *   - bare pointer-downs from the Primary pointer ("grabs", `InputFeed.watch`), which stop a
+ *     running release, so a re-grab mid-release stops the tail where it is, and the ends of its
+ *     presses, which let a projection node's release go on after a press that didn't drag.
+ * Each response is an Effect, run by `fork` on the provider runtime: its fiber starts at once and
+ * runs to its end inside the event (stopping a release interrupts a parked fiber in the caller's
+ * stack), and a release it starts, in a `FiberHandle`, is forked from it, keeping the runtime's
+ * scheduler, so it is on the Frame loop before its task ends. The next sample or grab interrupts it,
+ * which removes it from the loop at once. A response that fails is reported, and the next event's
+ * runs (ADR-0055 *Amendment (#379)*, Q4).
+ *
+ * **Drag controls** (#431, Motion's `useDragControls`) given to the element start its drag from a
+ * pointer pressed elsewhere: the track hands it to the element's pointer feed
+ * (`InputSource.adoptPointer`), whose adopted down the recognizer starts from as from a press on the
+ * element, and its grab stops a running release. `snapToCursor` moves the element's centre under the
+ * pointer there and then; `distanceThreshold` is that gesture's threshold. Their `stop` ends the drag
+ * as a release would; `cancel` ends it where it is, with no release and no `onDragEnd`. With
+ * `listen: false` (Motion's `dragListener={false}`) the element's own presses neither drag it nor stop
+ * its release. The track subscribes to the controls while its watch Scope is open, so an element an
+ * `<AnimatePresence>` is taking out (disposed) starts none, as Motion's doesn't.
+ *
+ * The samples subscribe before the grabs, so one event's samples reach the track
+ * before its grab: a Stale gesture's "end" (ADR-0019, rule B) starts its release and
+ * the grab of the same down stops it before its first frame, on every Environment.
+ * The track's state is a plain `MutableRef`: each response runs to completion, and a
+ * release is stopped before the next response changes the state.
+ */
+import * as Drag from "@wardic/core/Drag";
+import * as InputFeed from "@wardic/core/InputFeed";
+import * as InputSource from "@wardic/core/InputSource";
+import type * as Values from "@wardic/core/Values";
+import type * as FlushGate from "@wardic/dom/FlushGate";
+import type * as ProjectionSystem from "@wardic/dom/ProjectionSystem";
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { DragContainer } from "./drag-constraints.ts";
+import type { WardicServices } from "./runtime.ts";
+import type { WardicTransformPoint } from "./config.ts";
+import { type WardicDragControls } from "./drag-controls.ts";
+/**
+ * The element's values as its drag reads and writes them: `values` and `velocities` by key, when `x`
+ * and `y` last moved, and the clock's time. The drag goes on from where the element is, and leaves it
+ * where the drag left it, its speed with it.
+ */
+export interface DragSnapshot {
+    values: Values.Values;
+    velocities: Record<string, number>;
+    /** When the drag last moved `x` and `y`: their velocity holds 30 ms from then. */
+    drawnAt: Record<string, number>;
+    /** The time now, on the element's provider's Clock. */
+    readonly now: () => number;
+}
+/** A drag's config, read once as it starts: the `drag` props of a Wardic element. */
+export interface DragTrackConfig {
+    /** `true` = free; `"x"`/`"y"` = axis-locked. */
+    readonly axis: boolean | "x" | "y";
+    /**
+     * `true`: the drag takes no **Drag claim** and is never refused, so a draggable ancestor can
+     * drag with it (Motion's `dragPropagation`). Default `false`.
+     */
+    readonly propagation?: boolean | undefined;
+    /**
+     * Optional numeric constraints (per axis) on the element's x/y, whichever gesture moved it there
+     * (Motion's): the drag keeps it within them, and a Fling springs back
+     * to an edge it would cross. A projection node's x/y is its drag offset.
+     */
+    readonly constraints?: Drag.Bounds | undefined;
+    /** Rubber-band resistance past `constraints`: 0 a hard clamp. Default {@link DEFAULT_DRAG_ELASTIC}. */
+    readonly elastic?: number | undefined;
+    /** Fling on release (default true); `false` releases with no velocity. */
+    readonly momentum?: boolean | undefined;
+    /** Spring back to the origin on release: both edges at 0. */
+    readonly snapToOrigin?: boolean | undefined;
+    /**
+     * Motion's `dragDirectionLock`: each gesture starts once it passes 10 px on one
+     * axis, and drags, claims and releases on that axis alone (`DragRecognizer.drag`'s `lock`).
+     */
+    readonly directionLock?: boolean | undefined;
+    /** What the release runs on: the element's drag transition, resolved ({@link dragTransitionOf}). */
+    readonly transition: ProjectionSystem.DragTransition;
+    /**
+     * Motion's `dragListener`: `false`, the element's own presses start no drag and stop no
+     * release; only its **Drag controls**' starts do. Default `true`.
+     */
+    readonly listen?: boolean | undefined;
+}
+/** What the track's watches and responses run with: the provider's services and the gestures' input (#511). */
+export type TrackServices = WardicServices | InputSource.InputSource;
+/** Options for {@link driveDragTrack}. */
+export interface DragTrackOptions {
+    /**
+     * Runs the track in the element's watch Scope: its watches subscribed now, with no
+     * fiber, until the element goes and the Scope closes, which stops a running release. A throw from a
+     * watch's fold goes to the `onDefect` it's given (#209: each binding's Solid owns the Scope).
+     */
+    readonly watch: (track: (onDefect: InputFeed.OnDefect) => Effect.Effect<void, never, Scope.Scope | TrackServices>) => void;
+    /**
+     * Runs a response forked on the provider runtime: its fiber starts at once and runs to its
+     * end inside the event. A release it forks keeps the runtime's scheduler, a host's if it gave one,
+     * not a `runSync`'s sync one, which would resume
+     * the release's yields on a microtask.
+     */
+    readonly fork: (response: Effect.Effect<void, never, TrackServices>) => void;
+    /** The provider-owned flush gate; the drag writes `x`/`y` into `id`. */
+    readonly gate: FlushGate.Shape;
+    /** The element's gate id (shared with the spine, so writes merge). */
+    readonly id: string;
+    /** The live element the drag recognizer attaches to. */
+    readonly element: HTMLElement;
+    /** The spine's Snapshot object (shared — see {@link DragSnapshot}). */
+    readonly snapshot: DragSnapshot;
+    /** Merge a value-map into the presence snapshot (mirrors the spine's recordFrame). */
+    readonly recordFrame: (value: Values.Values) => void;
+    /** Flip the reactive `dragging` signal the spine reads for `whileDrag` + key stripping. */
+    readonly setDragging: (dragging: boolean) => void;
+    /** The static drag config (read once at setup). */
+    readonly config: DragTrackConfig;
+    /**
+     * When the element is a projection node, the drag feeds the projection
+     * instead of writing raw `x`/`y`, which stay the element's own, drawn on top:
+     * grab → `dragStart`, each sample → `dragMove(offset)`, release →
+     * `dragEnd(velocity)` (its Release offset — the free tail is skipped), a press →
+     * `stopRelease`, a press that ends with no drag → `resumeRelease`. Absent ⇒ free drag.
+     */
+    readonly projection?: ProjectionSystem.DragHandle | undefined;
+    /**
+     * The gesture's axis, read at each gesture's "start" and held until its "end"
+     * (`true` = free), in place of `config.axis`: the axis it moves on and claims
+     * (internal: a `<Reorder>` item, whose group decides the axis per gesture, D5).
+     */
+    readonly axisAt?: (() => boolean | "x" | "y") | undefined;
+    /**
+     * Each sample, after its projection write: after `dragMove` for "start" and
+     * "move", after `dragEnd` for "end", so a reader of the handle's `dragOffset()`
+     * sees this sample (internal: a `<Reorder>` item's group).
+     */
+    readonly onSample?: ((sample: Drag.Sample) => void) | undefined;
+    /**
+     * The release came to rest on its own (Motion's `onDragTransitionEnd`): its Fling or its
+     * spring back finished, or it was dropped where it rests. Told after the gate's flush of the rest
+     * value. Not for one a grab stopped. A free drag's only: a layout node's release is its Release
+     * offset, which the projection tells.
+     */
+    readonly onReleaseEnd?: (() => void) | undefined;
+    /**
+     * Whether its animations are skipped (its nearest `WardicConfig`'s `skipAnimations`), read at
+     * each release: a skipped one lands at once where it would come to rest. Omitted, never.
+     */
+    readonly skipAnimations?: (() => boolean) | undefined;
+    /**
+     * An element constraint (Motion's `dragConstraints={ref}`): the container whose box
+     * the element's must stay inside, in place of `config.constraints`. It's measured at each drag's
+     * start, and again when the element or the container resizes; a resize that changes the bounds
+     * moves an element at rest (or releasing, which it stops) to keep its place within them (Motion's
+     * `scalePositionWithinConstraints`). A container not there at a drag's start leaves it unconstrained.
+     */
+    readonly container?: DragContainer | undefined;
+    /**
+     * The **Drag controls** given to the element (Motion's `dragControls`): the track subscribes to
+     * them while its watch Scope is open.
+     */
+    readonly controls?: WardicDragControls | undefined;
+    /**
+     * Where the drag's points are (its nearest `WardicConfig`'s `transformPagePoint`): read at
+     * each down, and applied to its every point and to the box its snap to the cursor measures.
+     * Omitted, as they are.
+     */
+    readonly mapPoint?: (() => WardicTransformPoint | undefined) | undefined;
+}
+/** A running drag track, for the spine's Retargets (#340). */
+export interface DragTrack {
+    /**
+     * Take `x`/`y` from a free drag's running release (#340) for a Retarget that gives `retargeted`
+     * new targets, as a newer animation of Motion's value stops the one running: the release stops
+     * where it is and tells no end, and `dragging` is handed back at the end of the task (not in the
+     * caller's Retarget, which reads it). `false`, and nothing done, when no release runs, a gesture
+     * is on, or none of `retargeted` is an axis the release runs on (Motion's runs one per axis).
+     */
+    readonly takeRelease: (retargeted: {
+        readonly x: boolean;
+        readonly y: boolean;
+    }) => boolean;
+}
+/**
+ * Run the drag track for one element. Recognize `drag(element)` on its axis (read at
+ * each gesture's start for a `<Reorder>` item) with its **Drag claim** (none with
+ * `propagation`), then consume it, kept within its constraints, and the element's bare
+ * pointer-down grabs, each in place as it arrives (ADR-0032; the module doc). A drag
+ * refused its claim emits nothing, so a draggable ancestor of the element that claimed
+ * neither follows the pointer nor turns `whileDrag` on; its grab still stops its running
+ * release (ADR-0019, *Amendment (#29)*). The track runs in the element's watch Scope
+ * (`opts.watch`, #379), with no fiber at rest: closing it stops the watches (dropping the
+ * shared feed's count) and any in-flight release. A response that fails, or a release, is
+ * reported, and the track goes on.
+ *
+ * The drag config is read ONCE at setup (the caller passes a static
+ * {@link DragTrackConfig} — drag config is a document, not reactive); only the
+ * `dragging` signal the spine reads is reactive.
+ */
+export declare const driveDragTrack: (opts: DragTrackOptions) => DragTrack;
+//# sourceMappingURL=drag-track.d.ts.map

package/dist/solid/drag-track.d.ts.map

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