@casinogate/ui 1.11.14 → 2.0.1

package/dist/composed/dialog/_ui/nested-dialog/index.js

@@ -0,0 +1 @@
+export { default as NestedDialog } from './nested-dialog.svelte';

package/dist/composed/dialog/_ui/nested-dialog/nested-dialog.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+  import { Button } from '../../../../primitives/button/index.js';
+  import { useDialogItemContext } from '../../dialog-host-item.svelte';
+  import { dialogs } from '../../model/dialog-manager.svelte.js';
+
+  const itemCtx = useDialogItemContext();
+</script>
+
+<div class="cgui:bg-surface-white cgui:max-w-140 cgui:p-4">
+  <h2 class="cgui:text-lg cgui:font-medium cgui:text-fg-primary cgui:text-center">Nested Dialog</h2>
+
+  <p>
+    Amet ullamco cupidatat dolor. Ut deserunt consequat enim elit ad aliqua aliqua dolore minim. Sint reprehenderit
+    commodo cillum ut laborum amet fugiat dolor incididunt laborum ut laboris irure qui veniam. Non officia
+    reprehenderit est tempor id. Minim ea qui consectetur. Incididunt fugiat enim ut veniam. Tempor labore eiusmod ut
+    ullamco esse nulla cupidatat et est amet. Ullamco velit sunt anim ex elit nostrud incididunt. Anim minim elit
+    laborum fugiat incididunt. Aute sit irure enim do ea id et tempor sunt sit ea id in excepteur. Non culpa consequat
+    Lorem est sit. Cillum culpa do nostrud. Ipsum aliquip fugiat cillum incididunt dolor occaecat eu et. Ipsum culpa
+    amet culpa culpa in id.
+  </p>
+
+  <div class="cgui:flex cgui:gap-2">
+    <Button variant="outline" onclick={() => dialogs.closeAll()}>Close all</Button>
+
+    <Button onclick={() => itemCtx.close()}>Close Nested Dialog</Button>
+  </div>
+</div>

package/dist/composed/dialog/_ui/nested-dialog/nested-dialog.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const NestedDialog: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type NestedDialog = InstanceType<typeof NestedDialog>;
+export default NestedDialog;

package/dist/composed/dialog/dialog-host-item.svelte

@@ -0,0 +1,99 @@
+<script lang="ts" module>
+  import { Context, watch } from 'runed';
+
+  const DialogItemContext = new Context<Omit<DialogItemState, 'component'>>('dialog-item');
+
+  export const useDialogItemContext = () => DialogItemContext.get();
+</script>
+
+<script lang="ts">
+  import Content from '../../primitives/dialog/components/dialog.content.svelte';
+  import Overlay from '../../primitives/dialog/components/dialog.overlay.svelte';
+  import Portal from '../../primitives/dialog/components/dialog.portal.svelte';
+  import Positioner from '../../primitives/dialog/components/dialog.positioner.svelte';
+  import Root from '../../primitives/dialog/components/dialog.root.svelte';
+  import type { DialogItemState, InjectedDialogProps } from './types.js';
+
+  let { component, props: dialogProps, options, open, id, close, update }: DialogItemState = $props();
+
+  function createCtx(): InjectedDialogProps {
+    return {
+      id,
+      close: (canceled?: boolean) => close(canceled),
+      update,
+    };
+  }
+
+  const ctx = $derived(createCtx());
+
+  const {
+    interactOutsideBehavior = 'close',
+    escapeKeydownBehavior = 'close',
+    onOpenChange,
+    withOverlay = true,
+    contentClass,
+    positionerClass,
+    overlayClass,
+    contentProps: contentPropsOptions,
+    positionerProps: positionerPropsOptions,
+    overlayProps: overlayPropsOptions,
+    ...restOptions
+  } = options;
+
+  const Component = $derived(component);
+
+  const contentProps = $derived({
+    interactOutsideBehavior,
+    escapeKeydownBehavior,
+    class: contentClass,
+    ...contentPropsOptions,
+  });
+
+  const positionerProps = $derived({
+    class: positionerClass,
+    ...positionerPropsOptions,
+  });
+
+  const overlayProps = $derived({
+    class: overlayClass,
+    ...overlayPropsOptions,
+  });
+
+  DialogItemContext.set({
+    props: dialogProps,
+    options,
+    open,
+    id,
+    update,
+    close,
+  });
+
+  watch(
+    () => open,
+    () => {
+      onOpenChange?.(open);
+    }
+  );
+</script>
+
+<Root
+  {...restOptions}
+  bind:open={
+    () => open,
+    (v) => {
+      open = v;
+      close(true);
+    }
+  }
+>
+  <Portal>
+    {#if withOverlay}
+      <Overlay {...overlayProps} />
+    {/if}
+    <Positioner {...positionerProps}>
+      <Content {...contentProps}>
+        <Component {ctx} {...dialogProps} />
+      </Content>
+    </Positioner>
+  </Portal>
+</Root>

package/dist/composed/dialog/dialog-host-item.svelte.d.ts

@@ -0,0 +1,5 @@
+export declare const useDialogItemContext: () => Omit<DialogItemState, "component">;
+import type { DialogItemState } from './types.js';
+declare const DialogHostItem: import("svelte").Component<DialogItemState, {}, "">;
+type DialogHostItem = ReturnType<typeof DialogHostItem>;
+export default DialogHostItem;

package/dist/composed/dialog/dialog-host.svelte

@@ -0,0 +1,29 @@
+<script lang="ts" module>
+  export const createRegister = <TKey extends string, TComponent extends DialogComponent>(
+    key: TKey,
+    component: TComponent,
+    options?: Partial<DialogOptions>
+  ): { [K in TKey]: DialogRegistrationValue<TComponent> } => {
+    return {
+      [key]: { component, options },
+    } as { [K in TKey]: DialogRegistrationValue<TComponent> };
+  };
+</script>
+
+<script lang="ts">
+  import HostItem from './dialog-host-item.svelte';
+  import type { DialogComponent, DialogHostProps, DialogOptions, DialogRegistrationValue } from './types.js';
+
+  import { boxWith } from 'svelte-toolbelt';
+  import { DialogManagerState } from './model/dialog-manager.svelte.js';
+
+  let { register = {} }: DialogHostProps = $props();
+
+  const managerState = DialogManagerState.create({
+    register: boxWith(() => register),
+  });
+</script>
+
+{#each managerState.dialogs as dialog (dialog.id)}
+  <HostItem {...dialog} />
+{/each}

package/dist/composed/dialog/dialog-host.svelte.d.ts

@@ -0,0 +1,5 @@
+export declare const createRegister: <TKey extends string, TComponent extends DialogComponent>(key: TKey, component: TComponent, options?: Partial<DialogOptions>) => { [K in TKey]: DialogRegistrationValue<TComponent>; };
+import type { DialogComponent, DialogHostProps, DialogOptions, DialogRegistrationValue } from './types.js';
+declare const DialogHost: import("svelte").Component<DialogHostProps, {}, "">;
+type DialogHost = ReturnType<typeof DialogHost>;
+export default DialogHost;

package/dist/composed/dialog/index.d.ts

@@ -0,0 +1,4 @@
+export * as Dialog from './root/index.js';
+export { useDialogItemContext } from './dialog-host-item.svelte';
+export { dialogs } from './model/index.js';
+export type * from './types.js';

package/dist/composed/dialog/index.js

@@ -0,0 +1,3 @@
+export * as Dialog from './root/index.js';
+export { useDialogItemContext } from './dialog-host-item.svelte';
+export { dialogs } from './model/index.js';

package/dist/composed/dialog/model/dialog-manager.svelte.d.ts

@@ -0,0 +1,34 @@
+import { Context } from 'runed';
+import { type ReadableBoxedValues } from 'svelte-toolbelt';
+import type { CloseDialogCommandPayload, DialogComponent, DialogHandle, DialogItemState, DialogOptions, DialogRegistrationValue, OpenDialogCommandPayload, OpenRegisteredDialogCommandPayload, RegisteredDialogKeys } from '../types.js';
+export declare const DialogManagerContext: Context<DialogManagerState>;
+type DialogManagerOpts = ReadableBoxedValues<{
+    register: Record<string, DialogRegistrationValue>;
+}>;
+export declare class DialogManagerState {
+    #private;
+    static create(opts: DialogManagerOpts): DialogManagerState;
+    readonly opts: DialogManagerOpts;
+    constructor(opts: DialogManagerOpts);
+    innerClose(payload: CloseDialogCommandPayload): void;
+    get dialogs(): DialogItemState[];
+    set dialogs(value: DialogItemState[]);
+}
+declare function openRegistered<TKey extends RegisteredDialogKeys>(key: TKey, payload: OpenRegisteredDialogCommandPayload<TKey>): DialogHandle;
+declare function open<TComponent extends DialogComponent>(payload: OpenDialogCommandPayload<TComponent>): DialogHandle;
+declare function close(payload: CloseDialogCommandPayload): void;
+declare function closeAll(): void;
+declare function update(payload: {
+    id: string;
+}, fn: (currentProps: Record<string, unknown>, currentOptions: Partial<DialogOptions>) => {
+    props: Record<string, unknown>;
+    options: Partial<DialogOptions>;
+}): void;
+export declare const dialogs: {
+    openRegistered: typeof openRegistered;
+    open: typeof open;
+    close: typeof close;
+    closeAll: typeof closeAll;
+    update: typeof update;
+};
+export {};

package/dist/composed/dialog/model/dialog-manager.svelte.js

@@ -0,0 +1,170 @@
+import { EventDispatcher } from '../../../internal/index.js';
+import { keyWithPrefix, useId } from '../../../internal/utils/common.js';
+import { Context } from 'runed';
+import {} from 'svelte';
+import { mergeProps } from 'svelte-toolbelt';
+const Dispatcher = new EventDispatcher();
+export const DialogManagerContext = new Context(keyWithPrefix('dialog-manager'));
+export class DialogManagerState {
+    static create(opts) {
+        return DialogManagerContext.set(new DialogManagerState(opts));
+    }
+    #dialogs = $state([]);
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+        $effect(() => {
+            this.#subscribeToEvents();
+            return () => {
+                this.#unsubscribe?.();
+            };
+        });
+    }
+    #unsubscribe;
+    #subscribeToEvents() {
+        this.#unsubscribe = Dispatcher.subscribe({
+            'dialog:openRegistered': (event) => this.#handleOpenRegistered(event.detail),
+            'dialog:open': (event) => this.#handleOpen(event.detail),
+            'dialog:close': (event) => this.#handleClose(event.detail),
+            'dialog:closeAll': () => this.#handleCloseAll(),
+            'dialog:update': (event) => this.#updateDialog(event.detail.id, event.detail.fn),
+        });
+    }
+    #updateDialog(id, fn) {
+        const dialogIndex = this.#dialogs.findIndex((d) => d.id === id);
+        if (dialogIndex === -1)
+            return;
+        const currentDialog = this.#dialogs[dialogIndex];
+        if (!currentDialog)
+            return;
+        const { props: newProps, options: newOptions } = fn(currentDialog.props, currentDialog.options);
+        currentDialog.props = { id, ...newProps };
+        currentDialog.options = newOptions;
+    }
+    #handleOpenRegistered(payload) {
+        const { key, props, options = {}, id } = payload;
+        const registeredValue = this.opts.register.current?.[key];
+        if (!registeredValue) {
+            throw new Error(`Dialog with key "${key}" is not registered`);
+        }
+        const { component, options: registeredOptions } = registeredValue;
+        const componentProps = {
+            id,
+            ...props,
+        };
+        const mergedOptions = mergeProps(registeredOptions, options);
+        const state = {
+            component: component,
+            props: componentProps,
+            id,
+            close: (canceled) => close({ id, canceled }),
+            update: (fn) => {
+                this.#updateDialog(id, fn);
+            },
+            options: mergedOptions,
+            open: true,
+        };
+        const newDialogs = [...this.#dialogs.map((d) => ({ ...d, open: false })), state];
+        this.dialogs = newDialogs;
+    }
+    #handleOpen(payload) {
+        const { component, props, options = {}, id } = payload;
+        const componentProps = {
+            id,
+            ...props,
+        };
+        const state = {
+            component: component,
+            props: componentProps,
+            id,
+            close: (canceled) => close({ id, canceled }),
+            update: (fn) => {
+                this.#updateDialog(id, fn);
+            },
+            options,
+            open: true,
+        };
+        this.dialogs = [...this.dialogs.map((d) => ({ ...d, open: false })), state];
+    }
+    #handleClose(payload) {
+        const { id, canceled = true } = payload;
+        // Find the dialog to get its onClose callback
+        const closingDialog = this.#dialogs.find((d) => d.id === id);
+        for (let i = this.#dialogs.length - 1; i >= 0; i--) {
+            const dialog = this.#dialogs[i];
+            if (!dialog)
+                continue;
+            if (dialog.id === id) {
+                dialog.open = false;
+                continue;
+            }
+            if (!dialog.open) {
+                dialog.open = true;
+                break;
+            }
+        }
+        // Call onClose callback with canceled flag
+        closingDialog?.options.onClose?.(canceled);
+        setTimeout(() => {
+            this.dialogs = this.dialogs.filter((d) => d.id !== id);
+        }, 150);
+    }
+    #handleCloseAll() {
+        this.dialogs = [];
+    }
+    innerClose(payload) {
+        this.#handleClose(payload);
+    }
+    get dialogs() {
+        return this.#dialogs;
+    }
+    set dialogs(value) {
+        this.#dialogs = value;
+    }
+}
+function createHandle(id) {
+    return {
+        id,
+        close: (canceled) => close({ id, canceled }),
+        update: (fn) => update({ id }, fn),
+    };
+}
+function openRegistered(key, payload) {
+    const { props, options } = payload;
+    const id = useId();
+    Dispatcher.dispatch('dialog:openRegistered', {
+        key,
+        props,
+        id,
+        options,
+    });
+    return createHandle(id);
+}
+function open(payload) {
+    const { component, props, options } = payload;
+    const id = useId();
+    Dispatcher.dispatch('dialog:open', {
+        component,
+        props,
+        options,
+        id,
+    });
+    return createHandle(id);
+}
+function close(payload) {
+    const { id, canceled } = payload;
+    Dispatcher.dispatch('dialog:close', { id, canceled });
+}
+function closeAll() {
+    Dispatcher.dispatch('dialog:closeAll');
+}
+function update(payload, fn) {
+    Dispatcher.dispatch('dialog:update', { id: payload.id, fn });
+}
+export const dialogs = {
+    openRegistered,
+    open,
+    close,
+    closeAll,
+    update,
+};

package/dist/composed/dialog/model/index.d.ts

@@ -0,0 +1 @@
+export { DialogManagerContext, DialogManagerState, dialogs } from './dialog-manager.svelte.js';

package/dist/composed/dialog/model/index.js

@@ -0,0 +1 @@
+export { DialogManagerContext, DialogManagerState, dialogs } from './dialog-manager.svelte.js';

package/dist/composed/dialog/root/index.d.ts

@@ -0,0 +1,2 @@
+export { createRegister, default as Host } from '../dialog-host.svelte';
+export * from '../../../primitives/dialog/components/index.js';

package/dist/composed/dialog/root/index.js

@@ -0,0 +1,2 @@
+export { createRegister, default as Host } from '../dialog-host.svelte';
+export * from '../../../primitives/dialog/components/index.js';

package/dist/composed/dialog/types.d.ts

@@ -0,0 +1,95 @@
+import type { PrimitiveDivAttributes } from '../../internal/types/html-attributes.js';
+import type { DialogCloseProps as DialogClosePropsPrimitive, DialogContentProps as DialogContentPropsPrimitive, DialogOverlayProps as DialogOverlayPropsPrimitive, DialogPortalProps as DialogPortalPropsPrimitive, DialogRootProps as DialogRootPropsPrimitive } from 'bits-ui';
+import type { Component, ComponentProps } from 'svelte';
+import type { WithChildren, WithElementRef, Without } from 'svelte-toolbelt';
+import type { DialogCloseVariants, DialogContentVariants, DialogOverlayVariants, DialogPositionerVariants } from '../../primitives/dialog/styles.js';
+export type DialogRootProps = DialogRootPropsPrimitive;
+export type DialogPortalProps = DialogPortalPropsPrimitive;
+export type DialogContentProps = DialogContentPropsPrimitive & DialogContentVariants;
+export type DialogOverlayProps = DialogOverlayPropsPrimitive & DialogOverlayVariants;
+type DialogPositionerPropsWithoutHTML = WithElementRef<WithChildren<{}>> & DialogPositionerVariants;
+export type DialogPositionerProps = DialogPositionerPropsWithoutHTML & Without<PrimitiveDivAttributes, DialogPositionerPropsWithoutHTML>;
+export type DialogCloseProps = DialogClosePropsPrimitive & DialogCloseVariants;
+export type DialogHostProps = {
+    register?: Record<string, DialogRegistrationValue>;
+};
+export type DialogComponent = Component<any>;
+export interface RegisteredDialogsOverride {
+}
+export type RegisteredDialogCollectionOverwritten = keyof RegisteredDialogsOverride extends never ? {
+    dialogs: Record<string, DialogRegistrationValue>;
+} : RegisteredDialogsOverride;
+export type RegisteredDialogCollection = RegisteredDialogCollectionOverwritten['dialogs'];
+export type RegisteredDialogKeys = keyof RegisteredDialogCollectionOverwritten['dialogs'];
+export type DialogRegistrationValue<TComponent extends DialogComponent = DialogComponent> = {
+    component: TComponent;
+    options?: Partial<DialogOptions>;
+};
+/** Extract custom props from a dialog component (omit injected ctx) */
+export type DialogCustomProps<T extends Component<any>> = Omit<ComponentProps<T>, 'ctx'>;
+export type DialogOptions = Omit<DialogRootProps, 'open' | 'onOpenChangeComplete' | 'children'> & {
+    withOverlay?: boolean;
+    escapeKeydownBehavior?: Extract<DialogContentProps['escapeKeydownBehavior'], 'close' | 'ignore'>;
+    interactOutsideBehavior?: Extract<DialogContentProps['interactOutsideBehavior'], 'close' | 'ignore'>;
+    contentClass?: string;
+    positionerClass?: string;
+    overlayClass?: string;
+    contentProps?: Partial<Omit<DialogContentProps, 'id' | 'class' | 'children' | 'ref' | 'child'>>;
+    positionerProps?: Partial<Omit<DialogPositionerProps, 'id' | 'class' | 'children' | 'ref' | 'child'>>;
+    overlayProps?: Partial<Omit<DialogOverlayProps, 'id' | 'class' | 'children' | 'ref' | 'child'>>;
+    /** Called when dialog closes. `canceled: true` means user dismissed (escape, click outside, cancel button) */
+    onClose?: (canceled: boolean) => void;
+};
+export type DialogItemState = {
+    id: string;
+    open: boolean;
+    props: Record<string, unknown>;
+    component: DialogComponent;
+    options: Partial<DialogOptions>;
+    update: (fn: (currentProps: Record<string, unknown>, currentOptions: Partial<DialogOptions>) => {
+        props: Record<string, unknown>;
+        options: Partial<DialogOptions>;
+    }) => void;
+    close: (canceled?: boolean) => void;
+};
+export type OpenRegisteredDialogPayload<TKey extends RegisteredDialogKeys = RegisteredDialogKeys> = {
+    key: TKey;
+    props: DialogCustomProps<RegisteredDialogCollection[TKey]['component']>;
+    options?: Partial<DialogOptions>;
+};
+export type OpenRegisteredDialogCommandPayload<TKey extends RegisteredDialogKeys = RegisteredDialogKeys> = {
+    props: DialogCustomProps<RegisteredDialogCollection[TKey]['component']>;
+    options?: Partial<DialogOptions>;
+};
+export type OpenDialogCommandPayload<TComponent extends DialogComponent = DialogComponent> = {
+    component: TComponent;
+    props: DialogCustomProps<TComponent>;
+    options?: Partial<DialogOptions>;
+};
+export type CloseDialogCommandPayload = {
+    id: string;
+    canceled?: boolean;
+};
+export type InjectedDialogProps = {
+    id: string;
+    close: (canceled?: boolean) => void;
+    update: (fn: (currentProps: Record<string, unknown>, currentOptions: Partial<DialogOptions>) => {
+        props: Record<string, unknown>;
+        options: Partial<DialogOptions>;
+    }) => void;
+};
+export type WithDialogProps<T extends Record<string, unknown>> = {
+    ctx: InjectedDialogProps;
+} & T;
+export type DialogHandle = {
+    id: string;
+    close: (canceled?: boolean) => void;
+    update: (fn: (currentProps: Record<string, unknown>, currentOptions: Partial<DialogOptions>) => {
+        props: Record<string, unknown>;
+        options: Partial<DialogOptions>;
+    }) => void;
+};
+export type ExtractRegisterdDialogs<TData extends Record<string, DialogRegistrationValue>> = {
+    [TKey in keyof TData]: TData[TKey]['component'];
+};
+export {};

package/dist/composed/dialog/types.js

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

package/dist/composed/drawer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './root/index.js';
+export type * from './types.js';

package/dist/composed/drawer/index.js

@@ -0,0 +1 @@
+export * from './root/index.js';

package/dist/composed/drawer/root/drawer.root.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">
+  import * as Primitive from '../../../primitives/drawer/components/index.js';
+  import type { DrawerProps } from '../types.js';
+
+  let {
+    open = $bindable(false),
+    children,
+    trigger,
+    title,
+    description,
+    variant = 'default',
+    class: className,
+    overlayClass,
+    withOverlay = true,
+    withHandle = true,
+    triggerProps,
+    overlayProps,
+    ...restProps
+  }: DrawerProps = $props();
+</script>
+
+<Primitive.Root bind:open {...restProps}>
+  {#if trigger !== undefined}
+    {#if typeof trigger === 'string'}
+      <Primitive.Trigger {...triggerProps}>{trigger}</Primitive.Trigger>
+    {:else}
+      <Primitive.Trigger {...triggerProps}>
+        {#snippet child({ props })}
+          {@render trigger?.({ props })}
+        {/snippet}
+      </Primitive.Trigger>
+    {/if}
+  {/if}
+
+  <Primitive.Portal>
+    {#if withOverlay}
+      <Primitive.Overlay class={overlayClass} {...overlayProps} />
+    {/if}
+
+    <Primitive.Content {variant} class={className}>
+      {#if withHandle}
+        <Primitive.Handle />
+      {/if}
+
+      {#if title !== undefined}
+        {#if typeof title === 'string'}
+          <Primitive.Title>{title}</Primitive.Title>
+        {:else}
+          <Primitive.Title>
+            {@render title?.()}
+          </Primitive.Title>
+        {/if}
+      {/if}
+
+      {#if description !== undefined}
+        {#if typeof description === 'string'}
+          <Primitive.Description>{description}</Primitive.Description>
+        {:else}
+          <Primitive.Description>
+            {@render description?.()}
+          </Primitive.Description>
+        {/if}
+      {/if}
+
+      {@render children?.()}
+    </Primitive.Content>
+  </Primitive.Portal>
+</Primitive.Root>

package/dist/composed/drawer/root/drawer.root.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { DrawerProps } from '../types.js';
+declare const Drawer: import("svelte").Component<DrawerProps, {}, "open">;
+type Drawer = ReturnType<typeof Drawer>;
+export default Drawer;

package/dist/composed/drawer/root/index.d.ts

@@ -0,0 +1 @@
+export { default as Drawer } from './drawer.root.svelte';

package/dist/composed/drawer/root/index.js

@@ -0,0 +1 @@
+export { default as Drawer } from './drawer.root.svelte';

package/dist/composed/drawer/types.d.ts

@@ -0,0 +1,16 @@
+import type { DrawerContentProps, DrawerOverlayProps, DrawerRootProps, DrawerTriggerProps } from '../../primitives/drawer/types.js';
+import type { Snippet } from 'svelte';
+import type { WithoutChildrenOrChild } from 'svelte-toolbelt';
+export type DrawerProps = WithoutChildrenOrChild<DrawerRootProps> & Pick<DrawerContentProps, 'class' | 'variant'> & {
+    trigger?: Snippet<[{
+        props: Record<string, unknown>;
+    }]> | string;
+    title?: Snippet | string;
+    description?: Snippet | string;
+    children?: Snippet;
+    overlayClass?: string;
+    withOverlay?: boolean;
+    withHandle?: boolean;
+    triggerProps?: Omit<DrawerTriggerProps, 'class' | 'children' | 'ref' | 'child'>;
+    overlayProps?: Omit<DrawerOverlayProps, 'class' | 'children' | 'ref' | 'child'>;
+};

package/dist/composed/drawer/types.js

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

package/dist/composed/dropdown/index.d.ts

@@ -0,0 +1,2 @@
+export * as Dropdown from './root/index.js';
+export type * from './types.js';

package/dist/composed/dropdown/index.js

@@ -0,0 +1 @@
+export * as Dropdown from './root/index.js';

package/dist/composed/dropdown/model/use-dropdown-items.svelte.d.ts

@@ -0,0 +1,12 @@
+import { SvelteMap } from 'svelte/reactivity';
+import type { DropdownGroup, DropdownItem } from '../types.js';
+export declare const DROPDOWN_UNGROUPED_KEY = "__ungrouped__";
+type Opts<TItem extends DropdownItem> = {
+    items: () => TItem[];
+    groups: () => DropdownGroup[];
+};
+export declare const useDropdownItems: <TItem extends DropdownItem>({ items, groups }: Opts<TItem>) => {
+    readonly groupLabelMap: SvelteMap<string, string>;
+    readonly groupedItems: [string, TItem[]][];
+};
+export {};