@casinogate/ui 1.11.14 → 2.0.1

package/dist/primitives/chip/components/chip.item.svelte

@@ -0,0 +1,65 @@
+<script lang="ts">
+  import { useId } from '../../../internal/utils/common.js';
+  import { cn } from '../../../internal/utils/tailwindcss.js';
+  import { ToggleGroup } from 'bits-ui';
+  import { ChipStylesContext, chipVariants } from '../styles.js';
+  import type { ChipItemProps, ChipItemSnippetProps } from '../types.js';
+
+  type ChildSnippetProps = ChipItemSnippetProps & {
+    props: Record<string, unknown>;
+  };
+
+  const uid = $props.id();
+
+  let {
+    ref = $bindable(null),
+    id = useId(uid),
+    value,
+    disabled = false,
+    children: childrenSnippet,
+    child: childSnippet,
+    icon,
+    class: className,
+    variant,
+    rounded,
+    size,
+    ...restProps
+  }: ChipItemProps = $props();
+
+  const styles = ChipStylesContext.getOr(undefined);
+
+  const trueDisabled = $derived(disabled ?? false);
+
+  const variants = $derived({
+    variant: variant ?? styles?.current.variant ?? 'fill',
+    rounded: rounded ?? styles?.current.rounded ?? 'full',
+    size: size ?? styles?.current.size ?? 'xs',
+    disabled: trueDisabled,
+  });
+
+  const classValue = $derived(cn(chipVariants(variants), className));
+</script>
+
+{#snippet customChild({ props, pressed }: ChildSnippetProps)}
+  {@render childSnippet?.({ props, pressed })}
+{/snippet}
+
+{#snippet defaultChild({ props, pressed }: ChildSnippetProps)}
+  <button {...props}>
+    {#if pressed && icon}
+      {@render icon({ pressed })}
+    {/if}
+
+    {@render childrenSnippet?.({ pressed })}
+  </button>
+{/snippet}
+
+<ToggleGroup.Item
+  bind:ref
+  {id}
+  {value}
+  {disabled}
+  class={classValue}
+  child={childSnippet ? customChild : defaultChild}
+  {...restProps as any}
+/>

package/dist/primitives/chip/components/chip.item.svelte.d.ts

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

package/dist/primitives/chip/components/chip.root.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+  import { cn } from '../../../internal/utils/tailwindcss.js';
+  import { ToggleGroup } from 'bits-ui';
+  import { box } from 'svelte-toolbelt';
+  import { ChipStylesContext, chipGroupVariants } from '../styles.js';
+  import type { ChipRootProps } from '../types.js';
+
+  type ChildSnippetProps = {
+    props: Record<string, unknown>;
+  };
+
+  let {
+    value = $bindable(),
+    ref = $bindable(null),
+    type = 'single',
+    disabled = false,
+    loop = true,
+    orientation = 'horizontal',
+    rovingFocus = true,
+    children: childrenSnippet,
+    child: childSnippet,
+    class: className,
+    variant = 'fill',
+    rounded = 'full',
+    size = 'xs',
+    onValueChange,
+    ...restProps
+  }: ChipRootProps = $props();
+
+  const variants = $derived({
+    variant,
+    rounded,
+    size,
+    disabled,
+  });
+
+  ChipStylesContext.set(box.with(() => variants));
+</script>
+
+{#snippet customChild({ props }: ChildSnippetProps)}
+  {@render childSnippet?.({ props })}
+{/snippet}
+
+{#snippet defaultChild({ props }: ChildSnippetProps)}
+  <div {...props}>
+    {@render childrenSnippet?.()}
+  </div>
+{/snippet}
+
+<ToggleGroup.Root
+  bind:value
+  bind:ref
+  {type}
+  {disabled}
+  {loop}
+  {orientation}
+  {rovingFocus}
+  {onValueChange}
+  class={cn(chipGroupVariants(), className)}
+  child={childSnippet ? customChild : defaultChild}
+  {...restProps as any}
+/>

package/dist/primitives/chip/components/chip.root.svelte.d.ts

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

package/dist/primitives/chip/components/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Group } from './chip.root.svelte';
+export { default as Item } from './chip.item.svelte';
+export { default as Root } from './chip.root.svelte';

package/dist/primitives/chip/components/index.js

@@ -0,0 +1,3 @@
+export { default as Group } from './chip.root.svelte';
+export { default as Item } from './chip.item.svelte';
+export { default as Root } from './chip.root.svelte';

package/dist/primitives/chip/index.d.ts

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

package/dist/primitives/chip/index.js

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

package/dist/primitives/chip/styles.d.ts

@@ -0,0 +1,81 @@
+import { Context } from 'runed';
+import type { ReadableBox } from 'svelte-toolbelt';
+import type { VariantProps } from 'tailwind-variants';
+export declare const chipGroupVariants: import("tailwind-variants").TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import("tailwind-variants").TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const chipVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        fill: string[];
+        outline: string[];
+    };
+    rounded: {
+        none: never[];
+        xs: string[];
+        sm: string[];
+        md: string[];
+        lg: string[];
+        xl: string[];
+        full: string[];
+    };
+    size: {
+        xs: string[];
+        sm: string[];
+        md: string[];
+        lg: string[];
+        xl: string[];
+    };
+    disabled: {
+        true: string[];
+    };
+}, undefined, string[], {
+    variant: {
+        fill: string[];
+        outline: string[];
+    };
+    rounded: {
+        none: never[];
+        xs: string[];
+        sm: string[];
+        md: string[];
+        lg: string[];
+        xl: string[];
+        full: string[];
+    };
+    size: {
+        xs: string[];
+        sm: string[];
+        md: string[];
+        lg: string[];
+        xl: string[];
+    };
+    disabled: {
+        true: string[];
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    variant: {
+        fill: string[];
+        outline: string[];
+    };
+    rounded: {
+        none: never[];
+        xs: string[];
+        sm: string[];
+        md: string[];
+        lg: string[];
+        xl: string[];
+        full: string[];
+    };
+    size: {
+        xs: string[];
+        sm: string[];
+        md: string[];
+        lg: string[];
+        xl: string[];
+    };
+    disabled: {
+        true: string[];
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+export type ChipVariants = VariantProps<typeof chipVariants>;
+type ChipStylesContextValue = ReadableBox<Required<ChipVariants>>;
+export declare const ChipStylesContext: Context<ChipStylesContextValue>;
+export {};

package/dist/primitives/chip/styles.js

@@ -0,0 +1,51 @@
+import { keyWithPrefix } from '../../internal/utils/common.js';
+import { tv } from '../../internal/utils/tailwindcss.js';
+import { Context } from 'runed';
+export const chipGroupVariants = tv({
+    base: ['cgui:flex cgui:flex-wrap cgui:items-center cgui:gap-2'],
+});
+export const chipVariants = tv({
+    base: [
+        'cgui:inline-flex cgui:items-center cgui:justify-center cgui:gap-1 cgui:text-center cgui:overflow-hidden cgui:shrink-0 cgui:w-fit cgui:whitespace-nowrap',
+        'cgui:transition-all cgui:duration-250 cgui:ease-in-out',
+        'cgui:select-none cgui:font-normal cgui:text-caption-2',
+        'cgui:cursor-pointer cgui:outline-none',
+        'cgui:focus-visible:ring-2 cgui:focus-visible:ring-stroke-primary cgui:focus-visible:ring-offset-2',
+        'cgui:data-[disabled=""]:opacity-50 cgui:data-[disabled=""]:cursor-not-allowed',
+        'cgui:[&>svg]:pointer-events-none',
+    ],
+    variants: {
+        variant: {
+            fill: ['cgui:bg-surface-semilight cgui:data-[state=on]:bg-surface-primary cgui:data-[state=on]:text-fg-white'],
+            outline: [
+                'cgui:border cgui:bg-transparent cgui:border-stroke-default cgui:data-[state=on]:border-stroke-primary cgui:data-[state=on]:bg-surface-primary/20 cgui:data-[state=on]:text-fg-primary',
+            ],
+        },
+        rounded: {
+            none: [],
+            xs: ['cgui:rounded-xs'],
+            sm: ['cgui:rounded-sm'],
+            md: ['cgui:rounded-md'],
+            lg: ['cgui:rounded-lg'],
+            xl: ['cgui:rounded-xl'],
+            full: ['cgui:rounded-full'],
+        },
+        size: {
+            xs: ['cgui:text-caption-2', 'cgui:px-1.5 cgui:py-0.5', 'cgui:[&>svg]:size-3'],
+            sm: ['cgui:text-caption', 'cgui:px-2 cgui:py-0.5', 'cgui:[&>svg]:size-5.5'],
+            md: ['cgui:text-body-2', 'cgui:px-2.5 cgui:py-0.5', 'cgui:[&>svg]:size-6'],
+            lg: ['cgui:text-body', 'cgui:px-3 cgui:py-1', 'cgui:[&>svg]:size-6.5'],
+            xl: ['cgui:text-heading-2', 'cgui:px-3.5 cgui:py-1', 'cgui:[&>svg]:size-7'],
+        },
+        disabled: {
+            true: ['cgui:opacity-50 cgui:cursor-not-allowed'],
+        },
+    },
+    defaultVariants: {
+        variant: 'fill',
+        rounded: 'full',
+        size: 'xs',
+        disabled: false,
+    },
+});
+export const ChipStylesContext = new Context(keyWithPrefix('chip-styles'));

package/dist/primitives/chip/types.d.ts

@@ -0,0 +1,22 @@
+import type { WithVariants } from '../../internal/types/composition.js';
+import { ToggleGroup } from 'bits-ui';
+import type { ToggleGroupItemSnippetProps as UIToggleGroupItemSnippetProps } from 'bits-ui';
+import type { Snippet } from 'svelte';
+import type { ChipVariants } from './styles.js';
+export type ChipItemSnippetProps = UIToggleGroupItemSnippetProps;
+type ChipItemOwnProps = {
+    icon?: Snippet<[ChipItemSnippetProps]> | null;
+};
+export type ChipItemProps = WithVariants<ToggleGroup.ItemProps, ChipVariants> & ChipItemOwnProps;
+type ToggleGroupSingleRootProps = Extract<ToggleGroup.RootProps, {
+    type: 'single';
+}>;
+type ToggleGroupMultipleRootProps = Extract<ToggleGroup.RootProps, {
+    type: 'multiple';
+}>;
+type ChipSingleRootProps = Omit<ToggleGroupSingleRootProps, 'type'> & {
+    type?: 'single';
+};
+export type ChipRootProps = WithVariants<ChipSingleRootProps, ChipVariants> | WithVariants<ToggleGroupMultipleRootProps, ChipVariants>;
+export type ChipGroupProps = ChipRootProps;
+export {};

package/dist/primitives/chip/types.js

@@ -0,0 +1 @@
+import { ToggleGroup } from 'bits-ui';

package/dist/primitives/collapsible/components/collapsaible.content.svelte

@@ -0,0 +1,39 @@
+<script lang="ts">
+  import { useId } from '../../../internal/utils/common.js';
+  import { cn } from '../../../internal/utils/tailwindcss.js';
+
+  import { Collapsible as CollapsiblePrimitive } from 'bits-ui';
+  import { fade } from 'svelte/transition';
+  import { collapsibleContentVariants } from '../styles.js';
+  import type { CollapsibleContentProps } from '../types.js';
+
+  const uid = $props.id();
+
+  let {
+    ref = $bindable(null),
+    id = useId(uid),
+    forceMount = true,
+    class: className,
+    child: childSnippet,
+    children,
+    ...restProps
+  }: CollapsibleContentProps = $props();
+</script>
+
+<CollapsiblePrimitive.Content
+  bind:ref
+  {id}
+  class={cn(collapsibleContentVariants(), className)}
+  {forceMount}
+  {...restProps}
+>
+  {#snippet child(childProps)}
+    {#if childSnippet}
+      {@render childSnippet?.(childProps)}
+    {:else if childProps.open}
+      <div {...childProps.props} transition:fade={{ duration: 250 }}>
+        {@render children?.()}
+      </div>
+    {/if}
+  {/snippet}
+</CollapsiblePrimitive.Content>

package/dist/primitives/collapsible/components/collapsaible.content.svelte.d.ts

@@ -0,0 +1,4 @@
+import { Collapsible as CollapsiblePrimitive } from 'bits-ui';
+declare const Collapsaible: import("svelte").Component<CollapsiblePrimitive.ContentProps, {}, "ref">;
+type Collapsaible = ReturnType<typeof Collapsaible>;
+export default Collapsaible;

package/dist/primitives/collapsible/components/collapsaible.root.svelte

@@ -0,0 +1,60 @@
+<script lang="ts">
+  import { useId } from '../../../internal/utils/common.js';
+  import { cn } from '../../../internal/utils/tailwindcss.js';
+  import { Collapsible as CollapsiblePrimitive } from 'bits-ui';
+  import { box, mergeProps } from 'svelte-toolbelt';
+  import { CollapsibleStylesContext, collapsibleRootVariants } from '../styles.js';
+  import type { CollapsibleRootProps } from '../types.js';
+  import { CollapsibleGroupContext, CollapsibleRootState } from './collapsaible.svelte.js';
+
+  const uid = $props.id();
+
+  let {
+    open = $bindable(false),
+    ref = $bindable(null),
+    id = useId(uid),
+    disabled,
+    class: className,
+    variant = 'default',
+    iconPosition = 'start',
+    ...restProps
+  }: CollapsibleRootProps = $props();
+
+  const group = CollapsibleGroupContext.getOr(null);
+
+  if (group) {
+    if (group.opts.value.current.includes(id)) {
+      open = true;
+    } else {
+      open = false;
+    }
+  }
+
+  const rootState = CollapsibleRootState.create(
+    {
+      value: box.with(
+        () => open,
+        (v) => (open = v)
+      ),
+      ref: box.with(
+        () => ref,
+        (v) => (ref = v)
+      ),
+      disabled: box.with(() => disabled ?? false),
+      id: box.with(() => id),
+    },
+    group
+  );
+
+  const variants = $derived({ variant, iconPosition });
+
+  CollapsibleStylesContext.set(box.with(() => variants));
+
+  const mergedProps = $derived(mergeProps(restProps, rootState.props));
+</script>
+
+<CollapsiblePrimitive.Root
+  bind:open={rootState.opts.value.current}
+  class={cn(collapsibleRootVariants({ variant }), className)}
+  {...mergedProps}
+/>

package/dist/primitives/collapsible/components/collapsaible.root.svelte.d.ts

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

package/dist/primitives/collapsible/components/collapsaible.svelte.d.ts

@@ -0,0 +1,55 @@
+import type { OnChangeFn, RefAttachment } from '../../../internal/types/common.js';
+import { Context } from 'runed';
+import { type ReadableBoxedValues, type WithRefProps, type WritableBoxedValues } from 'svelte-toolbelt';
+import type { CollapsibleOpenVariant } from '../types.js';
+export declare const CollapsibleGroupContext: Context<CollapsibleGroupState>;
+type CollapsibleGroupStateOpts = WithRefProps<WritableBoxedValues<{
+    value: string[];
+}> & ReadableBoxedValues<{
+    variant: CollapsibleOpenVariant;
+    disabled: boolean;
+    onValueChange: OnChangeFn<string[]>;
+}>>;
+export declare class CollapsibleGroupState {
+    static create(opts: CollapsibleGroupStateOpts): CollapsibleGroupState;
+    readonly opts: CollapsibleGroupStateOpts;
+    readonly attachment: RefAttachment;
+    constructor(opts: CollapsibleGroupStateOpts);
+    addValue(value: string | undefined): void;
+    removeValue(value: string | undefined): void;
+    readonly props: {
+        readonly id: string;
+        readonly 'data-disabled': "" | undefined;
+        readonly role: "group";
+    };
+}
+type CollapsibleRootStateOpts = WithRefProps<WritableBoxedValues<{
+    value: boolean;
+}> & ReadableBoxedValues<{
+    disabled: boolean;
+}>>;
+export declare class CollapsibleRootState {
+    static create(opts: CollapsibleRootStateOpts, group: CollapsibleGroupState | null): CollapsibleRootState;
+    readonly opts: CollapsibleRootStateOpts;
+    readonly group: CollapsibleGroupState | null;
+    readonly attachment: RefAttachment;
+    readonly trueDisabled: boolean;
+    constructor(opts: CollapsibleRootStateOpts, group: CollapsibleGroupState | null);
+    readonly props: {
+        readonly id: string;
+        readonly disabled: boolean;
+        readonly 'data-disabled': "" | undefined;
+    };
+}
+export type CollapsibleTriggerStateOpts = WithRefProps<{}>;
+export declare class CollapsibleTriggerState {
+    static create(opts: CollapsibleTriggerStateOpts): CollapsibleTriggerState;
+    readonly opts: CollapsibleTriggerStateOpts;
+    readonly attachment: RefAttachment;
+    readonly root: CollapsibleRootState;
+    constructor(opts: CollapsibleTriggerStateOpts, root: CollapsibleRootState);
+    readonly props: {
+        readonly [x: symbol]: (node: HTMLElement) => () => void;
+    };
+}
+export {};

package/dist/primitives/collapsible/components/collapsaible.svelte.js

@@ -0,0 +1,108 @@
+import { getDataDisabled } from '../../../internal/utils/attrs.js';
+import { keyWithPrefix } from '../../../internal/utils/common.js';
+import { isEqual } from '../../../internal/utils/equal.js';
+import { Context, watch } from 'runed';
+import { attachRef } from 'svelte-toolbelt';
+const CollapsibleRootContext = new Context(keyWithPrefix('collapsible-root'));
+export const CollapsibleGroupContext = new Context(keyWithPrefix('collapsible-group'));
+export class CollapsibleGroupState {
+    static create(opts) {
+        return CollapsibleGroupContext.set(new CollapsibleGroupState(opts));
+    }
+    opts;
+    attachment;
+    constructor(opts) {
+        this.opts = opts;
+        this.attachment = attachRef(opts.ref);
+    }
+    addValue(value) {
+        if (!value)
+            return;
+        if (this.opts.value.current.includes(value))
+            return;
+        let newValue = [];
+        if (this.opts.variant.current === 'single') {
+            newValue = [value];
+        }
+        else {
+            newValue = [...$state.snapshot(this.opts.value.current), value];
+        }
+        this.opts.value.current = newValue;
+        if (isEqual(this.opts.value.current, newValue))
+            return;
+        this.opts.onValueChange.current(newValue);
+    }
+    removeValue(value) {
+        if (!value)
+            return;
+        const idx = this.opts.value.current.indexOf(value);
+        if (idx === -1)
+            return;
+        const newValue = this.opts.value.current.filter((v) => v !== value);
+        this.opts.value.current = newValue;
+        if (isEqual(this.opts.value.current, newValue))
+            return;
+        this.opts.onValueChange.current(newValue);
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        'data-disabled': getDataDisabled(this.opts.disabled.current),
+        role: 'group',
+        ...this.attachment,
+    }));
+}
+export class CollapsibleRootState {
+    static create(opts, group) {
+        return CollapsibleRootContext.set(new CollapsibleRootState(opts, group));
+    }
+    opts;
+    group;
+    attachment;
+    trueDisabled = $derived.by(() => {
+        if (this.group && this.group.opts.disabled.current)
+            return true;
+        return this.opts.disabled.current;
+    });
+    constructor(opts, group) {
+        this.opts = opts;
+        this.group = group;
+        this.attachment = attachRef(opts.ref);
+        watch.pre([() => $state.snapshot(this.group?.opts.value.current), () => this.opts.value.current], ([groupValue, value]) => {
+            if (!groupValue || !value)
+                return;
+            this.opts.value.current = groupValue.includes(this.opts.id.current);
+        });
+        watch.pre([() => this.opts.value.current], ([value]) => {
+            if (!value)
+                return;
+            if (value) {
+                this.group?.addValue(this.opts.id.current);
+            }
+            else {
+                this.group?.removeValue(this.opts.id.current);
+            }
+        });
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        disabled: this.trueDisabled,
+        'data-disabled': getDataDisabled(this.trueDisabled),
+        ...this.attachment,
+    }));
+}
+export class CollapsibleTriggerState {
+    static create(opts) {
+        return new CollapsibleTriggerState(opts, CollapsibleRootContext.get());
+    }
+    opts;
+    attachment;
+    root;
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        this.attachment = attachRef(opts.ref);
+    }
+    props = $derived.by(() => ({
+        ...this.attachment,
+    }));
+}

package/dist/primitives/collapsible/components/collapsaible.trigger.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">
+  import { Icon } from '../../../atomic/icons/index.js';
+  import { useId } from '../../../internal/utils/common.js';
+  import { cn } from '../../../internal/utils/tailwindcss.js';
+
+  import { Collapsible as CollapsiblePrimitive } from 'bits-ui';
+  import { boxWith, mergeProps } from 'svelte-toolbelt';
+  import { CollapsibleStylesContext, collapsibleIconVariants, collapsibleTriggerVariants } from '../styles.js';
+  import type { CollapsibleTriggerProps } from '../types.js';
+  import { CollapsibleTriggerState } from './collapsaible.svelte.js';
+
+  const uid = $props.id();
+
+  let {
+    ref = $bindable(null),
+    id = useId(uid),
+    class: className,
+    variant,
+    iconPosition,
+    child: childSnippet,
+    children: childrenSnippet,
+    icon: iconSnippet,
+    ...restProps
+  }: CollapsibleTriggerProps = $props();
+
+  const triggerState = CollapsibleTriggerState.create({
+    ref: boxWith(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: boxWith(() => id),
+  });
+
+  const styles = CollapsibleStylesContext.get();
+  const variants = $derived({
+    variant: variant ?? styles.current.variant,
+    iconPosition: iconPosition ?? styles.current.iconPosition,
+  });
+
+  const mergedProps = $derived(mergeProps(restProps, triggerState.props));
+</script>
+
+<CollapsiblePrimitive.Trigger
+  bind:ref
+  {id}
+  class={cn(collapsibleTriggerVariants(variants), className)}
+  {...mergedProps}
+>
+  {#snippet child({ props: childProps })}
+    {#if childSnippet}
+      {@render childSnippet?.({ props: childProps, open: triggerState.root.opts.value.current })}
+    {:else}
+      <button {...childProps}>
+        {#if iconSnippet !== null}
+          <span data-slot="icon" class={collapsibleIconVariants({ variant: variants.variant })}>
+            {#if iconSnippet}
+              {@render iconSnippet?.()}
+            {:else}
+              <Icon.ChevronSmallRight />
+            {/if}
+          </span>
+        {/if}
+
+        {@render childrenSnippet?.({ open: triggerState.root.opts.value.current })}
+      </button>
+    {/if}
+  {/snippet}
+</CollapsiblePrimitive.Trigger>

package/dist/primitives/collapsible/components/collapsaible.trigger.svelte.d.ts

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

package/dist/primitives/collapsible/components/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Content } from './collapsaible.content.svelte';
+export { default as Root } from './collapsaible.root.svelte';
+export { default as Trigger } from './collapsaible.trigger.svelte';

package/dist/primitives/collapsible/components/index.js

@@ -0,0 +1,3 @@
+export { default as Content } from './collapsaible.content.svelte';
+export { default as Root } from './collapsaible.root.svelte';
+export { default as Trigger } from './collapsaible.trigger.svelte';