@soybeanjs/headless 0.29.0-beta.9 → 0.29.1

package/dist/shared/time-picker.d.ts

@@ -0,0 +1,29 @@
+import { DateStep, HourCycle, TimeGranularity, TimeMatcher, TimeValue } from "../date/types.js";
+import { Formatter } from "../date/formatter.js";
+//#region src/shared/time-picker.d.ts
+interface TimePickerOption {
+  value: TimeValue;
+  label: string;
+  key: string;
+}
+interface FormatTimeValueProps {
+  formatter: Formatter;
+  granularity: TimeGranularity;
+  hideTimeZone?: boolean;
+  hourCycle?: HourCycle;
+  value: TimeValue;
+}
+interface CreateTimeOptionsProps extends Omit<FormatTimeValueProps, 'value'> {
+  isTimeUnavailable?: TimeMatcher;
+  maxValue?: TimeValue;
+  minValue?: TimeValue;
+  reference: TimeValue;
+  step?: DateStep;
+}
+declare function compareTimeValues(a: TimeValue, b: TimeValue): number;
+declare function isTimeBetweenInclusive(date: TimeValue, start: TimeValue, end: TimeValue): boolean;
+declare function formatTimeValue(props: FormatTimeValueProps): string;
+declare function createTimeOptions(props: CreateTimeOptionsProps): TimePickerOption[];
+declare function findClosestTimeOption(options: TimePickerOption[], value: TimeValue | undefined): TimePickerOption;
+//#endregion
+export { CreateTimeOptionsProps, FormatTimeValueProps, TimePickerOption, compareTimeValues, createTimeOptions, findClosestTimeOption, formatTimeValue, isTimeBetweenInclusive };

package/dist/shared/time-picker.js

@@ -0,0 +1 @@
+import{isAfter as e,isAfterOrSame as t,isBefore as n,isBeforeOrSame as r,isEqualValue as i,isTime as a,isZonedDateTime as o}from"../date/comparators.js";import{getOptsByGranularity as s}from"../date/utils.js";import"../date/index.js";function c(t,r){return n(t,r)?-1:+!!e(t,r)}function l(e,n,i){return t(e,n)&&r(e,i)}function u(e){return e.formatter.toParts(e.value,s(e.granularity,e.hourCycle,!0)).filter(t=>t.type===`timeZoneName`?e.hideTimeZone?!1:!a(e.value)&&o(e.value):!0).map(e=>e.value).join(``)}function d(t){let r=p(t.granularity,t.step),i=Math.ceil(1440*60/r);return Array.from({length:i},(e,n)=>{let i=n*r,a=Math.floor(i/3600)%24,o=Math.floor(i%3600/60),s=i%60,c=t.reference.set({hour:a,minute:o,second:s,millisecond:0});return{value:c,label:u({formatter:t.formatter,granularity:t.granularity,hideTimeZone:t.hideTimeZone,hourCycle:t.hourCycle,value:c}),key:c.toString()}}).filter(r=>!(t.minValue&&n(r.value,t.minValue)||t.maxValue&&e(r.value,t.maxValue)||t.isTimeUnavailable?.(r.value)))}function f(e,t){return t?e.find(e=>i(e.value,t))??e[0]:e[0]}function p(e,t){let n=(t?.hour??0)*3600+(t?.minute??0)*60+(t?.second??0);return n>0?n:e===`hour`?3600:e===`second`?30:1800}export{c as compareTimeValues,d as createTimeOptions,f as findClosestTimeOption,u as formatTimeValue,l as isTimeBetweenInclusive};

package/dist/shared/tree.d.ts

@@ -0,0 +1,11 @@
+import { DefinedValue } from "../types/common.js";
+//#region src/shared/tree.d.ts
+interface BaseTree<T extends DefinedValue = DefinedValue> {
+  value: T;
+}
+type Tree<T extends DefinedValue = DefinedValue, S extends BaseTree<T> = BaseTree<T>> = BaseTree<T> & {
+  children?: S[];
+};
+declare function getTreePaths<T extends DefinedValue = DefinedValue, S extends BaseTree<T> = BaseTree<T>>(targetValue: T, items: Tree<T, S>[]): T[];
+//#endregion
+export { getTreePaths };

package/dist/shared/tree.js

@@ -0,0 +1 @@
+function e(e,t){let n=[];if(!e)return n;function r(t,n){let i=[...n,t.value];if(t.value===e)return i;if(t.children&&t.children.length>0)for(let e of t.children){let t=r(e,i);if(t)return t}return null}for(let e of t){let t=r(e,[]);if(t){n.push(...t);break}}return n}export{e as getTreePaths};

package/dist/shared/value.d.ts

@@ -0,0 +1,63 @@
+import { CheckedState, DefinedValue, MaybeArray } from "../types/common.js";
+//#region src/shared/value.d.ts
+declare function isIndeterminate(checked?: CheckedState | null): checked is 'indeterminate';
+declare function getCheckedState(checked?: CheckedState | null): "checked" | "unchecked" | "indeterminate";
+declare function getBinaryCheckedState(checked?: CheckedState | null): "checked" | "unchecked";
+/**
+ * Check if value is enabled based on single or multiple selection mode
+ *
+ * @param value - The value to check
+ * @param modelValue - The model value (can be a single value or array)
+ * @param isSingle - Whether it's single selection mode
+ * @returns Whether it's enabled
+ */
+declare function getOpenFromSingleOrMultiple(value: DefinedValue, modelValue: MaybeArray<DefinedValue> | undefined, isMultiple: boolean): boolean;
+/**
+ * Return corresponding string based on open state
+ *
+ * @param open - Whether it's open
+ * @returns 'open' or 'closed'
+ */
+declare function getDisclosureState(open?: boolean): "open" | "closed";
+/**
+ * The `clamp` function restricts a number within a specified range by returning the value itself if it falls within the
+ * range, or the closest boundary value if it exceeds the range.
+ *
+ * @param {number} value - The `value` parameter represents the number that you want to clamp within the specified range
+ *   defined by `min` and `max` values.
+ * @param {number} min - If the `value` parameter is less than the `min` value, the function will return the `min`
+ *   value.
+ * @param {number} max - If the `value` parameter is greater than the `max` value, the function will return `max`.
+ * @returns The `clamp` function returns the value of `value` constrained within the range defined by `min` and `max`.
+ */
+declare function clamp(value: number, min?: number, max?: number): number;
+/**
+ * The function `roundToStepPrecision` rounds a number to a specified precision step.
+ *
+ * @param {number} value - The `value` parameter is the number that you want to round to a specific precision based on
+ *   the `step` parameter.
+ * @param {number} step - The `step` parameter in the `roundToStepPrecision` function represents the interval at which
+ *   you want to round the `value`. For example, if `step` is 0.5, the `value` will be rounded to the nearest half.
+ * @returns the `roundedValue` after rounding it to the precision specified by the `step`.
+ */
+declare function roundToStepPrecision(value: number, step: number): number;
+/**
+ * The function `snapValueToStep` snaps a given value to the nearest step within a specified range.
+ *
+ * @param {number} value - The `value` parameter represents the number that you want to snap to the nearest step value.
+ * @param {number | undefined} min - The `min` parameter represents the minimum value that the `value` should be snapped
+ *   to. If `value` is less than `min`, it will be snapped to `min`. If `min` is not provided (undefined), then the
+ *   snapping will not consider a minimum value.
+ * @param {number | undefined} max - The `max` parameter represents the maximum value that the `value` should be snapped
+ *   to. It ensures that the snapped value does not exceed this maximum value.
+ * @param {number} step - The `step` parameter in the `snapValueToStep` function represents the interval at which the
+ *   `value` should be snapped to. It determines the granularity of the snapping operation. For example, if `step` is 5,
+ *   the `value` will be snapped to the nearest multiple of
+ * @returns a number that has been snapped to the nearest step value within the specified range of minimum and maximum
+ *   values.
+ */
+declare function snapValueToStep(value: number, min: number | undefined, max: number | undefined, step: number): number;
+declare function setValue(obj: Record<string, any>, path: string, value?: any): Record<string, any>;
+declare function getValue<T>(obj: T, path: string, defaultValue?: unknown): any;
+//#endregion
+export { clamp, getBinaryCheckedState, getCheckedState, getDisclosureState, getOpenFromSingleOrMultiple, getValue, isIndeterminate, roundToStepPrecision, setValue, snapValueToStep };

package/dist/shared/value.js

@@ -0,0 +1 @@
+import{isNullish as e,isObject as t}from"./guard.js";import{compact as n}from"./object.js";import{isKey as r,stringToPath as i}from"./string.js";function a(e){return e===`indeterminate`}function o(e){return a(e)?`indeterminate`:e?`checked`:`unchecked`}function s(e){return e===!0?`checked`:`unchecked`}function c(e,t,n){return n?Array.isArray(t)&&t.includes(e):e===t}function l(e){return e?`open`:`closed`}function u(e,t=-1/0,n=1/0){return Math.min(n,Math.max(t,e))}function d(e,t){let n=e,r=t.toString(),i=r.indexOf(`.`),a=i>=0?r.length-i:0;if(a>0){let e=10**a;n=Math.round(n*e)/e}return n}function f(e,t,n,r){let i=Number(t),a=Number(n),o=(e-(Number.isNaN(i)?0:i))%r,s=d(Math.abs(o)*2>=r?e+Math.sign(o)*(r-Math.abs(o)):e-o,r);return Number.isNaN(i)?!Number.isNaN(a)&&s>a&&(s=Math.floor(d(a/r,r))*r):s<i?s=i:!Number.isNaN(a)&&s>a&&(s=i+Math.floor(d((a-i)/r,r))*r),s=d(s,r),s}function p(e,n,a){let o=-1,s=r(n)?[n]:i(n),c=s.length,l=c-1;for(;++o<c;){let n=s[o],r=a;if(n){if(o!==l){let i=e[n];r=t(i)||Array.isArray(i)?i:Number.isNaN(Number(s[o+1]))?{}:[]}e[n]=r,e=e[n]}}return e}function m(r,i,a){if(!i||!t(r))return a;let o=n(i.split(/[,[\].]+?/)).reduce((t,n)=>e(t)?t:t[n],r);if(o===void 0||o===r){let e=r[i];return e===void 0?a:e}return o}export{u as clamp,s as getBinaryCheckedState,o as getCheckedState,l as getDisclosureState,c as getOpenFromSingleOrMultiple,m as getValue,a as isIndeterminate,d as roundToStepPrecision,p as setValue,f as snapValueToStep};

package/dist/shared/vue.d.ts

@@ -0,0 +1,14 @@
+import { PropsToContext, VNodeRef } from "../types/vue.js";
+import { MaybeRefOrGetter, VNode } from "vue";
+
+//#region src/shared/vue.d.ts
+declare function getLifeCycleTarget(target?: any): any;
+declare function getRawChildren(children: VNode[]): VNode[];
+declare function getElFromTemplateRef<T extends HTMLElement>(nodeRef: VNodeRef): T | undefined;
+declare function transformPropsToContext<T extends Record<string, any>, K extends keyof T = keyof T>(props: T, keys?: K[]): PropsToContext<T, K>;
+declare function isFormControl(el?: HTMLElement | null): boolean;
+type RefToValue<T extends MaybeRefOrGetter> = T extends MaybeRefOrGetter<infer V> ? V : never;
+declare const getMergedRefsValue: <T extends Record<string, MaybeRefOrGetter>>(refs: T) => { [K in keyof T]: RefToValue<T[K]> };
+declare const getVueBooleanCasting: (value?: boolean | "") => boolean;
+//#endregion
+export { getElFromTemplateRef, getLifeCycleTarget, getMergedRefsValue, getRawChildren, getVueBooleanCasting, isFormControl, transformPropsToContext };

package/dist/shared/vue.js

@@ -0,0 +1 @@
+import{Comment as e,Fragment as t,computed as n,getCurrentInstance as r,toValue as i}from"vue";const a={KEYED_FRAGMENT:128,BAIL:-2};function o(e){return e||r()}function s(n){let r=[],i=0;for(let o=0;o<n.length;o++){let c=n[o];c.type===t?((c.patchFlag??0)===a.KEYED_FRAGMENT&&i++,r=r.concat(s(c.children))):c.type!==e&&r.push(c)}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=a.BAIL;return r}function c(e){let t=e?.$el??e;return t&&t.nodeType!==1&&(t=void 0),t}function l(e,t){return(t??Object.keys(e)).reduce((t,r)=>(t[r]=n(()=>typeof e[r]==`function`?e[r]():e[r]),t),{})}function u(e){return e?`classList`in e&&e.classList.contains(`form`):!0}const d=e=>{let t={};for(let n in e)t[n]=i(e[n]);return t},f=e=>!!e||e===``;export{c as getElFromTemplateRef,o as getLifeCycleTarget,d as getMergedRefsValue,s as getRawChildren,f as getVueBooleanCasting,u as isFormControl,l as transformPropsToContext};

package/dist/types/color.d.ts

@@ -0,0 +1,16 @@
+import { AnyColor, HslColor, HsvColor, OklchColor, RgbColor } from "@soybeanjs/colord";
+
+//#region src/types/color.d.ts
+type ColorValue = AnyColor;
+type ColorFormat = 'hex' | 'rgb' | 'hsl' | 'oklch';
+type ColorSpace = 'hsl' | 'hsv' | 'oklch';
+type ColorObjectSpace = 'rgb' | ColorSpace;
+type ColorChannel = 'hue' | 'saturation' | 'lightness' | 'brightness' | 'red' | 'green' | 'blue' | 'alpha' | 'chroma';
+interface ColorChannelRange {
+  min: number;
+  max: number;
+  step: number;
+}
+type NormalizedColor = RgbColor | HslColor | HsvColor | OklchColor;
+//#endregion
+export { ColorChannel, ColorChannelRange, ColorFormat, ColorObjectSpace, ColorSpace, ColorValue, NormalizedColor };

package/dist/types/common.d.ts

@@ -0,0 +1,73 @@
+//#region src/types/common.d.ts
+type PrimitiveType = null | undefined | string | number | boolean | symbol | bigint;
+type ClassValue = false | null | undefined | string | Record<string, any> | Array<ClassValue>;
+type UiClass<UiSlot extends string> = Record<UiSlot, ClassValue>;
+type DefinedValue = string | number;
+type DefinedWithBooleanValue = DefinedValue | boolean;
+type AcceptableValue = DefinedValue | null | undefined;
+type AcceptableBooleanValue = AcceptableValue | boolean;
+type MaybeArray<T> = T | Array<T>;
+type MaybePromise<T> = T | Promise<T>;
+type ArrayElement<T> = T extends (infer U)[] ? U : never;
+type DataOrientation = 'vertical' | 'horizontal';
+type Direction = 'ltr' | 'rtl';
+type DisclosureState = 'open' | 'closed';
+type FocusIntent = 'first' | 'last' | 'prev' | 'next';
+type CheckedState = boolean | 'indeterminate';
+type NavigationKey = 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'End' | 'Home' | 'PageDown' | 'PageUp';
+type KbdKey = 'meta' | 'ctrl' | 'alt' | 'win' | 'command' | 'shift' | 'option' | 'enter' | 'delete' | 'backspace' | 'escape' | 'tab' | 'capslock' | 'arrowup' | 'arrowright' | 'arrowdown' | 'arrowleft' | 'pageup' | 'pagedown' | 'home' | 'end';
+type Side = 'top' | 'right' | 'bottom' | 'left';
+type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+type HorizontalSide = Extract<Side, 'left' | 'right'>;
+type Align = 'start' | 'center' | 'end';
+type AlignSide = Extract<Align, 'start' | 'end'>;
+type Placement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+interface Size {
+  width: number;
+  height: number;
+}
+type Point = {
+  x: number;
+  y: number;
+};
+type Polygon = Point[];
+interface GraceIntent {
+  area: Polygon;
+  side: HorizontalSide;
+}
+type SelectionBehavior = 'toggle' | 'replace';
+interface SelectionProps<M extends boolean = false, N extends DefinedValue = string> {
+  /**
+   * The controlled value of the selected item(s).
+   *
+   * Use this when you need to control the state of the items. Can be bound with `v-model`
+   */
+  modelValue?: M extends true ? N[] : N;
+  /**
+   * The default value of the selected item(s).
+   *
+   * Use this when you need to set the initial state of the items.
+   */
+  defaultValue?: M extends true ? N[] : N;
+  /**
+   * Determines whether a "single" or "multiple" items can be selected at a time.
+   *
+   * This prop will overwrite the inferred type from `modelValue` and `defaultValue`.
+   */
+  multiple?: M;
+  /**
+   * Whether selected item can be cleared when `multiple` is false.
+   */
+  clearable?: boolean;
+  /**
+   * How multiple selection should behave in the collection.
+   *
+   * @defaultValue 'toggle'
+   */
+  selectionBehavior?: SelectionBehavior;
+}
+type SelectionEmits<M extends boolean = false, N extends DefinedValue = string> = {
+  'update:modelValue': [value: M extends true ? N[] : N];
+};
+//#endregion
+export { AcceptableBooleanValue, AcceptableValue, Align, AlignSide, ArrayElement, CheckedState, ClassValue, DataOrientation, DefinedValue, DefinedWithBooleanValue, Direction, DisclosureState, FocusIntent, GraceIntent, HorizontalSide, KbdKey, MaybeArray, MaybePromise, NavigationKey, Placement, Point, Polygon, PrimitiveType, SelectionBehavior, SelectionEmits, SelectionProps, Side, Size, SwipeDirection, UiClass };

package/dist/types/component.d.ts

@@ -0,0 +1,53 @@
+import { FocusOutsideEvent, PointerDownOutsideEvent } from "./event.js";
+
+//#region src/types/component.d.ts
+interface ForceMountProps {
+  /**
+   * Used to force mounting when more control is needed.
+   *
+   * Useful when controlling animation with Vue animation libraries.
+   */
+  forceMount?: boolean;
+}
+interface TrapFocusProps {
+  /**
+   * When `true`, focus cannot escape the content via keyboard, pointer, or a programmatic focus.
+   *
+   * @defaultValue false
+   */
+  trapFocus?: boolean;
+}
+interface DismissableLayerProps {
+  /**
+   * When `true`, hover/focus/click interactions will be disabled on elements outside the `DismissableLayer`. Users will
+   * need to click twice on outside elements to interact with them: once to close the `DismissableLayer`, and again to
+   * trigger the element.
+   */
+  disableOutsidePointerEvents?: boolean;
+}
+type DismissableLayerEmits = {
+  /** Event handler called when the escape key is down. Can be prevented. */escapeKeyDown: [event: KeyboardEvent]; /** Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`. Can be prevented. */
+  pointerDownOutside: [event: PointerDownOutsideEvent]; /** Event handler called when the focus moves outside of the `DismissableLayer`. Can be prevented. */
+  focusOutside: [event: FocusOutsideEvent];
+  /**
+   * Event handler called when an interaction happens outside the `DismissableLayer`. Specifically, when a `pointerdown`
+   * event happens outside or focus moves outside of it. Can be prevented.
+   */
+  interactOutside: [event: PointerDownOutsideEvent | FocusOutsideEvent];
+};
+type FocusScopeEmits = {
+  /** Event handler called when auto-focusing on open. Can be prevented. */openAutoFocus: [event: Event]; /** Event handler called when auto-focusing on close. Can be prevented. */
+  closeAutoFocus: [event: Event];
+};
+interface FormNameValueProps<T = unknown> {
+  name: string;
+  value: T;
+}
+interface FormFieldCommonProps {
+  /** The name of the field. Submitted with its owning form as part of a name/value pair. */
+  name?: string;
+  /** When `true`, indicates that the user must set the value before the owning form can be submitted. */
+  required?: boolean;
+}
+//#endregion
+export { DismissableLayerEmits, DismissableLayerProps, FocusScopeEmits, ForceMountProps, FormFieldCommonProps, FormNameValueProps, TrapFocusProps };

package/dist/types/dom.d.ts

@@ -0,0 +1,6 @@
+//#region src/types/dom.d.ts
+type HTMLAttributeReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+type HTMLAttributeCrossOrigin = 'anonymous' | 'use-credentials' | '';
+type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
+//#endregion
+export { HTMLAttributeCrossOrigin, HTMLAttributeReferrerPolicy, ImageLoadingStatus };

package/dist/types/event.d.ts

@@ -0,0 +1,36 @@
+import { AcceptableValue } from "./common.js";
+
+//#region src/types/event.d.ts
+type PointerDownOutsideEvent = CustomEvent<{
+  originalEvent: PointerEvent;
+}>;
+type FocusOutsideEvent = CustomEvent<{
+  originalEvent: FocusEvent;
+}>;
+type SelectEvent<T> = CustomEvent<{
+  originalEvent: MouseEvent;
+  value?: T;
+}>;
+type TreeSelectEvent<T = AcceptableValue> = CustomEvent<{
+  originalEvent: PointerEvent | KeyboardEvent;
+  value?: T;
+  isExpanded: boolean;
+  isSelected: boolean;
+}>;
+type TreeToggleEvent<T = AcceptableValue> = CustomEvent<{
+  originalEvent: PointerEvent | KeyboardEvent;
+  value?: T;
+  isExpanded: boolean;
+  isSelected: boolean;
+}>;
+type SwipeEvent = Omit<CustomEvent<{
+  originalEvent: PointerEvent;
+  delta: {
+    x: number;
+    y: number;
+  };
+}>, 'currentTarget'> & {
+  currentTarget: EventTarget & HTMLElement;
+};
+//#endregion
+export { FocusOutsideEvent, PointerDownOutsideEvent, SelectEvent, SwipeEvent, TreeSelectEvent, TreeToggleEvent };

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+import { ColorChannel, ColorChannelRange, ColorFormat, ColorObjectSpace, ColorSpace, ColorValue, NormalizedColor } from "./color.js";
+import { AcceptableBooleanValue, AcceptableValue, Align, AlignSide, ArrayElement, CheckedState, ClassValue, DataOrientation, DefinedValue, DefinedWithBooleanValue, Direction, DisclosureState, FocusIntent, GraceIntent, HorizontalSide, KbdKey, MaybeArray, MaybePromise, NavigationKey, Placement, Point, Polygon, PrimitiveType, SelectionBehavior, SelectionEmits, SelectionProps, Side, Size, SwipeDirection, UiClass } from "./common.js";
+import { FocusOutsideEvent, PointerDownOutsideEvent, SelectEvent, SwipeEvent, TreeSelectEvent, TreeToggleEvent } from "./event.js";
+import { DismissableLayerEmits, DismissableLayerProps, FocusScopeEmits, ForceMountProps, FormFieldCommonProps, FormNameValueProps, TrapFocusProps } from "./component.js";
+import { HTMLAttributeCrossOrigin, HTMLAttributeReferrerPolicy, ImageLoadingStatus } from "./dom.js";
+import { ArrayPath, IsTuple, Path, PathValue, TupleKeys } from "./path.js";
+import { BaseProps, DataAttributes, EmitsToHookProps, InferDefaults, PropsToContext, VNodeRef } from "./vue.js";
+export { AcceptableBooleanValue, AcceptableValue, Align, AlignSide, ArrayElement, ArrayPath, BaseProps, CheckedState, ClassValue, ColorChannel, ColorChannelRange, ColorFormat, ColorObjectSpace, ColorSpace, ColorValue, DataAttributes, DataOrientation, DefinedValue, DefinedWithBooleanValue, Direction, DisclosureState, DismissableLayerEmits, DismissableLayerProps, EmitsToHookProps, FocusIntent, FocusOutsideEvent, FocusScopeEmits, ForceMountProps, FormFieldCommonProps, FormNameValueProps, GraceIntent, HTMLAttributeCrossOrigin, HTMLAttributeReferrerPolicy, HorizontalSide, ImageLoadingStatus, InferDefaults, IsTuple, KbdKey, MaybeArray, MaybePromise, NavigationKey, NormalizedColor, Path, PathValue, Placement, Point, PointerDownOutsideEvent, Polygon, PrimitiveType, PropsToContext, SelectEvent, SelectionBehavior, SelectionEmits, SelectionProps, Side, Size, SwipeDirection, SwipeEvent, TrapFocusProps, TreeSelectEvent, TreeToggleEvent, TupleKeys, UiClass, VNodeRef };

package/dist/types/path.d.ts

@@ -0,0 +1,12 @@
+import { PrimitiveType } from "./common.js";
+
+//#region src/types/path.d.ts
+type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
+type PathImpl<K extends string | number, V> = V extends PrimitiveType ? `${K}` : `${K}` | `${K}.${Path<V>}`;
+type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
+type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? { [K in TupleKeys<T>]-?: PathImpl<K & string, T[K]> }[TupleKeys<T>] : PathImpl<number, V> : { [K in keyof T]-?: PathImpl<K & string, T[K]> }[keyof T];
+type ArrayPathImpl<K extends string | number, V> = V extends PrimitiveType ? never : V extends ReadonlyArray<infer U> ? U extends PrimitiveType ? never : `${K}` | `${K}.${ArrayPath<V>}` : `${K}.${ArrayPath<V>}`;
+type ArrayPath<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? { [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K]> }[TupleKeys<T>] : ArrayPathImpl<number, V> : { [K in keyof T]-?: ArrayPathImpl<K & string, T[K]> }[keyof T];
+type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any ? P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends Path<T[Key]> ? PathValue<T[Key], Rest> : never : Key extends `${number}` ? T extends ReadonlyArray<infer V> ? PathValue<V, Rest & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${number}` ? T extends ReadonlyArray<infer V> ? V : never : never : never;
+//#endregion
+export { ArrayPath, IsTuple, Path, PathValue, TupleKeys };

package/dist/types/vue.d.ts

@@ -0,0 +1,14 @@
+import { ComponentPublicInstance, ComputedRef, HTMLAttributes } from "vue";
+
+//#region src/types/vue.d.ts
+type VNodeRef = Element | ComponentPublicInstance | null | undefined;
+type PropsToContext<T, K extends keyof T = keyof T> = { [P in K]-?: ComputedRef<T[P]> };
+/** Convert emits to hook props */
+type EmitsToHookProps<T extends Record<string, any[]>> = { [K in keyof T as K extends `update:${infer Rest}` ? `onUpdate${Capitalize<Rest>}` : `on${Capitalize<string & K>}`]?: (...args: T[K]) => void };
+type InferDefaults<T> = { [K in keyof T]?: InferDefault<T, T[K]> };
+type NativeType = null | number | string | boolean | symbol | ((...args: any[]) => any);
+type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
+type DataAttributes = { [K in `data-${string}`]?: unknown };
+type BaseProps<T = HTMLAttributes> = /** @vue-ignore */DataAttributes & /** @vue-ignore */T;
+//#endregion
+export { BaseProps, DataAttributes, EmitsToHookProps, InferDefaults, PropsToContext, VNodeRef };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soybeanjs/headless",
-  "version": "0.29.0-beta.9",
+  "version": "0.29.1",
   "description": "SoybeanHeadless is a collection unstyled components for Vue 3. It is designed to be lightweight and easy to use.",
   "homepage": "https://github.com/soybeanjs/soybean-ui",
   "bugs": {
@@ -97,7 +97,7 @@
     "@soybeanjs/hooks": "^0.3.0",
     "@soybeanjs/utils": "^0.1.1",
     "@standard-schema/spec": "^1.1.0",
-    "@tanstack/vue-virtual": "^3.13.28",
+    "@tanstack/vue-virtual": "^3.13.29",
     "@vueuse/core": "^14.3.0",
     "@vueuse/shared": "^14.3.0",
     "aria-hidden": "^1.2.6",
@@ -116,6 +116,7 @@
     "typescript": "6.0.3",
     "unplugin-vue": "7.2.0",
     "unplugin-vue-components": "^32.1.0",
+    "vite-plus": "^0.1.24",
     "vue": "3.5.38",
     "vue-router": "5.1.0"
   },