@casinogate/ui 1.2.0 → 1.3.0

package/dist/components/collapsible/styles.js

@@ -6,22 +6,41 @@ export const collapsibleVariants = tv({
         root: [
             'cgui:relative cgui:overflow-hidden',
             'cgui:w-full',
-            'cgui:bg-surface-lightest',
-            'cgui:border cgui:border-stroke-divider cgui:rounded-sm',
             'cgui:transition-all cgui:duration-250 cgui:ease-in-out',
-            'cgui:hover:bg-surface-primary-light cgui:hover:[&_[data-slot=icon]]:text-icon-focus',
             'cgui:data-[disabled]:opacity-50 cgui:data-[disabled]:cursor-not-allowed cgui:data-[disabled]:pointer-events-none',
         ],
         trigger: [
             'cgui:w-full cgui:text-left cgui:py-1.5 cgui:px-2 cgui:flex cgui:items-center cgui:gap-1',
-            'cgui:cursor-pointer cgui:text-fg-darkest cgui:font-normal cgui:text-body-2',
+            'cgui:cursor-pointer cgui:font-normal cgui:text-body-2',
             'cgui:data-[state=open]:[&_[data-slot=icon]]:rotate-90',
         ],
         icon: [
-            'cgui:relative cgui:inline-flex cgui:size-6 cgui:items-center cgui:justify-center cgui:shrink-0 cgui:text-icon-regular',
+            'cgui:relative cgui:inline-flex cgui:size-6 cgui:items-center cgui:justify-center cgui:shrink-0 ',
             'cgui:transition-all cgui:duration-250 cgui:ease-in-out',
         ],
         content: ['cgui:px-2 cgui:pb-1.5', 'cgui:text-fg-medium cgui:text-body-2'],
     },
+    variants: {
+        variant: {
+            default: {
+                root: [
+                    'cgui:bg-surface-lightest',
+                    'cgui:border cgui:border-stroke-divider cgui:rounded-sm',
+                    'cgui:hover:bg-surface-primary-light cgui:hover:[&_[data-slot=icon]]:text-icon-focus',
+                ],
+                trigger: ['cgui:text-fg-darkest'],
+                icon: ['cgui:text-icon-regular'],
+            },
+            clean: {},
+        },
+        iconPosition: {
+            start: {
+                trigger: ['cgui:flex-row'],
+            },
+            end: {
+                trigger: ['cgui:flex-row-reverse cgui:justify-end'],
+            },
+        },
+    },
 });
 export const CollapsibleStylesContext = new Context(keyWithPrefix('collapsible-styles'));

package/dist/components/navigation/components/navigation.content.svelte

@@ -0,0 +1,44 @@
+<script lang="ts" module>
+  import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+  import { boxWith, mergeProps, type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+
+  type NavigationContentPropsWithoutHTML = WithElementRef<WithChild<{}>>;
+
+  export type NavigationContentProps = NavigationContentPropsWithoutHTML &
+    Without<PrimitiveElementAttributes, NavigationContentPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { NavigationStylesContext } from '../styles.js';
+  import { cn, useId } from '../../../internal/utils/common.js';
+  import { NavigationContentState } from './navigation.svelte.js';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    children,
+    child,
+    class: className,
+    ...restProps
+  }: NavigationContentProps = $props();
+
+  const contentState = NavigationContentState.create({
+    ref: boxWith(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: boxWith(() => id),
+  });
+
+  const mergedProps = $derived(
+    mergeProps(restProps, contentState.props, { class: cn(NavigationStylesContext.get().current.content(), className) })
+  );
+</script>
+
+{#if child}
+  {@render child({ props: mergedProps })}
+{:else}
+  <ul {...mergedProps}>
+    {@render children?.()}
+  </ul>
+{/if}

package/dist/components/navigation/components/navigation.content.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+type NavigationContentPropsWithoutHTML = WithElementRef<WithChild<{}>>;
+export type NavigationContentProps = NavigationContentPropsWithoutHTML & Without<PrimitiveElementAttributes, NavigationContentPropsWithoutHTML>;
+declare const Navigation: import("svelte").Component<NavigationContentProps, {}, "ref">;
+type Navigation = ReturnType<typeof Navigation>;
+export default Navigation;

package/dist/components/navigation/components/navigation.item.svelte

@@ -0,0 +1,55 @@
+<script lang="ts" module>
+  type NavigationItemPropsWithoutHTML = WithElementRef<WithChild<{}>>;
+
+  export type NavigationItemProps = NavigationItemPropsWithoutHTML &
+    Without<PrimitiveElementAttributes, NavigationItemPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { CollapsiblePrimitive } from '../../collapsible/index.js';
+  import { NavigationStylesContext } from '../styles.js';
+  import { PopoverPrimitive } from '../../popover/index.js';
+  import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn, useId } from '../../../internal/utils/common.js';
+  import { boxWith, mergeProps, type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+  import { NavigationItemState } from './navigation.svelte.js';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    children,
+    child,
+    class: className,
+    ...restProps
+  }: NavigationItemProps = $props();
+
+  const itemState = NavigationItemState.create({
+    ref: boxWith(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: boxWith(() => id),
+  });
+
+  const mergedProps = $derived(
+    mergeProps(restProps, itemState.props, { class: cn(NavigationStylesContext.get().current.item(), className) })
+  );
+</script>
+
+{#if child}
+  {@render child({ props: mergedProps })}
+{:else if itemState.root.isCompact}
+  <li {...mergedProps}>
+    <PopoverPrimitive.Root>
+      {@render children?.()}
+    </PopoverPrimitive.Root>
+  </li>
+{:else}
+  <CollapsiblePrimitive.Root variant="clean">
+    {#snippet child({ props: childProps })}
+      <li {...mergedProps} {...childProps}>
+        {@render children?.()}
+      </li>
+    {/snippet}
+  </CollapsiblePrimitive.Root>
+{/if}

package/dist/components/navigation/components/navigation.item.svelte.d.ts

@@ -0,0 +1,7 @@
+type NavigationItemPropsWithoutHTML = WithElementRef<WithChild<{}>>;
+export type NavigationItemProps = NavigationItemPropsWithoutHTML & Without<PrimitiveElementAttributes, NavigationItemPropsWithoutHTML>;
+import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const Navigation: import("svelte").Component<NavigationItemProps, {}, "ref">;
+type Navigation = ReturnType<typeof Navigation>;
+export default Navigation;

package/dist/components/navigation/components/navigation.root.svelte

@@ -0,0 +1,49 @@
+<script lang="ts" module>
+  type NavigationRootPropsWithoutHTML = WithElementRef<WithChild<{}, { compact: boolean }>> & NavigationVariantsProps;
+
+  export type NavigationRootProps = NavigationRootPropsWithoutHTML &
+    Without<PrimitiveElementAttributes, NavigationRootPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { NavigationStylesContext, navigationVariants, type NavigationVariantsProps } from '../styles.js';
+
+  import { NavigationRootState } from './navigation.svelte.js';
+
+  import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn, useId } from '../../../internal/utils/common.js';
+  import { box, mergeProps, type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    children,
+    child,
+    class: className,
+    compact = false,
+    ...restProps
+  }: NavigationRootProps = $props();
+
+  const rootState = NavigationRootState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+    compact: box.with(() => compact),
+  });
+
+  const variants = $derived(navigationVariants({ compact }));
+
+  NavigationStylesContext.set(box.with(() => variants));
+
+  const mergedProps = $derived(mergeProps(restProps, rootState.props, { class: cn(variants.root(), className) }));
+</script>
+
+{#if child}
+  {@render child({ props: mergedProps, compact })}
+{:else}
+  <nav {...mergedProps}>
+    {@render children?.({ compact })}
+  </nav>
+{/if}

package/dist/components/navigation/components/navigation.root.svelte.d.ts

@@ -0,0 +1,10 @@
+type NavigationRootPropsWithoutHTML = WithElementRef<WithChild<{}, {
+    compact: boolean;
+}>> & NavigationVariantsProps;
+export type NavigationRootProps = NavigationRootPropsWithoutHTML & Without<PrimitiveElementAttributes, NavigationRootPropsWithoutHTML>;
+import { type NavigationVariantsProps } from '../styles.js';
+import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const Navigation: import("svelte").Component<NavigationRootProps, {}, "ref">;
+type Navigation = ReturnType<typeof Navigation>;
+export default Navigation;

package/dist/components/navigation/components/navigation.sub-content.svelte

@@ -0,0 +1,70 @@
+<script lang="ts" module>
+  import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+  import { boxWith, mergeProps, type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+
+  type NavigationSubContentPropsWithoutHTML = WithElementRef<WithChild<{}, { compact: boolean }>>;
+
+  export type NavigationSubContentProps = NavigationSubContentPropsWithoutHTML &
+    Without<PrimitiveElementAttributes, NavigationSubContentPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { CollapsiblePrimitive } from '../../collapsible/index.js';
+  import { NavigationStylesContext } from '../styles.js';
+  import { PopoverPrimitive } from '../../popover/index.js';
+  import { cn, useId } from '../../../internal/utils/common.js';
+  import { cubicInOut } from 'svelte/easing';
+  import { fade, fly } from 'svelte/transition';
+  import { NavigationSubContentState } from './navigation.svelte.js';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    children,
+    child,
+    class: className,
+    ...restProps
+  }: NavigationSubContentProps = $props();
+
+  const subContentState = NavigationSubContentState.create({
+    ref: boxWith(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: boxWith(() => id),
+  });
+
+  const mergedProps = $derived(
+    mergeProps(restProps, subContentState.props, {
+      class: cn(NavigationStylesContext.get().current.subContent(), className),
+    })
+  );
+</script>
+
+{#if child}
+  {@render child({ props: mergedProps, compact: subContentState.root.isCompact })}
+{:else if subContentState.root.isCompact}
+  <PopoverPrimitive.Portal>
+    <PopoverPrimitive.Content side="right" sideOffset={8} forceMount>
+      {#snippet child({ props: childProps, wrapperProps, open })}
+        {#if open}
+          <div {...wrapperProps}>
+            <ul {...childProps} {...mergedProps} transition:fly={{ duration: 250, easing: cubicInOut, x: 10 }}>
+              {@render children?.({ compact: subContentState.root.isCompact })}
+            </ul>
+          </div>
+        {/if}
+      {/snippet}
+    </PopoverPrimitive.Content>
+  </PopoverPrimitive.Portal>
+{:else}
+  <CollapsiblePrimitive.Content {...mergedProps}>
+    {#snippet child({ props: childProps, open })}
+      {#if open}
+        <ul {...childProps} {...mergedProps} transition:fade={{ duration: 250, easing: cubicInOut }}>
+          {@render children?.({ compact: subContentState.root.isCompact })}
+        </ul>
+      {/if}
+    {/snippet}
+  </CollapsiblePrimitive.Content>
+{/if}

package/dist/components/navigation/components/navigation.sub-content.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+type NavigationSubContentPropsWithoutHTML = WithElementRef<WithChild<{}, {
+    compact: boolean;
+}>>;
+export type NavigationSubContentProps = NavigationSubContentPropsWithoutHTML & Without<PrimitiveElementAttributes, NavigationSubContentPropsWithoutHTML>;
+declare const Navigation: import("svelte").Component<NavigationSubContentProps, {}, "ref">;
+type Navigation = ReturnType<typeof Navigation>;
+export default Navigation;

package/dist/components/navigation/components/navigation.svelte.d.ts

@@ -0,0 +1,82 @@
+import type { RefAttachment } from '../../../internal/types/common.js';
+import { type ReadableBoxedValues, type WithRefProps } from 'svelte-toolbelt';
+type NavigationRootStateOpts = WithRefProps<ReadableBoxedValues<{
+    compact: boolean;
+}>>;
+export declare class NavigationRootState {
+    static create(opts: NavigationRootStateOpts): NavigationRootState;
+    readonly opts: NavigationRootStateOpts;
+    readonly attachment: RefAttachment;
+    readonly isCompact: boolean;
+    constructor(opts: NavigationRootStateOpts);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "root";
+        readonly role: "navigation";
+        readonly 'data-compact': boolean;
+    };
+}
+type NavigationContentStateOpts = WithRefProps<{}>;
+export declare class NavigationContentState {
+    static create(opts: NavigationContentStateOpts): NavigationContentState;
+    readonly opts: NavigationContentStateOpts;
+    readonly attachment: RefAttachment;
+    readonly root: NavigationRootState;
+    constructor(opts: NavigationContentStateOpts, root: NavigationRootState);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "content";
+        readonly role: "list";
+    };
+}
+type NavigationItemStateOpts = WithRefProps<{}>;
+export declare class NavigationItemState {
+    #private;
+    static create(opts: NavigationItemStateOpts): NavigationItemState;
+    readonly opts: NavigationItemStateOpts;
+    readonly attachment: RefAttachment;
+    readonly root: NavigationRootState;
+    constructor(opts: NavigationItemStateOpts, root: NavigationRootState);
+    get hasSubContent(): boolean;
+    set hasSubContent(value: boolean);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "item";
+        readonly 'data-compact': boolean;
+        readonly role: "listitem";
+    };
+}
+type NavigationTriggerStateOpts = WithRefProps<ReadableBoxedValues<{
+    disabled: boolean;
+}>>;
+export declare class NavigationTriggerState {
+    static create(opts: NavigationTriggerStateOpts): NavigationTriggerState;
+    readonly opts: NavigationTriggerStateOpts;
+    readonly attachment: RefAttachment;
+    readonly root: NavigationRootState;
+    readonly item: NavigationItemState;
+    constructor(opts: NavigationTriggerStateOpts, root: NavigationRootState, item: NavigationItemState);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "trigger";
+        readonly role: "button";
+        readonly tabindex: 0;
+        readonly 'data-disabled': "" | undefined;
+    };
+}
+type NavigationSubContentStateOpts = WithRefProps<{}>;
+export declare class NavigationSubContentState {
+    static create(opts: NavigationSubContentStateOpts): NavigationSubContentState;
+    readonly opts: NavigationSubContentStateOpts;
+    readonly attachment: RefAttachment;
+    readonly root: NavigationRootState;
+    readonly item: NavigationItemState;
+    constructor(opts: NavigationSubContentStateOpts, root: NavigationRootState, item: NavigationItemState);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "sub-content";
+        readonly 'data-compact': boolean;
+        readonly role: "list";
+    };
+}
+export {};

package/dist/components/navigation/components/navigation.svelte.js

@@ -0,0 +1,128 @@
+import { SLOT_ATTR_NAME } from '../../../internal/constants/attrs.js';
+import { boolAttr } from '../../../internal/utils/attrs.js';
+import { keyWithPrefix } from '../../../internal/utils/common.js';
+import { Context } from 'runed';
+import { attachRef } from 'svelte-toolbelt';
+const NavigationRootStateCtx = new Context(keyWithPrefix('navigation-root'));
+const NavigationItemStateCtx = new Context(keyWithPrefix('navigation-item'));
+const SLOT_ATTR_VALUES = {
+    root: 'root',
+    content: 'content',
+    subContent: 'sub-content',
+    item: 'item',
+    trigger: 'trigger',
+};
+export class NavigationRootState {
+    static create(opts) {
+        return NavigationRootStateCtx.set(new NavigationRootState(opts));
+    }
+    opts;
+    attachment;
+    isCompact = $derived.by(() => this.opts.compact.current);
+    constructor(opts) {
+        this.opts = opts;
+        this.attachment = attachRef(opts.ref);
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        [SLOT_ATTR_NAME]: SLOT_ATTR_VALUES.root,
+        role: 'navigation',
+        'data-compact': this.isCompact,
+        ...this.attachment,
+    }));
+}
+export class NavigationContentState {
+    static create(opts) {
+        return new NavigationContentState(opts, NavigationRootStateCtx.get());
+    }
+    opts;
+    attachment;
+    root;
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        this.attachment = attachRef(opts.ref);
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        [SLOT_ATTR_NAME]: SLOT_ATTR_VALUES.content,
+        role: 'list',
+        ...this.attachment,
+    }));
+}
+export class NavigationItemState {
+    static create(opts) {
+        return NavigationItemStateCtx.set(new NavigationItemState(opts, NavigationRootStateCtx.get()));
+    }
+    opts;
+    attachment;
+    root;
+    #hasSubContent = $state(false);
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        this.attachment = attachRef(opts.ref);
+    }
+    get hasSubContent() {
+        return this.#hasSubContent;
+    }
+    set hasSubContent(value) {
+        this.#hasSubContent = value;
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        [SLOT_ATTR_NAME]: SLOT_ATTR_VALUES.item,
+        'data-compact': this.root.isCompact,
+        role: 'listitem',
+        ...this.attachment,
+    }));
+}
+export class NavigationTriggerState {
+    static create(opts) {
+        return new NavigationTriggerState(opts, NavigationRootStateCtx.get(), NavigationItemStateCtx.get());
+    }
+    opts;
+    attachment;
+    root;
+    item;
+    constructor(opts, root, item) {
+        this.opts = opts;
+        this.root = root;
+        this.item = item;
+        this.attachment = attachRef(opts.ref);
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        [SLOT_ATTR_NAME]: SLOT_ATTR_VALUES.trigger,
+        role: 'button',
+        tabindex: 0,
+        'data-disabled': boolAttr(this.opts.disabled.current),
+        ...this.attachment,
+    }));
+}
+export class NavigationSubContentState {
+    static create(opts) {
+        return new NavigationSubContentState(opts, NavigationRootStateCtx.get(), NavigationItemStateCtx.get());
+    }
+    opts;
+    attachment;
+    root;
+    item;
+    constructor(opts, root, item) {
+        this.opts = opts;
+        this.root = root;
+        this.item = item;
+        this.attachment = attachRef(opts.ref);
+        this.item.hasSubContent = true;
+        $effect.pre(() => {
+            this.item.hasSubContent = true;
+        });
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        [SLOT_ATTR_NAME]: SLOT_ATTR_VALUES.subContent,
+        'data-compact': this.root.isCompact,
+        role: 'list',
+        ...this.attachment,
+    }));
+}

package/dist/components/navigation/components/navigation.trigger.svelte

@@ -0,0 +1,89 @@
+<script lang="ts" module>
+  type NavigationTriggerPropsWithoutHTML = WithElementRef<
+    WithChild<
+      {
+        href?: string;
+
+        disabled?: boolean;
+      },
+      {
+        compact: boolean;
+      }
+    >
+  >;
+
+  export type NavigationTriggerProps = NavigationTriggerPropsWithoutHTML &
+    Without<PrimitiveElementAttributes, NavigationTriggerPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { CollapsiblePrimitive } from '../../collapsible/index.js';
+  import ChevronDown from '../../icons/chevron-down.svelte';
+  import { NavigationStylesContext } from '../styles.js';
+  import { PopoverPrimitive } from '../../popover/index.js';
+  import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn, useId } from '../../../internal/utils/common.js';
+  import type { WithChild, WithElementRef, Without } from 'svelte-toolbelt';
+  import { boxWith, mergeProps } from 'svelte-toolbelt';
+  import { NavigationTriggerState } from './navigation.svelte.js';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    children,
+    child,
+    class: className,
+    href,
+    disabled = false,
+    ...restProps
+  }: NavigationTriggerProps = $props();
+
+  const triggerState = NavigationTriggerState.create({
+    ref: boxWith(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: boxWith(() => id),
+    disabled: boxWith(() => disabled),
+  });
+
+  const mergedProps = $derived(
+    mergeProps(restProps, triggerState.props, { class: cn(NavigationStylesContext.get().current.trigger(), className) })
+  );
+
+  const sharedProps = $derived({
+    compact: triggerState.root.isCompact,
+  });
+</script>
+
+{#if child}
+  {@render child({ props: mergedProps, ...sharedProps })}
+{:else if href}
+  <a {href} {...mergedProps}>
+    {@render children?.(sharedProps)}
+  </a>
+{:else if triggerState.item.hasSubContent && triggerState.root.isCompact}
+  <PopoverPrimitive.Trigger>
+    {#snippet child({ props: childProps })}
+      <button {...childProps} {...mergedProps} data-type="popover-trigger">
+        {@render children?.(sharedProps)}
+      </button>
+    {/snippet}
+  </PopoverPrimitive.Trigger>
+{:else if triggerState.item.hasSubContent && !triggerState.root.isCompact}
+  <CollapsiblePrimitive.Trigger>
+    {#snippet child({ props: childProps })}
+      <button {...childProps} {...mergedProps} data-type="collapsible-trigger">
+        {@render children?.(sharedProps)}
+
+        <span class="cgui:flex cgui:items-center cgui:justify-center cgui:size-5 cgui:shrink-0">
+          <ChevronDown width={20} height={20} />
+        </span>
+      </button>
+    {/snippet}
+  </CollapsiblePrimitive.Trigger>
+{:else}
+  <button {...mergedProps}>
+    {@render children?.(sharedProps)}
+  </button>
+{/if}

package/dist/components/navigation/components/navigation.trigger.svelte.d.ts

@@ -0,0 +1,12 @@
+type NavigationTriggerPropsWithoutHTML = WithElementRef<WithChild<{
+    href?: string;
+    disabled?: boolean;
+}, {
+    compact: boolean;
+}>>;
+export type NavigationTriggerProps = NavigationTriggerPropsWithoutHTML & Without<PrimitiveElementAttributes, NavigationTriggerPropsWithoutHTML>;
+import type { PrimitiveElementAttributes } from '../../../internal/types/html-attributes.js';
+import type { WithChild, WithElementRef, Without } from 'svelte-toolbelt';
+declare const Navigation: import("svelte").Component<NavigationTriggerProps, {}, "ref">;
+type Navigation = ReturnType<typeof Navigation>;
+export default Navigation;

package/dist/components/navigation/index.d.ts

@@ -0,0 +1,12 @@
+import { type NavigationContentProps } from './components/navigation.content.svelte';
+import { type NavigationItemProps } from './components/navigation.item.svelte';
+import { type NavigationRootProps } from './components/navigation.root.svelte';
+import { type NavigationSubContentProps } from './components/navigation.sub-content.svelte';
+export declare const NavigationPrimitive: {
+    readonly Root: import("svelte").Component<NavigationRootProps, {}, "ref">;
+    readonly Trigger: import("svelte").Component<import("./components/navigation.trigger.svelte").NavigationTriggerProps, {}, "ref">;
+    readonly Content: import("svelte").Component<NavigationContentProps, {}, "ref">;
+    readonly Item: import("svelte").Component<NavigationItemProps, {}, "ref">;
+    readonly SubContent: import("svelte").Component<NavigationSubContentProps, {}, "ref">;
+};
+export type { NavigationContentProps, NavigationItemProps, NavigationRootProps, NavigationSubContentProps };

package/dist/components/navigation/index.js

@@ -0,0 +1,12 @@
+import Content, {} from './components/navigation.content.svelte';
+import Item, {} from './components/navigation.item.svelte';
+import Root, {} from './components/navigation.root.svelte';
+import SubContent, {} from './components/navigation.sub-content.svelte';
+import Trigger from './components/navigation.trigger.svelte';
+export const NavigationPrimitive = {
+    Root,
+    Trigger,
+    Content,
+    Item,
+    SubContent,
+};