bits-ui 1.0.0-next.6 → 1.0.0-next.61

package/dist/{shared/date → internal/date-time}/calendar-helpers.svelte.js

@@ -1,13 +1,11 @@
 import { endOfMonth, isSameMonth, startOfMonth } from "@internationalized/date";
+import { afterTick, styleToString } from "svelte-toolbelt";
 import { untrack } from "svelte";
-import { getDaysInMonth, getLastFirstDayOfWeek, getNextLastDayOfWeek, isAfter, isBefore, parseStringToDateValue, toDate, } from "./index.js";
-import { RangeCalendarRootState } from "../../bits/range-calendar/range-calendar.svelte.js";
-import { getDataDisabled, getDataInvalid, getDataReadonly } from "../../internal/attrs.js";
-import { afterTick } from "../../internal/afterTick.js";
-import { chunk, isValidIndex } from "../../internal/arrays.js";
-import { isHTMLElement } from "../../internal/is.js";
-import { kbd } from "../../internal/kbd.js";
-import { styleToString } from "../../internal/style.js";
+import { getDaysInMonth, getLastFirstDayOfWeek, getNextLastDayOfWeek, isAfter, isBefore, parseStringToDateValue, toDate, } from "./utils.js";
+import { getDataDisabled, getDataInvalid, getDataReadonly } from "../attrs.js";
+import { chunk, isValidIndex } from "../arrays.js";
+import { isHTMLElement } from "../is.js";
+import { kbd } from "../kbd.js";
 /**
  * Checks if a given node is a calendar cell element.
  *
@@ -64,7 +62,12 @@ function createMonth(props) {
         if (!startFrom) {
             startFrom = dateObj.add({ months: 1 }).set({ day: 1 });
         }
-        const extraDaysArray = Array.from({ length: extraDays }, (_, i) => {
+        let length = extraDays;
+        if (nextMonthDays.length === 0) {
+            length = extraDays - 1;
+            nextMonthDays.push(startFrom);
+        }
+        const extraDaysArray = Array.from({ length }, (_, i) => {
             const incr = i + 1;
             return startFrom.add({ days: incr });
         });
@@ -186,7 +189,7 @@ export function shiftCalendarFocus({ node, add, placeholder, calendarNode, isPre
          * starting at the beginning of the array, shift focus by the nextIndex
          * amount.
          */
-        // shift the calendard forward a month unless next month is disabled
+        // shift the calendar forward a month unless next month is disabled
         if (isNextButtonDisabled)
             return;
         const firstMonth = months[0]?.value;
@@ -219,6 +222,7 @@ export function handleCalendarKeydown({ event, handleCellClick, shiftFocus, plac
     const currentCell = event.target;
     if (!isCalendarDayNode(currentCell))
         return;
+    // eslint-disable-next-line ts/no-explicit-any
     if (!ARROW_KEYS.includes(event.key) && !SELECT_KEYS.includes(event.key))
         return;
     event.preventDefault();
@@ -228,6 +232,7 @@ export function handleCalendarKeydown({ event, handleCellClick, shiftFocus, plac
         [kbd.ARROW_LEFT]: -1,
         [kbd.ARROW_RIGHT]: 1,
     };
+    // eslint-disable-next-line ts/no-explicit-any
     if (ARROW_KEYS.includes(event.key)) {
         const add = kbdFocusMap[event.key];
         if (add !== undefined) {
@@ -431,11 +436,6 @@ export function getCalendarElementProps({ fullCalendarLabel, id, isInvalid, disa
         "data-readonly": getDataReadonly(readonly),
     };
 }
-export function getCalendarBitsAttr(root, part) {
-    const isRange = root instanceof RangeCalendarRootState;
-    const prefix = isRange ? "data-range-calendar-" : "data-calendar-";
-    return `${prefix}${part}`;
-}
 export function pickerOpenFocus(e) {
     const nodeToFocus = document.querySelector("[data-bits-day][data-focused]");
     if (nodeToFocus) {

package/dist/{shared/date → internal/date-time}/field/helpers.d.ts

@@ -1,6 +1,7 @@
 import type { DateValue } from "@internationalized/date";
-import { type Formatter, type Granularity, type HourCycle } from "../index.js";
+import type { Formatter } from "../formatter.js";
 import type { DateAndTimeSegmentObj, DateSegmentPart, EditableSegmentPart, SegmentContentObj, SegmentPart, SegmentStateMap, SegmentValueObj } from "./types.js";
+import type { Granularity, HourCycle } from "../../../shared/date/types.js";
 export declare function initializeSegmentValues(granularity: Granularity): SegmentValueObj;
 type SharedContentProps = {
     granularity: Granularity;

package/dist/{shared/date → internal/date-time}/field/helpers.js

@@ -1,9 +1,11 @@
-import { getPlaceholder, getSegments, hasTime, isZonedDateTime, } from "../index.js";
+import { styleToString } from "svelte-toolbelt";
+import { getPlaceholder } from "../placeholders.js";
+import { hasTime, isZonedDateTime } from "../utils.js";
 import { ALL_SEGMENT_PARTS, DATE_SEGMENT_PARTS, EDITABLE_SEGMENT_PARTS, TIME_SEGMENT_PARTS, } from "./parts.js";
-import { isBrowser, isNull, isNumberString } from "../../../internal/is.js";
-import { styleToString } from "../../../internal/style.js";
-import { useId } from "../../../internal/useId.js";
-import { kbd } from "../../../internal/kbd.js";
+import { getSegments } from "./segments.js";
+import { isBrowser, isNull, isNumberString } from "../../is.js";
+import { useId } from "../../use-id.js";
+import { kbd } from "../../kbd.js";
 export function initializeSegmentValues(granularity) {
     const calendarDateTimeGranularities = ["hour", "minute", "second"];
     const initialParts = EDITABLE_SEGMENT_PARTS.map((part) => {
@@ -52,7 +54,7 @@ function createContentObj(props) {
             }
             else if (!isNull(value) && !isNull(intValue)) {
                 const formatted = formatter.part(dateRef.set({ [part]: value }), part, {
-                    hourCycle: props.hourCycle === 24 ? "h24" : undefined,
+                    hourCycle: props.hourCycle === 24 ? "h23" : undefined,
                 });
                 /**
                  * If we're operating in a 12 hour clock and the part is an hour, we handle
@@ -177,7 +179,7 @@ function getOptsByGranularity(granularity, hourCycle) {
         minute: "2-digit",
         second: "2-digit",
         timeZoneName: "short",
-        hourCycle: hourCycle === 24 ? "h24" : undefined,
+        hourCycle: hourCycle === 24 ? "h23" : undefined,
         hour12: hourCycle === 24 ? false : undefined,
     };
     if (granularity === "day") {
@@ -238,20 +240,20 @@ export function getValueFromSegments(props) {
     const { segmentObj, fieldNode, dateRef } = props;
     const usedSegments = getUsedSegments(fieldNode);
     let date = dateRef;
-    usedSegments.forEach((part) => {
+    for (const part of usedSegments) {
         if ("hour" in segmentObj) {
             const value = segmentObj[part];
             if (isNull(value))
-                return;
+                continue;
             date = date.set({ [part]: segmentObj[part] });
         }
         else if (isDateSegmentPart(part)) {
             const value = segmentObj[part];
             if (isNull(value))
-                return;
+                continue;
             date = date.set({ [part]: segmentObj[part] });
         }
-    });
+    }
     return date;
 }
 /**
@@ -300,12 +302,10 @@ export function isDateAndTimeSegmentObj(obj) {
  * value and granularity props.
  */
 export function inferGranularity(value, granularity) {
-    if (granularity) {
+    if (granularity)
         return granularity;
-    }
-    if (hasTime(value)) {
+    if (hasTime(value))
         return "minute";
-    }
     return "day";
 }
 export function isAcceptableSegmentKey(key) {

package/dist/{shared/date/field.js → internal/date-time/field/segments.js}

@@ -1,6 +1,6 @@
-import { isAnySegmentPart } from "./field/helpers.js";
-import { isHTMLElement } from "../../internal/is.js";
-import { kbd } from "../../internal/kbd.js";
+import { isAnySegmentPart } from "./helpers.js";
+import { isHTMLElement } from "../../is.js";
+import { kbd } from "../../kbd.js";
 /**
  * Handles segment navigation based on the provided keyboard event and field ID.
  *
@@ -124,6 +124,5 @@ export function getSegments(fieldNode) {
  * Get the first interactive segment within the field identified by the provided ID.
  */
 export function getFirstSegment(fieldNode) {
-    const segments = getSegments(fieldNode);
-    return segments[0];
+    return getSegments(fieldNode)[0];
 }

package/dist/{shared/date → internal/date-time}/formatter.d.ts

@@ -1,4 +1,5 @@
 import { type DateValue } from "@internationalized/date";
+import type { HourCycle } from "../../shared/date/types.js";
 export type Formatter = ReturnType<typeof createFormatter>;
 /**
  * Creates a wrapper around the `DateFormatter`, which is
@@ -17,7 +18,7 @@ export declare function createFormatter(initialLocale: string): {
     toParts: (date: DateValue, options?: Intl.DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
     custom: (date: Date, options: Intl.DateTimeFormatOptions) => string;
     part: (dateObj: DateValue, type: Intl.DateTimeFormatPartTypes, options?: Intl.DateTimeFormatOptions) => string;
-    dayPeriod: (date: Date) => "AM" | "PM";
+    dayPeriod: (date: Date, hourCycle?: HourCycle | undefined) => "AM" | "PM";
     selectedDate: (date: DateValue, includeTime?: boolean) => string;
     dayOfWeek: (date: Date, length?: Intl.DateTimeFormatOptions["weekday"]) => string;
 };

package/dist/{shared/date → internal/date-time}/formatter.js

@@ -1,5 +1,5 @@
 import { DateFormatter } from "@internationalized/date";
-import { hasTime, isZonedDateTime, toDate } from "./index.js";
+import { hasTime, isZonedDateTime, toDate } from "./utils.js";
 const defaultPartOptions = {
     year: "numeric",
     month: "numeric",
@@ -63,10 +63,11 @@ export function createFormatter(initialLocale) {
     function dayOfWeek(date, length = "narrow") {
         return new DateFormatter(locale, { weekday: length }).format(date);
     }
-    function dayPeriod(date) {
+    function dayPeriod(date, hourCycle = undefined) {
         const parts = new DateFormatter(locale, {
             hour: "numeric",
             minute: "numeric",
+            hourCycle: hourCycle === 24 ? "h23" : undefined,
         }).formatToParts(date);
         const value = parts.find((p) => p.type === "dayPeriod")?.value;
         if (value === "PM") {

package/dist/{shared/date → internal/date-time}/utils.d.ts

@@ -1,5 +1,5 @@
 import { CalendarDateTime, type DateValue, ZonedDateTime } from "@internationalized/date";
-import type { DateMatcher, Granularity } from "./types.js";
+import type { DateMatcher, Granularity } from "../../shared/date/types.js";
 type GetDefaultDateProps = {
     defaultValue?: DateValue | DateValue[] | undefined;
     defaultPlaceholder?: DateValue | undefined;

package/dist/internal/kbd-constants.d.ts

@@ -0,0 +1,40 @@
+export declare const ALT = "Alt";
+export declare const ARROW_DOWN = "ArrowDown";
+export declare const ARROW_LEFT = "ArrowLeft";
+export declare const ARROW_RIGHT = "ArrowRight";
+export declare const ARROW_UP = "ArrowUp";
+export declare const BACKSPACE = "Backspace";
+export declare const CAPS_LOCK = "CapsLock";
+export declare const CONTROL = "Control";
+export declare const DELETE = "Delete";
+export declare const END = "End";
+export declare const ENTER = "Enter";
+export declare const ESCAPE = "Escape";
+export declare const F1 = "F1";
+export declare const F10 = "F10";
+export declare const F11 = "F11";
+export declare const F12 = "F12";
+export declare const F2 = "F2";
+export declare const F3 = "F3";
+export declare const F4 = "F4";
+export declare const F5 = "F5";
+export declare const F6 = "F6";
+export declare const F7 = "F7";
+export declare const F8 = "F8";
+export declare const F9 = "F9";
+export declare const HOME = "Home";
+export declare const META = "Meta";
+export declare const PAGE_DOWN = "PageDown";
+export declare const PAGE_UP = "PageUp";
+export declare const SHIFT = "Shift";
+export declare const SPACE = " ";
+export declare const TAB = "Tab";
+export declare const CTRL = "Control";
+export declare const ASTERISK = "*";
+export declare const a = "a";
+export declare const P = "P";
+export declare const A = "A";
+export declare const p = "p";
+export declare const n = "n";
+export declare const j = "j";
+export declare const k = "k";

package/dist/internal/kbd-constants.js

@@ -0,0 +1,40 @@
+export const ALT = "Alt";
+export const ARROW_DOWN = "ArrowDown";
+export const ARROW_LEFT = "ArrowLeft";
+export const ARROW_RIGHT = "ArrowRight";
+export const ARROW_UP = "ArrowUp";
+export const BACKSPACE = "Backspace";
+export const CAPS_LOCK = "CapsLock";
+export const CONTROL = "Control";
+export const DELETE = "Delete";
+export const END = "End";
+export const ENTER = "Enter";
+export const ESCAPE = "Escape";
+export const F1 = "F1";
+export const F10 = "F10";
+export const F11 = "F11";
+export const F12 = "F12";
+export const F2 = "F2";
+export const F3 = "F3";
+export const F4 = "F4";
+export const F5 = "F5";
+export const F6 = "F6";
+export const F7 = "F7";
+export const F8 = "F8";
+export const F9 = "F9";
+export const HOME = "Home";
+export const META = "Meta";
+export const PAGE_DOWN = "PageDown";
+export const PAGE_UP = "PageUp";
+export const SHIFT = "Shift";
+export const SPACE = " ";
+export const TAB = "Tab";
+export const CTRL = "Control";
+export const ASTERISK = "*";
+export const a = "a";
+export const P = "P";
+export const A = "A";
+export const p = "p";
+export const n = "n";
+export const j = "j";
+export const k = "k";

package/dist/internal/kbd.d.ts

@@ -1,77 +1 @@
-export declare function getKbd(): {
-    ALT: string;
-    ARROW_DOWN: string;
-    ARROW_LEFT: string;
-    ARROW_RIGHT: string;
-    ARROW_UP: string;
-    BACKSPACE: string;
-    CAPS_LOCK: string;
-    CONTROL: string;
-    DELETE: string;
-    END: string;
-    ENTER: string;
-    ESCAPE: string;
-    F1: string;
-    F10: string;
-    F11: string;
-    F12: string;
-    F2: string;
-    F3: string;
-    F4: string;
-    F5: string;
-    F6: string;
-    F7: string;
-    F8: string;
-    F9: string;
-    HOME: string;
-    META: string;
-    PAGE_DOWN: string;
-    PAGE_UP: string;
-    SHIFT: string;
-    SPACE: string;
-    TAB: string;
-    CTRL: string;
-    ASTERISK: string;
-};
-export declare const kbd: {
-    ALT: string;
-    ARROW_DOWN: string;
-    ARROW_LEFT: string;
-    ARROW_RIGHT: string;
-    ARROW_UP: string;
-    BACKSPACE: string;
-    CAPS_LOCK: string;
-    CONTROL: string;
-    DELETE: string;
-    END: string;
-    ENTER: string;
-    ESCAPE: string;
-    F1: string;
-    F10: string;
-    F11: string;
-    F12: string;
-    F2: string;
-    F3: string;
-    F4: string;
-    F5: string;
-    F6: string;
-    F7: string;
-    F8: string;
-    F9: string;
-    HOME: string;
-    META: string;
-    PAGE_DOWN: string;
-    PAGE_UP: string;
-    SHIFT: string;
-    SPACE: string;
-    TAB: string;
-    CTRL: string;
-    ASTERISK: string;
-    a: string;
-    P: string;
-    A: string;
-    p: string;
-    n: string;
-    j: string;
-    k: string;
-};
+export * as kbd from "./kbd-constants.js";

package/dist/internal/kbd.js

@@ -1,79 +1 @@
-export function getKbd() {
-    return {
-        ALT: "Alt",
-        ARROW_DOWN: "ArrowDown",
-        ARROW_LEFT: "ArrowLeft",
-        ARROW_RIGHT: "ArrowRight",
-        ARROW_UP: "ArrowUp",
-        BACKSPACE: "Backspace",
-        CAPS_LOCK: "CapsLock",
-        CONTROL: "Control",
-        DELETE: "Delete",
-        END: "End",
-        ENTER: "Enter",
-        ESCAPE: "Escape",
-        F1: "F1",
-        F10: "F10",
-        F11: "F11",
-        F12: "F12",
-        F2: "F2",
-        F3: "F3",
-        F4: "F4",
-        F5: "F5",
-        F6: "F6",
-        F7: "F7",
-        F8: "F8",
-        F9: "F9",
-        HOME: "Home",
-        META: "Meta",
-        PAGE_DOWN: "PageDown",
-        PAGE_UP: "PageUp",
-        SHIFT: "Shift",
-        SPACE: " ",
-        TAB: "Tab",
-        CTRL: "Control",
-        ASTERISK: "*",
-    };
-}
-export const kbd = {
-    ALT: "Alt",
-    ARROW_DOWN: "ArrowDown",
-    ARROW_LEFT: "ArrowLeft",
-    ARROW_RIGHT: "ArrowRight",
-    ARROW_UP: "ArrowUp",
-    BACKSPACE: "Backspace",
-    CAPS_LOCK: "CapsLock",
-    CONTROL: "Control",
-    DELETE: "Delete",
-    END: "End",
-    ENTER: "Enter",
-    ESCAPE: "Escape",
-    F1: "F1",
-    F10: "F10",
-    F11: "F11",
-    F12: "F12",
-    F2: "F2",
-    F3: "F3",
-    F4: "F4",
-    F5: "F5",
-    F6: "F6",
-    F7: "F7",
-    F8: "F8",
-    F9: "F9",
-    HOME: "Home",
-    META: "Meta",
-    PAGE_DOWN: "PageDown",
-    PAGE_UP: "PageUp",
-    SHIFT: "Shift",
-    SPACE: " ",
-    TAB: "Tab",
-    CTRL: "Control",
-    ASTERISK: "*",
-    a: "a",
-    P: "P",
-    A: "A",
-    p: "p",
-    n: "n",
-    j: "j",
-    k: "k",
-};
+export * as kbd from "./kbd-constants.js";

package/dist/internal/should-trap-focus.d.ts

@@ -0,0 +1,6 @@
+export declare function shouldTrapFocus({ forceMount, present, trapFocus, open, }: {
+    forceMount: boolean;
+    present: boolean;
+    trapFocus: boolean;
+    open: boolean;
+}): boolean;

package/dist/internal/should-trap-focus.js

@@ -0,0 +1,6 @@
+export function shouldTrapFocus({ forceMount, present, trapFocus, open, }) {
+    if (forceMount) {
+        return open && trapFocus;
+    }
+    return present && trapFocus && open;
+}

package/dist/internal/types.d.ts

@@ -33,6 +33,34 @@ Ref = HTMLElement> = Omit<Props, "child" | "children"> & {
     style?: StyleProperties | string | null | undefined;
     ref?: Ref | null | undefined;
 };
+export type WithChildNoChildrenSnippetProps<
+/**
+ * The props that the component accepts.
+ */
+Props extends Record<PropertyKey, unknown> = {}, 
+/**
+ * The props that are passed to the `child` and `children` snippets. The `ElementProps` are
+ * merged with these props for the `child` snippet.
+ */
+SnippetProps extends Record<PropertyKey, unknown> = {
+    _default: never;
+}, 
+/**
+ * The underlying DOM element being rendered. You can bind to this prop to
+ * programmatically interact with the element.
+ */
+Ref = HTMLElement> = Omit<Props, "child" | "children"> & {
+    child?: SnippetProps extends {
+        _default: never;
+    } ? Snippet<[{
+        props: Record<string, unknown>;
+    }]> : Snippet<[SnippetProps & {
+        props: Record<string, unknown>;
+    }]>;
+    children?: Snippet;
+    style?: StyleProperties | string | null | undefined;
+    ref?: Ref | null | undefined;
+};
 export type WithChildren<Props = {}> = Props & {
     children?: Snippet | undefined;
 };

package/dist/internal/{useBodyScrollLock.svelte.d.ts → use-body-scroll-lock.svelte.d.ts}

@@ -1,5 +1,6 @@
+import { type Getter } from "svelte-toolbelt";
 export type ScrollBodyOption = {
     padding?: boolean | number;
     margin?: boolean | number;
 };
-export declare function useBodyScrollLock(initialState?: boolean | undefined): import("svelte-toolbelt").WritableBox<boolean>;
+export declare function useBodyScrollLock(initialState?: boolean | undefined, restoreScrollDelay?: Getter<number | null>): import("svelte-toolbelt").WritableBox<boolean>;

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

@@ -0,0 +1,110 @@
+import { SvelteMap } from "svelte/reactivity";
+import { afterSleep, afterTick, box } from "svelte-toolbelt";
+import { untrack } from "svelte";
+import { isBrowser, isIOS } from "./is.js";
+import { addEventListener } from "./events.js";
+import { useId } from "./use-id.js";
+import { createSharedHook } from "./create-shared-hook.svelte.js";
+const useBodyLockStackCount = createSharedHook(() => {
+    const map = new SvelteMap();
+    const locked = $derived.by(() => {
+        for (const value of map.values()) {
+            if (value) {
+                return true;
+            }
+        }
+        return false;
+    });
+    let initialBodyStyle = $state({});
+    let stopTouchMoveListener = null;
+    function resetBodyStyle() {
+        if (!isBrowser)
+            return;
+        document.body.style.paddingRight = initialBodyStyle.paddingRight ?? "";
+        document.body.style.marginRight = initialBodyStyle.marginRight ?? "";
+        document.body.style.pointerEvents = initialBodyStyle.pointerEvents ?? "";
+        document.body.style.removeProperty("--scrollbar-width");
+        document.body.style.overflow = initialBodyStyle.overflow ?? "";
+        isIOS && stopTouchMoveListener?.();
+    }
+    $effect(() => {
+        const curr = locked;
+        return untrack(() => {
+            if (!curr) {
+                return;
+            }
+            const bodyStyle = getComputedStyle(document.body);
+            initialBodyStyle.overflow = bodyStyle.overflow;
+            initialBodyStyle.paddingRight = bodyStyle.paddingRight;
+            initialBodyStyle.marginRight = bodyStyle.marginRight;
+            initialBodyStyle.pointerEvents = bodyStyle.pointerEvents;
+            // TODO: account for RTL direction, etc.
+            const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+            const paddingRight = Number.parseInt(initialBodyStyle.paddingRight ?? "0", 10);
+            const config = {
+                padding: paddingRight + verticalScrollbarWidth,
+                margin: Number.parseInt(initialBodyStyle.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";
+            });
+        });
+    });
+    $effect(() => {
+        return () => {
+            stopTouchMoveListener?.();
+        };
+    });
+    return {
+        get map() {
+            return map;
+        },
+        resetBodyStyle,
+    };
+});
+export function useBodyScrollLock(initialState, restoreScrollDelay = () => null) {
+    const id = useId();
+    const countState = useBodyLockStackCount();
+    const _restoreScrollDelay = $derived(restoreScrollDelay());
+    countState.map.set(id, initialState ?? false);
+    const locked = box.with(() => countState.map.get(id) ?? false, (v) => countState.map.set(id, v));
+    $effect(() => {
+        return () => {
+            countState.map.delete(id);
+            // if any locks are still active, we don't reset the body style
+            if (isAnyLocked(countState.map))
+                return;
+            // if no locks are active (meaning this was the last lock), we reset the body style
+            if (_restoreScrollDelay === null) {
+                requestAnimationFrame(() => countState.resetBodyStyle());
+            }
+            else {
+                afterSleep(_restoreScrollDelay, () => countState.resetBodyStyle());
+            }
+        };
+    });
+    return locked;
+}
+function isAnyLocked(map) {
+    for (const [_, value] of map) {
+        if (value)
+            return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,12 @@
+export type DataTypeahead = ReturnType<typeof useDataTypeahead>;
+type UseDataTypeaheadOpts = {
+    onMatch: (value: string) => void;
+    getCurrentItem: () => string;
+    enabled: boolean;
+};
+export declare function useDataTypeahead(opts: UseDataTypeaheadOpts): {
+    search: import("svelte-toolbelt").WritableBox<string>;
+    handleTypeaheadSearch: (key: string, candidateValues: string[]) => string | undefined;
+    resetTypeahead: () => void;
+};
+export {};

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

@@ -0,0 +1,30 @@
+import { getNextMatch } from "./arrays.js";
+import { boxAutoReset } from "./box-auto-reset.svelte.js";
+export function useDataTypeahead(opts) {
+    // Reset `search` 1 second after it was last updated
+    const search = boxAutoReset("", 1000);
+    function handleTypeaheadSearch(key, candidateValues) {
+        if (!opts.enabled)
+            return;
+        if (!candidateValues.length)
+            return;
+        search.current = search.current + key;
+        const currentItem = opts.getCurrentItem();
+        const currentMatch = candidateValues.find((item) => item === currentItem) ?? "";
+        const values = candidateValues.map((item) => item ?? "");
+        const nextMatch = getNextMatch(values, search.current, currentMatch);
+        const newItem = candidateValues.find((item) => item === nextMatch);
+        if (newItem) {
+            opts.onMatch(newItem);
+        }
+        return newItem;
+    }
+    function resetTypeahead() {
+        search.current = "";
+    }
+    return {
+        search,
+        handleTypeaheadSearch,
+        resetTypeahead,
+    };
+}