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

package/dist/DomProjectionSystem.js

@@ -0,0 +1,41 @@
+/**
+ * The DOM's Projection system: `layer` builds it, writing through the Environment's
+ * `FlushGate`, and `make` builds it over any sink, for a binding that wires it itself. Only a binding's
+ * layout feature imports it, so a page that never lays out ships none of it. Closing its Scope stops the
+ * engine: its run, its observers and listeners, and what it forked. Built after the gate, it ends before
+ * it.
+ *
+ * @example
+ * import * as DomProjectionSystem from "@wardic/dom/DomProjectionSystem"
+ *
+ * const layout = DomProjectionSystem.layer().pipe(Layer.provide(FlushGate.layer({ batch: (apply) => apply() })))
+ */
+// The DOM's **Projection system** engine (#548, ADR-0041's `Dom` implementations), apart from
+// `ProjectionSystem`'s key and types (ADR-0067, *Amendment (#548)*). Its members are plain functions.
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as FlushGate from "./FlushGate.js";
+import { PassEnds } from "./internal/pass-ends.js";
+import * as internal from "./internal/projection.js";
+import { makeRunner } from "./internal/runner.js";
+import { ProjectionSystem } from "./ProjectionSystem.js";
+/**
+ * Build the engine over `sink`, the context's Frame loop and Renderer, in the current Scope: what
+ * it forks runs in that Scope, and closing it ends the engine. It's the `ProjectionSystem` in the
+ * context it gives, beside what a Reorder controller over it needs.
+ */
+// The context holds the internal `PassEnds` too (internal/pass-ends.ts, #618), the engine's own, so a
+// ProjectionSystem a binding wraps or replaces in its context still has its Reorder controller hear
+// each Measure pass. Its runner forks on Effect's default scheduler, whatever call built the Layer
+// (`internal/runner.ts`).
+export const make = 
+/*#__PURE__*/ Effect.fnUntraced(function* (sink, options = {}) {
+    // Typed without `dispose` and `onPassEnd`: the Scope ends it, and `PassEnds` hands the other out.
+    const system = internal.makeProjectionSystem(yield* makeRunner(), sink, options);
+    yield* Effect.addFinalizer(() => Effect.sync(system.dispose));
+    return Context.make(ProjectionSystem, system).pipe(Context.add(PassEnds, { onPassEnd: system.onPassEnd }));
+});
+/** The engine as a Layer, writing through the Environment's `FlushGate`: built by `make`, ended by the Layer's Scope. */
+export const layer = (options = {}) => Layer.effectContext(Effect.flatMap(Effect.service(FlushGate.FlushGate), (gate) => make(gate, options)));
+//# sourceMappingURL=DomProjectionSystem.js.map

package/dist/DomProjectionSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomProjectionSystem.js","sourceRoot":"","sources":["../src/DomProjectionSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,8FAA8F;AAC9F,sGAAsG;AACtG,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,KAAK,QAAQ,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAsD,MAAM,uBAAuB,CAAA;AAE5G;;;;GAIG;AACH,sGAAsG;AACtG,oGAAoG;AACpG,mGAAmG;AACnG,0BAA0B;AAC1B,MAAM,CAAC,MAAM,IAAI;AACf,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,IAAU,EAAE,OAAO,GAAY,EAAE;IAC1E,kGAAkG;IAClG,MAAM,MAAM,GAAG,QAAQ,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,UAAU,EAAY,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;IAC1F,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAA;IAC7D,OAAO,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAe,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAA;AACrH,CAAC,CAAC,CAAA;AAEJ,yHAAyH;AACzH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,OAAO,GAAY,EAAE,EAAmF,EAAE,CAC9H,KAAK,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA"}

package/dist/DomRenderer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The DOM's Renderer: `project` turns a Frame's values into a style patch, grouping the transform keys
+ * into one `transform` and drawing a bare number on a length in `px`, and its `commit` writes the patch
+ * onto an element. The rest is for a binding's layout projection: an element's own move, scale, rotation
+ * and opacity, read from its values, and its transform template.
+ *
+ * @example
+ * import * as DomRenderer from "@wardic/dom/DomRenderer"
+ *
+ * DomRenderer.project({ x: 100, opacity: 0.5 }) // { transform: "translateX(100px)", opacity: 0.5 }
+ */
+export { RendererDomLive as layer, project, ownScaleOf, ownTranslateOf, ownRotateOf, ownOpacityOf, TEMPLATE_KEY, type TransformTemplate, heldTransformOf, LENGTH_KEYS, type LengthKey, } from "./internal/renderer.ts";
+//# sourceMappingURL=DomRenderer.d.ts.map

package/dist/DomRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomRenderer.d.ts","sourceRoot":"","sources":["../src/DomRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,eAAe,IAAI,KAAK,EACxB,OAAO,EACP,UAAU,EACV,cAAc,EACd,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,KAAK,iBAAiB,EACtB,eAAe,EACf,WAAW,EACX,KAAK,SAAS,GACf,MAAM,wBAAwB,CAAA"}

package/dist/DomRenderer.js

@@ -0,0 +1,15 @@
+/**
+ * The DOM's Renderer: `project` turns a Frame's values into a style patch, grouping the transform keys
+ * into one `transform` and drawing a bare number on a length in `px`, and its `commit` writes the patch
+ * onto an element. The rest is for a binding's layout projection: an element's own move, scale, rotation
+ * and opacity, read from its values, and its transform template.
+ *
+ * @example
+ * import * as DomRenderer from "@wardic/dom/DomRenderer"
+ *
+ * DomRenderer.project({ x: 100, opacity: 0.5 }) // { transform: "translateX(100px)", opacity: 0.5 }
+ */
+// `@wardic/dom/DomRenderer` (#132, ADR-0041): ADR-0006, ADR-0034; the **Transform template** (#443);
+// `LENGTH_KEYS` (#522).
+export { RendererDomLive as layer, project, ownScaleOf, ownTranslateOf, ownRotateOf, ownOpacityOf, TEMPLATE_KEY, heldTransformOf, LENGTH_KEYS, } from "./internal/renderer.js";
+//# sourceMappingURL=DomRenderer.js.map

package/dist/DomRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomRenderer.js","sourceRoot":"","sources":["../src/DomRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qGAAqG;AACrG,wBAAwB;AACxB,OAAO,EACL,eAAe,IAAI,KAAK,EACxB,OAAO,EACP,UAAU,EACV,cAAc,EACd,WAAW,EACX,YAAY,EACZ,YAAY,EAEZ,eAAe,EACf,WAAW,GAEZ,MAAM,wBAAwB,CAAA"}

package/dist/FlushGate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The Flush gate: where a binding writes each element's animated values, drawn onto the elements once a
+ * frame. A binding registers each element with its target, writes values as its animations step, and the
+ * gate draws them together, at the end of the frame's animation tick, through the Environment's renderer;
+ * a write made outside a tick, as a drag's move is, asks for a frame of its own. A server render gets
+ * `inert`, which does nothing.
+ *
+ * @example
+ * import * as FlushGate from "@wardic/dom/FlushGate"
+ *
+ * const gate = yield* FlushGate.FlushGate
+ * const unregister = gate.register("card", { target: card })
+ * gate.write("card", { opacity: 0.5 }) // drawn at the next frame
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+import * as internal from "./internal/gate.ts";
+/** The gate: what a binding registers its elements with and writes their values into. */
+export type Shape = Omit<internal.FlushGate, "dispose">;
+/** An element's commit target and hooks, given to `register`. */
+export type Sink = internal.FlushSink;
+/** What a binding hands its gate: the `batch` a frame's Starting-style switches run in. */
+export type Options = internal.FlushGateOptions;
+/** The services a gate needs from its Environment. */
+export type Services = internal.FlushGateServices;
+declare const FlushGate_base: Context.ServiceClass<FlushGate, "@wardic/dom/FlushGate", Shape>;
+/** The Environment's Flush gate. */
+export declare class FlushGate extends FlushGate_base {
+}
+/**
+ * Build a gate over the context's Renderer, Frame loop and Refresh frame source, in the current
+ * Scope: what it forks runs in that Scope, and closing it ends the gate.
+ */
+export declare const make: (options: Options) => Effect.Effect<Shape, never, Services | Scope.Scope>;
+/** The gate as a Layer: built by `make`, ended by the Layer's Scope. */
+export declare const layer: (options: Options) => Layer.Layer<FlushGate, never, Services>;
+/**
+ * The gate a server render gets: it flushes nothing, so `register` returns an unregister that does
+ * nothing, and the rest do nothing, `afterFlush` included, since no flush comes. Code that takes the gate
+ * at setup and uses it after mount keeps working on a server.
+ */
+export declare const inert: Shape;
+/** `inert` as a Layer, for a binding whose server render runs an Effect program. */
+export declare const layerInert: Layer.Layer<FlushGate>;
+export {};
+//# sourceMappingURL=FlushGate.d.ts.map

package/dist/FlushGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlushGate.d.ts","sourceRoot":"","sources":["../src/FlushGate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAA;AAG9C,yFAAyF;AACzF,MAAM,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;AAEvD,iEAAiE;AACjE,MAAM,MAAM,IAAI,GAAG,QAAQ,CAAC,SAAS,CAAA;AAErC,2FAA2F;AAC3F,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,gBAAgB,CAAA;AAE/C,sDAAsD;AACtD,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,iBAAiB,CAAA;;AAEjD,oCAAoC;AACpC,qBAAa,SAAU,SAAQ,cAA4D;CAAG;AAE9F;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,GAAG,KAAK,CAAC,KAAK,CAOvF,CAAA;AAEJ,wEAAwE;AACxE,eAAO,MAAM,KAAK,YAAa,OAAO,KAAG,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAA2C,CAAA;AAO1H;;;;GAIG;AAEH,eAAO,MAAM,KAAK,EAAE,KAOlB,CAAA;AAEF,oFAAoF;AACpF,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS,CAAmC,CAAA"}

package/dist/FlushGate.js

@@ -0,0 +1,62 @@
+/**
+ * The Flush gate: where a binding writes each element's animated values, drawn onto the elements once a
+ * frame. A binding registers each element with its target, writes values as its animations step, and the
+ * gate draws them together, at the end of the frame's animation tick, through the Environment's renderer;
+ * a write made outside a tick, as a drag's move is, asks for a frame of its own. A server render gets
+ * `inert`, which does nothing.
+ *
+ * @example
+ * import * as FlushGate from "@wardic/dom/FlushGate"
+ *
+ * const gate = yield* FlushGate.FlushGate
+ * const unregister = gate.register("card", { target: card })
+ * gate.write("card", { opacity: 0.5 }) // drawn at the next frame
+ */
+// The **Flush gate** (ADR-0006, ADR-0031, ADR-0033, ADR-0034). `@wardic/dom/FlushGate` (#132, ADR-0041). A
+// service built by a Layer (`layer`) and ended by that Layer's Scope: closing it takes the gate's hook off
+// the Frame loop, cancels a pending frame and clears what it held. Its members are plain functions, called
+// per element and per frame. `make` is the scoped constructor, for a binding that wires it itself. `inert`
+// (ADR-0021, decision 9): a value for a binding whose server builds no runtime, or `layerInert` for one
+// whose server runs an Effect program.
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Atom } from "effect/reactivity";
+import * as internal from "./internal/gate.js";
+import { makeRunner } from "./internal/runner.js";
+/** The Environment's Flush gate. */
+export class FlushGate extends Context.Service()("@wardic/dom/FlushGate") {
+}
+/**
+ * Build a gate over the context's Renderer, Frame loop and Refresh frame source, in the current
+ * Scope: what it forks runs in that Scope, and closing it ends the gate.
+ */
+export const make = Effect.fnUntraced(function* (options) {
+    // The gate itself, typed without `dispose`: the Scope ends it. Its runner forks on Effect's
+    // default scheduler, whatever call built the Layer (`internal/runner.ts`).
+    const gate = internal.makeFlushGate(yield* makeRunner(), options);
+    yield* Effect.addFinalizer(() => Effect.sync(gate.dispose));
+    return gate;
+});
+/** The gate as a Layer: built by `make`, ended by the Layer's Scope. */
+export const layer = (options) => Layer.effect(FlushGate)(make(options));
+const noop = () => { };
+/** What `inert`'s `valueOf` gives: an Atom that stays `undefined`, since nothing is committed on a server. */
+const NO_VALUE = Atom.make(undefined);
+/**
+ * The gate a server render gets: it flushes nothing, so `register` returns an unregister that does
+ * nothing, and the rest do nothing, `afterFlush` included, since no flush comes. Code that takes the gate
+ * at setup and uses it after mount keeps working on a server.
+ */
+// ADR-0021, decision 9.
+export const inert = Object.freeze({
+    register: () => noop,
+    write: noop,
+    flushPass: noop,
+    release: noop,
+    valueOf: () => NO_VALUE,
+    afterFlush: noop,
+});
+/** `inert` as a Layer, for a binding whose server render runs an Effect program. */
+export const layerInert = Layer.succeed(FlushGate, inert);
+//# sourceMappingURL=FlushGate.js.map

package/dist/FlushGate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlushGate.js","sourceRoot":"","sources":["../src/FlushGate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,2GAA2G;AAC3G,2GAA2G;AAC3G,2GAA2G;AAC3G,2GAA2G;AAC3G,wGAAwG;AACxG,uCAAuC;AACvC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAExC,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAcjD,oCAAoC;AACpC,MAAM,OAAO,SAAU,SAAQ,OAAO,CAAC,OAAO,EAAoB,CAAC,uBAAuB,CAAC;CAAG;AAE9F;;;GAGG;AACH,MAAM,CAAC,MAAM,IAAI,GAA8E,MAAM,CAAC,UAAU,CAC9G,QAAQ,CAAC,EAAE,OAAgB;IACzB,4FAA4F;IAC5F,2EAA2E;IAC3E,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,UAAU,EAAY,EAAE,OAAO,CAAC,CAAA;IAC3E,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;IAC3D,OAAO,IAAI,CAAA;AACb,CAAC,CAAC,CAAA;AAEJ,wEAAwE;AACxE,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,OAAgB,EAA2C,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;AAE1H,MAAM,IAAI,GAAG,GAAS,EAAE,GAAE,CAAC,CAAA;AAE3B,8GAA8G;AAC9G,MAAM,QAAQ,GAAuB,IAAI,CAAC,IAAI,CAAU,SAAS,CAAC,CAAA;AAElE;;;;GAIG;AACH,wBAAwB;AACxB,MAAM,CAAC,MAAM,KAAK,GAAU,MAAM,CAAC,MAAM,CAAC;IACxC,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI;IACpB,KAAK,EAAE,IAAI;IACX,SAAS,EAAE,IAAI;IACf,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ;IACvB,UAAU,EAAE,IAAI;CACjB,CAAC,CAAA;AAEF,oFAAoF;AACpF,MAAM,CAAC,MAAM,UAAU,GAA2B,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA"}

package/dist/MeasuredPair.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Measured pairs: a key that places or sizes the box, whose two ends are lengths of different types,
+ * `"auto"` against px, `"50%"` against a number, a `calc()`, can't blend as written. Both ends are
+ * measured in px at the end of the task that asks, as Motion's are, so the animation runs between them
+ * and lands on its target as given.
+ *
+ * @example
+ * import * as MeasuredPair from "@wardic/dom/MeasuredPair"
+ *
+ * MeasuredPair.needs("width", "auto", 200) // true
+ * MeasuredPair.needs("opacity", 0, 1) // false
+ */
+export { measure, measured, type Measured, needs, type Requested } from "./internal/measured-pairs.ts";
+//# sourceMappingURL=MeasuredPair.d.ts.map

package/dist/MeasuredPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasuredPair.d.ts","sourceRoot":"","sources":["../src/MeasuredPair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/MeasuredPair.js

@@ -0,0 +1,16 @@
+/**
+ * Measured pairs: a key that places or sizes the box, whose two ends are lengths of different types,
+ * `"auto"` against px, `"50%"` against a number, a `calc()`, can't blend as written. Both ends are
+ * measured in px at the end of the task that asks, as Motion's are, so the animation runs between them
+ * and lands on its target as given.
+ *
+ * @example
+ * import * as MeasuredPair from "@wardic/dom/MeasuredPair"
+ *
+ * MeasuredPair.needs("width", "auto", 200) // true
+ * MeasuredPair.needs("opacity", 0, 1) // false
+ */
+// **Measured pairs** (#430, CONTEXT.md, Motion's `DOMKeyframesResolver`). `@wardic/dom/MeasuredPair`: for
+// binding authors.
+export { measure, measured, needs } from "./internal/measured-pairs.js";
+//# sourceMappingURL=MeasuredPair.js.map

package/dist/MeasuredPair.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasuredPair.js","sourceRoot":"","sources":["../src/MeasuredPair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,0GAA0G;AAC1G,mBAAmB;AACnB,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAiB,KAAK,EAAkB,MAAM,8BAA8B,CAAA"}

package/dist/OwnValues.d.ts

@@ -0,0 +1,14 @@
+/**
+ * An element's own values: what its style or its computed style says for a key, read once, the value an
+ * animation starts from, and returns to when nothing else sets it. `valueLike` reads a raw value in the
+ * shape of the key's target.
+ *
+ * @example
+ * import * as OwnValues from "@wardic/dom/OwnValues"
+ *
+ * const own = OwnValues.of(element)
+ * own("opacity") // Some("1"), from its computed style
+ * OwnValues.valueLike("10px", 0) // Some(10)
+ */
+export { ownValues as of, styleValueOf, valueLike, type OwnValue, } from "./internal/own-values.ts";
+//# sourceMappingURL=OwnValues.d.ts.map

package/dist/OwnValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OwnValues.d.ts","sourceRoot":"","sources":["../src/OwnValues.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,SAAS,IAAI,EAAE,EACf,YAAY,EACZ,SAAS,EACT,KAAK,QAAQ,GACd,MAAM,0BAA0B,CAAA"}

package/dist/OwnValues.js

@@ -0,0 +1,15 @@
+/**
+ * An element's own values: what its style or its computed style says for a key, read once, the value an
+ * animation starts from, and returns to when nothing else sets it. `valueLike` reads a raw value in the
+ * shape of the key's target.
+ *
+ * @example
+ * import * as OwnValues from "@wardic/dom/OwnValues"
+ *
+ * const own = OwnValues.of(element)
+ * own("opacity") // Some("1"), from its computed style
+ * OwnValues.valueLike("10px", 0) // Some(10)
+ */
+// `@wardic/dom/OwnValues` (#132, ADR-0041): its Base values (ADR-0022).
+export { ownValues as of, styleValueOf, valueLike, } from "./internal/own-values.js";
+//# sourceMappingURL=OwnValues.js.map

package/dist/OwnValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OwnValues.js","sourceRoot":"","sources":["../src/OwnValues.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wEAAwE;AACxE,OAAO,EACL,SAAS,IAAI,EAAE,EACf,YAAY,EACZ,SAAS,GAEV,MAAM,0BAA0B,CAAA"}

package/dist/ProjectionSystem.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The Projection system: what runs the DOM's layout animations, one per Environment a binding builds. A binding registers
+ * each layout element with it, and when a layout changes it measures their boxes, draws each where it was
+ * with a transform, and animates it to where it is now; elements that share a `layoutId` fly one into the
+ * other. This module is its key and its types, which every element's code reads: the engine itself is
+ * `DomProjectionSystem`'s, so a page that never lays out ships none of it. `toJSON()` gives its tree as
+ * plain data, for a diagnostic view. A server render builds none.
+ *
+ * @example
+ * import * as ProjectionSystem from "@wardic/dom/ProjectionSystem"
+ *
+ * const system = yield* ProjectionSystem.ProjectionSystem
+ * const node = system.register({ id: "card", element: card, transition: () => Option.none() })
+ * system.animateLayout(() => expand(card)) // measured before and after, and animated between
+ */
+import * as Context from "effect/Context";
+import type * as internal from "./internal/projection.ts";
+export { type RegisterNodeOptions, type ProjectionNodeHandle as NodeHandle, type DragProjectionHandle as DragHandle, type AnimateLayoutOptions, type Tree, type TreeNode, } from "./internal/projection.ts";
+export { DEFAULT_DRAG_TRANSITION, DEFAULT_LAYOUT_TRANSITION, type DragTransition, type LayoutTransition } from "./internal/projection-defaults.ts";
+export type { ScaleCorrectorEntry as ScaleCorrector, CorrectorInfo } from "./internal/scale-correction.ts";
+export { dragBoundsWithin, measureLayoutBox } from "./internal/measure.ts";
+/** The engine: what a binding registers its layout elements with. */
+export type Shape = Omit<internal.ProjectionSystem, "dispose" | "onPassEnd">;
+/** What the engine writes each node's projection through: a `FlushGate`'s `write` and `flushPass`. */
+export type Sink = internal.ProjectionSink;
+/** What a binding hands its engine: whether reduced motion applies now, and the app's scale correctors. */
+export type Options = internal.ProjectionSystemOptions;
+/** The services the engine needs from its Environment. */
+export type Services = internal.ProjectionServices;
+declare const ProjectionSystem_base: Context.ServiceClass<ProjectionSystem, "@wardic/dom/ProjectionSystem", Shape>;
+/** The Environment's Projection system. */
+export declare class ProjectionSystem extends /*#__PURE__*/ ProjectionSystem_base {
+}
+//# sourceMappingURL=ProjectionSystem.d.ts.map

package/dist/ProjectionSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectionSystem.d.ts","sourceRoot":"","sources":["../src/ProjectionSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,QAAQ,MAAM,0BAA0B,CAAA;AAEzD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,IAAI,UAAU,EACvC,KAAK,oBAAoB,IAAI,UAAU,EACvC,KAAK,oBAAoB,EACzB,KAAK,IAAI,EACT,KAAK,QAAQ,GACd,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AAClJ,YAAY,EAAE,mBAAmB,IAAI,cAAc,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAC1G,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE1E,qEAAqE;AACrE,MAAM,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,GAAG,WAAW,CAAC,CAAA;AAE5E,sGAAsG;AACtG,MAAM,MAAM,IAAI,GAAG,QAAQ,CAAC,cAAc,CAAA;AAE1C,2GAA2G;AAE3G,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,uBAAuB,CAAA;AAEtD,0DAA0D;AAC1D,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,kBAAkB,CAAA;;AAElD,2CAA2C;AAC3C,qBAAa,gBAAiB,SAAQ,aAAa,CAAC,qBAA0E;CAAG"}

package/dist/ProjectionSystem.js

@@ -0,0 +1,29 @@
+/**
+ * The Projection system: what runs the DOM's layout animations, one per Environment a binding builds. A binding registers
+ * each layout element with it, and when a layout changes it measures their boxes, draws each where it was
+ * with a transform, and animates it to where it is now; elements that share a `layoutId` fly one into the
+ * other. This module is its key and its types, which every element's code reads: the engine itself is
+ * `DomProjectionSystem`'s, so a page that never lays out ships none of it. `toJSON()` gives its tree as
+ * plain data, for a diagnostic view. A server render builds none.
+ *
+ * @example
+ * import * as ProjectionSystem from "@wardic/dom/ProjectionSystem"
+ *
+ * const system = yield* ProjectionSystem.ProjectionSystem
+ * const node = system.register({ id: "card", element: card, transition: () => Option.none() })
+ * system.animateLayout(() => expand(card)) // measured before and after, and animated between
+ */
+// The **Projection system**, the DOM's engine for the **Projection** (ADR-0009, ADR-0010, ADR-0018): it
+// holds every Projection node, runs the Measure pass and the per-frame projection pass, and owns `layoutId`
+// matching. `@wardic/dom/ProjectionSystem` (#132, ADR-0041). The key apart from the engine: #548, ADR-0067
+// *Amendment (#548)*. An Effect `Inspectable` (#384): `console.log(system)` shows the tree, as `Tree`,
+// each node with its parent, its `layoutId` twin's part and what it's doing; the layout lab draws it. A
+// server render builds none (ADR-0021).
+import * as Context from "effect/Context";
+export {} from "./internal/projection.js";
+export { DEFAULT_DRAG_TRANSITION, DEFAULT_LAYOUT_TRANSITION } from "./internal/projection-defaults.js";
+export { dragBoundsWithin, measureLayoutBox } from "./internal/measure.js";
+/** The Environment's Projection system. */
+export class ProjectionSystem extends /*#__PURE__*/ /*#__PURE__*/ Context.Service()("@wardic/dom/ProjectionSystem") {
+}
+//# sourceMappingURL=ProjectionSystem.js.map

package/dist/ProjectionSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectionSystem.js","sourceRoot":"","sources":["../src/ProjectionSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wGAAwG;AACxG,4GAA4G;AAC5G,2GAA2G;AAC3G,uGAAuG;AACvG,wGAAwG;AACxG,wCAAwC;AACxC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAGzC,OAAO,EAON,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAA8C,MAAM,mCAAmC,CAAA;AAElJ,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAe1E,2CAA2C;AAC3C,MAAM,OAAO,gBAAiB,SAAQ,aAAa,CAAb,aAAa,CAAC,OAAO,CAAC,OAAO,EAA2B,CAAC,8BAA8B,CAAC;CAAG"}

package/dist/ReorderController.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A Reorder group on the DOM: the group, its items' drags, its keyboard and its announcements, one
+ * controller a group. `make` builds one over the context's Projection system and `Announcer`; a binding
+ * attaches its group element, gets a driver for each item, and closing the Scope ends the controller. A
+ * server render gets `inert`.
+ *
+ * @example
+ * import * as ReorderController from "@wardic/dom/ReorderController"
+ *
+ * const controller = yield* ReorderController.make({ values: () => items, onReorder: (next) => (items = next) })
+ * controller.attach(list)
+ * const driver = controller.item(item, () => Option.some(element))
+ */
+import * as Announcer from "@wardic/core/Announcer";
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import { PassEnds } from "./internal/pass-ends.ts";
+import * as internal from "./internal/reorder.ts";
+import * as ProjectionSystem from "./ProjectionSystem.ts";
+export { type ReorderEnd as End, type ReorderHoldEnd as HoldEnd, type ReorderHoldHow as HoldHow, type ReorderHoldStart as HoldStart, type ReorderItemDriver as ItemDriver, DEFAULT_REORDER_INSTRUCTIONS as DEFAULT_INSTRUCTIONS, REORDER_GROUP_STYLE as GROUP_STYLE, } from "./internal/reorder.ts";
+/** A **Reorder group** on the DOM: what a binding attaches its group element and items to. */
+export type ReorderController<V> = Omit<internal.ReorderController<V>, "dispose">;
+/** What a binding hands its group: the app's values, its axis, its keyboard and its announcements. */
+export type Options<V> = internal.ReorderControllerOptions<V>;
+/**
+ * The services a controller takes from its context: the projection system its items are nodes of,
+ * with what tells it each Measure pass's end (`DomProjectionSystem`'s Layer provides both), and the
+ * Environment's `Announcer`.
+ */
+export type Services = ProjectionSystem.ProjectionSystem | PassEnds | Announcer.Announcer;
+/**
+ * Build a group's controller over the context's projection system, announcing through its
+ * `Announcer`, in the current Scope: closing it ends the controller.
+ */
+export declare const make: <V>(options: Options<V>) => Effect.Effect<ReorderController<V>, never, Services | Scope.Scope>;
+/**
+ * The controller a server render gets: its group has no values, so every operation on it does nothing,
+ * its axis is `"y"`, and an item's driver does nothing too.
+ */
+export declare const inert: ReorderController<never>;
+//# sourceMappingURL=ReorderController.d.ts.map

package/dist/ReorderController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReorderController.d.ts","sourceRoot":"","sources":["../src/ReorderController.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,KAAK,QAAQ,MAAM,uBAAuB,CAAA;AAEjD,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD,OAAO,EACL,KAAK,UAAU,IAAI,GAAG,EACtB,KAAK,cAAc,IAAI,OAAO,EAC9B,KAAK,cAAc,IAAI,OAAO,EAC9B,KAAK,gBAAgB,IAAI,SAAS,EAClC,KAAK,iBAAiB,IAAI,UAAU,EACpC,4BAA4B,IAAI,oBAAoB,EACpD,mBAAmB,IAAI,WAAW,GACnC,MAAM,uBAAuB,CAAA;AAE9B,8FAA8F;AAC9F,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;AAEjF,sGAAsG;AACtG,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,QAAQ,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAA;AAE7D;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,gBAAgB,CAAC,gBAAgB,GAAG,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAA;AAEzF;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,KAAK,CAAC,KAAK,CAW5G,CAAA;AAEJ;;;GAGG;AAEH,eAAO,MAAM,KAAK,EAAE,iBAAiB,CAAC,KAAK,CAAqC,CAAA"}

package/dist/ReorderController.js

@@ -0,0 +1,44 @@
+/**
+ * A Reorder group on the DOM: the group, its items' drags, its keyboard and its announcements, one
+ * controller a group. `make` builds one over the context's Projection system and `Announcer`; a binding
+ * attaches its group element, gets a driver for each item, and closing the Scope ends the controller. A
+ * server render gets `inert`.
+ *
+ * @example
+ * import * as ReorderController from "@wardic/dom/ReorderController"
+ *
+ * const controller = yield* ReorderController.make({ values: () => items, onReorder: (next) => (items = next) })
+ * controller.attach(list)
+ * const driver = controller.item(item, () => Option.some(element))
+ */
+// A **Reorder group**'s controller (ADR-0019 *Amendment (Reorder)*, ADR-0037); a server render's `inert`
+// (ADR-0021). `@wardic/dom/ReorderController` (#132, ADR-0041). A scoped constructor, one per group (#132's
+// PR 3): `make` logs its `wardic.reorder:` events through the context's Logger, and ends with its Scope,
+// which stops its listening to Measure passes, resets its Auto-scroll and clears a pending announcement.
+// Its items' drivers stay plain, each with its own `dispose`, since one is made per element.
+import * as Announcer from "@wardic/core/Announcer";
+import * as Effect from "effect/Effect";
+import { PassEnds } from "./internal/pass-ends.js";
+import * as internal from "./internal/reorder.js";
+import { makeRunner } from "./internal/runner.js";
+import * as ProjectionSystem from "./ProjectionSystem.js";
+export { DEFAULT_REORDER_INSTRUCTIONS as DEFAULT_INSTRUCTIONS, REORDER_GROUP_STYLE as GROUP_STYLE, } from "./internal/reorder.js";
+/**
+ * Build a group's controller over the context's projection system, announcing through its
+ * `Announcer`, in the current Scope: closing it ends the controller.
+ */
+export const make = Effect.fnUntraced(function* (options) {
+    const projection = yield* ProjectionSystem.ProjectionSystem;
+    const passEnds = yield* PassEnds;
+    const announcer = yield* Announcer.Announcer;
+    const controller = internal.makeReorderController({ runtime: yield* makeRunner(), projection, announce: announcer.announce, onPassEnd: passEnds.onPassEnd }, options);
+    yield* Effect.addFinalizer(() => Effect.sync(controller.dispose));
+    return controller;
+});
+/**
+ * The controller a server render gets: its group has no values, so every operation on it does nothing,
+ * its axis is `"y"`, and an item's driver does nothing too.
+ */
+// ADR-0021.
+export const inert = internal.INERT_REORDER_CONTROLLER;
+//# sourceMappingURL=ReorderController.js.map

package/dist/ReorderController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReorderController.js","sourceRoot":"","sources":["../src/ReorderController.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,yGAAyG;AACzG,4GAA4G;AAC5G,yGAAyG;AACzG,yGAAyG;AACzG,6FAA6F;AAC7F,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,KAAK,QAAQ,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD,OAAO,EAML,4BAA4B,IAAI,oBAAoB,EACpD,mBAAmB,IAAI,WAAW,GACnC,MAAM,uBAAuB,CAAA;AAe9B;;;GAGG;AACH,MAAM,CAAC,MAAM,IAAI,GAAmG,MAAM,CAAC,UAAU,CACnI,QAAQ,CAAC,EAAK,OAAmB;IAC/B,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,gBAAgB,CAAC,gBAAgB,CAAA;IAC3D,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAA;IAChC,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,SAAS,CAAA;IAC5C,MAAM,UAAU,GAAG,QAAQ,CAAC,qBAAqB,CAC/C,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,UAAU,EAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS,EAAE,EAChH,OAAO,CACR,CAAA;IACD,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAA;IACjE,OAAO,UAAU,CAAA;AACnB,CAAC,CAAC,CAAA;AAEJ;;;GAGG;AACH,YAAY;AACZ,MAAM,CAAC,MAAM,KAAK,GAA6B,QAAQ,CAAC,wBAAwB,CAAA"}

package/dist/Report.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Reporting a failure where a fiber stops: logged at Error and handed to the Environment's
+ * `ErrorReporter`s, so an app's error tracking sees it. An interruption is neither: it's how a run is
+ * removed.
+ *
+ * @example
+ * import * as Report from "@wardic/dom/Report"
+ *
+ * yield* Report.failure("wardic: an animation failed", cause)
+ */
+export { reportFailure as failure, debugKept, debugOf, type DebugLog, } from "./internal/report.ts";
+//# sourceMappingURL=Report.d.ts.map

package/dist/Report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Report.d.ts","sourceRoot":"","sources":["../src/Report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,aAAa,IAAI,OAAO,EACxB,SAAS,EACT,OAAO,EACP,KAAK,QAAQ,GACd,MAAM,sBAAsB,CAAA"}

package/dist/Report.js

@@ -0,0 +1,13 @@
+/**
+ * Reporting a failure where a fiber stops: logged at Error and handed to the Environment's
+ * `ErrorReporter`s, so an app's error tracking sees it. An interruption is neither: it's how a run is
+ * removed.
+ *
+ * @example
+ * import * as Report from "@wardic/dom/Report"
+ *
+ * yield* Report.failure("wardic: an animation failed", cause)
+ */
+// `@wardic/dom/Report` (#132, ADR-0041): ADR-0030, decision 4.
+export { reportFailure as failure, debugKept, debugOf, } from "./internal/report.js";
+//# sourceMappingURL=Report.js.map

package/dist/Report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Report.js","sourceRoot":"","sources":["../src/Report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,+DAA+D;AAC/D,OAAO,EACL,aAAa,IAAI,OAAO,EACxB,SAAS,EACT,OAAO,GAER,MAAM,sBAAsB,CAAA"}

package/dist/ScrollOffset.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Scroll offsets, the DOM's: Motion's syntax for where a target's progress through its scroll container
+ * runs, from 0 to 1, which the DOM's `Probe.scroll` resolves. Core takes an offset as its Environment's
+ * own and passes it through, so its syntax, its names and its units are the DOM's.
+ *
+ * - **An edge** is a name (`start`, `center`, `end`), a fraction of a length (`0.5`), or a CSS length:
+ *   `"100px"` a distance, `"50%"` a fraction, `"10vw"` or `"10vh"` a share of the viewport.
+ * - **A stop** is a pair of edges, `[target, container]`: the scroll position where the target's edge
+ *   meets the container's. A string holds both (`"start end"`); one edge alone is both for a name or a
+ *   number (`"end"`, `0.5`), else the target's against the container's start (`"100px"`).
+ * - **An offset** is two stops or more: progress runs from 0 at the first to 1 at the last, evenly
+ *   between them, and holds past them.
+ *
+ * @example
+ * import * as ScrollOffset from "@wardic/dom/ScrollOffset"
+ *
+ * // From the target's top meeting the container's bottom, to its bottom meeting the container's top:
+ * const across: ScrollOffset.ScrollOffset = ["start end", "end start"]
+ */
+/** One edge of a stop: a name, a fraction, or a CSS length (see the module's doc). */
+export type Edge = string | number;
+/** One stop: `[target edge, container edge]`, a string of both, or one edge. */
+export type Stop = Edge | readonly [Edge, Edge];
+/** Where a target's progress runs: two stops or more. */
+export type ScrollOffset = ReadonlyArray<Stop>;
+/** Motion's presets: while the target comes into the container. */
+export declare const Enter: ScrollOffset;
+/** While the target leaves the container. */
+export declare const Exit: ScrollOffset;
+/** While any of the target is in the container. */
+export declare const Any: ScrollOffset;
+/** While all of the target is in the container: the offset with a target and none given. */
+export declare const All: ScrollOffset;
+//# sourceMappingURL=ScrollOffset.d.ts.map

package/dist/ScrollOffset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollOffset.d.ts","sourceRoot":"","sources":["../src/ScrollOffset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,sFAAsF;AACtF,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;AAElC,gFAAgF;AAChF,MAAM,MAAM,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;AAE/C,yDAAyD;AACzD,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,IAAI,CAAC,CAAA;AAE9C,mEAAmE;AACnE,eAAO,MAAM,KAAK,EAAE,YAGnB,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,IAAI,EAAE,YAGlB,CAAA;AAED,mDAAmD;AACnD,eAAO,MAAM,GAAG,EAAE,YAGjB,CAAA;AAED,4FAA4F;AAC5F,eAAO,MAAM,GAAG,EAAE,YAGjB,CAAA"}

package/dist/ScrollOffset.js

@@ -0,0 +1,42 @@
+/**
+ * Scroll offsets, the DOM's: Motion's syntax for where a target's progress through its scroll container
+ * runs, from 0 to 1, which the DOM's `Probe.scroll` resolves. Core takes an offset as its Environment's
+ * own and passes it through, so its syntax, its names and its units are the DOM's.
+ *
+ * - **An edge** is a name (`start`, `center`, `end`), a fraction of a length (`0.5`), or a CSS length:
+ *   `"100px"` a distance, `"50%"` a fraction, `"10vw"` or `"10vh"` a share of the viewport.
+ * - **A stop** is a pair of edges, `[target, container]`: the scroll position where the target's edge
+ *   meets the container's. A string holds both (`"start end"`); one edge alone is both for a name or a
+ *   number (`"end"`, `0.5`), else the target's against the container's start (`"100px"`).
+ * - **An offset** is two stops or more: progress runs from 0 at the first to 1 at the last, evenly
+ *   between them, and holds past them.
+ *
+ * @example
+ * import * as ScrollOffset from "@wardic/dom/ScrollOffset"
+ *
+ * // From the target's top meeting the container's bottom, to its bottom meeting the container's top:
+ * const across: ScrollOffset.ScrollOffset = ["start end", "end start"]
+ */
+// #234, ADR-0043 *Amendment (#233, #234)*; resolved in `internal/scroll.ts`. `@wardic/dom/ScrollOffset`
+// (ADR-0041): the type a binding gives its `scroll` helper's `offset`.
+/** Motion's presets: while the target comes into the container. */
+export const Enter = [
+    [0, 1],
+    [1, 1],
+];
+/** While the target leaves the container. */
+export const Exit = [
+    [0, 0],
+    [1, 0],
+];
+/** While any of the target is in the container. */
+export const Any = [
+    [1, 0],
+    [0, 1],
+];
+/** While all of the target is in the container: the offset with a target and none given. */
+export const All = [
+    [0, 0],
+    [1, 1],
+];
+//# sourceMappingURL=ScrollOffset.js.map

package/dist/ScrollOffset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollOffset.js","sourceRoot":"","sources":["../src/ScrollOffset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wGAAwG;AACxG,uEAAuE;AAWvE,mEAAmE;AACnE,MAAM,CAAC,MAAM,KAAK,GAAiB;IACjC,CAAC,CAAC,EAAE,CAAC,CAAC;IACN,CAAC,CAAC,EAAE,CAAC,CAAC;CACP,CAAA;AAED,6CAA6C;AAC7C,MAAM,CAAC,MAAM,IAAI,GAAiB;IAChC,CAAC,CAAC,EAAE,CAAC,CAAC;IACN,CAAC,CAAC,EAAE,CAAC,CAAC;CACP,CAAA;AAED,mDAAmD;AACnD,MAAM,CAAC,MAAM,GAAG,GAAiB;IAC/B,CAAC,CAAC,EAAE,CAAC,CAAC;IACN,CAAC,CAAC,EAAE,CAAC,CAAC;CACP,CAAA;AAED,4FAA4F;AAC5F,MAAM,CAAC,MAAM,GAAG,GAAiB;IAC/B,CAAC,CAAC,EAAE,CAAC,CAAC;IACN,CAAC,CAAC,EAAE,CAAC,CAAC;CACP,CAAA"}

package/dist/Style.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An element's style as a binding builds it: its starting style, what it's drawn with before any
+ * animation runs, from its `initial` (or its `animate`, with `initial: false`); how an app's own style and
+ * Wardic's are layered (`over`, `without`); and a drag element's default style. A server render draws the
+ * starting style, so an element is drawn where it starts before any code runs.
+ *
+ * @example
+ * import * as Style from "@wardic/dom/Style"
+ *
+ * const start = Style.resolveInitial({ initial: { opacity: 0, y: 8 }, animate: { opacity: 1, y: 0 } })
+ * Style.starting(undefined, start) // { style: { transform: "translateY(8px)", opacity: 0 }, attrs: {} }
+ */
+export { startingStyle as starting, resolveInitial, type InitialConfig, keyframesOf, splitValues, type SplitValues, type StopAt, type Stops, toValues, valuesAt, type StyleInput as Input, type StyleRecord as Style, over, without, heldTouches, } from "./internal/starting-style.ts";
+export { dragDefaultStyle as dragDefaults, type DragDefaultStyle as DragDefaults, DRAG_DEFAULT_ATTRIBUTES, reorderTouchAction, } from "./internal/drag-defaults.ts";
+//# sourceMappingURL=Style.d.ts.map

package/dist/Style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Style.d.ts","sourceRoot":"","sources":["../src/Style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EACL,aAAa,IAAI,QAAQ,EACzB,cAAc,EACd,KAAK,aAAa,EAClB,WAAW,EACX,WAAW,EACX,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,KAAK,EACV,QAAQ,EACR,QAAQ,EACR,KAAK,UAAU,IAAI,KAAK,EACxB,KAAK,WAAW,IAAI,KAAK,EACzB,IAAI,EACJ,OAAO,EACP,WAAW,GACZ,MAAM,8BAA8B,CAAA;AACrC,OAAO,EACL,gBAAgB,IAAI,YAAY,EAChC,KAAK,gBAAgB,IAAI,YAAY,EACrC,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,6BAA6B,CAAA"}