@ghia/native 0.0.0-stage → 0.11.0

package/dist/motion-value.d.ts

@@ -0,0 +1,269 @@
+import type { BoxShadow, MotionCurve, MotionEase, MotionKeyframes, MotionSpringDurationTransition, MotionSpringPhysicsTransition, MotionTransition, SvgMotionTransition, MotionValueHost, NativeRenderer } from "./host.js";
+/** A renderer that owns a motion value graph. */
+export type MotionValueRenderer = NativeRenderer & MotionValueHost;
+/**
+ * What a motion value can hold: a number, a colour string, a CSS length string
+ * (`"50%"`, `"2em"`, `"calc(100% - 20px)"`), a multi-value string of those
+ * (`"0.5em 0.75em"`, `"10px / 20px"`, `"red blue"`), a list of numbers, a
+ * `fontVariationSettings` string, a CSS angle (`"45deg"`, `"0.25turn"`, `"1rad"`, `"100grad"`), a CSS transform list
+ * (`"translateX(10px) rotate(45deg)"`, `"none"`), or box shadows. Lengths of different units animate as the two parts of
+ * a `calc()`, and a multi-value string animates component by component. Bound to a shorthand
+ * (`padding`, `margin`, `inset`, `gap`, `borderWidth`, `borderColor`,
+ * `borderRadius`) it gives each side, axis or corner its own component, and
+ * `get()` reads it back as px, percentages and `calc()`s, colours as `rgba()`.
+ *
+ * An angle drives the angle keys (`rotate`, `rotateX`, `rotateY`, `rotateZ`, `skew`, `skewX`, `skewY`) like a number of degrees and is held in
+ * degrees: `"0.5turn"` reads back as `"180deg"`. A number and an angle mix in degrees, so `0` animated to `"1turn"`
+ * passes `"180deg"` halfway (Motion mixes them to `NaN`). Bound to another key, an angle is skipped. A transform list
+ * bound to `transform` is the list of a motion component, and Motion's other transform keys beside it are ignored; two
+ * lists blend as a CSS transition does.
+ */
+export type MotionData = number | string | number[] | BoxShadow | BoxShadow[];
+/** `motionValue(0)` is a `MotionValue<number>`, not a `MotionValue<0>`. */
+export type Widen<Data> = Data extends number ? number : Data extends string ? string : Data;
+/** A spring transition without its `type`. */
+export type MotionSpringConfig = Omit<MotionSpringPhysicsTransition, "type"> | Omit<MotionSpringDurationTransition, "type">;
+export type MotionTransformOptions = {
+    /** Hold the output at its ends outside the input range. Defaults to true. */
+    clamp?: boolean;
+    /** One easing for every segment, or one per segment. */
+    ease?: MotionEase | MotionEase[];
+};
+export type MotionValueEvents<Data extends MotionData> = {
+    /**
+     * The value changed. For a bound value this arrives with the frame that
+     * sampled the change, not inside the call that made it.
+     */
+    change: (value: Data) => void;
+    animationStart: () => void;
+    animationComplete: () => void;
+};
+export type AnimationPlaybackState = "idle" | "running" | "paused" | "finished";
+/**
+ * What `animate` returns for a value, as Motion's `animate` does. Times are in seconds.
+ *
+ * Calls made before the value is bound to a renderer, when the animation has not started,
+ * apply when it does. Once the animation is stopped, cancelled or replaced by another one, its
+ * controls do nothing and read as they were, with state `"idle"`.
+ */
+export interface AnimationPlaybackControls {
+    /**
+     * Seconds since the animation began, the delay not counted in what it reads: it is 0 during the
+     * delay. Assigning it seeks, and the assigned time counts the delay, so seeking to 0.4 in an
+     * animation delayed by 0.5 is still inside the delay. It is not held at the end: an animation
+     * that finished keeps the time of the frame that found it done, and a seek past the end reads
+     * back as set. A running animation goes on from there, a held one stays, a finished one is
+     * held there and is not finished again.
+     */
+    time: number;
+    /**
+     * The pace: 2 is twice as fast, negative runs backwards to the first keyframe. 0 holds the
+     * animation, which stays `"running"`, and it stays held at any other speed until `play()`.
+     */
+    speed: number;
+    /**
+     * One iteration, without the delay or the repeats. A spring lasts until it is at rest,
+     * `Infinity` if that takes more than 20 seconds.
+     */
+    readonly duration: number;
+    /** `duration` and the delay. */
+    readonly iterationDuration: number;
+    /**
+     * Where the animation's clock started, in milliseconds on the renderer's clock since its origin
+     * (the `nowMs` of the test renderer's `clock*` calls): Motion's absolute base is
+     * `performance.now()`, so only differences between two times are comparable. It moves where
+     * Motion moves it: `play()`, a `time` set while running, a change of `speed`. `null` before the
+     * value is bound, once the animation finished, and after `stop()` and `cancel()`.
+     */
+    readonly startTime: number | null;
+    /**
+     * `"running"` from the start, the delay included and at speed 0; `"paused"` after `pause()`;
+     * `"finished"` at the end and after `complete()`; `"idle"` after `stop()` and `cancel()`, and
+     * once another animation replaced this one.
+     */
+    readonly state: AnimationPlaybackState;
+    /** Ends the animation where it is, for good. `finished` stays pending. */
+    stop(): void;
+    /**
+     * Ends the animation and puts the value back on its first keyframe, or leaves it on the last
+     * if the animation had finished. `finished` stays pending until `play()` runs it again.
+     */
+    cancel(): void;
+    /** Jumps to the end and finishes: `finished` resolves. */
+    complete(): void;
+    /**
+     * Continues from where `pause()` held the animation. A finished animation starts again, from
+     * its end if the speed is negative, and `finished` is a new promise. After `cancel()` it starts
+     * again from the first keyframe, at the speed it had; after `stop()` it does nothing.
+     */
+    play(): void;
+    /** Holds the value and the time. The value keeps `isAnimating()` and its velocity is 0. */
+    pause(): void;
+    /**
+     * Hands the animation's clock to a timeline, as Motion's `scroll()` does: the frame loop stops
+     * driving the animation (it stays `"running"` unless the timeline pauses it), and
+     * `timeline.observe(controls)` gets the controls to set `time` on. What `observe` returns is
+     * called when the animation is stopped, or the value is stopped, jumped or animated again.
+     * Attached before the value is bound, it is observed when the animation starts. `play()` gives
+     * the clock back. Returns a function that stops the animation.
+     */
+    attachTimeline(timeline: AnimationTimeline): () => void;
+}
+/** What `attachTimeline` takes: Motion's `{ observe }`. */
+export interface AnimationTimeline {
+    observe(animation: AnimationPlaybackControlsWithThen): () => void;
+}
+export interface AnimationPlaybackControlsWithThen extends AnimationPlaybackControls, PromiseLike<void> {
+    /**
+     * Resolves when the animation finishes by itself or `complete()` ends it. It never rejects, and
+     * a stopped, cancelled or replaced animation leaves it pending.
+     */
+    readonly finished: Promise<void>;
+}
+/**
+ * What `animate` takes for a value: one target, or keyframes. A `null` stands
+ * for the keyframe before it, or for the value's own value when it comes
+ * first. An array is keyframes unless it is itself a value of the kind the
+ * source holds: a `number[]` target of a list-of-numbers value, or a
+ * `BoxShadow[]` target of a shadow value. Keyframes of those kinds are lists of
+ * lists.
+ */
+export type MotionTarget<Data extends MotionData> = MotionKeyframes<Data>;
+export type NumberAnimationOptions = {
+    /** The renderer that samples the animation. */
+    host: MotionValueRenderer;
+    onUpdate?: (value: number) => void;
+};
+/**
+ * JSON has no `Infinity`, so an infinite repeat goes to the renderer as the
+ * string it accepts. The motion components send their transitions the same way.
+ */
+export declare function wireTransition(transition: MotionCurve): MotionCurve;
+export declare function wireTransition(transition: MotionCurve | undefined): MotionCurve | undefined;
+/**
+ * `wireTransition` for what a `motion.*` component takes: the repeat of the
+ * curve at the top, of `default`, and of each property's own.
+ */
+export declare function wireMotionTransition<Transition extends MotionTransition | SvgMotionTransition>(transition: Transition | undefined): Transition | undefined;
+/** Finds how long an animation lasts without a renderer. The native addon's `measureMotionAnimation`. */
+export type AnimationMeasurer = (from: MotionData, target: MotionTarget<MotionData>, transition: MotionCurve | undefined) => {
+    duration: number;
+    iterationDuration: number;
+};
+/** Called by the entry points that load the native addon, as `registerKeyframesValidator` is. */
+export declare function registerAnimationMeasurer(measure: AnimationMeasurer): void;
+type ComputedTrigger = "change" | "animationComplete";
+type Definition = {
+    kind: "source";
+} | {
+    kind: "spring";
+    config: MotionSpringConfig;
+} | {
+    kind: "transform";
+    input: MotionValue<number>;
+    inputRange: number[];
+    outputRange: MotionData[];
+    options?: MotionTransformOptions;
+} | {
+    kind: "follower";
+    source: MotionValue<MotionData>;
+    config: MotionSpringConfig;
+} | {
+    kind: "computed";
+    compute: () => MotionData;
+    triggers: ComputedTrigger[];
+};
+type ListenerKind = "change" | "animationStart" | "animationComplete";
+export declare class MotionValue<Data extends MotionData = MotionData> {
+    #private;
+    readonly id: number;
+    /** Use `motionValue`, `transformValue`, `springValue`, `computedValue` or `velocityValue`. */
+    constructor(definition: Definition, initial?: Data);
+    /** The renderer this value is bound to, if any. */
+    get host(): MotionValueRenderer | undefined;
+    /**
+     * The current value. Bound, it is read from the renderer at its clock. A
+     * transform and a spring follower have no state of their own, so they can
+     * only be read while bound.
+     */
+    get(): Data;
+    /**
+     * Writes the value. It does not stop a running animation: call `stop()`
+     * first to take the value from the animation. On a spring it moves the
+     * target.
+     */
+    set(value: Data): void;
+    /** Writes the value, ending any animation and dropping its velocity. */
+    jump(value: Data): void;
+    /** Units per second, for a value that holds a number. A value that is not bound has none. */
+    getVelocity(): number;
+    /** Whether an animation drives the value: it stays true after the controls' `stop()` and `cancel()`. */
+    isAnimating(): boolean;
+    /** Ends an animation where it is, keeping the speed for the next one. */
+    stop(): void;
+    /**
+     * Animates from where the value is, with the speed it has. Before the value
+     * is bound the animation waits, and starts from the value at that point.
+     * Only a `motionValue()` animates: a spring is moved with `set()`. The controls
+     * it returns have the names and semantics of Motion's.
+     */
+    animate(target: MotionTarget<Data>, transition?: MotionCurve): AnimationPlaybackControlsWithThen;
+    /**
+     * Makes `animate()` jump to its target, finishing on the next frame as a
+     * zero-length animation does, for as long as the returned release is not
+     * called. The adapters call it for a value that a reduced-motion
+     * `motion.*` element binds to `width`, `height` or an inset.
+     */
+    reduceMotion(): () => void;
+    on<Event extends ListenerKind>(event: Event, callback: MotionValueEvents<Data>[Event]): () => void;
+    /**
+     * Binds the value to a renderer, creating its native node on the first
+     * bind. Returns the release. The node goes when every binding is released
+     * and no listener is left; the value keeps its state in JS.
+     */
+    bind(renderer: NativeRenderer): () => void;
+    /**
+     * Drops the value: its node is disposed whatever still binds it, its
+     * listeners are removed and any animation ends. Every later call throws.
+     */
+    destroy(): void;
+}
+/** A value that is written with `set` and `jump` or animated. */
+export declare function motionValue<Data extends MotionData>(initial: Data): MotionValue<Widen<Data>>;
+export declare function isMotionValue(value: unknown): value is MotionValue;
+/**
+ * Maps a number value through `inputRange` and `outputRange`, natively: it is
+ * sampled at the same instant as its input. The input range is ascending or
+ * descending and may repeat a value, which is a step. The output holds
+ * numbers, colours or shadows. A bad range is reported when the value is bound.
+ */
+export declare function transformValue<Data extends MotionData>(input: MotionValue<number>, inputRange: number[], outputRange: Data[], options?: MotionTransformOptions): MotionValue<Widen<Data>>;
+/**
+ * A spring that follows `source`, or, given a plain value, a spring with a
+ * target of its own that `set` moves.
+ */
+export declare function springValue<Data extends MotionData>(source: MotionValue<Data>, config?: MotionSpringConfig): MotionValue<Data>;
+export declare function springValue<Data extends MotionData>(initial: Data, config?: MotionSpringConfig): MotionValue<Widen<Data>>;
+/**
+ * A value computed in JS from the motion values `compute` reads with `get()`.
+ * It is not native-linked: it follows their change events and writes a source,
+ * so it trails them by a frame, and it only updates while it is bound.
+ * Unbound, `get()` runs `compute`.
+ */
+export declare function computedValue<Data extends MotionData>(compute: () => Data): MotionValue<Widen<Data>>;
+/**
+ * The velocity of a number value, in units per second. Like `computedValue`
+ * it is JS-derived and not native-linked: it reads `getVelocity()` of the
+ * source on each of its changes, and again when its animation completes.
+ */
+export declare function velocityValue(source: MotionValue<number>): MotionValue<number>;
+/** Animates `value`. Returns the controls of the animation; `finished` resolves when it finishes. */
+export declare function animate<Data extends MotionData>(value: MotionValue<Data>, target: MotionTarget<Data>, transition?: MotionCurve): AnimationPlaybackControlsWithThen;
+/**
+ * Animates a number on `options.host`, reporting each frame to `onUpdate`.
+ * The temporary value is destroyed when the animation ends in any way, so the
+ * controls do nothing after that.
+ */
+export declare function animate(from: number, to: MotionTarget<number>, options: MotionCurve & NumberAnimationOptions): AnimationPlaybackControlsWithThen;
+export {};
+//# sourceMappingURL=motion-value.d.ts.map

package/dist/motion-value.d.ts.map

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