sheer-ui 0.4.2 → 0.5.0

package/dist/internal/tools/utils/dom.js

@@ -0,0 +1,59 @@
+import { BROWSER } from 'esm-env';
+const ELEMENT_NODE = 1;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+const isObject = (node) => typeof node === 'object' && node !== null && !Array.isArray(node);
+const hasNodeType = (node) => isObject(node) && typeof node.nodeType === 'number';
+const isNode = (node) => hasNodeType(node);
+export const isElement = (node) => hasNodeType(node) && node.nodeType === ELEMENT_NODE;
+const isDocument = (node) => hasNodeType(node) && node.nodeType === DOCUMENT_NODE;
+const isShadowRoot = (node) => hasNodeType(node) && node.nodeType === DOCUMENT_FRAGMENT_NODE && 'host' in node;
+export const isHTMLElement = (node) => isElement(node) && node.namespaceURI === 'http://www.w3.org/1999/xhtml';
+export const isElementOrSVGElement = (node) => isElement(node);
+export const isIOS = BROWSER &&
+    !!window.navigator.userAgent &&
+    (/iP(ad|hone|od)/.test(window.navigator.userAgent) ||
+        // iPad Pro Gen3 reports as Macintosh, so fall back to touch-point sniffing.
+        (window.navigator.maxTouchPoints > 2 && /iPad|Macintosh/.test(window.navigator.userAgent)));
+/**
+ * Yields `element` and then each of its ancestor elements, innermost first. The walk stays inside
+ * `element`'s own tree — a shadow root ends it rather than continuing through the host.
+ */
+export function* selfAndAncestors(element) {
+    for (let current = element; current; current = current.parentElement)
+        yield current;
+}
+export function contains(parent, child) {
+    if (!parent || !child)
+        return false;
+    if (!isNode(parent) || !isNode(child))
+        return false;
+    if (parent === child)
+        return true;
+    if (parent.contains(child))
+        return true;
+    // `parent.contains` already covered the same-tree case, so this only has to climb out of shadow
+    // roots via their host — a composed walk, which is why it can't use `selfAndAncestors`.
+    let current = child;
+    while (current) {
+        if (current === parent)
+            return true;
+        const root = current.getRootNode?.();
+        if (isShadowRoot(root) && current === root) {
+            current = root.host;
+        }
+        else {
+            current = current.parentNode;
+        }
+    }
+    return false;
+}
+export function getWindow(node) {
+    if (isShadowRoot(node))
+        return getWindow(node.host);
+    if (isDocument(node))
+        return node.defaultView ?? window;
+    if (isNode(node))
+        return node.ownerDocument?.defaultView ?? window;
+    return window;
+}

package/dist/internal/tools/utils/events.js

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

package/dist/internal/tools/utils/index.js

@@ -0,0 +1,5 @@
+export { attachRef, mountedAttachment } from './attach-ref.js';
+export { composeHandlers, mergeHandlers } from './compose-handlers.js';
+export { contains, getWindow, isElement, isElementOrSVGElement, isHTMLElement, isIOS } from './dom.js';
+export { DOMContext } from './dom-context.svelte.js';
+export * from './strings.js';

package/dist/internal/tools/utils/strings.d.ts

@@ -0,0 +1,4 @@
+import type { StyleProperties } from '../types.js';
+export declare const srOnlyStyles: StyleProperties;
+export declare function styleToString(style?: string | StyleProperties | null | undefined): string;
+export declare const srOnlyStylesString: string;

package/dist/internal/tools/utils/strings.js

@@ -0,0 +1,25 @@
+import { styleToString as serializeStyle } from 'overrule/props';
+export const srOnlyStyles = {
+    position: 'absolute',
+    width: '1px',
+    height: '1px',
+    padding: '0',
+    margin: '-1px',
+    overflow: 'hidden',
+    clip: 'rect(0, 0, 0, 0)',
+    clipPath: 'inset(50%)',
+    whiteSpace: 'nowrap',
+    borderWidth: '0',
+};
+// Adapter over overrule's serializer: this one also passes strings through
+// and tolerates null, the shapes floating-layer feeds it.
+export function styleToString(style = {}) {
+    if (!style)
+        return '';
+    if (typeof style === 'string')
+        return style;
+    return serializeStyle(style);
+}
+// Runs at module load, so it must not sit above `styleToString` (temporal
+// dead zone → ReferenceError during SSR).
+export const srOnlyStylesString = styleToString(srOnlyStyles);

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

@@ -0,0 +1,15 @@
+export declare const textContentOf: (node: HTMLElement) => string;
+type TypeaheadOpts<T> = {
+    getSearchText: (candidate: T) => string;
+    getCurrentCandidate: () => T | null;
+    onMatch: (candidate: T) => void;
+    getWindow: () => Window & typeof globalThis;
+};
+export declare class Typeahead<T> {
+    #private;
+    search: string;
+    constructor(opts: TypeaheadOpts<T>);
+    handleKey(key: string, candidates: T[]): T | undefined;
+    reset(): void;
+}
+export {};

package/dist/internal/typeahead.svelte.js

@@ -0,0 +1,31 @@
+import { createEffectTimeout } from './timeout-fn.svelte.js';
+import { getNextMatch } from './arrays.js';
+export const textContentOf = (node) => node.textContent?.trim() ?? '';
+export class Typeahead {
+    #opts;
+    search = $state.raw('');
+    #resetTimer;
+    constructor(opts) {
+        this.#opts = opts;
+        this.#resetTimer = createEffectTimeout(() => this.reset(), () => 1000, opts.getWindow);
+    }
+    handleKey(key, candidates) {
+        if (!candidates.length)
+            return;
+        this.search += key;
+        this.#resetTimer.start();
+        const currentCandidate = this.#opts.getCurrentCandidate();
+        const current = candidates.find((candidate) => candidate === currentCandidate);
+        const currentMatch = current === undefined ? '' : this.#opts.getSearchText(current);
+        const values = candidates.map((candidate) => this.#opts.getSearchText(candidate));
+        const nextMatch = getNextMatch(values, this.search, currentMatch);
+        const newCandidate = candidates.find((candidate) => this.#opts.getSearchText(candidate) === nextMatch);
+        if (newCandidate)
+            this.#opts.onMatch(newCandidate);
+        return newCandidate;
+    }
+    reset() {
+        this.search = '';
+        this.#resetTimer.stop();
+    }
+}

package/dist/internal/types.d.ts

@@ -0,0 +1,122 @@
+import type { Snippet } from 'svelte';
+import type { Box, ReadableBoxedValues, WritableBoxedValues, RefAttachment as InternalRefAttachment } from './tools/index.js';
+import type { StyleProperties } from './tools/types.js';
+export type OnChangeFn<T> = (value: T) => void;
+export type ElementRef = Box<HTMLElement | null>;
+export type WithChild<
+/**
+ * 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?: SnippetProps extends {
+        _default: never;
+    } ? Snippet : Snippet<[SnippetProps]>;
+    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;
+};
+/**
+ * Constructs a new type by omitting properties from type
+ * 'T' that exist in type 'U'.
+ *
+ * @template T - The base object type from which properties will be omitted.
+ * @template U - The object type whose properties will be omitted from 'T'.
+ * @example
+ * type Result = Without<{ a: number; b: string; }, { b: string; }>;
+ * // Result type will be { a: number; }
+ */
+export type Without<T extends object, U extends object> = Omit<T, keyof U>;
+export type Arrayable<T> = T[] | T;
+export type Fn = () => void;
+export type AnyFn = (...args: any[]) => any;
+export type WithRefOpts<T = {}> = T & ReadableBoxedValues<{
+    id: string;
+}> & WritableBoxedValues<{
+    ref: HTMLElement | null;
+}>;
+/** A part's `id` and bindable `ref` as accessors over its `$props()`; engines read them, the attachment writes `ref`. */
+export type RefOpts = {
+    readonly id: string;
+    ref: HTMLElement | null;
+};
+export type BitsEvent<T extends Event = Event, U extends HTMLElement = HTMLElement> = T & {
+    currentTarget: U;
+};
+export type BitsPointerEvent<T extends HTMLElement = HTMLElement> = BitsEvent<PointerEvent, T>;
+export type BitsKeyboardEvent<T extends HTMLElement = HTMLElement> = BitsEvent<KeyboardEvent, T>;
+export type BitsMouseEvent<T extends HTMLElement = HTMLElement> = BitsEvent<MouseEvent, T>;
+export type BitsFocusEvent<T extends HTMLElement = HTMLElement> = BitsEvent<FocusEvent, T>;
+export type BitsInputEvent<T extends HTMLElement = HTMLElement> = BitsEvent<InputEvent, T>;
+export type RefAttachment<T extends HTMLElement = HTMLElement> = InternalRefAttachment<T>;
+export type FloatingContentSnippetProps = {
+    /**
+     * Whether the content is open or closed.
+     */
+    open: boolean;
+};
+export type StaticContentSnippetProps = FloatingContentSnippetProps;
+/**
+ * Accepted for API compatibility on Dialog and Popover content and ignored: every surface is
+ * mounted while closed now (native top layer, or hidden inline with a CSS exit).
+ */
+export type PresenceProps = {
+    forceMount?: boolean;
+};
+export type TextSelectionGuardProps = {
+    /**
+     * Whether to prevent a drag that starts inside the surface from selecting page text behind
+     * it: the open surface is flagged for the `user-select` guard in ui.css.
+     *
+     * @default true
+     */
+    preventOverflowTextSelection?: boolean;
+};

package/dist/internal/types.js

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

package/dist/internal/utils.d.ts

@@ -0,0 +1,10 @@
+export type WithoutChild<T> = T extends {
+    child?: any;
+} ? Omit<T, 'child'> : T;
+export type WithoutChildren<T> = T extends {
+    children?: any;
+} ? Omit<T, 'children'> : T;
+export type WithoutChildrenOrChild<T> = WithoutChildren<WithoutChild<T>>;
+export type WithElementRef<T, U extends HTMLElement = HTMLElement> = T & {
+    ref?: U | null;
+};

package/dist/internal/utils.js

@@ -0,0 +1,4 @@
+// Snippet/ref prop helpers used across the styled bits-ui components (the
+// shadcn-svelte convention). The reactive accessor/box types live in
+// `#lib/internal/tools` and `#lib/internal/types` — these are only the surface props.
+export {};

package/dist/internal/vaul/browser.d.ts

@@ -0,0 +1,3 @@
+export declare const isIOSFirefox: () => boolean;
+export declare const isWebKit: () => boolean;
+export declare const needsIOSFixedBodyScrollLock: () => boolean;

package/dist/internal/vaul/browser.js

@@ -0,0 +1,5 @@
+// FxiOS is a WebKit shell yet resizes window.innerHeight on keyboard toggle (mozilla-mobile/firefox-ios#17929)
+export const isIOSFirefox = () => /FxiOS/.test(navigator.userAgent);
+// On iOS this is every engine except EU alt-engine ports (allowed since iOS 17.4) — Safari, WKWebView shells, FxiOS, CriOS all carry AppleWebKit.
+export const isWebKit = () => /AppleWebKit/.test(navigator.userAgent);
+export const needsIOSFixedBodyScrollLock = () => /iPad|iPhone|iPod/.test(navigator.userAgent) || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);

package/dist/internal/vaul/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const TRANSITIONS: {
+    DURATION: number;
+    EASE: number[];
+};
+export declare const VELOCITY_THRESHOLD = 0.4;
+export declare const CLOSE_THRESHOLD = 0.25;
+export declare const SCROLL_LOCK_TIMEOUT = 100;
+export declare const BORDER_RADIUS = 8;
+export declare const NESTED_DISPLACEMENT = 16;
+export declare const WINDOW_TOP_OFFSET = 26;
+export declare const DRAG_CLASS = "vaul-dragging";

package/dist/internal/vaul/constants.js

@@ -0,0 +1,12 @@
+// Mirrored as --vaul-duration/--vaul-ease in drawer.svelte's stylesheet — keep in sync.
+export const TRANSITIONS = {
+    DURATION: 0.5,
+    EASE: [0.32, 0.72, 0, 1],
+};
+export const VELOCITY_THRESHOLD = 0.4;
+export const CLOSE_THRESHOLD = 0.25;
+export const SCROLL_LOCK_TIMEOUT = 100;
+export const BORDER_RADIUS = 8;
+export const NESTED_DISPLACEMENT = 16;
+export const WINDOW_TOP_OFFSET = 26;
+export const DRAG_CLASS = 'vaul-dragging';

package/dist/internal/vaul/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { DrawerDirection } from './types.js';
+type StyleValue = string | number | null | undefined;
+type Style = Record<string, StyleValue>;
+export declare const applyStyle: (element: Element | HTMLElement | null | undefined, style: Style) => void;
+export declare const assignStyle: (element: HTMLElement | null | undefined, style: Style) => () => void;
+export declare const isVertical: (direction: DrawerDirection) => direction is "bottom" | "top";
+export declare const getTranslate: (element: HTMLElement, direction: DrawerDirection) => number;
+export declare const dampenValue: (value: number) => number;
+export {};

package/dist/internal/vaul/helpers.js

@@ -0,0 +1,27 @@
+export const applyStyle = (element, style) => {
+    if (!(element instanceof HTMLElement))
+        return;
+    for (const [key, value] of Object.entries(style)) {
+        if (value != null)
+            Object.assign(element.style, { [key]: String(value) });
+    }
+};
+export const assignStyle = (element, style) => {
+    if (!element)
+        return () => { };
+    const prevStyle = element.style.cssText;
+    applyStyle(element, style);
+    return () => {
+        element.style.cssText = prevStyle;
+    };
+};
+export const isVertical = (direction) => direction === 'top' || direction === 'bottom';
+export const getTranslate = (element, direction) => {
+    const win = element.ownerDocument.defaultView ?? window;
+    const transform = win.getComputedStyle(element).transform;
+    if (transform === 'none')
+        return 0;
+    const matrix = new win.DOMMatrixReadOnly(transform);
+    return isVertical(direction) ? matrix.m42 : matrix.m41;
+};
+export const dampenValue = (value) => 8 * (Math.log(value + 1) - 2);

package/dist/internal/vaul/types.d.ts

@@ -0,0 +1,122 @@
+import type { BitsPrimitiveDivAttributes } from "../attribute-types.js";
+import type { DialogContentPropsWithoutHTML, DialogOverlayPropsWithoutHTML, DialogRootProps } from "../../components/dialog/types.js";
+import type { WithChildren, Without } from "../types.js";
+import type { WithoutChildrenOrChild } from "../utils.js";
+export type DrawerDirection = "left" | "right" | "top" | "bottom";
+export type Getters<T> = {
+    [K in keyof T]: () => T[K];
+};
+type WithFadeFromProps = {
+    /**
+     * Array of numbers from 0 to 100 that corresponds to % of the screen a given snap point should take up.
+     * Should go from least visible. Example `[0.2, 0.5, 0.8]`.
+     * You can also use px values, which doesn't take screen height into account.
+     */
+    snapPoints: (number | string)[];
+    /**
+     * Index of a `snapPoint` from which the overlay fade should be applied. Defaults to the last snap point.
+     */
+    fadeFromIndex: number;
+};
+type WithoutFadeFromProps = {
+    /**
+     * Array of numbers from 0 to 100 that corresponds to % of the screen a given snap point should take up.
+     * Should go from least visible. Example `[0.2, 0.5, 0.8]`.
+     * You can also use px values, which doesn't take screen height into account.
+     */
+    snapPoints?: (number | string)[];
+    fadeFromIndex?: never;
+};
+type BaseDrawerRootPropsWithoutHTML = WithChildren<{
+    activeSnapPoint?: number | string | null;
+    onActiveSnapPointChange?: (snapPoint: number | string | null) => void;
+    open?: boolean;
+    /**
+     * Number between 0 and 1 that determines when the drawer should be closed.
+     * Example: threshold of 0.5 would close the drawer if the user swiped for 50% of the height of the drawer or more.
+     * @default 0.25
+     */
+    closeThreshold?: number;
+    /**
+     * When `true` the `body` doesn't get any styles assigned from Vaul
+     */
+    noBodyStyles?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    shouldScaleBackground?: boolean;
+    /**
+     * When `false` we don't change body's background color when the drawer is open.
+     * @default true
+     */
+    setBackgroundColorOnScale?: boolean;
+    /**
+     * Duration for which the drawer is not draggable after scrolling content inside of the drawer.
+     * @default 500ms
+     */
+    scrollLockTimeout?: number;
+    /**
+     * When `true`, don't move the drawer upwards if there's space, but rather only change it's height so it's fully scrollable when the keyboard is open
+     */
+    fixed?: boolean;
+    /**
+     * When `true` only allows the drawer to be dragged by the `<Drawer.Handle />` component.
+     * @default false
+     */
+    handleOnly?: boolean;
+    /**
+     * When `false` dragging, clicking outside, pressing esc, etc. will not close the drawer.
+     * Use this in combination with the `open` prop, otherwise you won't be able to open/close the drawer.
+     * @default true
+     */
+    dismissible?: boolean;
+    onDrag?: (event: PointerEvent, percentageDragged: number) => void;
+    onRelease?: (event: PointerEvent, open: boolean) => void;
+    /**
+     * When `false` it allows to interact with elements outside of the drawer without closing it.
+     * @default true
+     */
+    modal?: boolean;
+    nested?: boolean;
+    onClose?: () => void;
+    /**
+     * Direction of the drawer. Can be `top` or `bottom`, `left`, `right`.
+     * @default 'bottom'
+     */
+    direction?: "top" | "bottom" | "left" | "right";
+    /**
+     * Opened by default, skips initial enter animation. Still reacts to `open` state changes
+     * @default false
+     */
+    defaultOpen?: boolean;
+    /**
+     * When set to `true` prevents scrolling on the document body on mount, and restores it on unmount.
+     * @default false
+     */
+    disablePreventScroll?: boolean;
+    /**
+     * When `true` Vaul will reposition inputs rather than scroll then into view if the keyboard is in the way.
+     * Setting it to `false` will fall back to the default browser behavior.
+     * @default true when {@link snapPoints} is defined
+     */
+    repositionInputs?: boolean;
+    /**
+     * Disabled velocity based swiping for snap points.
+     * This means that a snap point won't be skipped even if the velocity is high enough.
+     * Useful if each snap point in a drawer is equally important.
+     * @default false
+     */
+    snapToSequentialPoint?: boolean;
+    container?: HTMLElement | null;
+    /**
+     * Gets triggered after the open or close animation ends, it receives an `open` argument with the `open` state of the drawer by the time the function was triggered.
+     * Useful to revert any state changes for example.
+     */
+    onAnimationEnd?: (open: boolean) => void;
+    preventScrollRestoration?: boolean;
+    autoFocus?: boolean;
+}> & (WithFadeFromProps | WithoutFadeFromProps);
+export type DrawerRootProps = BaseDrawerRootPropsWithoutHTML & Without<DialogRootProps, BaseDrawerRootPropsWithoutHTML>;
+type DrawerContentPropsWithoutHTML = WithChildren<WithoutChildrenOrChild<Omit<DialogContentPropsWithoutHTML, "preventScroll">>>;
+export type DrawerContentProps = DrawerContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, DrawerContentPropsWithoutHTML>;
+type DrawerOverlayPropsWithoutHTML = WithChildren<WithoutChildrenOrChild<DialogOverlayPropsWithoutHTML>>;
+export type DrawerOverlayProps = DrawerOverlayPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, DrawerOverlayPropsWithoutHTML>;
+export {};

package/dist/internal/vaul/types.js

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

package/dist/internal/vaul/use-drawer-content.svelte.d.ts

@@ -0,0 +1,65 @@
+import { type ComponentProps } from 'svelte';
+import { type ReadableBoxedValues, type WithRefProps } from '../tools/index.js';
+import * as DrawerPrimitive from '../../components/dialog/index.js';
+import type { DrawerDirection } from './types.js';
+type DrawerPrimitiveContentProps = Pick<ComponentProps<typeof DrawerPrimitive.Content>, 'onInteractOutside' | 'onOpenAutoFocus' | 'onFocusOutside' | 'onpointerdown' | 'onpointermove' | 'onpointerup' | 'onpointerout' | 'oncontextmenu'>;
+interface UseDrawerContentProps extends WithRefProps, ReadableBoxedValues<Required<DrawerPrimitiveContentProps>> {
+}
+export declare function useDrawerContent(opts: UseDrawerContentProps): {
+    readonly props: {
+        id: string;
+        'data-vaul-drawer-direction': DrawerDirection;
+        'data-vaul-drawer': string;
+        'data-vaul-delayed-snap-points': string;
+        'data-vaul-snap-points': string;
+        'data-vaul-custom-container': string;
+        'data-vaul-animate': string;
+        onpointerdown: (e: PointerEvent & {
+            currentTarget: EventTarget & HTMLDivElement;
+        }) => void;
+        onOpenAutoFocus: (e: Event) => void;
+        onInteractOutside: (e: PointerEvent) => void;
+        onFocusOutside: (e: Event) => void;
+        onpointerup: (e: PointerEvent & {
+            currentTarget: EventTarget & HTMLDivElement;
+        }) => void;
+        onpointermove: (e: PointerEvent & {
+            currentTarget: EventTarget & HTMLDivElement;
+        }) => void;
+        onpointerout: (e: PointerEvent & {
+            currentTarget: EventTarget & HTMLDivElement;
+        }) => void;
+        oncontextmenu: (e: PointerEvent & {
+            currentTarget: EventTarget & HTMLDivElement;
+        }) => void;
+        preventScroll: boolean;
+    };
+    ctx: {
+        open: import("../tools/box.svelte.js").WritableBox<boolean>;
+        snapPoints: import("../tools/box.svelte.js").ReadableBox<(string | number)[] | undefined>;
+        modal: import("../tools/box.svelte.js").ReadableBox<boolean>;
+        direction: import("../tools/box.svelte.js").ReadableBox<DrawerDirection>;
+        shouldScaleBackground: import("../tools/box.svelte.js").ReadableBox<boolean>;
+        setBackgroundColorOnScale: import("../tools/box.svelte.js").ReadableBox<boolean>;
+        noBodyStyles: import("../tools/box.svelte.js").ReadableBox<boolean>;
+        handleOnly: import("../tools/box.svelte.js").ReadableBox<boolean>;
+        container: import("../tools/box.svelte.js").ReadableBox<HTMLElement | null>;
+        autoFocus: import("../tools/box.svelte.js").ReadableBox<boolean>;
+        keyboardIsOpen: boolean;
+        setDrawerNode: (node: HTMLElement | null) => void;
+        setOverlayNode: (node: HTMLElement | null) => void;
+        onPress: (event: PointerEvent) => void;
+        onDrag: (event: PointerEvent) => void;
+        onRelease: (event: PointerEvent | null) => void;
+        onNestedDrag: (_event: PointerEvent, percentageDragged: number) => void;
+        onNestedOpenChange: (o: boolean) => void;
+        onNestedRelease: (_event: PointerEvent, o: boolean) => void;
+        onDialogOpenChange: (o: boolean) => void;
+        handleOpenChangeComplete: (o: boolean) => void;
+        readonly shouldAnimate: boolean;
+        readonly shouldFade: boolean;
+        readonly snapPointsOffset: number[];
+        readonly activeSnapPointIndex: number | undefined;
+    };
+};
+export {};