@vireo-ai/trellis-ui 0.1.0

package/types/runtime/index.d.ts

@@ -0,0 +1,85 @@
+import type Alpine from 'alpinejs';
+export { createAnchoredPopover, type AnchoredPopover, type AnchoredPopoverOptions, type PopoverAlign, type PopoverSide, } from './anchored-popover';
+export { className, cx, type ClassArray, type ClassDictionary, type ClassNameOptions, type ClassValue } from './class-name';
+export { createCollectionNavigation, type CollectionElementOptions, type CollectionItemsOptions, type CollectionKeydownOptions, type CollectionNavigation, type CollectionNavigationOptions, } from './collection-navigation';
+export { registerConfirm, unregisterConfirm, type ConfirmEventDetail, type ConfirmRuntimeOptions } from './confirm';
+export { create, type CreateOptions, type StyleTree } from './create';
+export { props, type BindingObject, type PropInput, type PropsOptions } from './props';
+export { defineProps, string, number, bool, json, oneOf, type CodecFn, type PropState, type SchemaToProps } from './codecs';
+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';
+export { getPathValue, normalizeOptionText, parseItemData, splitControlValues } from './option-data';
+export { createResizable, registerResizable, type ResizableOptions, type ResizeAxis, type ResizeEvent, type ResizeMode, type ResizePhase, } from './resizable';
+export { defineManifest, propsFromSchema, type ComponentManifest, type DefineManifestOptions, type ManifestPart, type ManifestProp, type ManifestPropDetails, type ManifestToken, type PropsFromSchemaOptions, type SchemaPropDetails, } from './manifest';
+export { defineStyles, resolveStyle, type DefineStylesOptions, type ResolveStyleOptions, type StyleDefinition, type StylePart, type StyleProps, } from './styles';
+export { applyStreamPatch, applyStreamPatches, applyUiEffect, applyUiEffects, connectStream, dispatchStreamEvent, registerStream, type PatchMode, type StreamEventPayload, type StreamPatchPayload, type UiEffectPayload, } from './stream';
+export { applyThemeMode, createDarkModeStore, registerThemeStore, type DarkModeStore, type ThemeChangeDetail, type ThemeMode, } from './theme';
+export { lockDocumentScroll, unlockDocumentScroll } from './scroll-lock';
+type TrellisAlpineComponent<T> = Alpine.AlpineComponent<T> & {
+    init(): void;
+    destroy(): void;
+};
+export type { TrellisAlpineComponent };
+declare const ui: {
+    readonly createAnchoredPopover: ({ reference, floating, position: getPosition, align: getAlign, gap, offset, matchReferenceWidth, }: import("./anchored-popover").AnchoredPopoverOptions) => import("./anchored-popover").AnchoredPopover;
+    readonly createCollectionNavigation: ({ root: getRoot, itemSelector, activeAttribute, isDisabled, loop, }: import("./collection-navigation").CollectionNavigationOptions) => import("./collection-navigation").CollectionNavigation;
+    readonly create: <const T extends Record<string, import("./create").StyleTree>>({ definition }: import("./create").CreateOptions<T>) => Readonly<T>;
+    readonly addDismissableLayer: ({ isEnabled, roots, onDismiss, }: import("./dismissable-layer").DismissableLayerOptions) => (() => void);
+    readonly addListener: ({ target, event, handler, cleanup, options, }: import("./dom").AddListenerOptions) => (() => void);
+    readonly asBool: ({ value }: import("./dom").BoolOptions) => boolean;
+    readonly dispatch: <T = unknown>({ el, name, detail }: import("./dom").DispatchOptions<T>) => void;
+    readonly dispatchNativeControlChange: ({ container, fallback, marker, }: import("./form-control").DispatchNativeControlChangeOptions) => void;
+    readonly isRtl: ({ el }: import("./dom").ElementOptions) => boolean;
+    readonly removeAttribute: ({ el, attr }: Omit<import("./dom").AttributeOptions, "value">) => void;
+    readonly setAttribute: ({ el, attr, value }: import("./dom").AttributeOptions) => void;
+    readonly setPresence: ({ el, attr, present, value }: import("./dom").PresenceOptions) => void;
+    readonly syncControlPresence: ({ el, state, value, }: import("./form-control").SyncControlPresenceOptions) => void;
+    readonly syncNativeControl: ({ input, state, }: import("./form-control").SyncNativeControlOptions) => void;
+    readonly syncRepeatedHiddenInputs: ({ container, state, currentKey, }: import("./form-control").SyncRepeatedHiddenInputsOptions) => string;
+    readonly getPathValue: (item: unknown, path: string) => unknown;
+    readonly normalizeOptionText: (value: string) => string;
+    readonly parseItemData: (raw: string | undefined) => unknown;
+    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 props: ({ inputs }: import("./props").PropsOptions) => import("./props").BindingObject;
+    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;
+    readonly cx: ({ values }: import("./class-name").ClassNameOptions) => string;
+    readonly motion: {
+        readonly createAnimator: <T extends string | number>(value: import("motion").MotionValue<T> | T, defaultOptions?: import("motion").ValueAnimationTransition<T>) => import("..").Animator<T>;
+        readonly parallel: (...handles: import("..").MotionHandle[]) => import("..").MotionHandle;
+        readonly sequential: (...steps: Array<() => import("..").MotionHandle>) => import("..").MotionHandle;
+        readonly bindTransform: <T extends import("..").TransformContext>(element: HTMLElement, values: T, compose: import("..").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("..").MotionPreference) => T;
+        readonly resolveTargets: (scope?: import("..").ViewScope, targets?: import("..").MotionTarget | import("..").MotionTarget[] | null) => Element[];
+        readonly applyViewKeys: (scope?: import("..").ViewScope, options?: {
+            key?: string;
+            layout?: boolean;
+        }) => (() => void);
+        readonly animateView: (update: () => void | Promise<void>, targets?: import("..").MotionTarget | import("..").MotionTarget[] | null, options?: import("..").AnimateViewOptions) => import("..").MotionHandle;
+        readonly animatePresence: (element: Element, phase: import("..").PresencePhase, preset?: import("..").PresenceDefinition, options?: import("..").PresenceOptions) => import("..").MotionHandle;
+        readonly createPresenceLifecycle: ({ element, preset, enter, exit, options, enterOptions, exitOptions, owner, }: import("..").PresenceLifecycleOptions) => import("..").PresenceLifecycle;
+        readonly animateStreamPatch: <AlpineInstance>(_Alpine: AlpineInstance, patchOrPatches: import("../motion/stream").StreamPatchLike | import("../motion/stream").StreamPatchLike[], options?: import("..").AnimateStreamPatchOptions) => import("..").MotionHandle;
+    };
+    readonly applyStreamPatch: (AlpineInstance: import("./stream").StreamAlpine, payload: import("./stream").StreamPatchPayload) => void;
+    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<{
+        abort(reason?: string): void;
+    }>;
+    readonly dispatchStreamEvent: (payload: import("./stream").StreamEventPayload) => void;
+    readonly applyThemeMode: (mode: import("./theme").ThemeMode) => import("./theme").ThemeChangeDetail;
+    readonly createDarkModeStore: () => import("./theme").DarkModeStore;
+    readonly lockDocumentScroll: () => void;
+    readonly registerConfirm: ({ root }?: import("./confirm").ConfirmRuntimeOptions) => void;
+    readonly registerResizable: (AlpineInstance: Alpine.Alpine) => void;
+    readonly registerStream: (AlpineInstance: Alpine.Alpine) => void;
+    readonly registerThemeStore: (AlpineInstance: Alpine.Alpine) => void;
+    readonly unregisterConfirm: () => void;
+    readonly unlockDocumentScroll: () => void;
+};
+export { ui };

package/types/runtime/manifest.d.ts

@@ -0,0 +1,49 @@
+import type { CodecFn } from './codecs';
+type PropKind = 'string' | 'number' | 'boolean' | 'enum' | 'json';
+type ManifestProp = {
+    type: PropKind;
+    default?: unknown;
+    values?: readonly string[];
+    description?: string;
+};
+type ManifestPart = {
+    selector: string;
+    description: string;
+};
+type ManifestToken = {
+    name: string;
+    description: string;
+};
+type ManifestAcceptedEvent = {
+    description: string;
+    detail?: Record<string, string>;
+};
+type ComponentManifest = {
+    name: string;
+    title: string;
+    description: string;
+    props?: Record<string, ManifestProp>;
+    propSchema?: Record<string, CodecFn<unknown>>;
+    slots?: Record<string, string>;
+    events?: Record<string, string>;
+    acceptedEvents?: Record<string, ManifestAcceptedEvent>;
+    parts?: Record<string, ManifestPart>;
+    tokens?: readonly ManifestToken[];
+};
+type ManifestPropDetails = Pick<ManifestProp, 'description'> & {
+    name?: string;
+};
+type SchemaPropDetails<T extends Record<string, CodecFn<unknown>>> = {
+    [K in keyof T]?: ManifestPropDetails;
+};
+type DefineManifestOptions<T extends ComponentManifest> = {
+    manifest: T;
+};
+type PropsFromSchemaOptions<T extends Record<string, CodecFn<unknown>>> = {
+    schema: T;
+    details: SchemaPropDetails<T>;
+};
+declare const defineManifest: <const T extends ComponentManifest>({ manifest }: DefineManifestOptions<T>) => Readonly<T>;
+declare const propsFromSchema: <const T extends Record<string, CodecFn<unknown>>>({ schema, details, }: PropsFromSchemaOptions<T>) => Record<string, ManifestProp>;
+export { defineManifest, propsFromSchema };
+export type { ComponentManifest, DefineManifestOptions, ManifestPart, ManifestProp, ManifestPropDetails, ManifestAcceptedEvent, ManifestToken, PropsFromSchemaOptions, PropKind, SchemaPropDetails, };

package/types/runtime/option-data.d.ts

@@ -0,0 +1,5 @@
+declare const normalizeOptionText: (value: string) => string;
+declare const splitControlValues: (value: string) => string[];
+declare const parseItemData: (raw: string | undefined) => unknown;
+declare const getPathValue: (item: unknown, path: string) => unknown;
+export { getPathValue, normalizeOptionText, parseItemData, splitControlValues };

package/types/runtime/props.d.ts

@@ -0,0 +1,9 @@
+import { type ClassValue } from './class-name';
+type AttributeValue = unknown;
+export type BindingObject = Record<string, AttributeValue>;
+export type PropInput = ClassValue | BindingObject;
+export type PropsOptions = {
+    inputs: readonly PropInput[];
+};
+export declare const props: ({ inputs }: PropsOptions) => BindingObject;
+export {};

package/types/runtime/resizable.d.ts

@@ -0,0 +1,36 @@
+import type Alpine from 'alpinejs';
+type ResizeAxis = 'x' | 'y';
+type ResizeMode = 'onChange' | 'onEnd';
+type ResizePhase = 'start' | 'resize' | 'end';
+type ResizeEvent = {
+    width: number;
+    height: number;
+    previewWidth: number;
+    previewHeight: number;
+    delta: number;
+    axis: ResizeAxis;
+    phase: ResizePhase;
+    input: {
+        clientX: number;
+        clientY: number;
+    };
+};
+type ResizableOptions = {
+    element: HTMLElement;
+    handle: HTMLElement;
+    axis?: ResizeAxis;
+    min?: number;
+    max?: number | null;
+    step?: number;
+    mode?: ResizeMode;
+    hitArea?: number;
+    coarseHitArea?: number;
+    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 registerResizable: (AlpineInstance: Alpine.Alpine) => void;
+export { createResizable, registerResizable };
+export type { ResizableOptions, ResizeAxis, ResizeEvent, ResizeMode, ResizePhase };

package/types/runtime/scroll-lock.d.ts

@@ -0,0 +1,3 @@
+declare const lockDocumentScroll: () => void;
+declare const unlockDocumentScroll: () => void;
+export { lockDocumentScroll, unlockDocumentScroll };

package/types/runtime/stream.d.ts

@@ -0,0 +1,47 @@
+import type Alpine from 'alpinejs';
+type PatchMode = 'morph' | 'outer' | 'replace' | 'update' | 'append' | 'prepend' | 'before' | 'after' | 'remove';
+type StreamPatchPayload = {
+    html?: string | null;
+    target?: string | null;
+    selector?: string | null;
+    mode?: PatchMode | null;
+};
+type StreamEventPayload = {
+    event: string;
+    detail?: Record<string, unknown>;
+};
+type LocationPayload = {
+    url: string;
+    mode?: 'push' | 'replace' | 'assign';
+};
+type UiEffectPayload = ({
+    type: 'patch';
+} & StreamPatchPayload) | ({
+    type: 'dispatch';
+} & StreamEventPayload) | ({
+    type: 'location';
+} & LocationPayload);
+type StreamController = {
+    abort(reason?: string): void;
+};
+type StreamAlpine = {
+    initTree(el: HTMLElement): void;
+    morph?: (target: HTMLElement, html: string, options?: {
+        key?: (el: HTMLElement) => string | null;
+    }) => void;
+};
+declare const MANAGED_HISTORY_STATE_KEY = "__trellisUi";
+type ManagedHistoryState = Record<string, unknown> & {
+    [MANAGED_HISTORY_STATE_KEY]: true;
+};
+declare const applyStreamPatchNow: (AlpineInstance: StreamAlpine, payload: StreamPatchPayload) => void;
+declare const applyStreamPatches: (AlpineInstance: StreamAlpine, payload: StreamPatchPayload | StreamPatchPayload[]) => void;
+declare const applyStreamPatch: (AlpineInstance: StreamAlpine, payload: StreamPatchPayload) => void;
+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 registerStream: (AlpineInstance: Alpine.Alpine) => void;
+export { applyUiEffect, applyUiEffects, applyStreamPatch, applyStreamPatchNow, applyStreamPatches, connectStream, dispatchStreamEvent, isManagedHistoryState, registerStream, };
+export type { LocationPayload, PatchMode, StreamAlpine, StreamEventPayload, StreamPatchPayload, UiEffectPayload };

package/types/runtime/styles.d.ts

@@ -0,0 +1,28 @@
+import { type ClassValue } from 'clsx';
+type StyleProps = Record<string, unknown>;
+type CompoundStyle = {
+    readonly when: Record<string, string | boolean | number>;
+    readonly class: ClassValue;
+};
+type StylePart = {
+    readonly base?: ClassValue;
+    readonly variants?: Record<string, Record<string, ClassValue>>;
+    readonly defaults?: Record<string, string | boolean | number>;
+    readonly compounds?: readonly CompoundStyle[];
+};
+type StyleDefinition = {
+    readonly component: string;
+    readonly parts: Record<string, StylePart>;
+};
+type DefineStylesOptions<T extends StyleDefinition> = {
+    definition: T;
+};
+type ResolveStyleOptions = {
+    part: StylePart;
+    props?: StyleProps;
+    className?: ClassValue;
+};
+declare const defineStyles: <const T extends StyleDefinition>({ definition }: DefineStylesOptions<T>) => Readonly<T>;
+declare const resolveStyle: ({ part, props, className: override, }: ResolveStyleOptions) => string;
+export { defineStyles, resolveStyle };
+export type { CompoundStyle, DefineStylesOptions, ResolveStyleOptions, StyleDefinition, StylePart, StyleProps };

package/types/runtime/theme.d.ts

@@ -0,0 +1,17 @@
+import type { Alpine as AlpineType } from 'alpinejs';
+declare const THEME_VALUES: readonly ["light", "dark", "system"];
+type ThemeMode = typeof THEME_VALUES[number];
+type ThemeChangeDetail = {
+    mode: ThemeMode;
+    on: boolean;
+};
+type DarkModeStore = {
+    mode: ThemeMode;
+    on: boolean;
+    set: (mode: ThemeMode) => void;
+    toggle: () => void;
+};
+declare const applyThemeMode: (mode: ThemeMode) => ThemeChangeDetail;
+declare const createDarkModeStore: () => DarkModeStore;
+declare const registerThemeStore: (AlpineInstance: AlpineType) => void;
+export { applyThemeMode, createDarkModeStore, registerThemeStore, type DarkModeStore, type ThemeChangeDetail, type ThemeMode, };