@lumx/vue 4.12.0-next.5 → 4.12.0-next.6

package/_internal/CO3BhTbu.js

@@ -0,0 +1,161 @@
+import { defineComponent as s, provide as u, inject as f, ref as p, watch as P, onBeforeUnmount as v, createVNode as h, Teleport as I, isVNode as C, onMounted as L, computed as b, unref as x, watchEffect as R } from "vue";
+import { Theme as A } from "@lumx/core/js/constants";
+const S = () => (...e) => e.reduce(
+  (n, o) => (n[o] = { required: !1 }, n),
+  {}
+), y = /* @__PURE__ */ Symbol("LumxPortal"), E = () => ({
+  container: "body"
+}), Y = /* @__PURE__ */ s((e, {
+  slots: n
+}) => (u(y, e.value), () => n.default?.()), {
+  name: "LumxPortalProvider",
+  props: {
+    value: {
+      type: Function,
+      required: !0
+    }
+  }
+});
+function T(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !C(e);
+}
+const K = /* @__PURE__ */ s((e, {
+  slots: n
+}) => {
+  const o = f(y, E), t = p(null), a = () => {
+    e.enabled ? t.value = o() : t.value = null;
+  };
+  return a(), P(() => e.enabled, a), v(() => {
+    t.value?.teardown?.();
+  }), () => {
+    const c = n.default?.(), r = t.value?.container;
+    return !e.enabled || !r ? c : h(I, {
+      to: r
+    }, T(c) ? c : {
+      default: () => [c]
+    });
+  };
+}, {
+  name: "LumxPortal",
+  props: {
+    enabled: {
+      type: Boolean,
+      default: !0
+    }
+  }
+}), d = ["mousedown", "touchstart"];
+function w(e, n) {
+  return !n.some((o) => o instanceof Node && e.some((t) => o.contains(t)));
+}
+function k(e, n) {
+  if (!n)
+    return;
+  const o = (t) => {
+    const a = [t.composedPath?.()[0], t.target].filter((r) => r instanceof Node), c = e();
+    w(a, c) && n(t);
+  };
+  return d.forEach((t) => document.addEventListener(t, o)), () => {
+    d.forEach((t) => document.removeEventListener(t, o));
+  };
+}
+const m = /* @__PURE__ */ Symbol("LumxClickAway"), q = /* @__PURE__ */ s((e, {
+  slots: n
+}) => {
+  const o = f(m, null), t = [], a = {
+    childrenRefs: t,
+    addRefs(...r) {
+      for (const l of r) {
+        const i = l.value;
+        i && t.push(i);
+      }
+      o && (o.addRefs(...r), e.parentRef && o.addRefs(e.parentRef));
+    }
+  };
+  u(m, a);
+  let c;
+  return L(() => {
+    const r = e.childrenRefs.value;
+    r && a.addRefs(...r), c = k(() => t, (l) => {
+      const i = e.callback;
+      typeof i == "function" && i(l);
+    });
+  }), v(() => {
+    c?.();
+  }), () => n.default?.();
+}, {
+  name: "LumxClickAwayProvider",
+  props: {
+    callback: {
+      type: [Function, Boolean, void 0],
+      default: void 0
+    },
+    childrenRefs: {
+      type: Object,
+      required: !0
+    },
+    parentRef: {
+      type: Object,
+      default: void 0
+    }
+  }
+}), B = s(
+  (e, { slots: n }) => (u(
+    "theme",
+    b(() => e.value)
+  ), () => n.default?.()),
+  {
+    name: "LumxThemeProvider",
+    props: { value: { type: String, default: void 0 } }
+  }
+);
+function F(e = { defaultTheme: A.light }) {
+  const { defaultTheme: n } = e, o = f("theme", void 0);
+  return b(() => x(o) || n);
+}
+function N(e, n, o) {
+  const t = new IntersectionObserver((a = []) => {
+    a.some((r) => r.isIntersecting) && n();
+  }, o);
+  return t.observe(e), () => {
+    t.unobserve(e);
+  };
+}
+const O = "lumx-infinite-scroll-anchor", _ = ({
+  ref: e
+}) => (
+  // In order to avoid issues when a zoom is added to the browser, we add a small height to the div so that
+  // the intersection has a higher chance of working correctly.
+  h("div", {
+    ref: e,
+    "aria-hidden": "true",
+    className: O,
+    style: {
+      height: "4px"
+    }
+  }, null)
+), V = /* @__PURE__ */ s((e) => {
+  const n = p(null);
+  return R((o) => {
+    const t = n.value;
+    if (!t) return;
+    const a = N(t, e.callback, e.options);
+    o(a);
+  }), () => _({
+    ref: n
+  });
+}, {
+  name: "LumxInfiniteScroll",
+  inheritAttrs: !1,
+  props: S()("callback", "options")
+});
+export {
+  q as C,
+  V as I,
+  K as P,
+  B as T,
+  Y as a,
+  S as k,
+  k as s,
+  F as u
+};
+//# sourceMappingURL=CO3BhTbu.js.map

package/_internal/CO3BhTbu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CO3BhTbu.js","sources":["../../src/utils/VueToJSX.ts","../../src/utils/Portal/PortalProvider.tsx","../../src/utils/Portal/Portal.tsx","../../../lumx-core/src/js/utils/ClickAway/index.ts","../../src/utils/ClickAway/ClickAwayProvider.tsx","../../src/utils/theme/ThemeProvider.ts","../../src/utils/theme/useTheme.ts","../../../lumx-core/src/js/utils/InfiniteScroll/setupInfiniteScrollObserver.ts","../../../lumx-core/src/js/utils/InfiniteScroll/index.tsx","../../src/utils/InfiniteScroll/InfiniteScroll.tsx"],"sourcesContent":["import { PropsToOverride } from '@lumx/core/js/types';\n/**\n * Props interface for components wrapped with VueToJSX.\n * It omits JSX-specific props like `children` and `className` and adds Vue's `class`.\n *\n * @template Props - The base props type\n * @template OmitProps - Additional props to omit beyond the defaults (children, className, ref)\n */\nexport type VueToJSXProps<Props, OmitProps extends keyof Props = never> = Omit<\n    Props,\n    PropsToOverride | 'children' | 'className' | OmitProps\n> & {\n    /** Class name forwarded to the root element of the component. */\n    class?: string;\n};\n\n/**\n * Hyphenated aria-* prop keys that must NOT be declared as Vue component props.\n * When declared, Vue normalizes them to camelCase (e.g. aria-haspopup → ariaHaspopup),\n * which breaks hyphenated key destructuring in core component templates.\n * By excluding them from props, they flow through `attrs` with their original hyphenated keys.\n */\nexport type HyphenatedAriaProps = 'aria-expanded' | 'aria-haspopup' | 'aria-label' | 'aria-pressed';\n\nexport const keysOf = <T>() => {\n    return <K extends readonly (keyof T)[]>(\n        ...keys: [keyof T] extends [K[number]]\n            ? K\n            : [Error: '❌ Missing keys in your list:', Exclude<keyof T, K[number]>]\n    ) => {\n        // Return an object with all props marked as optional (not required)\n        // This ensures Vue's type system correctly infers props as optional\n        return keys.reduce(\n            (acc, key) => {\n                acc[key as K[number]] = { required: false };\n                return acc;\n            },\n            {} as Record<K[number], { required: false }>,\n        );\n    };\n};\n\n/**\n * Derive the typed Vue emits map from a runtime `emitSchema` object.\n *\n * @example\n * export const emitSchema = {\n *     change: (_newValue?: unknown) => true,\n *     search: (_text: string) => true,\n * };\n * export type MyEmits<O> = EmitsOf<typeof emitSchema>\n */\nexport type EmitsOf<S> = {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [K in keyof S]: S[K] extends (...args: infer A) => any ? (...args: A) => void : never;\n};\n","import { defineComponent, provide, type PropType, type InjectionKey } from 'vue';\n\nexport type { PortalInit, PortalProviderProps } from '@lumx/core/js/utils/Portal';\nimport type { PortalInit, PortalProviderProps } from '@lumx/core/js/utils/Portal';\n\nexport const PORTAL_KEY: InjectionKey<PortalInit> = Symbol('LumxPortal');\n\nexport const defaultPortalInit: PortalInit = () => ({ container: 'body' });\n\n/**\n * Customize where <Portal> wrapped elements render (tooltip, popover, dialog, etc.)\n */\nexport const PortalProvider = defineComponent(\n    (props: PortalProviderProps, { slots }) => {\n        provide(PORTAL_KEY, props.value);\n        return () => slots.default?.();\n    },\n    {\n        name: 'LumxPortalProvider',\n        props: {\n            value: {\n                type: Function as PropType<PortalInit>,\n                required: true,\n            },\n        },\n    },\n);\n","import { defineComponent, inject, onBeforeUnmount, Teleport, ref, watch } from 'vue';\nimport { PORTAL_KEY, defaultPortalInit } from './PortalProvider';\n\nexport type { PortalProps } from '@lumx/core/js/utils/Portal';\nimport type { PortalProps } from '@lumx/core/js/utils/Portal';\n\n/**\n * Render children in a portal outside the current DOM position\n * (defaults to `document.body` but can be customized with the PortalProvider)\n */\nexport const Portal = defineComponent(\n    (props: PortalProps, { slots }) => {\n        const portalInit = inject(PORTAL_KEY, defaultPortalInit);\n        const context = ref<ReturnType<typeof portalInit> | null>(null);\n\n        // Initialize portal context when enabled\n        const initializePortal = () => {\n            if (props.enabled) {\n                context.value = portalInit();\n            } else {\n                context.value = null;\n            }\n        };\n\n        // Initialize on mount and when enabled changes\n        initializePortal();\n        watch(() => props.enabled, initializePortal);\n\n        // Register teardown on unmount\n        onBeforeUnmount(() => {\n            context.value?.teardown?.();\n        });\n\n        return () => {\n            const content = slots.default?.();\n            const container = context.value?.container;\n\n            // If disabled or no container, render inline\n            if (!props.enabled || !container) {\n                return content;\n            }\n\n            // Render in portal using Teleport\n            return <Teleport to={container}>{content}</Teleport>;\n        };\n    },\n    {\n        name: 'LumxPortal',\n        props: {\n            enabled: {\n                type: Boolean,\n                default: true,\n            },\n        },\n    },\n);\n","/**\n * Shared types and logic for ClickAway detection.\n *\n * ClickAway detects clicks outside a set of elements and triggers a callback.\n * The core logic (event listening + target checking) is framework-agnostic.\n * Framework-specific wrappers (React hook, Vue composable) and context providers\n * (React context, Vue provide/inject) are implemented in each framework package.\n */\n\nimport type { Falsy } from '@lumx/core/js/types';\n\n/** Event types that trigger click away detection. */\nexport const CLICK_AWAY_EVENT_TYPES = ['mousedown', 'touchstart'] as const;\n\n/** Callback triggered when a click away is detected. */\nexport type ClickAwayCallback = EventListener | Falsy;\n\n/**\n * Check if the click event targets are outside all the given elements.\n *\n * @param targets - The event target elements (from `event.target` and `event.composedPath()`).\n * @param elements - The elements considered \"inside\" the click away context.\n * @returns `true` if the click is outside all elements (i.e. a click away).\n */\nexport function isClickAway(targets: HTMLElement[], elements: HTMLElement[]): boolean {\n    return !elements.some((element) => element instanceof Node && targets.some((target) => element.contains(target)));\n}\n\n/**\n * Imperative setup for click away detection.\n * Adds mousedown/touchstart listeners on `document` and calls the callback when a click\n * occurs outside the elements returned by `getElements`.\n *\n * Note: when `getElements` returns an empty array, any click is considered a click away.\n * Callers should guard against calling `setupClickAway` when no refs are registered.\n *\n * @param getElements - Getter returning the current list of elements considered \"inside\".\n * @param callback - Callback to invoke on click away.\n * @returns A teardown function that removes the event listeners.\n */\nexport function setupClickAway(\n    getElements: () => HTMLElement[],\n    callback: ClickAwayCallback,\n): (() => void) | undefined {\n    if (!callback) {\n        return undefined;\n    }\n\n    const listener: EventListener = (evt) => {\n        const targets = [evt.composedPath?.()[0], evt.target].filter((t): t is HTMLElement => t instanceof Node);\n        const elements = getElements();\n        if (isClickAway(targets, elements)) {\n            callback(evt);\n        }\n    };\n\n    CLICK_AWAY_EVENT_TYPES.forEach((evtType) => document.addEventListener(evtType, listener));\n    return () => {\n        CLICK_AWAY_EVENT_TYPES.forEach((evtType) => document.removeEventListener(evtType, listener));\n    };\n}\n","import {\n    defineComponent,\n    inject,\n    onBeforeUnmount,\n    onMounted,\n    provide,\n    type InjectionKey,\n    type PropType,\n    type Ref,\n} from 'vue';\nimport { setupClickAway, type ClickAwayCallback } from '@lumx/core/js/utils/ClickAway';\n\ninterface ContextValue {\n    childrenRefs: HTMLElement[];\n    addRefs(...newChildrenRefs: Array<Ref<HTMLElement | undefined>>): void;\n}\n\nexport const CLICK_AWAY_KEY: InjectionKey<ContextValue> = Symbol('LumxClickAway');\n\n/**\n * Component combining click away detection with Vue's provide/inject to hook into the component tree\n * and take into account both the DOM tree and the component tree to detect click away.\n */\nexport const ClickAwayProvider = defineComponent(\n    (\n        props: {\n            callback: ClickAwayCallback;\n            childrenRefs: Ref<Array<Ref<HTMLElement | undefined>>>;\n            parentRef?: Ref<HTMLElement | undefined>;\n        },\n        { slots },\n    ) => {\n        const parentContext = inject(CLICK_AWAY_KEY, null);\n\n        const contextChildrenRefs: HTMLElement[] = [];\n\n        const currentContext: ContextValue = {\n            childrenRefs: contextChildrenRefs,\n            addRefs(...newChildrenRefs) {\n                for (const newRef of newChildrenRefs) {\n                    const el = newRef.value;\n                    if (el) {\n                        contextChildrenRefs.push(el);\n                    }\n                }\n                if (parentContext) {\n                    parentContext.addRefs(...newChildrenRefs);\n                    if (props.parentRef) {\n                        parentContext.addRefs(props.parentRef);\n                    }\n                }\n            },\n        };\n\n        provide(CLICK_AWAY_KEY, currentContext);\n\n        let teardown: (() => void) | undefined;\n\n        onMounted(() => {\n            const refs = props.childrenRefs.value;\n            if (refs) {\n                currentContext.addRefs(...refs);\n            }\n\n            // Setup click away using a closure that always reads the latest callback prop.\n            // This handles transitions like closeMode=\"hide\" where the callback changes\n            // between open (handleClose) and closed (undefined) without re-creating the listener.\n            teardown = setupClickAway(\n                () => contextChildrenRefs,\n                (event) => {\n                    const cb = props.callback;\n                    if (typeof cb === 'function') cb(event);\n                },\n            );\n        });\n\n        onBeforeUnmount(() => {\n            teardown?.();\n        });\n\n        return () => slots.default?.();\n    },\n    {\n        name: 'LumxClickAwayProvider',\n        props: {\n            callback: {\n                type: [Function, Boolean, undefined] as PropType<ClickAwayCallback>,\n                default: undefined,\n            },\n            childrenRefs: {\n                type: Object as PropType<Ref<Array<Ref<HTMLElement | undefined>>>>,\n                required: true,\n            },\n            parentRef: {\n                type: Object as PropType<Ref<HTMLElement | undefined>>,\n                default: undefined,\n            },\n        },\n    },\n);\n","import { computed, defineComponent, provide, type PropType } from 'vue';\nimport type { Theme } from '@lumx/core/js/constants';\n\n/**\n * ThemeProvider for Vue: wraps children with `provide('theme', value)` for theme isolation.\n * Vue's `provide()` requires a component boundary, so this is a component.\n */\nexport const ThemeProvider = defineComponent(\n    (props: { value: Theme | undefined }, { slots }) => {\n        provide(\n            'theme',\n            computed(() => props.value),\n        );\n        return () => slots.default?.();\n    },\n    {\n        name: 'LumxThemeProvider',\n        props: { value: { type: String as PropType<Theme | undefined>, default: undefined } },\n    },\n);\n","import { type ComputedRef, type Ref, computed, inject, unref } from 'vue';\n\nimport { Theme } from '@lumx/core/js/constants';\n\nexport interface UseTheme {\n    defaultTheme?: Theme;\n}\n/**\n * Retrieves the globally applied theme.\n * @returns computed theme value (auto-updates when the provided theme changes)\n */\nexport function useTheme(options: UseTheme = { defaultTheme: Theme.light }): ComputedRef<Theme | undefined> {\n    const { defaultTheme } = options;\n    const injected = inject<Theme | Ref<Theme | undefined> | undefined>('theme', undefined);\n    return computed(() => unref(injected) || defaultTheme);\n}\n","type EventCallback = (evt?: Event) => void;\n\n/**\n * Sets up an IntersectionObserver on the given element.\n * Calls `callback` when at least one observed entry is intersecting.\n * Returns a cleanup function that unobserves the element.\n */\nexport function setupInfiniteScrollObserver(\n    element: Element,\n    callback: EventCallback,\n    options?: IntersectionObserverInit,\n): () => void {\n    const observer = new IntersectionObserver((entries = []) => {\n        const hasIntersection = entries.some((entry) => entry.isIntersecting);\n\n        if (!hasIntersection) {\n            return;\n        }\n\n        callback();\n    }, options);\n\n    observer.observe(element);\n\n    return () => {\n        observer.unobserve(element);\n    };\n}\n","import type { CommonRef } from '../../types';\n\nexport { setupInfiniteScrollObserver } from './setupInfiniteScrollObserver';\n\nexport const INFINITE_SCROLL_CLASSNAME = 'lumx-infinite-scroll-anchor';\n\nexport interface InfiniteScrollProps {\n    /** Callback when infinite scroll component is in view */\n    // eslint-disable-next-line react/no-unused-prop-types\n    callback: (evt?: Event) => void;\n    /** Customize intersection observer option */\n    // eslint-disable-next-line react/no-unused-prop-types\n    options?: IntersectionObserverInit;\n}\n\n/**\n * Framework-agnostic InfiniteScroll sentinel component.\n *\n * Renders a tiny invisible div that triggers a callback when it enters the viewport\n * (or intersects its root element) via IntersectionObserver.\n *\n * The div has a small height (4px) to avoid issues when a browser zoom is applied,\n * where a zero-height element might not trigger IntersectionObserver reliably.\n */\nexport const InfiniteScroll = ({ ref }: { ref?: CommonRef }) => (\n    // In order to avoid issues when a zoom is added to the browser, we add a small height to the div so that\n    // the intersection has a higher chance of working correctly.\n    <div ref={ref} aria-hidden=\"true\" className={INFINITE_SCROLL_CLASSNAME} style={{ height: '4px' }} />\n);\n","import { defineComponent, ref, watchEffect } from 'vue';\nimport {\n    InfiniteScroll as UI,\n    type InfiniteScrollProps,\n    setupInfiniteScrollObserver,\n} from '@lumx/core/js/utils/InfiniteScroll';\nimport { keysOf } from '../VueToJSX';\n\nexport type { InfiniteScrollProps };\n\n/**\n * Handles basic callback pattern by using intersection observers.\n */\nexport const InfiniteScroll = defineComponent(\n    (props: InfiniteScrollProps) => {\n        const elementRef = ref<HTMLDivElement | null>(null);\n\n        watchEffect((onCleanup) => {\n            const element = elementRef.value;\n            if (!element) return;\n\n            const cleanup = setupInfiniteScrollObserver(element, props.callback, props.options);\n            onCleanup(cleanup);\n        });\n\n        return () => UI({ ref: elementRef });\n    },\n    {\n        name: 'LumxInfiniteScroll',\n        inheritAttrs: false,\n        props: keysOf<InfiniteScrollProps>()('callback', 'options'),\n    },\n);\n\nexport default InfiniteScroll;\n"],"names":["keysOf","keys","acc","key","PORTAL_KEY","Symbol","defaultPortalInit","container","PortalProvider","props","slots","provide","value","default","name","type","Function","required","_isSlot","s","Object","prototype","toString","call","_isVNode","Portal","portalInit","inject","context","ref","initializePortal","enabled","watch","onBeforeUnmount","teardown","content","_createVNode","Teleport","Boolean","CLICK_AWAY_EVENT_TYPES","isClickAway","targets","elements","element","target","setupClickAway","getElements","callback","listener","evt","t","evtType","CLICK_AWAY_KEY","ClickAwayProvider","parentContext","contextChildrenRefs","currentContext","childrenRefs","addRefs","newChildrenRefs","newRef","el","push","parentRef","onMounted","refs","event","cb","undefined","ThemeProvider","defineComponent","computed","useTheme","options","Theme","defaultTheme","injected","unref","setupInfiniteScrollObserver","observer","entries","entry","INFINITE_SCROLL_CLASSNAME","InfiniteScroll","height","elementRef","watchEffect","onCleanup","cleanup","UI","inheritAttrs"],"mappings":"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"}

package/components/chip/SelectionChipGroup.d.ts

@@ -1,23 +1,43 @@
+import { EmitFn, EmitsToProps, PublicProps } from 'vue';
 import { SelectionChipGroupProps as UIProps } from '@lumx/core/js/components/Chip/SelectionChipGroup';
 import { VueToJSXProps } from '../../utils/VueToJSX';
 /**
  * Props omit 'ref' (handled internally).
  * inputRef is added here for Vue (ref to an associated input element for backspace focus handling).
  */
-export type SelectionChipGroupProps = VueToJSXProps<UIProps<any>> & {
+export type SelectionChipGroupProps<O = any> = VueToJSXProps<UIProps<O>> & {
     /** Ref to the associated input element (for focus restoration on backspace) */
     inputRef?: HTMLInputElement | null;
 };
+/** SelectionChipGroup emit schema */
 export declare const emitSchema: {
     change: (_newValue?: any[]) => boolean;
 };
+/**
+ * SelectionChipGroup emits adapted to the value generic type
+ */
+export type SelectionChipGroupEmits<O> = {
+    change: (newValue: O[] | undefined) => void;
+};
+/**
+ * SelectionChipGroup component constructor with generic type attached to props
+ *
+ * Vue's `defineComponent` setup-fn overload cannot carry an unbound generic from the setup
+ * signature to the resulting component constructor, so the generic is layered on via cast.
+ */
+export interface SelectionChipGroupConstructor {
+    new <O = any>(props: SelectionChipGroupProps<O> & EmitsToProps<SelectionChipGroupEmits<O>> & PublicProps): {
+        $props: SelectionChipGroupProps<O> & EmitsToProps<SelectionChipGroupEmits<O>>;
+        $emit: EmitFn<SelectionChipGroupEmits<O>>;
+    };
+}
 /**
  * SelectionChipGroup component.
  *
  * @param  props Component props.
  * @return Vue element.
  */
-declare const SelectionChipGroup: import('vue').DefineSetupFnComponent<SelectionChipGroupProps, {
+declare const SelectionChipGroup: import('vue').DefineSetupFnComponent<SelectionChipGroupProps<any>, {
     change: (_newValue?: any[]) => boolean;
 }, {}, Omit<UIProps<any>, "className" | import('@lumx/core/js/types').PropsToOverride | "children"> & {
     class?: string;
@@ -26,5 +46,6 @@ declare const SelectionChipGroup: import('vue').DefineSetupFnComponent<Selection
     inputRef?: HTMLInputElement | null;
 } & {
     onChange?: ((_newValue?: any[] | undefined) => any) | undefined;
-}, import('vue').PublicProps>;
-export default SelectionChipGroup;
+}, PublicProps>;
+declare const _default: SelectionChipGroupConstructor & typeof SelectionChipGroup;
+export default _default;

package/components/select-text-field/SelectTextField.d.ts

@@ -0,0 +1,129 @@
+import { EmitFn, EmitsToProps, PublicProps } from 'vue';
+import { BaseSelectTextFieldWrapperProps } from '@lumx/core/js/utils/select/types';
+import { JSXElement } from '@lumx/core/js/types';
+import { EmitsOf } from '../../utils/VueToJSX';
+/** Props shared across single and multiple selection modes. */
+interface BaseSelectTextFieldProps<O = any> extends BaseSelectTextFieldWrapperProps<O> {
+    /** Content to render before the options list. */
+    beforeOptions?: JSXElement;
+    /** CSS class. */
+    class?: string;
+}
+/** Props specific to single selection mode. */
+export interface SingleSelectTextFieldProps<O = any> extends BaseSelectTextFieldProps<O> {
+    /** Selection type. */
+    selectionType: 'single';
+    /** Selected option object. */
+    value?: O;
+}
+/** Props specific to multiple selection mode. */
+export interface MultipleSelectTextFieldProps<O = any> extends BaseSelectTextFieldProps<O> {
+    /** Selection type. */
+    selectionType: 'multiple';
+    /** Selected option objects. */
+    value?: O[];
+}
+/**
+ * SelectTextField props — supports both single and multiple selection.
+ * Discriminated on `selectionType`: when `'multiple'`, `value` is `O[]`.
+ */
+export type SelectTextFieldProps<O = any> = SingleSelectTextFieldProps<O> | MultipleSelectTextFieldProps<O>;
+/**
+ * SelectTextField events schema
+ */
+declare const emitSchema: {
+    /**
+     * Selection change. Payload type depends on `selectionType`:
+     * - `'single'`   → `O | undefined` (option on select, `undefined` on clear).
+     * - `'multiple'` → `O[] | undefined` (`undefined` when fully cleared).
+     *
+     * The runtime validator uses `unknown` since the discriminated payload can't be
+     * expressed without the component generic. The typed payload is restored by the
+     * `change` override on `SelectTextFieldEmits<O, S>`.
+     */
+    change: (_newValue?: unknown) => boolean;
+    /** User typed in the search input. */
+    search: (_searchText: string) => boolean;
+    /** Bottom of the options list reached — consumer should fetch the next page. */
+    'load-more': () => boolean;
+    /** Input lost focus. */
+    blur: (_event?: FocusEvent) => boolean;
+    /** Input received focus. */
+    focus: (_event?: FocusEvent) => boolean;
+    /** Key pressed while the input is focused. */
+    keydown: (_event?: KeyboardEvent) => boolean;
+    /** Clear button clicked (single mode only). */
+    clear: (_event?: MouseEvent) => boolean;
+    /** Dropdown opened or closed. */
+    open: (_isOpen: boolean) => boolean;
+};
+/**
+ * SelectTextField emits (adapting to the selection type).
+ */
+type SelectTextFieldEmits<O, S extends 'single' | 'multiple'> = Omit<EmitsOf<typeof emitSchema>, 'change'> & {
+    change: (newValue: (S extends 'multiple' ? O[] : O) | undefined) => void;
+};
+type SingleSelectTextFieldPublicProps<O> = SingleSelectTextFieldProps<O> & EmitsToProps<SelectTextFieldEmits<O, 'single'>>;
+type MultipleSelectTextFieldPublicProps<O> = MultipleSelectTextFieldProps<O> & EmitsToProps<SelectTextFieldEmits<O, 'multiple'>>;
+/**
+ * SelectTextField component constructor with generic type attached to props
+ *
+ * Vue's `defineComponent` setup-fn overload cannot carry an unbound generic from the setup
+ * signature to the resulting component constructor, so the generic is layered on via cast.
+ */
+export interface SelectTextFieldConstructor {
+    new <O = any>(props: SingleSelectTextFieldPublicProps<O> & PublicProps): {
+        $props: SingleSelectTextFieldPublicProps<O>;
+        $emit: EmitFn<SelectTextFieldEmits<O, 'single'>>;
+    };
+    new <O = any>(props: MultipleSelectTextFieldPublicProps<O> & PublicProps): {
+        $props: MultipleSelectTextFieldPublicProps<O>;
+        $emit: EmitFn<SelectTextFieldEmits<O, 'multiple'>>;
+    };
+}
+/**
+ * A text field with a select dropdown to choose between a list of options.
+ * Supports search/filter, single selection, and multiple selection with chips.
+ *
+ * Scoped slots:
+ * - `option({ option, index })` — custom option rendering inside a `<Combobox.Option>`.
+ * - `sectionTitle({ sectionId, options })` — custom section header rendering.
+ * - `chip({ option, index })` — custom chip rendering (multiple selection only).
+ */
+declare const SelectTextField: import('vue').DefineSetupFnComponent<SelectTextFieldProps<any>, {
+    /**
+     * Selection change. Payload type depends on `selectionType`:
+     * - `'single'`   → `O | undefined` (option on select, `undefined` on clear).
+     * - `'multiple'` → `O[] | undefined` (`undefined` when fully cleared).
+     *
+     * The runtime validator uses `unknown` since the discriminated payload can't be
+     * expressed without the component generic. The typed payload is restored by the
+     * `change` override on `SelectTextFieldEmits<O, S>`.
+     */
+    change: (_newValue?: unknown) => boolean;
+    /** User typed in the search input. */
+    search: (_searchText: string) => boolean;
+    /** Bottom of the options list reached — consumer should fetch the next page. */
+    'load-more': () => boolean;
+    /** Input lost focus. */
+    blur: (_event?: FocusEvent) => boolean;
+    /** Input received focus. */
+    focus: (_event?: FocusEvent) => boolean;
+    /** Key pressed while the input is focused. */
+    keydown: (_event?: KeyboardEvent) => boolean;
+    /** Clear button clicked (single mode only). */
+    clear: (_event?: MouseEvent) => boolean;
+    /** Dropdown opened or closed. */
+    open: (_isOpen: boolean) => boolean;
+}, {}, SelectTextFieldProps<any> & {
+    onSearch?: ((_searchText: string) => any) | undefined;
+    onBlur?: ((_event?: FocusEvent | undefined) => any) | undefined;
+    onChange?: ((_newValue?: unknown) => any) | undefined;
+    onFocus?: ((_event?: FocusEvent | undefined) => any) | undefined;
+    onKeydown?: ((_event?: KeyboardEvent | undefined) => any) | undefined;
+    onClear?: ((_event?: MouseEvent | undefined) => any) | undefined;
+    onOpen?: ((_isOpen: boolean) => any) | undefined;
+    "onLoad-more"?: (() => any) | undefined;
+}, PublicProps>;
+declare const _default: SelectTextFieldConstructor & typeof SelectTextField;
+export default _default;

package/components/select-text-field/SelectTextField.stories.d.ts

@@ -0,0 +1,203 @@
+declare const _default: {
+    component: any;
+    play({ canvas }: any): Promise<void>;
+    title: string;
+};
+export default _default;
+export declare const Default: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const WithSelectedValue: {
+    args: {
+        value: {
+            id: string;
+            name: string;
+            icon: string;
+            category: string;
+            categoryIcon: string;
+            description: string;
+        };
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const NoClearButton: {
+    args: {
+        value: {
+            id: string;
+            name: string;
+            icon: string;
+            category: string;
+            categoryIcon: string;
+            description: string;
+        };
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const WithDescriptions: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const WithSections: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const WithIcon: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const Disabled: {
+    args: {
+        value: {
+            id: string;
+            name: string;
+            icon: string;
+            category: string;
+            categoryIcon: string;
+            description: string;
+        };
+    };
+    decorators: ((story: any, context: any) => any)[];
+    play: any;
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const WithError: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const WithHelper: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const MultipleSelection: {
+    args: {
+        value: never[];
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const MultipleWithPreselected: {
+    args: {
+        value: {
+            id: string;
+            name: string;
+            icon: string;
+            category: string;
+            categoryIcon: string;
+            description: string;
+        }[];
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const MultipleWithManyChips: {
+    args: {
+        value: ({
+            id: string;
+            name: string;
+            icon: string;
+            category: string;
+            categoryIcon: string;
+            description: string;
+        } | {
+            id: string;
+            name: string;
+            category: string;
+        })[];
+    };
+    decorators: ((story: any, context: any) => any)[];
+    play: any;
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const MultipleDisabled: {
+    args: {
+        value: {
+            id: string;
+            name: string;
+            icon: string;
+            category: string;
+            categoryIcon: string;
+            description: string;
+        }[];
+    };
+    decorators: ((story: any, context: any) => any)[];
+    play: any;
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const Loading: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const LoadingMore: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+export declare const ErrorState: {
+    args: {
+        value: undefined;
+    };
+    decorators: ((story: any, context: any) => any)[];
+    render: ({ value, onChange }: any) => import("vue/jsx-runtime").JSX.Element;
+};
+/** SelectTextField with custom option, section title, and chip rendering via scoped slots */
+export declare const CustomRender: {
+    render: () => {
+        components: {
+            StoryCustomRender: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        };
+        template: string;
+    };
+};
+/** SelectTextField with a creatable option before the list */
+export declare const WithCreatableOptions: {
+    render: () => {
+        components: {
+            StoryWithCreatableOptions: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        };
+        template: string;
+    };
+};
+/** Single-select with consumer-controlled search (`filter="manual"` + `@search` listener) */
+export declare const WithSearch: {
+    render: () => {
+        components: {
+            StoryWithSearch: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        };
+        template: string;
+    };
+};
+/** Multi-select with consumer-controlled search (`filter="manual"` + `@search` listener) */
+export declare const MultipleWithSearch: {
+    render: () => {
+        components: {
+            StoryMultipleWithSearch: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        };
+        template: string;
+    };
+};

package/components/select-text-field/SelectTextField.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/select-text-field/SelectTextField.test.stories.d.ts

@@ -0,0 +1,37 @@
+declare const _default: {
+    title: string;
+    component: any;
+    tags: string[];
+    parameters: {
+        chromatic: {
+            disable: boolean;
+        };
+    };
+};
+export default _default;
+export declare const ClickOutsideCloses: {
+    render: (args: any) => import("vue/jsx-runtime").JSX.Element;
+    play({ canvas }: any): Promise<void>;
+};
+export declare const BlurResetsToSelectedValue: {
+    render: (args: any) => import("vue/jsx-runtime").JSX.Element;
+    play({ canvas }: any): Promise<void>;
+};
+export declare const BlurResetsToEmpty: {
+    render: (args: any) => import("vue/jsx-runtime").JSX.Element;
+    play({ canvas }: any): Promise<void>;
+};
+export declare const MultiBlurResetsSearch: {
+    render: (args: any) => import("vue/jsx-runtime").JSX.Element;
+    play({ canvas }: any): Promise<void>;
+};
+/** Test infinite scroll loads more options when scrolling to the bottom */
+export declare const WithInfiniteScroll: {
+    render: () => {
+        components: {
+            StoryWithInfiniteScroll: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        };
+        template: string;
+    };
+    play({ canvas }: any): Promise<void>;
+};

package/components/select-text-field/Stories/CustomRender.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/select-text-field/Stories/MultipleWithSearch.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/select-text-field/Stories/WithCreatableOptions.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/select-text-field/Stories/WithInfiniteScroll.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/select-text-field/Stories/WithSearch.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;