bits-ui 2.6.2 → 2.8.0

package/dist/bits/utilities/presence-layer/presence.svelte.js

@@ -0,0 +1,116 @@
+import { executeCallbacks } from "svelte-toolbelt";
+import { Previous, watch } from "runed";
+import { on } from "svelte/events";
+import { StateMachine } from "../../../internal/state-machine.js";
+const presenceMachine = {
+    mounted: {
+        UNMOUNT: "unmounted",
+        ANIMATION_OUT: "unmountSuspended",
+    },
+    unmountSuspended: {
+        MOUNT: "mounted",
+        ANIMATION_END: "unmounted",
+    },
+    unmounted: {
+        MOUNT: "mounted",
+    },
+};
+export class Presence {
+    opts;
+    prevAnimationNameState = $state("none");
+    styles = $state({});
+    initialStatus;
+    previousPresent;
+    machine;
+    present;
+    constructor(opts) {
+        this.opts = opts;
+        this.present = this.opts.open;
+        this.initialStatus = opts.open.current ? "mounted" : "unmounted";
+        this.previousPresent = new Previous(() => this.present.current);
+        this.machine = new StateMachine(this.initialStatus, presenceMachine);
+        this.handleAnimationEnd = this.handleAnimationEnd.bind(this);
+        this.handleAnimationStart = this.handleAnimationStart.bind(this);
+        watchPresenceChange(this);
+        watchStatusChange(this);
+        watchRefChange(this);
+    }
+    /**
+     * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`
+     * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we
+     * make sure we only trigger ANIMATION_END for the currently active animation.
+     */
+    handleAnimationEnd(event) {
+        if (!this.opts.ref.current)
+            return;
+        const currAnimationName = getAnimationName(this.opts.ref.current);
+        const isCurrentAnimation = currAnimationName.includes(event.animationName) || currAnimationName === "none";
+        if (event.target === this.opts.ref.current && isCurrentAnimation) {
+            this.machine.dispatch("ANIMATION_END");
+        }
+    }
+    handleAnimationStart(event) {
+        if (!this.opts.ref.current)
+            return;
+        if (event.target === this.opts.ref.current) {
+            this.prevAnimationNameState = getAnimationName(this.opts.ref.current);
+        }
+    }
+    isPresent = $derived.by(() => {
+        return ["mounted", "unmountSuspended"].includes(this.machine.state.current);
+    });
+}
+function watchPresenceChange(state) {
+    watch(() => state.present.current, () => {
+        if (!state.opts.ref.current)
+            return;
+        const hasPresentChanged = state.present.current !== state.previousPresent.current;
+        if (!hasPresentChanged)
+            return;
+        const prevAnimationName = state.prevAnimationNameState;
+        const currAnimationName = getAnimationName(state.opts.ref.current);
+        if (state.present.current) {
+            state.machine.dispatch("MOUNT");
+        }
+        else if (currAnimationName === "none" || state.styles.display === "none") {
+            // If there is no exit animation or the element is hidden, animations won't run
+            // so we unmount instantly
+            state.machine.dispatch("UNMOUNT");
+        }
+        else {
+            /**
+             * When `present` changes to `false`, we check changes to animation-name to
+             * determine whether an animation has started. We chose this approach (reading
+             * computed styles) because there is no `animationrun` event and `animationstart`
+             * fires after `animation-delay` has expired which would be too late.
+             */
+            const isAnimating = prevAnimationName !== currAnimationName;
+            if (state.previousPresent.current && isAnimating) {
+                state.machine.dispatch("ANIMATION_OUT");
+            }
+            else {
+                state.machine.dispatch("UNMOUNT");
+            }
+        }
+    });
+}
+function watchStatusChange(state) {
+    watch(() => state.machine.state.current, () => {
+        if (!state.opts.ref.current)
+            return;
+        const currAnimationName = getAnimationName(state.opts.ref.current);
+        state.prevAnimationNameState =
+            state.machine.state.current === "mounted" ? currAnimationName : "none";
+    });
+}
+function watchRefChange(state) {
+    watch(() => state.opts.ref.current, () => {
+        if (!state.opts.ref.current)
+            return;
+        state.styles = getComputedStyle(state.opts.ref.current);
+        return executeCallbacks(on(state.opts.ref.current, "animationstart", state.handleAnimationStart), on(state.opts.ref.current, "animationcancel", state.handleAnimationEnd), on(state.opts.ref.current, "animationend", state.handleAnimationEnd));
+    });
+}
+function getAnimationName(node) {
+    return node ? getComputedStyle(node).animationName || "none" : "none";
+}

package/dist/bits/utilities/presence-layer/types.d.ts

@@ -8,13 +8,11 @@ export type PresenceLayerProps = {
 };
 export type PresenceLayerImplProps = PresenceLayerProps & {
     /**
-     * The presence status.
+     * The open state of the component.
      */
-    present: boolean;
+    open: boolean;
     presence?: Snippet<[{
-        present: {
-            current: boolean;
-        };
+        present: boolean;
     }]>;
     ref: ReadableBox<HTMLElement | null>;
 };

package/dist/bits/utilities/scroll-lock/scroll-lock.svelte

@@ -1,10 +1,10 @@
 <script lang="ts">
 	import type { ScrollLockProps } from "./index.js";
-	import { useBodyScrollLock } from "../../../internal/use-body-scroll-lock.svelte.js";
+	import { BodyScrollLock } from "../../../internal/body-scroll-lock.svelte.js";
 
 	let { preventScroll = true, restoreScrollDelay = null }: ScrollLockProps = $props();
 
 	if (preventScroll) {
-		useBodyScrollLock(preventScroll, () => restoreScrollDelay);
+		new BodyScrollLock(preventScroll, () => restoreScrollDelay);
 	}
 </script>

package/dist/bits/utilities/text-selection-layer/text-selection-layer.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { box } from "svelte-toolbelt";
 	import type { TextSelectionLayerImplProps } from "./types.js";
-	import { useTextSelectionLayer } from "./use-text-selection-layer.svelte.js";
+	import { TextSelectionLayerState } from "./use-text-selection-layer.svelte.js";
 	import { noop } from "../../../internal/noop.js";
 
 	let {
@@ -14,7 +14,7 @@
 		ref,
 	}: TextSelectionLayerImplProps = $props();
 
-	useTextSelectionLayer({
+	TextSelectionLayerState.create({
 		id: box.with(() => id),
 		onPointerDown: box.with(() => onPointerDown),
 		onPointerUp: box.with(() => onPointerUp),

package/dist/bits/utilities/text-selection-layer/use-text-selection-layer.svelte.d.ts

@@ -1,14 +1,14 @@
-import { DOMContext } from "svelte-toolbelt";
+import { DOMContext, type ReadableBoxedValues } from "svelte-toolbelt";
 import type { TextSelectionLayerImplProps } from "./types.js";
-import type { ReadableBoxedValues } from "../../../internal/box.svelte.js";
-type TextSelectionLayerStateProps = ReadableBoxedValues<Required<Omit<TextSelectionLayerImplProps, "children" | "preventOverflowTextSelection" | "ref">> & {
+interface TextSelectionLayerStateOpts extends ReadableBoxedValues<Required<Omit<TextSelectionLayerImplProps, "children" | "preventOverflowTextSelection" | "ref">> & {
     ref: HTMLElement | null;
-}>;
+}> {
+}
 export declare class TextSelectionLayerState {
     #private;
-    readonly opts: TextSelectionLayerStateProps;
+    static create(opts: TextSelectionLayerStateOpts): TextSelectionLayerState;
+    readonly opts: TextSelectionLayerStateOpts;
     readonly domContext: DOMContext;
-    constructor(opts: TextSelectionLayerStateProps);
+    constructor(opts: TextSelectionLayerStateOpts);
 }
-export declare function useTextSelectionLayer(props: TextSelectionLayerStateProps): TextSelectionLayerState;
 export {};

package/dist/bits/utilities/text-selection-layer/use-text-selection-layer.svelte.js

@@ -5,6 +5,9 @@ import { noop } from "../../../internal/noop.js";
 import { isHTMLElement } from "../../../internal/is.js";
 globalThis.bitsTextSelectionLayers ??= new Map();
 export class TextSelectionLayerState {
+    static create(opts) {
+        return new TextSelectionLayerState(opts);
+    }
     opts;
     domContext;
     #unsubSelectionLock = noop;
@@ -50,9 +53,6 @@ export class TextSelectionLayerState {
         this.#unsubSelectionLock = noop;
     };
 }
-export function useTextSelectionLayer(props) {
-    return new TextSelectionLayerState(props);
-}
 const getUserSelect = (node) => node.style.userSelect || node.style.webkitUserSelect;
 function preventTextSelectionOverflow(node, body) {
     const originalBodyUserSelect = getUserSelect(body);

package/dist/internal/animations-complete.d.ts

@@ -0,0 +1,12 @@
+import { type ReadableBoxedValues } from "svelte-toolbelt";
+interface AnimationsCompleteOpts extends ReadableBoxedValues<{
+    ref: HTMLElement | null;
+    afterTick: boolean;
+}> {
+}
+export declare class AnimationsComplete {
+    #private;
+    constructor(opts: AnimationsCompleteOpts);
+    run(fn: () => void | Promise<void>): void;
+}
+export {};

package/dist/internal/animations-complete.js

@@ -0,0 +1,55 @@
+import { afterTick, onDestroyEffect } from "svelte-toolbelt";
+export class AnimationsComplete {
+    #opts;
+    #currentFrame = undefined;
+    #isRunning = false;
+    constructor(opts) {
+        this.#opts = opts;
+        onDestroyEffect(() => this.#cleanup());
+    }
+    #cleanup() {
+        if (this.#currentFrame) {
+            window.cancelAnimationFrame(this.#currentFrame);
+            this.#currentFrame = undefined;
+        }
+        this.#isRunning = false;
+    }
+    run(fn) {
+        // prevent multiple concurrent runs
+        if (this.#isRunning)
+            return;
+        this.#cleanup();
+        this.#isRunning = true;
+        const node = this.#opts.ref.current;
+        if (!node) {
+            this.#isRunning = false;
+            return;
+        }
+        if (typeof node.getAnimations !== "function") {
+            this.#executeCallback(fn);
+            return;
+        }
+        this.#currentFrame = window.requestAnimationFrame(() => {
+            const animations = node.getAnimations();
+            if (animations.length === 0) {
+                this.#executeCallback(fn);
+                return;
+            }
+            Promise.allSettled(animations.map((animation) => animation.finished)).then(() => {
+                this.#executeCallback(fn);
+            });
+        });
+    }
+    #executeCallback(fn) {
+        const execute = () => {
+            fn();
+            this.#isRunning = false;
+        };
+        if (this.#opts.afterTick) {
+            afterTick(execute);
+        }
+        else {
+            execute();
+        }
+    }
+}

package/dist/internal/arrays.js

@@ -2,42 +2,35 @@
  * Checks if two arrays are equal by comparing their values.
  */
 export function arraysAreEqual(arr1, arr2) {
-    if (arr1.length !== arr2.length) {
+    if (arr1.length !== arr2.length)
         return false;
-    }
     return arr1.every((value, index) => isEqual(value, arr2[index]));
 }
 /**
  * A utility function that compares two values for equality.
  */
 function isEqual(a, b) {
-    if (Number.isNaN(a) && Number.isNaN(b)) {
+    if (Number.isNaN(a) && Number.isNaN(b))
         return true;
-    }
-    if (Array.isArray(a) && Array.isArray(b)) {
+    if (Array.isArray(a) && Array.isArray(b))
         return arraysAreEqual(a, b);
-    }
-    if (typeof a === "object" && typeof b === "object") {
+    if (typeof a === "object" && typeof b === "object")
         return isDeepEqual(a, b);
-    }
     return Object.is(a, b);
 }
 /**
  * A utility function that compares two values for deep equality.
  */
 function isDeepEqual(a, b) {
-    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
         return false;
-    }
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
+    if (aKeys.length !== bKeys.length)
         return false;
-    }
     for (const key of aKeys) {
-        if (!bKeys.includes(key)) {
+        if (!bKeys.includes(key))
             return false;
-        }
         if (!isEqual(a[key], b[key])) {
             return false;
         }
@@ -56,9 +49,8 @@ function isDeepEqual(a, b) {
  * ```
  */
 export function chunk(arr, size) {
-    if (size <= 0) {
+    if (size <= 0)
         return [];
-    }
     const result = [];
     for (let i = 0; i < arr.length; i += size) {
         result.push(arr.slice(i, i + size));
@@ -88,15 +80,12 @@ export function isValidIndex(index, arr) {
  * @param loop loop to the beginning of the array if the next index is out of bounds?
  */
 export function next(array, index, loop = true) {
-    if (array.length === 0 || index < 0 || index >= array.length) {
-        return undefined;
-    }
-    if (array.length === 1 && index === 0) {
+    if (array.length === 0 || index < 0 || index >= array.length)
+        return;
+    if (array.length === 1 && index === 0)
         return array[0];
-    }
-    if (index === array.length - 1) {
+    if (index === array.length - 1)
         return loop ? array[0] : undefined;
-    }
     return array[index + 1];
 }
 /**
@@ -107,15 +96,12 @@ export function next(array, index, loop = true) {
  * @param loop loop to the end of the array if the previous index is out of bounds?
  */
 export function prev(array, index, loop = true) {
-    if (array.length === 0 || index < 0 || index >= array.length) {
-        return undefined;
-    }
-    if (array.length === 1 && index === 0) {
+    if (array.length === 0 || index < 0 || index >= array.length)
+        return;
+    if (array.length === 1 && index === 0)
         return array[0];
-    }
-    if (index === 0) {
+    if (index === 0)
         return loop ? array[array.length - 1] : undefined;
-    }
     return array[index - 1];
 }
 /**
@@ -129,9 +115,8 @@ export function prev(array, index, loop = true) {
  * @param loop loop around the array if the target index is out of bounds?
  */
 export function forward(array, index, increment, loop = true) {
-    if (array.length === 0 || index < 0 || index >= array.length) {
-        return undefined;
-    }
+    if (array.length === 0 || index < 0 || index >= array.length)
+        return;
     let targetIndex = index + increment;
     if (loop) {
         // Ensure positive modulus
@@ -154,9 +139,8 @@ export function forward(array, index, increment, loop = true) {
  * @param loop loop around the array if the target index is out of bounds?
  */
 export function backward(array, index, decrement, loop = true) {
-    if (array.length === 0 || index < 0 || index >= array.length) {
-        return undefined;
-    }
+    if (array.length === 0 || index < 0 || index >= array.length)
+        return;
     let targetIndex = index - decrement;
     if (loop) {
         // Ensure positive modulus

package/dist/internal/attrs.d.ts

@@ -25,12 +25,19 @@ export type BitsAttrsConfig<T extends readonly string[]> = {
     parts: T;
     getVariant?: () => string | null;
 };
-export type BitsAttrs<T extends readonly string[]> = {
+export type CreateBitsAttrsReturn<T extends readonly string[]> = {
     [K in T[number]]: string;
 } & {
     selector: (part: T[number]) => string;
     getAttr: (part: T[number], variant?: string) => string;
 };
+export declare class BitsAttrs<T extends readonly string[]> {
+    #private;
+    attrs: Record<T[number], string>;
+    constructor(config: BitsAttrsConfig<T>);
+    getAttr(part: T[number], variantOverride?: string): string;
+    selector(part: T[number], variantOverride?: string): string;
+}
 export declare function createBitsAttrs<const T extends readonly string[]>(config: Omit<BitsAttrsConfig<T>, "parts"> & {
     parts: T;
-}): BitsAttrs<T>;
+}): CreateBitsAttrsReturn<T>;

package/dist/internal/attrs.js

@@ -67,21 +67,31 @@ export function getAriaPressed(condition) {
 export function getRequired(condition) {
     return condition ? true : undefined;
 }
-export function createBitsAttrs(config) {
-    const variant = config.getVariant?.();
-    const prefix = variant ? `data-${variant}-` : `data-${config.component}-`;
-    function getAttr(part, variantOverride) {
+export class BitsAttrs {
+    #variant;
+    #prefix;
+    attrs;
+    constructor(config) {
+        this.#variant = config.getVariant ? config.getVariant() : null;
+        this.#prefix = this.#variant ? `data-${this.#variant}-` : `data-${config.component}-`;
+        this.getAttr = this.getAttr.bind(this);
+        this.selector = this.selector.bind(this);
+        this.attrs = Object.fromEntries(config.parts.map((part) => [part, this.getAttr(part)]));
+    }
+    getAttr(part, variantOverride) {
         if (variantOverride)
             return `data-${variantOverride}-${part}`;
-        return `${prefix}${part}`;
+        return `${this.#prefix}${part}`;
     }
-    function selector(part, variantOverride) {
-        return `[${getAttr(part, variantOverride)}]`;
+    selector(part, variantOverride) {
+        return `[${this.getAttr(part, variantOverride)}]`;
     }
-    const attrs = Object.fromEntries(config.parts.map((part) => [part, getAttr(part)]));
+}
+export function createBitsAttrs(config) {
+    const bitsAttrs = new BitsAttrs(config);
     return {
-        ...attrs,
-        selector,
-        getAttr,
+        ...bitsAttrs.attrs,
+        selector: bitsAttrs.selector,
+        getAttr: bitsAttrs.getAttr,
     };
 }

package/dist/internal/body-scroll-lock.svelte.d.ts

@@ -0,0 +1,10 @@
+import { type Getter, type ReadableBox } from "svelte-toolbelt";
+export interface ScrollBodyOption {
+    padding?: boolean | number;
+    margin?: boolean | number;
+}
+export declare class BodyScrollLock {
+    #private;
+    readonly locked: ReadableBox<boolean> | undefined;
+    constructor(initialState?: boolean | undefined, restoreScrollDelay?: Getter<number | null>);
+}

package/dist/internal/body-scroll-lock.svelte.js

@@ -0,0 +1,106 @@
+import { SvelteMap } from "svelte/reactivity";
+import { afterSleep, afterTick, box, onDestroyEffect, } from "svelte-toolbelt";
+import { isBrowser, isIOS } from "./is.js";
+import { addEventListener } from "./events.js";
+import { useId } from "./use-id.js";
+import { watch } from "runed";
+import { SharedState } from "./shared-state.svelte.js";
+const bodyLockStackCount = new SharedState(() => {
+    const map = new SvelteMap();
+    const locked = $derived.by(() => {
+        for (const value of map.values()) {
+            if (value)
+                return true;
+        }
+        return false;
+    });
+    let initialBodyStyle = $state(null);
+    let stopTouchMoveListener = null;
+    function resetBodyStyle() {
+        if (!isBrowser)
+            return;
+        document.body.setAttribute("style", initialBodyStyle ?? "");
+        document.body.style.removeProperty("--scrollbar-width");
+        isIOS && stopTouchMoveListener?.();
+    }
+    watch(() => locked, () => {
+        if (!locked)
+            return;
+        initialBodyStyle = document.body.getAttribute("style");
+        const bodyStyle = getComputedStyle(document.body);
+        // TODO: account for RTL direction, etc.
+        const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+        const paddingRight = Number.parseInt(bodyStyle.paddingRight ?? "0", 10);
+        const config = {
+            padding: paddingRight + verticalScrollbarWidth,
+            margin: Number.parseInt(bodyStyle.marginRight ?? "0", 10),
+        };
+        if (verticalScrollbarWidth > 0) {
+            document.body.style.paddingRight = `${config.padding}px`;
+            document.body.style.marginRight = `${config.margin}px`;
+            document.body.style.setProperty("--scrollbar-width", `${verticalScrollbarWidth}px`);
+            document.body.style.overflow = "hidden";
+        }
+        if (isIOS) {
+            stopTouchMoveListener = addEventListener(document, "touchmove", (e) => {
+                if (e.target !== document.documentElement)
+                    return;
+                if (e.touches.length > 1)
+                    return;
+                e.preventDefault();
+            }, { passive: false });
+        }
+        afterTick(() => {
+            document.body.style.pointerEvents = "none";
+            document.body.style.overflow = "hidden";
+        });
+    });
+    onDestroyEffect(() => {
+        return () => {
+            stopTouchMoveListener?.();
+        };
+    });
+    return {
+        get map() {
+            return map;
+        },
+        resetBodyStyle,
+    };
+});
+export class BodyScrollLock {
+    #id = useId();
+    #initialState;
+    #restoreScrollDelay = () => null;
+    #countState;
+    locked;
+    constructor(initialState, restoreScrollDelay = () => null) {
+        this.#initialState = initialState;
+        this.#restoreScrollDelay = restoreScrollDelay;
+        this.#countState = bodyLockStackCount.get();
+        if (!this.#countState)
+            return;
+        this.#countState.map.set(this.#id, this.#initialState ?? false);
+        this.locked = box.with(() => this.#countState.map.get(this.#id) ?? false, (v) => this.#countState.map.set(this.#id, v));
+        onDestroyEffect(() => {
+            this.#countState.map.delete(this.#id);
+            // if any locks are still active, we don't reset the body style
+            if (isAnyLocked(this.#countState.map))
+                return;
+            const restoreScrollDelay = this.#restoreScrollDelay();
+            // if no locks are active (meaning this was the last lock), we reset the body style
+            if (restoreScrollDelay === null) {
+                requestAnimationFrame(() => this.#countState.resetBodyStyle());
+            }
+            else {
+                afterSleep(restoreScrollDelay, () => this.#countState.resetBodyStyle());
+            }
+        });
+    }
+}
+function isAnyLocked(map) {
+    for (const [_, value] of map) {
+        if (value)
+            return true;
+    }
+    return false;
+}

package/dist/internal/data-typeahead.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { Getter } from "svelte-toolbelt";
+interface DataTypeaheadOpts {
+    onMatch: (value: string) => void;
+    getCurrentItem: () => string;
+    candidateValues: Getter<string[]>;
+    enabled: Getter<boolean>;
+    getWindow: () => Window & typeof globalThis;
+}
+export declare class DataTypeahead {
+    #private;
+    constructor(opts: DataTypeaheadOpts);
+    handleTypeaheadSearch(key: string): string | undefined;
+    resetTypeahead(): void;
+}
+export {};

package/dist/internal/data-typeahead.svelte.js

@@ -0,0 +1,33 @@
+import { getNextMatch } from "./arrays.js";
+import { boxAutoReset } from "./box-auto-reset.svelte.js";
+export class DataTypeahead {
+    #opts;
+    #candidateValues = $derived.by(() => this.#opts.candidateValues());
+    #search;
+    constructor(opts) {
+        this.#opts = opts;
+        this.#search = boxAutoReset("", {
+            afterMs: 1000,
+            getWindow: this.#opts.getWindow,
+        });
+        this.handleTypeaheadSearch = this.handleTypeaheadSearch.bind(this);
+        this.resetTypeahead = this.resetTypeahead.bind(this);
+    }
+    handleTypeaheadSearch(key) {
+        if (!this.#opts.enabled() || !this.#candidateValues.length)
+            return;
+        this.#search.current = this.#search.current + key;
+        const currentItem = this.#opts.getCurrentItem();
+        const currentMatch = this.#candidateValues.find((item) => item === currentItem) ?? "";
+        const values = this.#candidateValues.map((item) => item ?? "");
+        const nextMatch = getNextMatch(values, this.#search.current, currentMatch);
+        const newItem = this.#candidateValues.find((item) => item === nextMatch);
+        if (newItem) {
+            this.#opts.onMatch(newItem);
+        }
+        return newItem;
+    }
+    resetTypeahead() {
+        this.#search.current = "";
+    }
+}

package/dist/internal/date-time/calendar-helpers.svelte.d.ts

@@ -198,7 +198,7 @@ export declare function useEnsureNonDisabledPlaceholder({ ref, placeholder, defa
     defaultPlaceholder: DateValue;
 }): void;
 export declare function getDateWithPreviousTime(date: DateValue | undefined, prev: DateValue | undefined): DateValue | undefined;
-export declare const calendarAttrs: import("../attrs.js").BitsAttrs<readonly ["root", "grid", "cell", "next-button", "prev-button", "day", "grid-body", "grid-head", "grid-row", "head-cell", "header", "heading", "month-select", "year-select"]>;
+export declare const calendarAttrs: import("../attrs.js").CreateBitsAttrsReturn<readonly ["root", "grid", "cell", "next-button", "prev-button", "day", "grid-body", "grid-head", "grid-row", "head-cell", "header", "heading", "month-select", "year-select"]>;
 type GetDefaultYearsProps = {
     placeholderYear: number;
     minValue: DateValue | undefined;

package/dist/internal/dom-typeahead.svelte.d.ts

@@ -0,0 +1,14 @@
+type DOMTypeaheadOptions = {
+    onMatch?: (item: HTMLElement) => void;
+    getCurrentItem?: () => HTMLElement | null;
+    getActiveElement: () => HTMLElement | null;
+    getWindow: () => Window & typeof globalThis;
+};
+export declare class DOMTypeahead {
+    #private;
+    constructor(opts: DOMTypeaheadOptions);
+    handleTypeaheadSearch(key: string, candidates: HTMLElement[]): HTMLElement | undefined;
+    resetTypeahead(): void;
+    get search(): string;
+}
+export {};