@soybeanjs/headless 0.0.1-beta.3

package/dist/shared/dom.d.ts

@@ -0,0 +1,19 @@
+import { VNode } from "vue";
+
+//#region src/shared/dom.d.ts
+declare function removeLinks(items: HTMLElement[]): HTMLElement[];
+declare function getActiveElement<T extends Element = HTMLElement>(): T | null;
+declare function isElementHasAttribute(element: HTMLElement, attribute: string): boolean;
+declare function getCollectionItemElements(element: HTMLElement): HTMLElement[];
+declare function getAriaLabel(element?: HTMLElement | null, id?: string, ariaLabel?: string): string | undefined;
+/**
+ * Extract text content from VNode for generating aria-label. Use iteration instead of recursion to avoid stack
+ * overflow.
+ *
+ * @param node VNode node
+ * @returns Extracted text content
+ */
+declare function getAriaLabelByVNode(node?: VNode | null): string;
+declare function getAriaLabelByVNodeList(nodes?: VNode[] | null): string;
+//#endregion
+export { getActiveElement, getAriaLabel, getAriaLabelByVNode, getAriaLabelByVNodeList, getCollectionItemElements, isElementHasAttribute, removeLinks };

package/dist/shared/dom.js

@@ -0,0 +1 @@
+import{COLLECTION_ITEM_ATTRIBUTE as e}from"../constants/attr.js";import{Comment as t}from"vue";function n(e){return e.filter(e=>e.tagName!==`A`)}function r(){let e=document.activeElement;if(e===null)return null;for(;e!==null&&e.shadowRoot!==null&&e.shadowRoot.activeElement!==null;)e=e.shadowRoot.activeElement;return e}function i(e,t){return[e.getAttribute(t),e.getAttribute(`data-${t}`)].some(e=>e===``||e===`true`)}function a(t){return Array.from(t.querySelectorAll(`[${e}]`))}function o(e,t,n){if(n)return n;if(!(!t||!e))return document.querySelector(`[for="${t}"]`)?.textContent??void 0}function s(e){if(!e)return``;let n=[],r=[e];for(;r.length>0;){let e=r.pop();if(e.type!==t){if(typeof e.children==`string`){let t=e.children.trim();t&&n.push(t);continue}if(Array.isArray(e.children))for(let t=e.children.length-1;t>=0;t--){let n=e.children[t];n&&typeof n==`object`&&`type`in n&&r.push(n)}}}return n.join(` `).replace(/\s+/g,` `).trim()}function c(e){return e?.length?e.map(e=>s(e)).join(` `).replace(/\s+/g,` `).trim():``}export{r as getActiveElement,o as getAriaLabel,s as getAriaLabelByVNode,c as getAriaLabelByVNodeList,a as getCollectionItemElements,i as isElementHasAttribute,n as removeLinks};

package/dist/shared/env.d.ts

@@ -0,0 +1,7 @@
+//#region src/shared/env.d.ts
+declare const isBrowser: boolean;
+declare const isClient: boolean;
+declare function isIOS(): boolean;
+declare function refreshIOSDetection(): boolean;
+//#endregion
+export { isBrowser, isClient, isIOS, refreshIOSDetection };

package/dist/shared/env.js

@@ -0,0 +1 @@
+const e=typeof document<`u`,t=typeof window<`u`&&typeof document<`u`;let n=null;function r(){return!t||!window?.navigator?.userAgent?!1:/iP(?:ad|hone|od)/.test(window.navigator.userAgent)||window.navigator.maxTouchPoints>2&&/iPad|Macintosh/.test(window.navigator.userAgent)}function i(){return n===null&&(n=r()),n}function a(){return n=null,i()}export{e as isBrowser,t as isClient,i as isIOS,a as refreshIOSDetection};

package/dist/shared/event.d.ts

@@ -0,0 +1,7 @@
+//#region src/shared/event.d.ts
+declare function handleAndDispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(name: string, handler: ((event: E) => void) | undefined, detail: {
+  originalEvent: OriginalEvent;
+} & (E extends CustomEvent<infer D> ? D : never)): void;
+declare function isMouseEvent(event: PointerEvent): boolean;
+//#endregion
+export { handleAndDispatchCustomEvent, isMouseEvent };

package/dist/shared/event.js

@@ -0,0 +1 @@
+function e(e,t,n){let r=n.originalEvent.target,i=new CustomEvent(e,{bubbles:!1,cancelable:!0,detail:n});t&&r.addEventListener(e,t,{once:!0}),r.dispatchEvent(i)}function t(e){return e.pointerType===`mouse`}export{e as handleAndDispatchCustomEvent,t as isMouseEvent};

package/dist/shared/focus.d.ts

@@ -0,0 +1,38 @@
+import { DataOrientation, Direction, FocusIntent } from "../types/common.js";
+import "../types/index.js";
+import "../index.js";
+
+//#region src/shared/focus.d.ts
+type FocusableTarget = HTMLElement | {
+  focus: () => void;
+};
+/** Attempts focusing the first element in a list of candidates. Stops when focus has actually moved. */
+declare function focusFirstAndSelect(candidates: HTMLElement[], {
+  select
+}?: {
+  select?: boolean | undefined;
+}): void;
+declare function tryFocusFirst(candidates: HTMLElement[], preventScroll?: boolean): boolean;
+declare function removeFromTabOrder(candidates: HTMLElement[]): () => void;
+/** Returns the first and last tabbable elements inside a container. */
+declare function getTabbableEdges(container: HTMLElement): readonly [HTMLElement | undefined, HTMLElement | undefined];
+/**
+ * Returns a list of potential tabbable candidates.
+ *
+ * NOTE: This is only a close approximation. For example it doesn't take into account cases like when elements are not
+ * visible. This cannot be worked out easily by just reading a property, but rather necessitate runtime knowledge
+ * (computed styles, etc). We deal with these cases separately.
+ *
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker Credit:
+ * https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
+ */
+declare function getTabbableCandidates(container: HTMLElement): HTMLElement[];
+declare function focus(element?: FocusableTarget | null, {
+  select
+}?: {
+  select?: boolean | undefined;
+}): void;
+declare function getDirectionAwareKey(key: string, dir?: Direction): string;
+declare function getFocusIntent(event: KeyboardEvent, orientation?: DataOrientation, dir?: Direction): FocusIntent | undefined;
+//#endregion
+export { focus, focusFirstAndSelect, getDirectionAwareKey, getFocusIntent, getTabbableCandidates, getTabbableEdges, removeFromTabOrder, tryFocusFirst };

package/dist/shared/focus.js

@@ -0,0 +1 @@
+import{MAP_KEY_TO_FOCUS_INTENT as e}from"../constants/common.js";import{getActiveElement as t}from"./dom.js";function n(e,{select:n=!1}={}){let r=t();for(let i of e)if(u(i,{select:n}),t()!==r)return}function r(e,n=!1){let r=t();return e.some(e=>e===r?!0:(e.focus({preventScroll:n}),t()!==r))}function i(e){return e.forEach(e=>{e.dataset.tabindex=e.getAttribute(`tabindex`)||``,e.setAttribute(`tabindex`,`-1`)}),()=>{e.forEach(e=>{let t=e.dataset.tabindex;e.setAttribute(`tabindex`,t)})}}function a(e){let t=o(e);return[s(t,e),s(t.reverse(),e)]}function o(e){let t=[],n=document.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,{acceptNode(e){let t=e.tagName===`INPUT`&&e.type===`hidden`;return e.disabled||e.hidden||t?NodeFilter.FILTER_SKIP:e.tabIndex>=0?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_SKIP}});for(;n.nextNode();)t.push(n.currentNode);return t}function s(e,t){return e.find(e=>!c(e,{upTo:t}))}function c(e,{upTo:t}){if(getComputedStyle(e).visibility===`hidden`)return!0;let n=e;for(;n;){if(t!==void 0&&n===t)return!1;if(getComputedStyle(n).display===`none`)return!0;n=n.parentElement}return!1}function l(e){return e instanceof HTMLInputElement&&`select`in e}function u(e,{select:n=!1}={}){if(!e||!e.focus)return;let r=t();e.focus({preventScroll:!0}),n&&e!==r&&l(e)&&e.select()}function d(e,t){return t===`rtl`?e===`ArrowLeft`?`ArrowRight`:e===`ArrowRight`?`ArrowLeft`:e:e}function f(t,n,r){let i=d(t.key,r);if(!(n===`vertical`&&[`ArrowLeft`,`ArrowRight`].includes(i))&&!(n===`horizontal`&&[`ArrowUp`,`ArrowDown`].includes(i)))return e[i]}export{u as focus,n as focusFirstAndSelect,d as getDirectionAwareKey,f as getFocusIntent,o as getTabbableCandidates,a as getTabbableEdges,i as removeFromTabOrder,r as tryFocusFirst};

package/dist/shared/form.d.ts

@@ -0,0 +1,67 @@
+import { FormNameValueProps } from "../types/component.js";
+import "../types/index.js";
+
+//#region src/shared/form.d.ts
+
+/**
+ * Generate form field names, supporting nested structures
+ *
+ * @example
+ *   createFieldName('user', 0, 'name'); // 'user[0][name]'
+ *   createFieldName('form', 'profile', 'email'); // 'form[profile][email]'
+ *
+ * @param baseName - Base field name
+ * @param paths - Nested paths (can be string or number)
+ * @returns Formatted field name, e.g., "user[0][name]"
+ */
+declare function createFieldName(baseName: string, ...paths: (string | number)[]): string;
+/**
+ * Parse primitive values into form fields
+ *
+ * @param name - Field name
+ * @param value - Primitive value
+ * @returns Array of form fields
+ */
+declare function parsePrimitiveValue(name: string, value: string | number | boolean | null | undefined): FormNameValueProps[];
+/**
+ * Parse array values into form fields
+ *
+ * @example
+ *   parseArrayValue('items', ['a', 'b']);
+ *   // [{ name: 'items[0]', value: 'a' }, { name: 'items[1]', value: 'b' }]
+ *
+ *   parseArrayValue('users', [{ name: 'John', age: 30 }]);
+ *   // [{ name: 'users[0][name]', value: 'John' }, { name: 'users[0][age]', value: 30 }]
+ *
+ * @param baseName - Base field name
+ * @param array - Array value
+ * @returns Array of form fields
+ */
+declare function parseArrayValue(baseName: string, array: unknown[]): FormNameValueProps[];
+/**
+ * Parse object values into form fields
+ *
+ * @example
+ *   parseObjectValue('user', { name: 'John', age: 30 });
+ *   // [{ name: 'user[name]', value: 'John' }, { name: 'user[age]', value: 30 }]
+ *
+ * @param baseName - Base field name
+ * @param obj - Object value
+ * @returns Array of form fields
+ */
+declare function parseObjectValue(baseName: string, obj: Record<string, unknown>): FormNameValueProps[];
+/**
+ * Parse any value into form field array
+ *
+ * @example
+ *   parseFormValue('test', 'hello'); // [{ name: 'test', value: 'hello' }]
+ *   parseFormValue('items', [1, 2, 3]); // [{ name: 'items[0]', value: 1 }, ...]
+ *   parseFormValue('user', { name: 'John' }); // [{ name: 'user[name]', value: 'John' }]
+ *
+ * @param name - Field name
+ * @param value - Value to parse
+ * @returns Array of form fields
+ */
+declare function parseFormValue(name: string, value: unknown): FormNameValueProps[];
+//#endregion
+export { createFieldName, parseArrayValue, parseFormValue, parseObjectValue, parsePrimitiveValue };

package/dist/shared/form.js

@@ -0,0 +1 @@
+import{isArrayValue as e,isNonNullObject as t,isPrimitive as n}from"./guard.js";function r(e,...t){return t.reduce((e,t)=>`${e}[${String(t)}]`,e)}function i(e,t){return[{name:e,value:t}]}function a(e,n){return n.flatMap((n,i)=>t(n)?Object.entries(n).map(([t,n])=>({name:r(e,i,t),value:n})):{name:r(e,i),value:n})}function o(e,t){return Object.entries(t).map(([t,n])=>({name:r(e,t),value:n}))}function s(r,s){return r?n(s)?i(r,s):e(s)?a(r,s):t(s)?o(r,s):s==null?[]:[{name:r,value:String(s)}]:[]}export{r as createFieldName,a as parseArrayValue,s as parseFormValue,o as parseObjectValue,i as parsePrimitiveValue};

package/dist/shared/geometry.d.ts

@@ -0,0 +1,39 @@
+import { Point, Polygon, Side } from "../types/common.js";
+import "../types/index.js";
+
+//#region src/shared/geometry.d.ts
+declare function isPointerInGraceArea(event: PointerEvent, area?: Polygon): boolean;
+declare function isPointInPolygon(point: Point, polygon: Polygon): boolean;
+/**
+ * Determine which side of the rectangle the point is closest to
+ *
+ * @param point Target point
+ * @param rect DOM rectangle
+ * @returns The closest side
+ */
+declare function getExitSideFromRect(point: Point, rect: DOMRect): Side;
+/**
+ * Create padded points based on exit point and exit side
+ *
+ * @param exitPoint Exit point
+ * @param exitSide Exit side
+ * @param padding Padding distance, default 5
+ * @returns Array of padded points
+ */
+declare function getPaddedExitPoints(exitPoint: Point, exitSide: Side, padding?: number): Point[];
+/**
+ * Get four corner points from DOMRect
+ *
+ * @param rect DOM rectangle
+ * @returns Array of points (clockwise starting from top-left)
+ */
+declare function getPointsFromRect(rect: DOMRect): Point[];
+/**
+ * Calculate convex hull using Graham scan algorithm - optimized version with better performance
+ *
+ * @param points Point collection
+ * @returns Array of convex hull points
+ */
+declare function getHull<P extends Point>(points: Readonly<Array<P>>): Array<P>;
+//#endregion
+export { getExitSideFromRect, getHull, getPaddedExitPoints, getPointsFromRect, isPointInPolygon, isPointerInGraceArea };

package/dist/shared/geometry.js

@@ -0,0 +1 @@
+function e(e,n){if(!n)return!1;let{clientX:r,clientY:i}=e;return t({x:r,y:i},n)}function t(e,t){let{x:n,y:r}=e;if(t.length<3)return!1;let{x:i,y:a}=t[0],{x:o,y:s}=t[0];for(let e=1;e<t.length;e++){let n=t[e];i=Math.min(i,n.x),o=Math.max(o,n.x),a=Math.min(a,n.y),s=Math.max(s,n.y)}if(n<i||n>o||r<a||r>s)return!1;let c=0;for(let e=0;e<t.length;e++){let i=t[e],a=t[(e+1)%t.length],{x:o,y:s}=i,{x:l,y:u}=a;s>r!=u>r&&n<o+(r-s)*(l-o)/(u-s)&&c++}return c%2==1}function n(e,t){let{x:n,y:r}=e,{top:i,right:a,bottom:o,left:s}=t,c=Math.abs(i-r),l=Math.abs(o-r),u=Math.abs(s-n),d=Math.abs(a-n);return Math.min(u,d)<Math.min(c,l)?u<d?`left`:`right`:c<l?`top`:`bottom`}function r(e,t,n=5){let{x:r,y:i}=e;return{top:[{x:r-n,y:i+n},{x:r+n,y:i+n}],bottom:[{x:r-n,y:i-n},{x:r+n,y:i-n}],left:[{x:r+n,y:i-n},{x:r+n,y:i+n}],right:[{x:r-n,y:i-n},{x:r-n,y:i+n}]}[t]}function i(e){let{top:t,right:n,bottom:r,left:i}=e;return[{x:i,y:t},{x:n,y:t},{x:n,y:r},{x:i,y:r}]}function a(e,t){let n=e.x-t.x,r=e.y-t.y;return n*n+r*r}function o(e,t,n){return(t.x-e.x)*(n.y-e.y)-(t.y-e.y)*(n.x-e.x)}function s(e){if(e.length<=1||e.length===2)return[...e];if(e.length===3){let[t,n,r]=e,i=o(t,n,r);if(Math.abs(i)<1e-10){let e=a(t,n),i=a(t,r),o=a(n,r),s=Math.max(e,i,o);return s===e?[t,n]:s===i?[t,r]:[n,r]}return[...e]}return c([...e].sort((e,t)=>e.x===t.x?e.y-t.y:e.x-t.x))}function c(e){if(e.length<=1)return[...e];let t=[];for(let n of e){for(;t.length>=2&&o(t[t.length-2],t[t.length-1],n)<=0;)t.pop();t.push(n)}let n=[];for(let t=e.length-1;t>=0;t--){let r=e[t];for(;n.length>=2&&o(n[n.length-2],n[n.length-1],r)<=0;)n.pop();n.push(r)}return t.pop(),n.pop(),t.length===1&&n.length===1&&t[0].x===n[0].x&&t[0].y===n[0].y?t:t.concat(n)}export{n as getExitSideFromRect,s as getHull,r as getPaddedExitPoints,i as getPointsFromRect,t as isPointInPolygon,e as isPointerInGraceArea};

package/dist/shared/guard.d.ts

@@ -0,0 +1,51 @@
+//#region src/shared/guard.d.ts
+/**
+ * Type guard: check if value is a string
+ *
+ * @param value
+ * @returns
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * Type guard: check if value is a primitive type
+ *
+ * @param value - The value to check
+ * @returns Whether the value is string | number | boolean
+ */
+declare function isPrimitive(value: unknown): value is string | number | boolean | null | undefined;
+/**
+ * Type guard: check if value is a non-null object (excluding arrays)
+ *
+ * @param value - The value to check
+ * @returns Whether the value is a non-null object
+ */
+declare function isNonNullObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard: check if value is an array
+ *
+ * @param value - The value to check
+ * @returns Whether the value is an array
+ */
+declare function isArrayValue(value: unknown): value is unknown[];
+/**
+ * Type guard: check if value is null or undefined
+ *
+ * @param value - The value to check
+ * @returns Whether the value is null or undefined
+ */
+declare function isNullish(value: unknown): value is null | undefined;
+/**
+ * Type guard: check if value is an empty string
+ *
+ * @param value - The value to check
+ * @returns Whether the value is an empty string
+ */
+declare function isBlankString(value: unknown | undefined): value is string;
+declare function isDateObject(value: unknown): value is Date;
+declare function isObjectType(value: unknown): value is object | null;
+declare function isFunction(value: unknown): value is (...args: any[]) => any;
+declare function isObject(value: unknown): boolean;
+declare function isPromise(value: any): value is PromiseLike<any>;
+declare function keysOf<TRecord extends Record<string, unknown>>(record: TRecord): (keyof TRecord)[];
+//#endregion
+export { isArrayValue, isBlankString, isDateObject, isFunction, isNonNullObject, isNullish, isObject, isObjectType, isPrimitive, isPromise, isString, keysOf };

package/dist/shared/guard.js

@@ -0,0 +1 @@
+function e(e){return typeof e==`string`}function t(e){let t=typeof e;return t===`string`||t===`number`||t===`boolean`||i(e)}function n(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function r(e){return typeof e==`object`&&Array.isArray(e)}function i(e){return e==null}function a(e){return typeof e==`string`&&e===``}function o(e){return e instanceof Date}function s(e){return typeof e==`object`}function c(e){return typeof e==`function`}function l(e){return!i(e)&&!Array.isArray(e)&&s(e)&&!o(e)}function u(e){return l(e)&&c(e?.then)}function d(e){return Object.keys(e)}export{r as isArrayValue,a as isBlankString,o as isDateObject,c as isFunction,n as isNonNullObject,i as isNullish,l as isObject,s as isObjectType,t as isPrimitive,u as isPromise,e as isString,d as keysOf};

package/dist/shared/index.d.ts

@@ -0,0 +1,13 @@
+import { isArrayValue, isBlankString, isDateObject, isFunction, isNonNullObject, isNullish, isObject, isObjectType, isPrimitive, isPromise, isString, keysOf } from "./guard.js";
+import { appendAt, arrayRemove, compact, findValuesBetween, flattenChildren, getNextMatch, insertAt, moveAt, omit, pick, prependAt, removeAt, swapAt, updateAt, wrapArray } from "./object.js";
+import { isKey, stringToPath, toCamelCase, toKebabCase, toPascalCase } from "./string.js";
+import { isValueEqualOrExist } from "./comparison.js";
+import { clamp, getBinaryCheckedState, getCheckedState, getDisclosureState, getOpenFromSingleOrMultiple, getValue, isIndeterminate, roundToStepPrecision, setValue, snapValueToStep } from "./value.js";
+import { createFieldName, parseArrayValue, parseFormValue, parseObjectValue, parsePrimitiveValue } from "./form.js";
+import { getActiveElement, getAriaLabel, getAriaLabelByVNode, getAriaLabelByVNodeList, getCollectionItemElements, isElementHasAttribute, removeLinks } from "./dom.js";
+import { focus, focusFirstAndSelect, getDirectionAwareKey, getFocusIntent, getTabbableCandidates, getTabbableEdges, removeFromTabOrder, tryFocusFirst } from "./focus.js";
+import { getElFromTemplateRef, getLifeCycleTarget, getRawChildren, isFormControl, transformPropsToContext } from "./vue.js";
+import { isBrowser, isClient, isIOS, refreshIOSDetection } from "./env.js";
+import { handleAndDispatchCustomEvent, isMouseEvent } from "./event.js";
+import { getExitSideFromRect, getHull, getPaddedExitPoints, getPointsFromRect, isPointInPolygon, isPointerInGraceArea } from "./geometry.js";
+export { appendAt, arrayRemove, clamp, compact, createFieldName, findValuesBetween, flattenChildren, focus, focusFirstAndSelect, getActiveElement, getAriaLabel, getAriaLabelByVNode, getAriaLabelByVNodeList, getBinaryCheckedState, getCheckedState, getCollectionItemElements, getDirectionAwareKey, getDisclosureState, getElFromTemplateRef, getExitSideFromRect, getFocusIntent, getHull, getLifeCycleTarget, getNextMatch, getOpenFromSingleOrMultiple, getPaddedExitPoints, getPointsFromRect, getRawChildren, getTabbableCandidates, getTabbableEdges, getValue, handleAndDispatchCustomEvent, insertAt, isArrayValue, isBlankString, isBrowser, isClient, isDateObject, isElementHasAttribute, isFormControl, isFunction, isIOS, isIndeterminate, isKey, isMouseEvent, isNonNullObject, isNullish, isObject, isObjectType, isPointInPolygon, isPointerInGraceArea, isPrimitive, isPromise, isString, isValueEqualOrExist, keysOf, moveAt, omit, parseArrayValue, parseFormValue, parseObjectValue, parsePrimitiveValue, pick, prependAt, refreshIOSDetection, removeAt, removeFromTabOrder, removeLinks, roundToStepPrecision, setValue, snapValueToStep, stringToPath, swapAt, toCamelCase, toKebabCase, toPascalCase, transformPropsToContext, tryFocusFirst, updateAt, wrapArray };

package/dist/shared/index.js

@@ -0,0 +1 @@
+import{isArrayValue as e,isBlankString as t,isDateObject as n,isFunction as r,isNonNullObject as i,isNullish as a,isObject as o,isObjectType as s,isPrimitive as c,isPromise as l,isString as u,keysOf as d}from"./guard.js";import{appendAt as f,arrayRemove as p,compact as m,findValuesBetween as h,flattenChildren as g,getNextMatch as _,insertAt as v,moveAt as y,omit as b,pick as x,prependAt as S,removeAt as C,swapAt as w,updateAt as T,wrapArray as E}from"./object.js";import{isKey as D,stringToPath as O,toCamelCase as k,toKebabCase as A,toPascalCase as j}from"./string.js";import{isValueEqualOrExist as M}from"./comparison.js";import{clamp as N,getBinaryCheckedState as P,getCheckedState as F,getDisclosureState as I,getOpenFromSingleOrMultiple as L,getValue as R,isIndeterminate as z,roundToStepPrecision as B,setValue as V,snapValueToStep as H}from"./value.js";import{createFieldName as U,parseArrayValue as W,parseFormValue as G,parseObjectValue as K,parsePrimitiveValue as q}from"./form.js";import{getActiveElement as J,getAriaLabel as Y,getAriaLabelByVNode as X,getAriaLabelByVNodeList as Z,getCollectionItemElements as Q,isElementHasAttribute as $,removeLinks as ee}from"./dom.js";import{focus as te,focusFirstAndSelect as ne,getDirectionAwareKey as re,getFocusIntent as ie,getTabbableCandidates as ae,getTabbableEdges as oe,removeFromTabOrder as se,tryFocusFirst as ce}from"./focus.js";import{getElFromTemplateRef as le,getLifeCycleTarget as ue,getRawChildren as de,isFormControl as fe,transformPropsToContext as pe}from"./vue.js";import{isBrowser as me,isClient as he,isIOS as ge,refreshIOSDetection as _e}from"./env.js";import{handleAndDispatchCustomEvent as ve,isMouseEvent as ye}from"./event.js";import{getExitSideFromRect as be,getHull as xe,getPaddedExitPoints as Se,getPointsFromRect as Ce,isPointInPolygon as we,isPointerInGraceArea as Te}from"./geometry.js";export{f as appendAt,p as arrayRemove,N as clamp,m as compact,U as createFieldName,h as findValuesBetween,g as flattenChildren,te as focus,ne as focusFirstAndSelect,J as getActiveElement,Y as getAriaLabel,X as getAriaLabelByVNode,Z as getAriaLabelByVNodeList,P as getBinaryCheckedState,F as getCheckedState,Q as getCollectionItemElements,re as getDirectionAwareKey,I as getDisclosureState,le as getElFromTemplateRef,be as getExitSideFromRect,ie as getFocusIntent,xe as getHull,ue as getLifeCycleTarget,_ as getNextMatch,L as getOpenFromSingleOrMultiple,Se as getPaddedExitPoints,Ce as getPointsFromRect,de as getRawChildren,ae as getTabbableCandidates,oe as getTabbableEdges,R as getValue,ve as handleAndDispatchCustomEvent,v as insertAt,e as isArrayValue,t as isBlankString,me as isBrowser,he as isClient,n as isDateObject,$ as isElementHasAttribute,fe as isFormControl,r as isFunction,ge as isIOS,z as isIndeterminate,D as isKey,ye as isMouseEvent,i as isNonNullObject,a as isNullish,o as isObject,s as isObjectType,we as isPointInPolygon,Te as isPointerInGraceArea,c as isPrimitive,l as isPromise,u as isString,M as isValueEqualOrExist,d as keysOf,y as moveAt,b as omit,W as parseArrayValue,G as parseFormValue,K as parseObjectValue,q as parsePrimitiveValue,x as pick,S as prependAt,_e as refreshIOSDetection,C as removeAt,se as removeFromTabOrder,ee as removeLinks,B as roundToStepPrecision,V as setValue,H as snapValueToStep,O as stringToPath,w as swapAt,k as toCamelCase,A as toKebabCase,j as toPascalCase,pe as transformPropsToContext,ce as tryFocusFirst,T as updateAt,E as wrapArray};

package/dist/shared/object.d.ts

@@ -0,0 +1,73 @@
+//#region src/shared/object.d.ts
+/**
+ * Select specified properties from an object
+ *
+ * @param obj - Source object
+ * @param keys - Array of property keys to select
+ * @returns New object containing specified properties
+ */
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Exclude specified properties from an object
+ *
+ * @param obj - Source object
+ * @param keys - Array of property keys to exclude
+ * @returns New object with specified properties excluded
+ */
+declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+declare function compact<T>(value: T[]): T[];
+/**
+ * Remove specified element from an array
+ *
+ * @param array - Source array
+ * @param item - Element to remove
+ * @returns New array with element removed
+ */
+declare function arrayRemove<T>(array: T[], item: T): T[];
+/**
+ * Wraps an array around itself at a given start index Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a',
+ * 'b']`
+ */
+declare function wrapArray<T>(array: T[], startIndex: number): T[];
+declare function appendAt<T>(data: T[], value: T): T[];
+declare function prependAt<T>(data: T[], value: T): T[];
+declare function removeAt<T>(data: T[], index?: number): T[];
+declare function swapAt<T>(data: T[], indexA: number, indexB: number): void;
+declare function moveAt<T>(data: T[], from: number, to: number): void;
+declare function insertAt<T>(data: T[], index: number, value: T): T[];
+declare function updateAt<T>(data: T[], index: number, value: T): T[];
+/**
+ * This is the "meat" of the typeahead matching logic. It takes in all the values, the search and the current match, and
+ * returns the next match (or `undefined`).
+ *
+ * We normalize the search because if a user has repeatedly pressed a character, we want the exact same behavior as if
+ * we only had that one character (ie. cycle through options starting with that character)
+ *
+ * We also reorder the values by wrapping the array around the current match. This is so we always look forward from the
+ * current match, and picking the first match will always be the correct one.
+ *
+ * Finally, if the normalized search is exactly one character, we exclude the current match from the values because
+ * otherwise it would be the first to match always and focus would never move. This is as opposed to the regular case,
+ * where we don't want focus to move if the current match still matches.
+ */
+declare function getNextMatch(values?: string[], search?: string, currentMatch?: string): string | undefined;
+/**
+ * The function `findValuesBetween` takes an array and two values, then returns a subarray containing elements between
+ * the first occurrence of the start value and the first occurrence of the end value in the array.
+ *
+ * @param {T[]} array - The `array` parameter is an array of values of type `T`.
+ * @param {T} start - The `start` parameter is the value that marks the beginning of the range you want to find in the
+ *   array.
+ * @param {T} end - The `end` parameter in the `findValuesBetween` function represents the end value that you want to
+ *   find in the array. This function will return a subarray of values that are between the `start` and `end` values in
+ *   the original array.
+ * @returns The `findValuesBetween` function returns an array of values from the input array that are between the
+ *   `start` and `end` values (inclusive). If either the `start` or `end` values are not found in the input array, an
+ *   empty array is returned.
+ */
+declare function findValuesBetween<T>(array: T[], start: T, end: T): T[];
+declare function flattenChildren<T extends {
+  children?: any[];
+}>(items?: T[]): Omit<T, "children">[];
+//#endregion
+export { appendAt, arrayRemove, compact, findValuesBetween, flattenChildren, getNextMatch, insertAt, moveAt, omit, pick, prependAt, removeAt, swapAt, updateAt, wrapArray };

package/dist/shared/object.js

@@ -0,0 +1 @@
+import{isEqual as e}from"ohash";function t(e,t){let n={};for(let r of t)n[r]=e[r];return n}function n(e,t){let n={};for(let r in e){let i=r;t.includes(i)||(n[i]=e[i])}return n}function r(e){return Array.isArray(e)?e.filter(Boolean):[]}function i(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}function a(e,t){if(e.length===0)return[];let n=(t%e.length+e.length)%e.length;return e.map((t,r)=>e[(n+r)%e.length])}function o(e,t){return[...e,t]}function s(e,t){return[t,...e]}function c(e,t){if(t===void 0)return[];let n=[...e];return n.splice(t,1),n}function l(e,t,n){let r=e[t];e[t]=e[n],e[n]=r}function u(e,t,n){let[r]=e.splice(t,1);e.splice(n,0,r)}function d(e,t,n){return[...e.slice(0,t),n,...e.slice(t)]}function f(e,t,n){let r=[...e];return r[t]=n,r}function p(e,t,n){if(!e?.length||!t)return;let r=t.length>1&&t[0]?.repeat(t.length)===t?t[0]:t,i=r.toLowerCase(),a=r.length===1,o=n?e.indexOf(n):-1,s=Math.max(o,0),c=e.length;for(let t=0;t<c;t++){let r=e[(s+t)%c];if((!a||r!==n)&&r?.toLowerCase().startsWith(i))return r===n?void 0:r}}function m(t,n,r){let i=t.findIndex(t=>e(t,n)),a=t.findIndex(t=>e(t,r));if(i===-1||a===-1)return[];let[o,s]=[i,a].sort((e,t)=>e-t);return t.slice(o,s+1)}function h(e){return e?e.reduce((e,t)=>(e.push(t),t.children&&e.push(...h(t.children)),e),[]):[]}export{o as appendAt,i as arrayRemove,r as compact,m as findValuesBetween,h as flattenChildren,p as getNextMatch,d as insertAt,u as moveAt,n as omit,t as pick,s as prependAt,c as removeAt,l as swapAt,f as updateAt,a as wrapArray};

package/dist/shared/string.d.ts

@@ -0,0 +1,50 @@
+//#region src/shared/string.d.ts
+/**
+ * Convert string to kebab-case format
+ *
+ * @example
+ *   toKebabCase('helloWorld'); // 'hello-world'
+ *   toKebabCase('HelloWorld'); // 'hello-world'
+ *
+ * @param str - The string to convert
+ * @returns String in kebab-case format
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Convert string to PascalCase format
+ *
+ * @example
+ *   toPascalCase('hello-world'); // 'HelloWorld'
+ *   toPascalCase('hello_world'); // 'HelloWorld'
+ *
+ * @param str - The string to convert
+ * @returns String in PascalCase format
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Convert string to camelCase format
+ *
+ * @example
+ *   toCamelCase('hello-world'); // 'helloWorld'
+ *   toCamelCase('hello_world'); // 'helloWorld'
+ *
+ * @param str - The string to convert
+ * @returns String in camelCase format
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Convert string to path
+ *
+ * @param str - The string to convert
+ * @returns Path
+ */
+declare function stringToPath(str: string): string[];
+/**
+ * Check if string is a key
+ *
+ * @param str - The string to check
+ * @returns Whether the string is a key
+ */
+declare function isKey(str: string): boolean;
+//#endregion
+export { isKey, stringToPath, toCamelCase, toKebabCase, toPascalCase };

package/dist/shared/string.js

@@ -0,0 +1 @@
+import{compact as e}from"./object.js";function t(e){return e.replace(/([a-z0-9])([A-Z])/g,`$1-$2`).toLowerCase()}function n(e){return e.replace(/(^\w|-\w)/g,e=>e.replace(`-`,``).toUpperCase())}function r(e){return e.replace(/(-\w)/g,e=>e.replace(`-`,``).toUpperCase())}function i(t){return e(t.replace(/["|']|\]/g,``).split(/\.|\[/))}function a(e){return/^\w*$/.test(e)}export{a as isKey,i as stringToPath,r as toCamelCase,t as toKebabCase,n as toPascalCase};

package/dist/shared/value.d.ts

@@ -0,0 +1,65 @@
+import { CheckedState, DefinedValue, MaybeArray } from "../types/common.js";
+import "../types/index.js";
+
+//#region src/shared/value.d.ts
+declare function isIndeterminate(checked?: CheckedState | null): checked is 'indeterminate';
+declare function getCheckedState(checked?: CheckedState | null): "indeterminate" | "checked" | "unchecked";
+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,12 @@
+import { PropsToContext, VNodeRef } from "../types/vue.js";
+import "../types/index.js";
+import { 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;
+//#endregion
+export { getElFromTemplateRef, getLifeCycleTarget, getRawChildren, isFormControl, transformPropsToContext };

package/dist/shared/vue.js

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

package/dist/types/common.d.ts

@@ -0,0 +1,57 @@
+//#region src/types/common.d.ts
+type PrimitiveType = null | undefined | string | number | boolean | symbol | bigint;
+type ClassValue = string | null | undefined | Record<string, boolean> | ClassValue[];
+type DefinedValue = string | number;
+type AcceptableValue = DefinedValue | null | undefined;
+type AcceptableBooleanValue = AcceptableValue | boolean;
+type MaybeArray<T> = T | Array<T>;
+type MaybePromise<T> = T | Promise<T>;
+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 HorizontalSide = Extract<Side, 'left' | 'right'>;
+type Align = 'start' | 'center' | 'end';
+type Placement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+type Point = {
+  x: number;
+  y: number;
+};
+type Polygon = Point[];
+/**
+ * if padding or margin is number, it will be in px if padding or margin is true, it will be var(--scrollbar-width)
+ * otherwise, it will be passed string
+ */
+type ScrollBodyOption = {
+  padding?: boolean | number | string;
+  margin?: boolean | number | string;
+};
+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;
+}
+type SelectionEmits<M extends boolean = false, N extends DefinedValue = string> = {
+  'update:modelValue': [value: M extends true ? N[] : N];
+};
+//#endregion
+export { AcceptableBooleanValue, AcceptableValue, Align, CheckedState, ClassValue, DataOrientation, DefinedValue, Direction, DisclosureState, FocusIntent, HorizontalSide, KbdKey, MaybeArray, MaybePromise, NavigationKey, Placement, Point, Polygon, PrimitiveType, ScrollBodyOption, SelectionEmits, SelectionProps, Side };

package/dist/types/component.d.ts

@@ -0,0 +1,58 @@
+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 };