@vireo-ai/trellis-ui 0.1.2 → 0.1.5

package/types/components/textarea/index.d.ts

@@ -0,0 +1,13 @@
+import type Alpine from 'alpinejs';
+import { type TrellisAlpineComponent } from '../../runtime';
+import { type TextareaProps } from './contract';
+type TextareaData = {
+    props: TextareaProps;
+    control(): HTMLElement;
+    textarea(): HTMLTextAreaElement;
+    sync(): void;
+};
+declare const UiTextarea: () => TrellisAlpineComponent<TextareaData>;
+declare const registerTextarea: (AlpineInstance: Alpine.Alpine) => void;
+export { registerTextarea, UiTextarea };
+export type { TextareaData };

package/types/components/toast/index.d.ts

@@ -14,11 +14,15 @@ type ToastData = {
     props: ToastProps;
     cleanup: CleanupStack;
     timer: number | null;
+    applyProps(changedKeys?: string[]): void;
+    sync(): void;
+    resetTimer(): void;
     dismiss(): void;
 };
 type ToastOutletData = {
     props: ToastOutletProps;
     cleanup: CleanupStack;
+    sync(): void;
     add(detail: ToastDetail): void;
 };
 declare const UiToast: () => TrellisAlpineComponent<ToastData>;

package/types/index.d.ts

@@ -1,15 +1,17 @@
 import type { Alpine as AlpineType } from 'alpinejs';
 import { motion } from './motion';
-import { bool, className, create, createResizable, cx, defineManifest, defineProps, defineStyles, json, mergeBindings, number, oneOf, propsFromSchema, resolveStyle, string } from './runtime';
+import { bool, className, create, createMachine, createVisibilityMachine, createResizable, cx, defineManifest, defineProps, defineStyles, json, mergeBindings, number, oneOf, propsFromSchema, resolveStyle, string } from './runtime';
 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, }: import("./runtime/codecs").DefinePropsOptions<T>) => import("./runtime").PropState<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;
@@ -41,6 +43,6 @@ export { trellisUi, ui };
 export default trellisUi;
 export type { TrellisUIPlugin };
 export { motion };
-export { bool, className, create, createResizable, cx, defineManifest, defineProps, defineStyles, json, mergeBindings, number, oneOf, propsFromSchema, resolveStyle, string, };
-export type { ClassArray, ClassDictionary, ClassNameOptions, ClassValue, CodecFn, ComponentManifest, CreateOptions, 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 { 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';

package/types/runtime/codecs.d.ts

@@ -12,12 +12,21 @@ interface CodecFn<T> {
 type SchemaToProps<T extends Record<string, CodecFn<unknown>>> = {
     [K in keyof T]: ReturnType<T[K]>;
 };
+type SchemaPropKey<T extends Record<string, CodecFn<unknown>>> = Extract<keyof SchemaToProps<T>, string>;
 type PropState<T extends Record<string, CodecFn<unknown>>> = SchemaToProps<T> & {
     readonly disconnect: () => void;
 };
+type PropChangeSource = 'attribute' | 'property';
+type PropChange<T extends Record<string, CodecFn<unknown>>> = {
+    key: SchemaPropKey<T>;
+    previous: SchemaToProps<T>[keyof SchemaToProps<T>];
+    value: SchemaToProps<T>[keyof SchemaToProps<T>];
+    source: PropChangeSource;
+};
 type DefinePropsOptions<T extends Record<string, CodecFn<unknown>>> = {
     el: HTMLElement;
     schema: T;
+    onChange?: (state: PropState<T>, changes: Array<PropChange<T>>) => void;
 };
 type ReactiveFn = <T>(value: T) => T;
 interface StringCodec extends CodecFn<string> {
@@ -56,11 +65,11 @@ interface JsonCodecFactory {
     array<T>(fallback: T[]): JsonCodec<T[]>;
 }
 declare const setPropReactivity: (nextReactive: ReactiveFn) => void;
-declare const defineProps: <T extends Record<string, CodecFn<unknown>>>({ el, schema, }: DefinePropsOptions<T>) => PropState<T>;
+declare const defineProps: <T extends Record<string, CodecFn<unknown>>>({ el, schema, onChange, }: DefinePropsOptions<T>) => PropState<T>;
 declare const string: StringCodec;
 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, PropState, ReactiveFn, SchemaToProps, StringCodec, };
+export type { BoolCodec, CodecFn, CodecKind, CodecMeta, DefinePropsOptions, JsonCodec, JsonCodecFactory, NumberCodec, OneOfCodec, PropChange, PropChangeSource, PropState, ReactiveFn, SchemaToProps, StringCodec, };

package/types/runtime/index.d.ts

@@ -6,6 +6,7 @@ export { registerConfirm, unregisterConfirm, type ConfirmEventDetail, type Confi
 export { create, type CreateOptions, type StyleTree } from './create';
 export { mergeBindings, type BindingInput, type BindingObject, type MergeBindingsOptions } from './merge-bindings';
 export { defineProps, string, number, bool, json, oneOf, type CodecFn, type PropState, type SchemaToProps } from './codecs';
+export { createMachine, createVisibilityMachine, type Machine, type MachineAction, type MachineActionList, type MachineActionRef, type MachineConfig, type MachineEffect, type MachineEvent, type MachineEventObject, type MachineGuard, type MachineOptions, type MachineScope, type MachineStateConfig, type MachineTransition, type VisibilityMachineConfig, } from './machine';
 export { addListener, asBool, dispatch, isRtl, removeAttribute, setAttribute, setPresence, type AddListenerOptions, type AttributeOptions, type BoolOptions, type CleanupStack, type DispatchOptions, type ElementOptions, type PresenceOptions, } from './dom';
 export { addDismissableLayer, type DismissableLayerOptions } from './dismissable-layer';
 export { dispatchNativeControlChange, syncControlPresence, syncNativeControl, syncRepeatedHiddenInputs, type ControlState, type DispatchNativeControlChangeOptions, type HiddenInputState, type NativeControlState, type SyncControlPresenceOptions, type SyncNativeControlOptions, type SyncRepeatedHiddenInputsOptions, } from './form-control';
@@ -43,6 +44,8 @@ declare const ui: {
     readonly splitControlValues: (value: string) => string[];
     readonly createResizable: ({ element, handle, axis, min, max, step, mode, hitArea, coarseHitArea, disabled, onStart, onResize, onEnd, }: import("./resizable").ResizableOptions) => (() => void);
     readonly mergeBindings: ({ inputs }: import("./merge-bindings").MergeBindingsOptions) => import("./merge-bindings").BindingObject;
+    readonly createMachine: <TContext>(config: import("./machine").MachineConfig<TContext>, options: import("./machine").MachineOptions<TContext>) => import("./machine").Machine<TContext>;
+    readonly createVisibilityMachine: <TContext>({ enter, exit, }?: import("./machine").VisibilityMachineConfig) => import("./machine").MachineConfig<TContext>;
     readonly propsFromSchema: <const T extends Record<string, import("./codecs").CodecFn<unknown>>>({ schema, details, }: import("./manifest").PropsFromSchemaOptions<T>) => Record<string, import("./manifest").ManifestProp>;
     readonly resolveStyle: ({ part, props, className: override, }: import("./styles").ResolveStyleOptions) => string;
     readonly className: ({ values }: import("./class-name").ClassNameOptions) => string;
@@ -68,9 +71,9 @@ declare const ui: {
     readonly applyStreamPatches: (AlpineInstance: import("./stream").StreamAlpine, payload: import("./stream").StreamPatchPayload | import("./stream").StreamPatchPayload[]) => void;
     readonly applyUiEffect: (AlpineInstance: import("./stream").StreamAlpine, effect: import("./stream").UiEffectPayload) => void;
     readonly applyUiEffects: (AlpineInstance: import("./stream").StreamAlpine, effects: import("./stream").UiEffectPayload | import("./stream").UiEffectPayload[]) => void;
-    readonly connectStream: (AlpineInstance: import("./stream").StreamAlpine, url: string) => Promise<{
+    readonly connectStream: (AlpineInstance: import("./stream").StreamAlpine, url: string) => {
         abort(reason?: string): void;
-    }>;
+    };
     readonly dispatchStreamEvent: (payload: import("./stream").StreamEventPayload) => void;
     readonly applyThemeMode: (mode: import("./theme").ThemeMode) => import("./theme").ThemeChangeDetail;
     readonly createThemeStore: () => import("./theme").ThemeStore;

package/types/runtime/machine.d.ts

@@ -0,0 +1,55 @@
+type MachineEventObject = {
+    type: string;
+    [key: string]: unknown;
+};
+type MachineEvent = string | MachineEventObject;
+type MachineActionRef = string | MachineAction | MachineEffect;
+type MachineActionList = MachineActionRef | MachineActionRef[];
+type MachineTransition<TContext> = string | {
+    target?: string;
+    guard?: string | MachineGuard<TContext>;
+    actions?: MachineActionList;
+};
+type MachineStateConfig<TContext> = {
+    id?: string;
+    initial?: string;
+    tags?: string[];
+    entry?: MachineActionList;
+    exit?: MachineActionList;
+    on?: Record<string, MachineTransition<TContext> | Array<MachineTransition<TContext>>>;
+    states?: Record<string, MachineStateConfig<TContext>>;
+};
+type MachineConfig<TContext> = {
+    initial: string;
+    states: Record<string, MachineStateConfig<TContext>>;
+};
+type MachineScope<TContext> = {
+    context: TContext;
+    event: MachineEventObject;
+    state: string;
+};
+type MachineAction<TContext = unknown> = (scope: MachineScope<TContext>) => void;
+type MachineEffect<TContext = unknown> = (scope: MachineScope<TContext>) => void | (() => void);
+type MachineGuard<TContext = unknown> = (scope: MachineScope<TContext>) => boolean;
+type MachineOptions<TContext> = {
+    context: TContext;
+    actions?: Record<string, MachineAction<TContext>>;
+    guards?: Record<string, MachineGuard<TContext>>;
+    effects?: Record<string, MachineEffect<TContext>>;
+};
+type VisibilityMachineConfig = {
+    enter?: MachineActionList;
+    exit?: MachineActionList;
+};
+type Machine<TContext> = {
+    state: string;
+    context: TContext;
+    send(event: MachineEvent): void;
+    matches(state: string): boolean;
+    hasTag(tag: string): boolean;
+    stop(): void;
+};
+declare const createVisibilityMachine: <TContext>({ enter, exit, }?: VisibilityMachineConfig) => MachineConfig<TContext>;
+declare const createMachine: <TContext>(config: MachineConfig<TContext>, options: MachineOptions<TContext>) => Machine<TContext>;
+export { createMachine, createVisibilityMachine };
+export type { Machine, MachineAction, MachineActionList, MachineActionRef, MachineConfig, MachineEffect, MachineEvent, MachineEventObject, MachineGuard, MachineOptions, MachineScope, MachineStateConfig, MachineTransition, VisibilityMachineConfig, };

package/types/runtime/manifest.d.ts

@@ -5,6 +5,7 @@ type ManifestProp = {
     default?: unknown;
     values?: readonly string[];
     description?: string;
+    initialOnly?: boolean;
 };
 type ManifestPart = {
     selector: string;
@@ -36,6 +37,7 @@ type ComponentManifest = {
 };
 type ManifestPropDetails = Pick<ManifestProp, 'description'> & {
     name?: string;
+    initialOnly?: boolean;
 };
 type SchemaPropDetails<T extends Record<string, CodecFn<unknown>>> = {
     [K in keyof T]?: ManifestPropDetails;

package/types/runtime/stream.d.ts

@@ -41,7 +41,7 @@ declare const dispatchStreamEvent: (payload: StreamEventPayload) => void;
 declare const isManagedHistoryState: (state: unknown) => state is ManagedHistoryState;
 declare const applyUiEffect: (AlpineInstance: StreamAlpine, effect: UiEffectPayload) => void;
 declare const applyUiEffects: (AlpineInstance: StreamAlpine, effects: UiEffectPayload | UiEffectPayload[]) => void;
-declare const connectStream: (AlpineInstance: StreamAlpine, url: string) => Promise<StreamController>;
+declare const connectStream: (AlpineInstance: StreamAlpine, url: string) => StreamController;
 declare const registerStream: (AlpineInstance: Alpine.Alpine) => void;
 export { applyUiEffect, applyUiEffects, applyStreamPatch, applyStreamPatchNow, applyStreamPatches, connectStream, dispatchStreamEvent, isManagedHistoryState, registerStream, };
 export type { LocationPayload, PatchMode, StreamAlpine, StreamEventPayload, StreamPatchPayload, UiEffectPayload };