@unrulysystems/native-motion-core 0.1.0-alpha.0

package/dist/component/transition.js

@@ -0,0 +1,339 @@
+// SPEC-COMPONENT §2 — the transition unit boundary (REQ-API-001). The public `Transition` (in ./types)
+// speaks Motion's SECONDS convention; the internal SPRING (`SpringConfig`) and TIMING (`TimingConfig`)
+// resolvers consume MILLISECONDS. These pure converters are the SINGLE crossing point, so the internal
+// millisecond unit never leaks into the authored public surface and a Motion-idiomatic transition config
+// resolves identically here. Host-agnostic (REQ-CORE-003) — relative imports only.
+import { isEasingList } from "../timing.js";
+import { TARGET_PROPERTY_KEYS } from "./types.js";
+// Motion authors durations in seconds; the SPRING/TIMING generators are seeded in milliseconds. This is the
+// only conversion factor, named rather than inlined so the seconds↔ms boundary is explicit.
+const MS_PER_SECOND = 1000;
+const TRANSITION_MAP_KEYS = new Set(['default', 'layout', ...TARGET_PROPERTY_KEYS]);
+function isTransitionMapKey(key) {
+    return TRANSITION_MAP_KEYS.has(key);
+}
+function flatTransitionSnapshot(source) {
+    const out = Object.create(null);
+    for (const key of Reflect.ownKeys(source)) {
+        if (typeof key !== 'string' || key === 'inherit' || isTransitionMapKey(key))
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor === undefined)
+            continue;
+        Object.defineProperty(out, key, {
+            value: source[key],
+            enumerable: descriptor.enumerable === true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return Object.freeze(out);
+}
+/**
+ * Resolve one Motion consumer against an authored transition map. The result is a detached flat
+ * bag: map entries never cross into a generator, and nested maps never recurse. Validation/capture
+ * owns malformed-shape refusal; this selector assumes that boundary has passed and preserves the
+ * pin's key → default → root precedence.
+ */
+export function resolveTransitionForKey(transition, key) {
+    const source = transition;
+    const named = isTransitionMapKey(key) ? source[key] : undefined;
+    const fallback = source['default'];
+    const selected = named !== undefined && named !== null
+        ? named
+        : fallback !== undefined && fallback !== null
+            ? fallback
+            : transition;
+    if (selected === transition)
+        return flatTransitionSnapshot(source);
+    const root = flatTransitionSnapshot(source);
+    const nested = selected;
+    if (nested['inherit'] !== true) {
+        // Motion's getValueTransition returns a replacing child bag unchanged. The separate delay
+        // rebase in animateTarget supplies only its orchestration delay before spreading this bag, so
+        // an ordinary selected bag does not inherit the root transition's delay (motion-dom@12.42.2).
+        return flatTransitionSnapshot(nested);
+    }
+    const merged = Object.create(null);
+    for (const key of Reflect.ownKeys(root)) {
+        const descriptor = Object.getOwnPropertyDescriptor(root, key);
+        if (descriptor !== undefined)
+            Object.defineProperty(merged, key, { ...descriptor, configurable: true, writable: true });
+    }
+    const child = flatTransitionSnapshot(nested);
+    for (const key of Reflect.ownKeys(child)) {
+        const descriptor = Object.getOwnPropertyDescriptor(child, key);
+        if (descriptor !== undefined)
+            Object.defineProperty(merged, key, { ...descriptor, configurable: true, writable: true });
+    }
+    return Object.freeze(merged);
+}
+// Bridge the public `Transition` to the internal spring `SpringConfig`. `duration` crosses seconds→ms;
+// `visualDuration` is already seconds in both surfaces (passthrough); the physics options are unit-
+// consistent with Motion. Absent fields are omitted entirely (not written as `undefined`) so the result
+// satisfies `exactOptionalPropertyTypes`.
+export function toSpringConfig(transition) {
+    const config = {};
+    if (transition.stiffness !== undefined)
+        config.stiffness = transition.stiffness;
+    if (transition.damping !== undefined)
+        config.damping = transition.damping;
+    if (transition.mass !== undefined)
+        config.mass = transition.mass;
+    if (transition.bounce !== undefined)
+        config.bounce = transition.bounce;
+    if (transition.velocity !== undefined)
+        config.velocity = transition.velocity;
+    // U7c (REQ-SPRING-014): the authored settle thresholds cross verbatim — unit-free passthroughs
+    // (the velocity precedent). An explicit 0 is forwarded as PRESENT; the `||=` quirk (0 ≡ absent,
+    // motion-dom@12.42.2 spring.ts:275-280) resolves in the solver's `||` read, never here.
+    if (transition.restDelta !== undefined)
+        config.restDelta = transition.restDelta;
+    if (transition.restSpeed !== undefined)
+        config.restSpeed = transition.restSpeed;
+    if (transition.visualDuration !== undefined)
+        config.visualDuration = transition.visualDuration;
+    if (transition.duration !== undefined)
+        config.duration = transition.duration * MS_PER_SECOND;
+    return config;
+}
+// Bridge the public `Transition` to the internal `TimingConfig` (tween path). `duration` crosses
+// seconds→ms; `ease` passes through. Absent fields omitted (exactOptionalPropertyTypes).
+// Family-2 / T20: `easings` and `easing` are Motion catalog aliases of `ease`.
+// Dual authorship is refused at validate.
+export function effectiveTransitionEase(transition) {
+    if (transition.ease !== undefined)
+        return transition.ease;
+    if (transition.easings !== undefined)
+        return transition.easings;
+    return transition.easing;
+}
+// Rewrite `easings` → `ease` for host pass-through (web motion.div speaks `ease`). Identity when
+// only `ease` is authored. Dual authorship never reaches here (validate refuses first).
+// Preserve null-prototype + freeze + own descriptors from captureTransition (G-INV-8): object
+// spread would re-open prototype pollution and drop non-enumerable own keys.
+// Explicit `ease: undefined` / `easings: undefined` are ABSENT (same law, 00i0nt) — strip those
+// own keys so nested config merge cannot treat them as present values that clobber a parent.
+const EASE_ALIAS_KEYS = ['easings', 'easing'];
+function normalizeFlatTransitionEaseAlias(transition) {
+    const source = transition;
+    const hasOwnEase = Object.hasOwn(transition, 'ease');
+    const easeIsExplicitUndefined = hasOwnEase && source['ease'] === undefined;
+    let aliasKey;
+    let aliasValue;
+    let aliasExplicitUndefined = false;
+    for (const key of EASE_ALIAS_KEYS) {
+        if (!Object.hasOwn(transition, key))
+            continue;
+        const value = source[key];
+        if (value === undefined) {
+            aliasExplicitUndefined = true;
+            continue;
+        }
+        if (aliasKey === undefined) {
+            aliasKey = key;
+            aliasValue = value;
+        }
+    }
+    if (aliasKey === undefined) {
+        if (!easeIsExplicitUndefined && !aliasExplicitUndefined)
+            return transition;
+        const stripped = Object.create(null);
+        let changed = false;
+        for (const key of Reflect.ownKeys(transition)) {
+            if (key === 'ease' && source[key] === undefined) {
+                changed = true;
+                continue;
+            }
+            if ((key === 'easings' || key === 'easing') && source[key] === undefined) {
+                changed = true;
+                continue;
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(transition, key);
+            if (descriptor === undefined)
+                continue;
+            Object.defineProperty(stripped, key, {
+                value: descriptor.value,
+                enumerable: descriptor.enumerable === true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return changed ? Object.freeze(stripped) : transition;
+    }
+    const captured = Object.create(null);
+    for (const key of Reflect.ownKeys(transition)) {
+        if (key === 'easings' || key === 'easing')
+            continue;
+        if (key === 'ease' && source[key] === undefined)
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(transition, key);
+        if (descriptor === undefined)
+            continue;
+        Object.defineProperty(captured, key, {
+            value: descriptor.value,
+            enumerable: descriptor.enumerable === true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    Object.defineProperty(captured, 'ease', {
+        value: aliasValue,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+    return Object.freeze(captured);
+}
+const TRANSITION_MAP_KEYS_FOR_ALIAS = new Set([
+    'default',
+    'layout',
+    ...TARGET_PROPERTY_KEYS,
+]);
+/**
+ * Canonicalize the public `easings` alias at both legal transition levels. The pin-facing web/native
+ * consumers never receive nested bags directly, but MotionConfig and variant inheritance can carry a
+ * captured map through several handoff boundaries before the consumer selector runs. Normalize exactly
+ * one nested bag level; recursive maps are a validation error, not an invitation to walk unbounded data.
+ */
+export function normalizeTransitionEaseAlias(transition) {
+    const root = normalizeFlatTransitionEaseAlias(transition);
+    const source = transition;
+    let changed = root !== transition;
+    const replacements = new Map();
+    for (const key of Reflect.ownKeys(transition)) {
+        if (typeof key !== 'string' || !TRANSITION_MAP_KEYS_FOR_ALIAS.has(key))
+            continue;
+        const nested = source[key];
+        if (typeof nested !== 'object' ||
+            nested === null ||
+            Array.isArray(nested) ||
+            (Object.getPrototypeOf(nested) !== Object.prototype && Object.getPrototypeOf(nested) !== null))
+            continue;
+        const normalized = normalizeFlatTransitionEaseAlias(nested);
+        if (normalized !== nested) {
+            changed = true;
+            replacements.set(key, normalized);
+        }
+    }
+    if (!changed)
+        return root;
+    const out = Object.create(null);
+    for (const key of Reflect.ownKeys(root)) {
+        const descriptor = Object.getOwnPropertyDescriptor(root, key);
+        if (descriptor === undefined)
+            continue;
+        Object.defineProperty(out, key, {
+            value: replacements.get(key) ?? descriptor.value,
+            enumerable: descriptor.enumerable === true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return Object.freeze(out);
+}
+export function toRepeatFoldOptions(transition) {
+    const repeat = transition.repeat;
+    if (repeat === undefined || repeat <= 0)
+        return null;
+    return {
+        repeat,
+        repeatType: transition.repeatType ?? 'loop',
+        repeatDelayMs: (transition.repeatDelay ?? 0) * MS_PER_SECOND,
+    };
+}
+// T18-b (REQ-TIMING-004 / REQ-API-050): the public `delay` crosses seconds→ms HERE, at the same
+// boundary as every other public time (duration in toTimingConfig/toKeyframesConfig, repeatDelay
+// above) — the rebase consumes milliseconds. Absent reads as 0, the pin's default.
+export function toDelayMs(transition) {
+    return (transition.delay ?? 0) * MS_PER_SECOND;
+}
+export function toTimingConfig(transition) {
+    const config = {};
+    if (transition.duration !== undefined)
+        config.duration = transition.duration * MS_PER_SECOND;
+    // The scalar TWEEN path takes a SINGLE easing only. A per-segment `ease` LIST (R8 M2-B) is a
+    // keyframe-array param carried exclusively by `toKeyframesConfig`; passing a list here would break
+    // `resolveEasing` (it expects one easing). A list on a scalar target is a cross-field error caught
+    // by `keyframeTimingRefusal`, so dropping it here is safe and keeps the tween path total.
+    const ease = effectiveTransitionEase(transition);
+    if (ease !== undefined && !isEasingList(ease))
+        config.ease = ease;
+    return config;
+}
+// transition-default-selection F6: the pin's timing LANE predicate, and the ONE rule both drivers
+// and validation read. `isTransitionDefined` counts an authored duration AND the ease spellings
+// (only the orchestration keys are exempt, is-transition-defined.ts:4-29), and a DEFINED-but-
+// typeless bag resolves through the keyframes/timing generator at the 300ms default
+// (motion-dom@12.42.2 JSAnimation.ts:106-116 `type = keyframesGenerator`,
+// generators/keyframes.ts:25 `duration = 300`) — never the spring backstop. The lane is therefore:
+// type omitted AND (an authored duration OR an authored ease spelling — `ease`/`easings`/`easing`,
+// the 00i0nt alias law). Inertia narrows off by its literal `type`.
+//
+// The duration arm is REQ-TIMING-006's: the pin's `isTransitionDefined({ duration })` is TRUE, so
+// `animateMotionValue` SKIPS the per-key `getDefaultTransition` (the spring, REQ-SPRING-012) and
+// `JSAnimation.initAnimation` falls through `type = keyframesGenerator` (motion-value.ts:68-71,
+// JSAnimation.ts:104,115-116) — an authored scalar transition with `duration` and no `type` runs
+// the keyframes/timing generator, monotone, NEVER a duration-spring. This predicate SUBSUMES that
+// arm; the narrower `isDurationOnlyTransition` it superseded at every call site was removed rather
+// than left as dead exported surface, so do not reintroduce a duration-only predicate here.
+//
+// The ease-only arm is the F6 addition and is why an absent `duration` does NOT imply the spring
+// backstop: `{ ease: 'linear' }` matches. It keeps its authored ease verbatim —
+// `toTimingLaneConfig` injects easeOut ONLY when no spelling is authored, so no injection fires
+// here. An orchestration-only bag matches NEITHER arm and keeps the spring backstop: unreachable
+// on the component path (the controller's flat arm already merged the per-key default under it,
+// REQ-SPRING-012) but held as the defensive default.
+export function isTimingLaneTransition(transition) {
+    if (transition.type !== undefined)
+        return false;
+    if (transition.duration !== undefined)
+        return true;
+    return effectiveTransitionEase(transition) !== undefined;
+}
+// transition-default-selection F5: the duration-zero half of the pin's `makeAnimationInstant`
+// guard (motion-dom@12.42.2 animation/interfaces/motion-value.ts:89-98 —
+// `(options as any).type === false || (options.duration === 0 && !options.repeatDelay)`; the
+// `type === false` half is the U7a lane, which the drivers check beside this one). The routing is
+// TYPE-INDEPENDENT — a typed spring with `duration: 0` instants too — and honors the pin's
+// truthiness: an authored `repeatDelay: 0` reads as absent. A repeatDelay-bearing bag is EXEMPT:
+// it keeps its normal generator (the pin builds a real animation whose zero-length plays are
+// separated by the repeatDelay gaps).
+export function isDurationZeroInstantTransition(transition) {
+    if (transition.type === 'inertia')
+        return false;
+    return transition.duration === 0 && !transition.repeatDelay;
+}
+// REQ-TIMING-006 + transition-default-selection F1: the timing LANE's config — the ONE builder
+// every timing-lane consumer reads (both drivers' scalar arms, the presence exit lane). The pin's
+// `animateMotionValue` options base is `{ keyframes: [null, target], ease: "easeOut", ...valueTransition }`
+// (motion-dom@12.42.2 motion-value.ts:45-49), so only an AUTHORED ease spelling overrides:
+// whenever the timing lane is selected — a typed tween OR a duration-only untyped bag — and no
+// ease spelling is authored, the ease is [0, 0, 0.58, 1], never the generator default
+// [0.25, 0.1, 0.35, 1] (REQ-TIMING-002, whose default now governs only the pin's per-key default
+// tween, default-transitions.ts:35-48). Any authored spelling (`ease`/`easings`/`easing`, the
+// 00i0nt alias law) suppresses the injection. Mirrors the sealed layout-lane law (REQ-LAYOUT-023
+// a, 7htzcf).
+export function toTimingLaneConfig(transition) {
+    const config = toTimingConfig(transition);
+    if (effectiveTransitionEase(transition) === undefined)
+        config.ease = 'easeOut';
+    return config;
+}
+// Bridge the public `Transition` to the internal `KeyframesConfig` (the multi-keyframe timing path,
+// REQ-API-033). `duration` crosses seconds→ms; `ease` passes through — a single easing (applied to
+// every segment) OR a per-SEGMENT list (R8 M2-B, law d); `times` (custom 0–1 offsets) passes through
+// as-is (offsets are unitless, no seconds→ms crossing). Absent fields omitted
+// (exactOptionalPropertyTypes). Shape validation happens before this bridge; target-count fallback is
+// owned by the shared core/UI keyframe normalization seam.
+export function toKeyframesConfig(transition) {
+    const config = {};
+    if (transition.duration !== undefined)
+        config.duration = transition.duration * MS_PER_SECOND;
+    const ease = effectiveTransitionEase(transition);
+    if (ease !== undefined)
+        config.ease = ease;
+    if (transition.times !== undefined)
+        config.times = transition.times;
+    return config;
+}

package/dist/component/types.cjs

@@ -0,0 +1,114 @@
+"use strict";
+// SPEC-COMPONENT §2 — the end-state public API types (REQ-API-006/015). This is the "Motion's API on top"
+// authoring surface: the declarative `Target` an author writes for `initial`/`animate`/`exit`, and the
+// `Transition` config. The types admit ONLY the universal-subset properties (REQ-SUBSET-011) with their
+// value shapes — there is NO permissive index signature and NO `any` escape hatch, so an unknown key or a
+// wrong-shaped value is a compile error where statically possible (REQ-API-015). Runtime `validateTarget`
+// (REQ-API-013) is the fail-closed backstop for what the type cannot catch (units, ranges, untyped
+// callers). Host-agnostic (REQ-CORE-003): the public `Transition` uses Motion's SECONDS unit — the internal
+// millisecond SPRING/TIMING resolver config is a DISTINCT type, bridged at an explicit boundary
+// (`./transition`), never leaked into this public surface. Imports no host package.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORCHESTRATION_OPTION_KEYS = exports.TRANSITION_OPTION_KEYS = exports.TARGET_PROPERTY_KEYS = void 0;
+// The universal target-property keys, grouped by the value shape an author may write. They mirror the
+// SUBSET registry's universal, non-gesture properties (REQ-SUBSET-011); `types.test.ts` asserts this list
+// is EXACTLY the registry's, so the compile-time `Target` type and the runtime membership authority can
+// never drift. Written as literal `const` arrays because the registry stores keys widened to `string` and
+// cannot furnish a literal key union — this is the single literal source the `Target` type is built from.
+const LENGTH_KEYS = [
+    'x',
+    'y',
+    'perspective',
+    'width',
+    'height',
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'borderRadius',
+    'borderTopLeftRadius',
+    'borderTopRightRadius',
+    'borderBottomLeftRadius',
+    'borderBottomRightRadius',
+    'borderWidth',
+    'borderTopWidth',
+    'borderRightWidth',
+    'borderBottomWidth',
+    'borderLeftWidth',
+    'margin',
+    'marginTop',
+    'marginRight',
+    'marginBottom',
+    'marginLeft',
+    'padding',
+    'paddingTop',
+    'paddingRight',
+    'paddingBottom',
+    'paddingLeft',
+];
+const UNITLESS_KEYS = ['scale', 'scaleX', 'scaleY', 'opacity'];
+const ANGLE_KEYS = ['rotate', 'rotateX', 'rotateY', 'skewX', 'skewY'];
+const COLOR_KEYS = ['backgroundColor', 'color', 'borderColor'];
+const DISCRETE_KEYS = ['display', 'visibility'];
+// Runtime enumeration of every universal target-property key — the drift guard's compile-time↔runtime
+// bridge, and the key set `validateTarget`/`resolveTarget` iterate. Deep-immutable (readonly, `as const`).
+exports.TARGET_PROPERTY_KEYS = [
+    ...LENGTH_KEYS,
+    ...UNITLESS_KEYS,
+    ...ANGLE_KEYS,
+    ...COLOR_KEYS,
+    ...DISCRETE_KEYS,
+];
+// This data is the runtime-readable counterpart of Transition below. Native's public-surface
+// verifier consumes it directly, so parity tooling cannot invent a second transition vocabulary.
+exports.TRANSITION_OPTION_KEYS = [
+    'type',
+    'duration',
+    'delay',
+    'ease',
+    // Family-2 shipping slice: Motion authors sometimes spell the per-segment list `easings`
+    // (catalog Animation-keyframes). Runtime treats it as an alias of `ease` (same shape law).
+    'easings',
+    // T20 (REQ-API-052): catalog spelling `easing` (Benchmark-cold-start-motion). Same exclusive
+    // alias law as `easings`; converters normalize to `ease`.
+    'easing',
+    // R8 M2-B (REQ-API-033 law d): custom keyframe OFFSETS for a keyframe-array target. Keyframe-only —
+    // the layout lane never interpolates a keyframe array, so `times` is a PROPERTY-lane option, absent
+    // from the layout transition domain (shippedSurface.ts).
+    'times',
+    'stiffness',
+    'damping',
+    'mass',
+    'bounce',
+    'visualDuration',
+    'velocity',
+    // U7c (REQ-SPRING-014): the authored settle thresholds — spring physics options routed into
+    // the solver's settle condition, forwarded untransformed (the velocity precedent).
+    'restDelta',
+    'restSpeed',
+    // T18-a (REQ-API-049): the repeat family. PROPERTY-lane options — the layout/layoutId lanes
+    // refuse them rather than fold a snapshot delta (packet L4), so they are absent from the layout
+    // transition domain (shippedSurface.ts).
+    'repeat',
+    'repeatType',
+    'repeatDelay',
+    // T21 (REQ-API-053): the orchestration family — TREE-lane options consumed at the controlling
+    // node's start scheduling, never by a driver (the converters strip them, per-value map entries
+    // refuse them, and the layout lanes never list them).
+    'when',
+    'delayChildren',
+    'staggerChildren',
+    'staggerDirection',
+    // U8 (REQ-API-059): parametric path factory (`arc()`). PROPERTY-lane / element bag only;
+    // nested map entries and layout bags refuse (F3).
+    'path',
+];
+// T21 (REQ-API-053): the tree-lane subset of the vocabulary, single-sourced so the validator's
+// map-entry refusal, the native controller's driver-strip, and the web shim's pass-through all
+// branch on the same set.
+exports.ORCHESTRATION_OPTION_KEYS = [
+    'when',
+    'delayChildren',
+    'staggerChildren',
+    'staggerDirection',
+];

package/dist/component/types.d.cts

@@ -0,0 +1,60 @@
+import type { RepeatType } from "../repeat.cjs";
+import type { Easing } from "../timing.cjs";
+declare const LENGTH_KEYS: readonly ["x", "y", "perspective", "width", "height", "top", "right", "bottom", "left", "borderRadius", "borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius", "borderWidth", "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth", "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft"];
+declare const UNITLESS_KEYS: readonly ["scale", "scaleX", "scaleY", "opacity"];
+declare const ANGLE_KEYS: readonly ["rotate", "rotateX", "rotateY", "skewX", "skewY"];
+declare const COLOR_KEYS: readonly ["backgroundColor", "color", "borderColor"];
+declare const DISCRETE_KEYS: readonly ["display", "visibility"];
+type LengthValue = number | string;
+type AngleValue = number | string;
+type UnitlessValue = number;
+type ColorValue = string;
+type DiscreteValue = string;
+type Keyframes<V> = V | readonly (V | null)[];
+export type TransitionEndTarget = Partial<Record<(typeof LENGTH_KEYS)[number], LengthValue>> & Partial<Record<(typeof UNITLESS_KEYS)[number], UnitlessValue>> & Partial<Record<(typeof ANGLE_KEYS)[number], AngleValue>> & Partial<Record<(typeof COLOR_KEYS)[number], ColorValue>> & Partial<Record<(typeof DISCRETE_KEYS)[number], DiscreteValue>>;
+export type Target = Partial<Record<(typeof LENGTH_KEYS)[number], Keyframes<LengthValue>>> & Partial<Record<(typeof UNITLESS_KEYS)[number], Keyframes<UnitlessValue>>> & Partial<Record<(typeof ANGLE_KEYS)[number], Keyframes<AngleValue>>> & Partial<Record<(typeof COLOR_KEYS)[number], Keyframes<ColorValue>>> & Partial<Record<(typeof DISCRETE_KEYS)[number], Keyframes<DiscreteValue>>> & {
+    readonly transitionEnd?: TransitionEndTarget;
+};
+export declare const TARGET_PROPERTY_KEYS: readonly string[];
+export type TransitionType = 'spring' | 'tween' | false;
+export declare const TRANSITION_OPTION_KEYS: readonly ["type", "duration", "delay", "ease", "easings", "easing", "times", "stiffness", "damping", "mass", "bounce", "visualDuration", "velocity", "restDelta", "restSpeed", "repeat", "repeatType", "repeatDelay", "when", "delayChildren", "staggerChildren", "staggerDirection", "path"];
+export declare const ORCHESTRATION_OPTION_KEYS: readonly ["when", "delayChildren", "staggerChildren", "staggerDirection"];
+export interface TransitionOptionBag {
+    readonly type?: TransitionType;
+    readonly duration?: number;
+    readonly delay?: number;
+    readonly ease?: Easing | readonly Easing[];
+    readonly easings?: Easing | readonly Easing[];
+    readonly easing?: Easing | readonly Easing[];
+    readonly times?: readonly number[];
+    readonly stiffness?: number;
+    readonly damping?: number;
+    readonly mass?: number;
+    readonly bounce?: number;
+    readonly visualDuration?: number;
+    readonly velocity?: number;
+    readonly restDelta?: number;
+    readonly restSpeed?: number;
+    readonly repeat?: number;
+    readonly repeatType?: RepeatType;
+    readonly repeatDelay?: number;
+    readonly when?: false | 'beforeChildren' | 'afterChildren';
+    readonly delayChildren?: number | import('./orchestration').DynamicDelay;
+    readonly staggerChildren?: number;
+    readonly staggerDirection?: 1 | -1;
+    readonly path?: unknown;
+    readonly inherit?: boolean;
+}
+export type TargetPropertyKey = (typeof LENGTH_KEYS)[number] | (typeof UNITLESS_KEYS)[number] | (typeof ANGLE_KEYS)[number] | (typeof COLOR_KEYS)[number];
+export type TransitionMapKey = 'default' | 'layout' | TargetPropertyKey;
+export type Transition = Omit<TransitionOptionBag, 'inherit'> & Partial<Record<TransitionMapKey, TransitionOptionBag>>;
+export type VariantLabels = string | readonly string[];
+export interface MotionTargetProps {
+    readonly initial?: Target | VariantLabels | false;
+    readonly animate?: Target | VariantLabels | boolean;
+    readonly exit?: Target | VariantLabels;
+    readonly transition?: Transition;
+    readonly variants?: import('./variants').VariantsDictionary;
+    readonly inherit?: boolean;
+}
+export {};

package/dist/component/types.d.ts

@@ -0,0 +1,60 @@
+import type { RepeatType } from "../repeat.js";
+import type { Easing } from "../timing.js";
+declare const LENGTH_KEYS: readonly ["x", "y", "perspective", "width", "height", "top", "right", "bottom", "left", "borderRadius", "borderTopLeftRadius", "borderTopRightRadius", "borderBottomLeftRadius", "borderBottomRightRadius", "borderWidth", "borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth", "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft"];
+declare const UNITLESS_KEYS: readonly ["scale", "scaleX", "scaleY", "opacity"];
+declare const ANGLE_KEYS: readonly ["rotate", "rotateX", "rotateY", "skewX", "skewY"];
+declare const COLOR_KEYS: readonly ["backgroundColor", "color", "borderColor"];
+declare const DISCRETE_KEYS: readonly ["display", "visibility"];
+type LengthValue = number | string;
+type AngleValue = number | string;
+type UnitlessValue = number;
+type ColorValue = string;
+type DiscreteValue = string;
+type Keyframes<V> = V | readonly (V | null)[];
+export type TransitionEndTarget = Partial<Record<(typeof LENGTH_KEYS)[number], LengthValue>> & Partial<Record<(typeof UNITLESS_KEYS)[number], UnitlessValue>> & Partial<Record<(typeof ANGLE_KEYS)[number], AngleValue>> & Partial<Record<(typeof COLOR_KEYS)[number], ColorValue>> & Partial<Record<(typeof DISCRETE_KEYS)[number], DiscreteValue>>;
+export type Target = Partial<Record<(typeof LENGTH_KEYS)[number], Keyframes<LengthValue>>> & Partial<Record<(typeof UNITLESS_KEYS)[number], Keyframes<UnitlessValue>>> & Partial<Record<(typeof ANGLE_KEYS)[number], Keyframes<AngleValue>>> & Partial<Record<(typeof COLOR_KEYS)[number], Keyframes<ColorValue>>> & Partial<Record<(typeof DISCRETE_KEYS)[number], Keyframes<DiscreteValue>>> & {
+    readonly transitionEnd?: TransitionEndTarget;
+};
+export declare const TARGET_PROPERTY_KEYS: readonly string[];
+export type TransitionType = 'spring' | 'tween' | false;
+export declare const TRANSITION_OPTION_KEYS: readonly ["type", "duration", "delay", "ease", "easings", "easing", "times", "stiffness", "damping", "mass", "bounce", "visualDuration", "velocity", "restDelta", "restSpeed", "repeat", "repeatType", "repeatDelay", "when", "delayChildren", "staggerChildren", "staggerDirection", "path"];
+export declare const ORCHESTRATION_OPTION_KEYS: readonly ["when", "delayChildren", "staggerChildren", "staggerDirection"];
+export interface TransitionOptionBag {
+    readonly type?: TransitionType;
+    readonly duration?: number;
+    readonly delay?: number;
+    readonly ease?: Easing | readonly Easing[];
+    readonly easings?: Easing | readonly Easing[];
+    readonly easing?: Easing | readonly Easing[];
+    readonly times?: readonly number[];
+    readonly stiffness?: number;
+    readonly damping?: number;
+    readonly mass?: number;
+    readonly bounce?: number;
+    readonly visualDuration?: number;
+    readonly velocity?: number;
+    readonly restDelta?: number;
+    readonly restSpeed?: number;
+    readonly repeat?: number;
+    readonly repeatType?: RepeatType;
+    readonly repeatDelay?: number;
+    readonly when?: false | 'beforeChildren' | 'afterChildren';
+    readonly delayChildren?: number | import('./orchestration').DynamicDelay;
+    readonly staggerChildren?: number;
+    readonly staggerDirection?: 1 | -1;
+    readonly path?: unknown;
+    readonly inherit?: boolean;
+}
+export type TargetPropertyKey = (typeof LENGTH_KEYS)[number] | (typeof UNITLESS_KEYS)[number] | (typeof ANGLE_KEYS)[number] | (typeof COLOR_KEYS)[number];
+export type TransitionMapKey = 'default' | 'layout' | TargetPropertyKey;
+export type Transition = Omit<TransitionOptionBag, 'inherit'> & Partial<Record<TransitionMapKey, TransitionOptionBag>>;
+export type VariantLabels = string | readonly string[];
+export interface MotionTargetProps {
+    readonly initial?: Target | VariantLabels | false;
+    readonly animate?: Target | VariantLabels | boolean;
+    readonly exit?: Target | VariantLabels;
+    readonly transition?: Transition;
+    readonly variants?: import('./variants').VariantsDictionary;
+    readonly inherit?: boolean;
+}
+export {};