@vireo-ai/trellis-ui 0.1.9 → 0.1.10

package/packages/client/types/index.d.ts

@@ -1,48 +1,16 @@
 import type { Alpine as AlpineType } from 'alpinejs';
 import { motion } from './motion';
-import { bool, className, create, createMachine, createVisibilityMachine, createResizable, cx, defineManifest, defineProps, defineStyles, json, mergeBindings, number, oneOf, propsFromSchema, resolveStyle, string } from './runtime';
+import { bool, createAlpineMachine, createMachine, createResizable, decodeProps, defineManifest, defineProps, defineStyles, json, mergeBindings, number, oneOf, propsFromSchema, resolveStyle, string } from './runtime';
+import { ui } from './runtime/ui';
 type TrellisUIPlugin = (AlpineInstance: AlpineType) => void;
-declare const ui: {
-    readonly bool: import("./runtime/codecs").BoolCodec;
-    readonly className: ({ values }: import("./runtime").ClassNameOptions) => string;
-    readonly create: <const T extends Record<string, import("./runtime").StyleTree>>({ definition }: import("./runtime").CreateOptions<T>) => Readonly<T>;
-    readonly createMachine: <TContext>(config: import("./runtime").MachineConfig<TContext>, options: import("./runtime").MachineOptions<TContext>) => import("./runtime").Machine<TContext>;
-    readonly createVisibilityMachine: <TContext>({ enter, exit, }?: import("./runtime").VisibilityMachineConfig) => import("./runtime").MachineConfig<TContext>;
-    readonly createResizable: ({ element, handle, axis, min, max, step, mode, hitArea, coarseHitArea, disabled, onStart, onResize, onEnd, }: import("./runtime").ResizableOptions) => (() => void);
-    readonly cx: ({ values }: import("./runtime").ClassNameOptions) => string;
-    readonly defineManifest: <const T extends import("./runtime").ComponentManifest>({ manifest }: import("./runtime").DefineManifestOptions<T>) => Readonly<T>;
-    readonly defineProps: <T extends Record<string, import("./runtime").CodecFn<unknown>>>({ el, schema, onChange, }: import("./runtime/codecs").DefinePropsOptions<T>) => import("./runtime").PropState<T>;
-    readonly defineStyles: <const T extends import("./runtime").StyleDefinition>({ definition }: import("./runtime").DefineStylesOptions<T>) => Readonly<T>;
-    readonly json: import("./runtime/codecs").JsonCodecFactory;
-    readonly mergeBindings: ({ inputs }: import("./runtime").MergeBindingsOptions) => import("./runtime").BindingObject;
-    readonly motion: {
-        readonly createAnimator: <T extends string | number>(value: import("./motion").MotionValue<T> | T, defaultOptions?: import("./motion").ValueAnimationTransition<T>) => import("./motion").Animator<T>;
-        readonly parallel: (...handles: import("./motion").MotionHandle[]) => import("./motion").MotionHandle;
-        readonly sequential: (...steps: Array<() => import("./motion").MotionHandle>) => import("./motion").MotionHandle;
-        readonly bindTransform: <T extends import("./motion").TransformContext>(element: HTMLElement, values: T, compose: import("./motion").TransformComposer<T>) => (() => void);
-        readonly bindStyle: <T extends string | number>(element: HTMLElement, property: keyof CSSStyleDeclaration, value: import("./motion").MotionValue<T>, map?: (value: T) => string) => (() => void);
-        readonly withReducedMotion: <T extends import("./motion").AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: import("./motion").MotionPreference) => T;
-        readonly resolveTargets: (scope?: import("./motion").ViewScope, targets?: import("./motion").MotionTarget | import("./motion").MotionTarget[] | null) => Element[];
-        readonly applyViewKeys: (scope?: import("./motion").ViewScope, options?: {
-            key?: string;
-            layout?: boolean;
-        }) => (() => void);
-        readonly animateView: (update: () => void | Promise<void>, targets?: import("./motion").MotionTarget | import("./motion").MotionTarget[] | null, options?: import("./motion").AnimateViewOptions) => import("./motion").MotionHandle;
-        readonly animatePresence: (element: Element, phase: import("./motion").PresencePhase, preset?: import("./motion").PresenceDefinition, options?: import("./motion").PresenceOptions) => import("./motion").MotionHandle;
-        readonly createPresenceLifecycle: ({ element, preset, enter, exit, options, enterOptions, exitOptions, owner, }: import("./motion").PresenceLifecycleOptions) => import("./motion").PresenceLifecycle;
-        readonly animateStreamPatch: <AlpineInstance>(_Alpine: AlpineInstance, patchOrPatches: import("./motion/stream").StreamPatchLike | import("./motion/stream").StreamPatchLike[], options?: import("./motion").AnimateStreamPatchOptions) => import("./motion").MotionHandle;
-    };
-    readonly number: import("./runtime/codecs").NumberCodec;
-    readonly oneOf: <T extends string>(allowed: readonly T[], fallback: T) => import("./runtime/codecs").OneOfCodec<T>;
-    readonly propsFromSchema: <const T extends Record<string, import("./runtime").CodecFn<unknown>>>({ schema, details, }: import("./runtime").PropsFromSchemaOptions<T>) => Record<string, import("./runtime").ManifestProp>;
-    readonly resolveStyle: ({ part, props, className: override, }: import("./runtime").ResolveStyleOptions) => string;
-    readonly string: import("./runtime/codecs").StringCodec;
-};
 declare const trellisUi: TrellisUIPlugin;
 export { trellisUi, ui };
 export default trellisUi;
 export type { TrellisUIPlugin };
+export type { ModalCancelDetail, UiDropdownApi, UiInputApi, UiModalApi, UiModalTriggerApi, UiPanelsApi } from './components/runtime';
 export { motion };
-export { bool, className, create, createMachine, createVisibilityMachine, createResizable, cx, defineManifest, defineProps, defineStyles, json, mergeBindings, number, oneOf, propsFromSchema, resolveStyle, string, };
-export type { ClassArray, ClassDictionary, ClassNameOptions, ClassValue, CodecFn, ComponentManifest, CreateOptions, Machine, MachineAction, MachineActionList, MachineActionRef, MachineConfig, MachineEffect, MachineEvent, MachineEventObject, MachineGuard, MachineOptions, MachineScope, MachineStateConfig, MachineTransition, VisibilityMachineConfig, DefineManifestOptions, DefineStylesOptions, ManifestPart, ManifestProp, ManifestPropDetails, ManifestToken, BindingInput, PropState, PropsFromSchemaOptions, MergeBindingsOptions, ResizableOptions, ResizeAxis, ResizeEvent, ResizeMode, ResizePhase, ResolveStyleOptions, SchemaPropDetails, SchemaToProps, StyleDefinition, StylePart, StyleProps, StyleTree, TrellisAlpineComponent, } from './runtime';
-export type { AnimateStreamPatchOptions, AnimateViewOptions, Animator, MotionHandle, MotionPreference, MotionTarget, PresenceDefinition, PresenceLifecycle, PresenceLifecycleCallbacks, PresenceLifecycleOptions, PresenceOptions, PresencePhase, PresencePreset, ResolvedViewTarget, TransformComposer, TransformContext, ViewPreset, ViewScope, } from './motion';
+export { createTransitionCoordinator, defineHook } from './runtime';
+export { registerTransitionDirective } from './directives';
+export { bool, createAlpineMachine, createMachine, createResizable, decodeProps, defineManifest, defineProps, defineStyles, json, mergeBindings, number, oneOf, propsFromSchema, resolveStyle, string, };
+export type { AlpineMachine, AlpineMachineOwner, AlpinePropsChangedEvent, CodecFn, ComponentManifest, CreateAlpineMachineOptions, DecodePropsOptions, Machine, MachineConfig, MachineEffect, MachineEffectList, MachineEffectRef, MachineEntry, MachineEvent, MachineEventObject, MachineGuard, MachineOptions, MachineReducer, MachineReducerList, MachineReducerRef, MachineScope, MachineSnapshot, MachineStateConfig, MachineStateValue, MachineTransition, MachineTransitionDefinition, MachineUpdate, DefineManifestOptions, DefineStylesOptions, ManifestPart, ManifestProp, ManifestPropDetails, ManifestToken, MachineFactoryScope, BindingInput, PropState, PropsFromSchemaOptions, MergeBindingsOptions, ResizableOptions, ResizeAxis, ResizeDirection, ResizeEvent, ResizeMode, ResizePhase, ResolveStyleOptions, SchemaPropDetails, SchemaToProps, StyleDefinition, StylePart, StyleProps, TrellisAlpineComponent, AnyTransitionHook, TransitionCallback, TransitionContext, TransitionCoordinator, TransitionCoordinatorOptions, TransitionEventCreator, TransitionHookDefinition, UiRuntime, } from './runtime';
+export type { Controller, ControllerDefinitions, ControllerOptions, ControllerScalar, ControllerState, ControllerValueDefinition, ControllerValues, MotionHandle, MotionKeyframePreset, MotionPlanOptions, MotionPreference, MotionSpeed, MotionTransition, MotionTarget, StyleProjection, ViewPreset, ViewOptions, ViewScope, } from './motion';

package/packages/client/types/motion/animate.d.ts

@@ -1,53 +1,14 @@
-import { type AnimationPlaybackControls, type MotionValue, type ValueAnimationTransition } from '../motion';
-type MotionHandle = {
+import { type AnimationPlaybackControls } from '../motion';
+type MotionHandle = PromiseLike<void> & {
     finished: Promise<void>;
     cancel(): void;
     stop(): void;
     complete(): void;
 };
-type Animator<T extends string | number> = {
-    value: MotionValue<T>;
-    animateTo(to: T, options?: ValueAnimationTransition<T>): MotionHandle;
-};
-type TransformContext = Record<string, MotionValue<number>>;
-type TransformComposer<T extends TransformContext> = (ctx: T) => string;
+declare const motionHandle: (finished: Promise<void>, controls: Pick<MotionHandle, "cancel" | "stop" | "complete">) => MotionHandle;
 declare const noopHandle: (run?: () => void | Promise<void>) => MotionHandle;
 declare const toMotionHandle: (controls: Pick<AnimationPlaybackControls, "finished" | "cancel" | "stop" | "complete">, cleanup?: () => void) => MotionHandle;
-declare const createAnimator: <T extends string | number>(value: MotionValue<T> | T, defaultOptions?: ValueAnimationTransition<T>) => Animator<T>;
 declare const parallel: (...handles: MotionHandle[]) => MotionHandle;
 declare const sequential: (...steps: Array<() => MotionHandle>) => MotionHandle;
-declare const bindStyle: <T extends string | number>(element: HTMLElement, property: keyof CSSStyleDeclaration, value: MotionValue<T>, map?: (value: T) => string) => (() => void);
-declare const bindTransform: <T extends TransformContext>(element: HTMLElement, values: T, compose: TransformComposer<T>) => (() => void);
-declare const motionDurations: {
-    readonly fast: 0.14;
-    readonly normal: 0.18;
-    readonly slow: 0.24;
-};
-declare const motionEasings: {
-    readonly out: readonly [0.23, 1, 0.32, 1];
-    readonly inOut: readonly [0.77, 0, 0.175, 1];
-};
-declare const presenceOptions: {
-    popover: {
-        duration: 0.14;
-        ease: readonly [0.23, 1, 0.32, 1];
-    };
-    modal: {
-        duration: 0.24;
-        ease: readonly [0.23, 1, 0.32, 1];
-    };
-    toast: {
-        duration: 0.18;
-        ease: readonly [0.23, 1, 0.32, 1];
-    };
-    sidebar: {
-        duration: 0.24;
-        ease: readonly [0.23, 1, 0.32, 1];
-    };
-    sheet: {
-        duration: 0.24;
-        ease: readonly [0.23, 1, 0.32, 1];
-    };
-};
-export { bindStyle, bindTransform, createAnimator, motionDurations, motionEasings, noopHandle, parallel, presenceOptions, sequential, toMotionHandle, };
-export type { Animator, MotionHandle, TransformComposer, TransformContext };
+export { motionHandle, noopHandle, parallel, sequential, toMotionHandle, };
+export type { MotionHandle };

package/packages/client/types/motion/controller.d.ts

@@ -0,0 +1,33 @@
+import { type ValueAnimationTransition } from '../motion';
+import { type MotionHandle } from './animate';
+import { type MotionPreference } from './reduced-motion';
+type ControllerScalar = string | number;
+type ControllerValues = Record<string, ControllerScalar>;
+type ControllerValueDefinition<T extends ControllerScalar> = T | Readonly<{
+    initial: T;
+    transition?: ValueAnimationTransition<T>;
+}>;
+type ControllerDefinitions = Record<string, ControllerValueDefinition<ControllerScalar>>;
+type Widen<T> = T extends number ? number : T extends string ? string : never;
+type DefinitionValue<T> = T extends {
+    initial: infer Initial;
+} ? Widen<Initial> : Widen<T>;
+type ControllerState<T extends ControllerDefinitions> = {
+    [K in keyof T]: DefinitionValue<T[K]>;
+};
+type StyleProjection<T extends ControllerValues> = (values: Readonly<T>) => Readonly<Record<string, string | number>>;
+type ControllerOptions<T extends ControllerDefinitions> = Readonly<{
+    values: T;
+    style: StyleProjection<ControllerState<T>>;
+    reducedMotion?: MotionPreference;
+}>;
+type Controller<T extends ControllerValues> = {
+    mount(element: HTMLElement): () => void;
+    set(values: Partial<T>): void;
+    animate(values: Partial<T>, transition?: ValueAnimationTransition): MotionHandle;
+    current(): Readonly<T>;
+    destroy(): void;
+};
+declare const createController: <T extends ControllerDefinitions>(options: ControllerOptions<T>) => Controller<ControllerState<T>>;
+export { createController };
+export type { Controller, ControllerDefinitions, ControllerOptions, ControllerScalar, ControllerState, ControllerValueDefinition, ControllerValues, StyleProjection, };

package/packages/client/types/motion/index.d.ts

@@ -1,24 +1,47 @@
-declare const motion: {
-    readonly createAnimator: <T extends string | number>(value: import("../motion").MotionValue<T> | T, defaultOptions?: import("../motion").ValueAnimationTransition<T>) => import("./animate").Animator<T>;
-    readonly parallel: (...handles: import("./animate").MotionHandle[]) => import("./animate").MotionHandle;
-    readonly sequential: (...steps: Array<() => import("./animate").MotionHandle>) => import("./animate").MotionHandle;
-    readonly bindTransform: <T extends import("./animate").TransformContext>(element: HTMLElement, values: T, compose: import("./animate").TransformComposer<T>) => (() => void);
-    readonly bindStyle: <T extends string | number>(element: HTMLElement, property: keyof CSSStyleDeclaration, value: import("../motion").MotionValue<T>, map?: (value: T) => string) => (() => void);
+declare const motion: ((subject: import("./subject").MotionSubject) => import("./plan").MotionPlan) & {
+    readonly presets: Readonly<{
+        opacity: Readonly<{
+            in: import("./recipe").MotionKeyframePreset;
+            out: import("./recipe").MotionKeyframePreset;
+        }>;
+        popover: Readonly<{
+            in: import("./recipe").MotionKeyframePreset;
+            out: import("./recipe").MotionKeyframePreset;
+        }>;
+        modal: Readonly<{
+            in: import("./recipe").MotionKeyframePreset;
+            out: import("./recipe").MotionKeyframePreset;
+        }>;
+        toast: Readonly<{
+            in: import("./recipe").MotionKeyframePreset;
+            out: import("./recipe").MotionKeyframePreset;
+        }>;
+    }>;
+    readonly speeds: Readonly<{
+        fast: Readonly<{
+            duration: 0.08;
+            bounce: 0;
+        }>;
+        moderate: Readonly<{
+            duration: 0.16;
+            bounce: 0;
+        }>;
+        slow: Readonly<{
+            duration: 0.24;
+            bounce: 0;
+        }>;
+    }>;
+    readonly createController: <T extends import("./controller").ControllerDefinitions>(options: import("./controller").ControllerOptions<T>) => import("./controller").Controller<import("./controller").ControllerState<T>>;
     readonly withReducedMotion: <T extends import("../motion").AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: import("./reduced-motion").MotionPreference) => T;
-    readonly resolveTargets: (scope?: import("./targets").ViewScope, targets?: import("./targets").MotionTarget | import("./targets").MotionTarget[] | null) => Element[];
-    readonly applyViewKeys: (scope?: import("./targets").ViewScope, options?: {
-        key?: string;
-        layout?: boolean;
-    }) => (() => void);
-    readonly animateView: (update: () => void | Promise<void>, targets?: import("./targets").MotionTarget | import("./targets").MotionTarget[] | null, options?: import("./view").AnimateViewOptions) => import("./animate").MotionHandle;
-    readonly animatePresence: (element: Element, phase: import("./presence").PresencePhase, preset?: import("./presence").PresenceDefinition, options?: import("./presence").PresenceOptions) => import("./animate").MotionHandle;
-    readonly createPresenceLifecycle: ({ element, preset, enter, exit, options, enterOptions, exitOptions, owner, }: import("./presence").PresenceLifecycleOptions) => import("./presence").PresenceLifecycle;
-    readonly animateStreamPatch: <AlpineInstance>(_Alpine: AlpineInstance, patchOrPatches: import("./stream").StreamPatchLike | import("./stream").StreamPatchLike[], options?: import("./stream").AnimateStreamPatchOptions) => import("./animate").MotionHandle;
+    readonly view: (update: () => void | Promise<void>, options?: import("./view").ViewOptions) => import("./animate").MotionHandle;
 };
 export { motion };
-export { bindStyle, bindTransform, createAnimator, parallel, sequential, type Animator, type MotionHandle, type TransformComposer, type TransformContext, } from './animate';
+export { type MotionHandle } from './animate';
+export { createController, type Controller, type ControllerDefinitions, type ControllerOptions, type ControllerScalar, type ControllerState, type ControllerValueDefinition, type ControllerValues, type StyleProjection, } from './controller';
 export { prefersReducedMotion, reducedMotionQuery, shouldReduceMotion, withReducedMotion, type MotionPreference, } from './reduced-motion';
-export { animatePresence, createPresenceLifecycle, type PresenceDefinition, type PresenceLifecycle, type PresenceLifecycleCallbacks, type PresenceLifecycleOptions, type PresenceOptions, type PresencePhase, type PresencePreset, } from './presence';
-export { animateStreamPatch, streamTargetsFromPatches, type AnimateStreamPatchOptions } from './stream';
-export { MOTION_ACTIVE_ATTR, MOTION_KEY_ATTR, MOTION_LAYOUT_ATTR, MOTION_TEMP_ATTR, applyViewKeys, resolveTargets, resolveViewTargets, type MotionTarget, type ResolvedViewTarget, type ViewScope, } from './targets';
-export { animateView, type AnimateViewOptions, type ViewPreset } from './view';
+export { createMotionPlan, MotionPlan, type MotionDefaults, type MotionPlanOptions, type MotionSegment, type MotionStage, } from './plan';
+export { presets, speeds, type DurationSpeed, type MotionKeyframePreset, type MotionKeyframes, type MotionSpeed, type MotionSpeedName, type MotionTransition, type PhysicsSpeed, } from './recipe';
+export { resize, type ResizeDestination, type ResizeOptions } from './resize';
+export { type MotionSubject, type MotionTransitionSubject } from './subject';
+export type { MotionTarget, ViewScope } from './targets';
+export { view, type ViewOptions, type ViewPreset } from './view';

package/packages/client/types/motion/owned.d.ts

@@ -0,0 +1,5 @@
+import type { AnimationPlaybackControls } from '../motion';
+import { type MotionHandle } from './animate';
+import { type ActiveMotion, type MotionProperty } from './registry';
+declare const ownMotion: (element: Element, start: (previous?: ActiveMotion) => Pick<AnimationPlaybackControls, "finished" | "cancel" | "stop" | "complete">, properties: ReadonlySet<MotionProperty>, signal?: AbortSignal | null, cleanup?: () => void) => MotionHandle;
+export { ownMotion };

package/packages/client/types/motion/plan.d.ts

@@ -0,0 +1,46 @@
+import { type DOMKeyframesDefinition } from '../motion';
+import { type MotionHandle } from './animate';
+import { type MotionSpeed, type MotionTransition } from './recipe';
+import { type ResizeOptions } from './resize';
+import { type MotionSubject } from './subject';
+type MotionTarget = Element | string;
+type AnimateSegment = Readonly<{
+    kind: 'animate';
+    target?: MotionTarget;
+    keyframes: Readonly<DOMKeyframesDefinition>;
+    speed?: MotionSpeed;
+    transition?: MotionTransition;
+}>;
+type ResizeSegment = Readonly<{
+    kind: 'resize';
+    options: ResizeOptions;
+    speed?: MotionSpeed;
+}>;
+type MotionSegment = AnimateSegment | ResizeSegment;
+type MotionStage = readonly MotionSegment[];
+type MotionDefaults = Readonly<{
+    speed?: MotionSpeed;
+    transition?: MotionTransition;
+}>;
+type MotionPlanOptions = Readonly<{
+    speed?: MotionSpeed;
+    transition?: MotionTransition;
+}>;
+declare class MotionPlan {
+    #private;
+    constructor(subject: MotionSubject, stages?: readonly MotionStage[], defaults?: MotionDefaults);
+    animate(keyframes: Readonly<DOMKeyframesDefinition>): MotionPlan;
+    animate(target: MotionTarget, keyframes: Readonly<DOMKeyframesDefinition>): MotionPlan;
+    with(keyframes: Readonly<DOMKeyframesDefinition>): MotionPlan;
+    with(target: MotionTarget, keyframes: Readonly<DOMKeyframesDefinition>): MotionPlan;
+    then(keyframes: Readonly<DOMKeyframesDefinition>): MotionPlan;
+    then(target: MotionTarget, keyframes: Readonly<DOMKeyframesDefinition>): MotionPlan;
+    resize(options: ResizeOptions): MotionPlan;
+    speed(speed: MotionSpeed): MotionPlan;
+    transition(transition: MotionTransition): MotionPlan;
+    defaults(options: MotionPlanOptions): MotionPlan;
+    play(): MotionHandle;
+}
+declare const createMotionPlan: (subject: MotionSubject) => MotionPlan;
+export { createMotionPlan, MotionPlan };
+export type { MotionDefaults, MotionPlanOptions, MotionSegment, MotionStage, MotionTarget };

package/packages/client/types/motion/recipe.d.ts

@@ -0,0 +1,56 @@
+import type { AnimationOptions, DOMKeyframesDefinition } from '../motion';
+type MotionSpeedName = 'fast' | 'moderate' | 'slow';
+type DurationSpeed = Readonly<{
+    duration: number;
+    bounce?: number;
+}>;
+type PhysicsSpeed = Readonly<{
+    stiffness: number;
+    damping: number;
+    mass?: number;
+}>;
+type MotionSpeed = MotionSpeedName | DurationSpeed | PhysicsSpeed;
+type MotionKeyframes<T> = T | readonly T[];
+type MotionKeyframePreset = Readonly<DOMKeyframesDefinition>;
+type MotionTransition = Readonly<AnimationOptions>;
+declare const speeds: Readonly<{
+    fast: Readonly<{
+        duration: 0.08;
+        bounce: 0;
+    }>;
+    moderate: Readonly<{
+        duration: 0.16;
+        bounce: 0;
+    }>;
+    slow: Readonly<{
+        duration: 0.24;
+        bounce: 0;
+    }>;
+}>;
+declare const motionEasings: {
+    readonly out: readonly [0.23, 1, 0.32, 1];
+    readonly inOut: readonly [0.77, 0, 0.175, 1];
+};
+declare const presets: Readonly<{
+    opacity: Readonly<{
+        in: MotionKeyframePreset;
+        out: MotionKeyframePreset;
+    }>;
+    popover: Readonly<{
+        in: MotionKeyframePreset;
+        out: MotionKeyframePreset;
+    }>;
+    modal: Readonly<{
+        in: MotionKeyframePreset;
+        out: MotionKeyframePreset;
+    }>;
+    toast: Readonly<{
+        in: MotionKeyframePreset;
+        out: MotionKeyframePreset;
+    }>;
+}>;
+declare const speedOptions: (speed?: MotionSpeed) => DurationSpeed | PhysicsSpeed;
+declare const finalKeyframe: <T>(keyframes: MotionKeyframes<T>) => T;
+declare const mutableKeyframes: <T>(keyframes: MotionKeyframes<T>) => T | T[];
+export { finalKeyframe, motionEasings, mutableKeyframes, presets, speedOptions, speeds };
+export type { DurationSpeed, MotionKeyframePreset, MotionKeyframes, MotionSpeed, MotionSpeedName, MotionTransition, PhysicsSpeed, };

package/packages/client/types/motion/registry.d.ts

@@ -0,0 +1,12 @@
+import type { MotionHandle } from './animate';
+type MotionProperty = string;
+type ActiveMotion = Readonly<{
+    handle: MotionHandle;
+    properties: ReadonlySet<MotionProperty>;
+}>;
+declare const activeMotion: (element: Element) => ActiveMotion | undefined;
+declare const replaceMotion: (element: Element) => ActiveMotion | undefined;
+declare const registerMotion: (element: Element, motion: ActiveMotion) => void;
+declare const releaseMotion: (element: Element, handle: MotionHandle) => void;
+export { activeMotion, registerMotion, releaseMotion, replaceMotion };
+export type { ActiveMotion, MotionProperty };

package/packages/client/types/motion/resize.d.ts

@@ -0,0 +1,15 @@
+import { type MotionHandle } from './animate';
+import { type MotionKeyframes, type MotionSpeed } from './recipe';
+import { type MotionSubject } from './subject';
+type ResizeDestination = 'content' | 'collapsed';
+type ResizeOptions = Readonly<{
+    from: ResizeDestination;
+    measure?: Element | string;
+    opacity?: MotionKeyframes<number>;
+    speed?: MotionSpeed;
+    target?: Element | string;
+    to: ResizeDestination;
+}>;
+declare const resize: (subject: MotionSubject, options: ResizeOptions) => MotionHandle;
+export { resize };
+export type { ResizeDestination, ResizeOptions };

package/packages/client/types/motion/subject.d.ts

@@ -0,0 +1,10 @@
+type MotionTransitionSubject = Readonly<{
+    el: unknown;
+    root: unknown;
+    signal: AbortSignal;
+}>;
+type MotionSubject = Element | MotionTransitionSubject;
+declare const resolveMotionTarget: (subject: MotionSubject, target?: Element | string) => Element;
+declare const motionSignal: (subject: MotionSubject) => AbortSignal | null;
+export { motionSignal, resolveMotionTarget };
+export type { MotionSubject, MotionTransitionSubject };

package/packages/client/types/motion/targets.d.ts

@@ -16,16 +16,13 @@ type ResolvedViewTarget = {
 };
 declare const MOTION_KEY_ATTR = "data-ui-motion-key";
 declare const MOTION_LAYOUT_ATTR = "data-ui-motion-layout";
-declare const MOTION_TEMP_ATTR = "data-ui-motion-temp";
-declare const MOTION_ACTIVE_ATTR = "data-ui-motion-active";
 declare const cssEscape: (value: string) => string;
 declare const keySelector: (key: string) => string;
 declare const partSelector: (part: string) => string;
-declare const resolveTargets: (scope?: ViewScope, targets?: MotionTarget | MotionTarget[] | null) => Element[];
 declare const resolveViewTargets: (scope?: ViewScope, targets?: MotionTarget | MotionTarget[] | null) => ResolvedViewTarget[];
-declare const applyViewKeys: (scope?: ViewScope, options?: {
+declare const markLayoutParticipant: (scope?: ViewScope, options?: {
     key?: string;
     layout?: boolean;
 }) => (() => void);
-export { MOTION_ACTIVE_ATTR, MOTION_KEY_ATTR, MOTION_LAYOUT_ATTR, MOTION_TEMP_ATTR, applyViewKeys, cssEscape, keySelector, partSelector, resolveTargets, resolveViewTargets, };
+export { MOTION_KEY_ATTR, MOTION_LAYOUT_ATTR, cssEscape, keySelector, markLayoutParticipant, partSelector, resolveViewTargets, };
 export type { MotionTarget, ResolvedViewTarget, ViewScope, ViewTargetDefinition };

package/packages/client/types/motion/view.d.ts

@@ -17,6 +17,11 @@ type AnimateViewOptions = {
     crop?: boolean;
     group?: boolean;
 };
+type ViewOptions = AnimateViewOptions & {
+    targets?: MotionTarget | MotionTarget[] | null;
+};
+declare const configureViewFlush: (flush: () => Promise<unknown>) => void;
 declare const animateView: (update: () => void | Promise<void>, targets?: MotionTarget | MotionTarget[] | null, options?: AnimateViewOptions) => MotionHandle;
-export { animateView };
-export type { AnimateViewOptions, ViewPreset };
+declare const view: (update: () => void | Promise<void>, options?: ViewOptions) => MotionHandle;
+export { animateView, configureViewFlush, view };
+export type { AnimateViewOptions, ViewOptions, ViewPreset };

package/packages/client/types/runtime/alpine-machine.d.ts

@@ -0,0 +1,68 @@
+import type Alpine from 'alpinejs';
+import { type CodecFn, type PropChange, type SchemaToProps } from './codecs';
+import { type TransitionCallback } from './transition-coordinator';
+import type { Machine, MachineEvent, MachineSnapshot } from './state-machine';
+type MachineElement = HTMLElement & Alpine.ElementWithXAttributes;
+type MachineSchema = Record<string, CodecFn<unknown>>;
+type MachineProps<TSchema extends MachineSchema> = SchemaToProps<TSchema>;
+type TransitionHookLike = {
+    name: string;
+    state: string;
+    project?: (...args: never[]) => unknown;
+    projectEach?: (...args: never[]) => readonly unknown[];
+    onDone: string;
+    onError: string;
+};
+type HookName<THooks extends readonly {
+    name: string;
+}[]> = THooks[number]['name'];
+type HookData<THook> = THook extends {
+    project: (...args: never[]) => infer TData;
+} ? TData : THook extends {
+    projectEach: (...args: never[]) => readonly (infer TData)[];
+} ? TData : never;
+type HookForName<THooks, TName> = Extract<THooks extends readonly unknown[] ? THooks[number] : never, {
+    name: TName;
+}>;
+type AlpinePropsChangedEvent<TSchema extends MachineSchema> = {
+    type: 'PROPS_CHANGED';
+    props: MachineProps<TSchema>;
+    changes: Array<PropChange<TSchema>>;
+};
+type MachineFactoryScope<TSchema extends MachineSchema> = {
+    el: MachineElement;
+    props: MachineProps<TSchema>;
+};
+type CreateAlpineMachineOptions<TContext, TSchema extends MachineSchema, THooks extends readonly TransitionHookLike[]> = {
+    schema: TSchema;
+    hooks: THooks;
+    createMachine(scope: MachineFactoryScope<TSchema>): Machine<TContext, MachineProps<TSchema>>;
+    resolveTransitionElement?(scope: Readonly<{
+        name: string;
+        data: unknown;
+        root: MachineElement;
+        registrationEl: MachineElement;
+    }>): MachineElement | null | undefined;
+};
+type AlpineMachineOwner<TProps = unknown> = {
+    onTransition<TData>(name: string, callback: TransitionCallback<TProps, TData, MachineElement>, el?: MachineElement): () => void;
+};
+type AlpineMachine<TContext, TProps, THooks extends readonly TransitionHookLike[]> = AlpineMachineOwner<TProps> & {
+    snapshot: {
+        current: MachineSnapshot<TContext, TProps> | null;
+    };
+    connect(el: MachineElement, snapshot?: {
+        current: MachineSnapshot<TContext, TProps> | null;
+    }): void;
+    disconnect(): void;
+    getSnapshot(): MachineSnapshot<TContext, TProps>;
+    getCommittedSnapshot(): MachineSnapshot<TContext, TProps>;
+    send(event: MachineEvent): void;
+    matches(state: string): boolean;
+    hasTag(tag: string): boolean;
+    onTransition<TName extends HookName<THooks>, TData = HookData<HookForName<THooks, TName>>>(name: TName, callback: TransitionCallback<TProps, TData, MachineElement>, el?: MachineElement): () => void;
+};
+declare const findAlpineMachineOwner: (AlpineInstance: Alpine.Alpine, el: Element) => AlpineMachineOwner | undefined;
+declare const createAlpineMachine: <TContext, TSchema extends MachineSchema, const THooks extends readonly TransitionHookLike[]>({ schema, hooks, createMachine: machineFactory, resolveTransitionElement, }: CreateAlpineMachineOptions<TContext, TSchema, THooks>) => AlpineMachine<TContext, MachineProps<TSchema>, THooks>;
+export { createAlpineMachine, findAlpineMachineOwner };
+export type { AlpineMachine, AlpineMachineOwner, AlpinePropsChangedEvent, CreateAlpineMachineOptions, MachineFactoryScope, };

package/packages/client/types/runtime/anchored-popover.d.ts

@@ -15,6 +15,14 @@ type AnchoredPopover = {
     unmount(): void;
     sync(): void;
 };
+type AnchoredPopoverSurface = {
+    opened(): boolean;
+    open(): void;
+    close(): void;
+    sync(): void;
+    destroy(): void;
+};
 declare const createAnchoredPopover: ({ reference, floating, position: getPosition, align: getAlign, gap, offset, matchReferenceWidth, }: AnchoredPopoverOptions) => AnchoredPopover;
-export { createAnchoredPopover };
-export type { AnchoredPopover, AnchoredPopoverOptions, PopoverAlign, PopoverSide };
+declare const createAnchoredPopoverSurface: (options: AnchoredPopoverOptions) => AnchoredPopoverSurface;
+export { createAnchoredPopover, createAnchoredPopoverSurface };
+export type { AnchoredPopover, AnchoredPopoverOptions, AnchoredPopoverSurface, PopoverAlign, PopoverSide };

package/packages/client/types/runtime/codecs.d.ts

@@ -4,6 +4,7 @@ type CodecMeta<T> = {
     default: T;
     values?: readonly string[];
     emptyString?: 'default' | 'value';
+    attribute?: string;
 };
 interface CodecFn<T> {
     (el: HTMLElement, attr: string): T;
@@ -28,6 +29,10 @@ type DefinePropsOptions<T extends Record<string, CodecFn<unknown>>> = {
     schema: T;
     onChange?: (state: PropState<T>, changes: Array<PropChange<T>>) => void;
 };
+type DecodePropsOptions<T extends Record<string, CodecFn<unknown>>> = {
+    el: HTMLElement;
+    schema: T;
+};
 type ReactiveFn = <T>(value: T) => T;
 interface StringCodec extends CodecFn<string> {
     trim: StringCodec;
@@ -45,6 +50,8 @@ interface StringCodec extends CodecFn<string> {
 }
 interface NumberCodec extends CodecFn<number> {
     clamp(min: number, max: number): NumberCodec;
+    snap(step: number): NumberCodec;
+    bounded(min: number, max: number, step?: number): NumberCodec;
     min(n: number): NumberCodec;
     max(n: number): NumberCodec;
     step(n: number): NumberCodec;
@@ -64,6 +71,13 @@ interface JsonCodecFactory {
     object<T extends Record<string, unknown>>(fallback: T): JsonCodec<T>;
     array<T>(fallback: T[]): JsonCodec<T[]>;
 }
+declare const dataAttributeForProp: (key: string) => string;
+declare const dataAttributeForSchemaProp: (key: string, codec: CodecFn<unknown>) => string;
+declare const clampNumber: (value: number, min: number, max: number) => number;
+declare const snapNumber: (value: number, step: number) => number;
+declare const boundNumber: (value: number, min: number, max: number, step?: number) => number;
+declare const attribute: <T>(codec: CodecFn<T>, name: string) => CodecFn<T>;
+declare const decodeProps: <T extends Record<string, CodecFn<unknown>>>({ el, schema, }: DecodePropsOptions<T>) => SchemaToProps<T>;
 declare const setPropReactivity: (nextReactive: ReactiveFn) => void;
 declare const defineProps: <T extends Record<string, CodecFn<unknown>>>({ el, schema, onChange, }: DefinePropsOptions<T>) => PropState<T>;
 declare const string: StringCodec;
@@ -71,5 +85,5 @@ declare const number: NumberCodec;
 declare const bool: BoolCodec;
 declare const json: JsonCodecFactory;
 declare const oneOf: <T extends string>(allowed: readonly T[], fallback: T) => OneOfCodec<T>;
-export { defineProps, setPropReactivity, string, number, bool, json, oneOf };
-export type { BoolCodec, CodecFn, CodecKind, CodecMeta, DefinePropsOptions, JsonCodec, JsonCodecFactory, NumberCodec, OneOfCodec, PropChange, PropChangeSource, PropState, ReactiveFn, SchemaToProps, StringCodec, };
+export { attribute, boundNumber, clampNumber, decodeProps, dataAttributeForProp, dataAttributeForSchemaProp, defineProps, setPropReactivity, snapNumber, string, number, bool, json, oneOf, };
+export type { BoolCodec, CodecFn, CodecKind, CodecMeta, DecodePropsOptions, DefinePropsOptions, JsonCodec, JsonCodecFactory, NumberCodec, OneOfCodec, PropChange, PropChangeSource, PropState, ReactiveFn, SchemaToProps, StringCodec, };

package/packages/client/types/runtime/{resizable.d.ts → drag-and-drop/index.d.ts}

@@ -2,6 +2,7 @@ import type Alpine from 'alpinejs';
 type ResizeAxis = 'x' | 'y';
 type ResizeMode = 'onChange' | 'onEnd';
 type ResizePhase = 'start' | 'resize' | 'end';
+type ResizeDirection = 'positive' | 'negative';
 type ResizeEvent = {
     width: number;
     height: number;
@@ -25,12 +26,13 @@ type ResizableOptions = {
     mode?: ResizeMode;
     hitArea?: number;
     coarseHitArea?: number;
+    direction?: ResizeDirection;
     disabled?: () => boolean;
     onStart?: (event: ResizeEvent) => void;
     onResize?: (event: ResizeEvent) => void;
     onEnd?: (event: ResizeEvent) => void;
 };
-declare const createResizable: ({ element, handle, axis, min, max, step, mode, hitArea, coarseHitArea, disabled, onStart, onResize, onEnd, }: ResizableOptions) => (() => void);
+declare const createResizable: ({ element, handle, axis, min, max, step, mode, hitArea, coarseHitArea, direction, disabled, onStart, onResize, onEnd, }: ResizableOptions) => (() => void);
 declare const registerResizable: (AlpineInstance: Alpine.Alpine) => void;
 export { createResizable, registerResizable };
-export type { ResizableOptions, ResizeAxis, ResizeEvent, ResizeMode, ResizePhase };
+export type { ResizableOptions, ResizeAxis, ResizeDirection, ResizeEvent, ResizeMode, ResizePhase };

package/packages/client/types/runtime/engine/request.d.ts

@@ -1,5 +1,5 @@
 import type Alpine from 'alpinejs';
-import { type StreamAlpine } from './stream';
+import type { StreamAlpine } from './stream';
 type RequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 type RequestData = FormData | URLSearchParams | HTMLFormElement | Record<string, unknown> | string | Blob | ArrayBuffer;
 type RequestExtra = Record<string, unknown> | FormData | URLSearchParams;
@@ -15,7 +15,7 @@ type RequestOptions = {
 };
 type RequestResult = {
     response: Response | null;
-    type: 'empty' | 'sse' | 'redirect' | 'other' | 'aborted';
+    type: 'empty' | 'redirect' | 'other' | 'aborted' | 'unavailable';
 };
 type RequestLifecycleDetail = {
     source: Element | Document;