sheer-ui 0.4.2 → 0.5.0

package/dist/components/popover/popover.svelte.js

@@ -0,0 +1,301 @@
+import { createContext, untrack } from 'svelte';
+import { attachRef } from '../../internal/tools/index.js';
+import { kbd } from '../../internal/kbd.js';
+import { createBitsAttrs, boolToStr, getDataOpenClosed } from '../../internal/attrs.js';
+import { isElement } from '../../internal/tools/utils/dom.js';
+import { SafePolygon } from '../../internal/safe-polygon.svelte.js';
+import { isTabbable } from '../../internal/tabbable.js';
+import { createEffectTimeout } from '../../internal/timeout-fn.svelte.js';
+const popoverAttrs = createBitsAttrs({
+    component: 'popover',
+    parts: ['root', 'trigger', 'content', 'close'],
+});
+const [getPopoverRoot, setPopoverRoot] = createContext();
+export class PopoverRootState {
+    static create(opts) {
+        return setPopoverRoot(new PopoverRootState(opts));
+    }
+    opts;
+    contentNode = $state(null);
+    triggerNode = $state(null);
+    // hover tracking state
+    openedViaHover = $state(false);
+    hasInteractedWithContent = $state(false);
+    hoverCooldown = $state(false);
+    // The trigger installs its closeDelay here; a getter so the read tracks the trigger's prop.
+    #closeDelaySource = $state.raw(() => 0);
+    #closeTimer = createEffectTimeout(() => {
+        if (this.openedViaHover && !this.hasInteractedWithContent) {
+            this.opts.open = false;
+        }
+    }, () => this.closeDelay);
+    constructor(opts) {
+        this.opts = opts;
+        $effect(() => {
+            const isOpen = this.opts.open;
+            untrack(() => {
+                if (!isOpen) {
+                    this.openedViaHover = false;
+                    this.hasInteractedWithContent = false;
+                    this.#closeTimer.stop();
+                }
+            });
+        });
+    }
+    get closeDelay() {
+        return this.#closeDelaySource();
+    }
+    setCloseDelaySource(source) {
+        this.#closeDelaySource = source;
+    }
+    toggleOpen() {
+        this.#closeTimer.stop();
+        this.opts.open = !this.opts.open;
+    }
+    handleClose() {
+        this.#closeTimer.stop();
+        if (!this.opts.open)
+            return;
+        this.opts.open = false;
+    }
+    handleHoverOpen() {
+        this.#closeTimer.stop();
+        if (this.opts.open)
+            return;
+        this.openedViaHover = true;
+        this.opts.open = true;
+    }
+    handleHoverClose() {
+        if (!this.opts.open)
+            return;
+        // only close if opened via hover and user hasn't interacted with content
+        if (this.openedViaHover && !this.hasInteractedWithContent) {
+            this.opts.open = false;
+        }
+    }
+    handleDelayedHoverClose() {
+        if (!this.opts.open)
+            return;
+        if (!this.openedViaHover || this.hasInteractedWithContent)
+            return;
+        if (this.closeDelay <= 0) {
+            this.#closeTimer.stop();
+            this.opts.open = false;
+            return;
+        }
+        this.#closeTimer.start();
+    }
+    cancelDelayedClose() {
+        this.#closeTimer.stop();
+    }
+    markInteraction() {
+        this.hasInteractedWithContent = true;
+        this.#closeTimer.stop();
+    }
+}
+export class PopoverTriggerState {
+    static create(opts) {
+        return new PopoverTriggerState(opts, getPopoverRoot());
+    }
+    opts;
+    root;
+    attachment;
+    #openTimer = createEffectTimeout(() => this.root.handleHoverOpen(), () => this.opts.openDelay);
+    #isHovering = $state(false);
+    #wasOpenOnPointerDown = false;
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        this.attachment = attachRef((v) => (opts.ref = v), (v) => (this.root.triggerNode = v));
+        this.onclick = this.onclick.bind(this);
+        this.onkeydown = this.onkeydown.bind(this);
+        this.onpointerdown = this.onpointerdown.bind(this);
+        this.onpointerenter = this.onpointerenter.bind(this);
+        this.onpointerleave = this.onpointerleave.bind(this);
+        this.root.setCloseDelaySource(() => opts.closeDelay);
+    }
+    onpointerenter(e) {
+        if (this.opts.disabled)
+            return;
+        if (!this.opts.openOnHover)
+            return;
+        if (e.pointerType === 'touch')
+            return;
+        this.#isHovering = true;
+        this.root.cancelDelayedClose();
+        if (this.root.opts.open || this.root.hoverCooldown)
+            return;
+        if (this.opts.openDelay <= 0) {
+            this.root.handleHoverOpen();
+            return;
+        }
+        this.#openTimer.start();
+    }
+    onpointerleave(e) {
+        if (this.opts.disabled)
+            return;
+        if (!this.opts.openOnHover)
+            return;
+        if (e.pointerType === 'touch')
+            return;
+        this.#isHovering = false;
+        this.#openTimer.stop();
+        this.root.hoverCooldown = false;
+        // let GraceArea handle the close - it will call handleHoverClose via onPointerExit
+        // we just need to stop any pending open timer
+    }
+    onpointerdown(_) {
+        this.#wasOpenOnPointerDown = this.root.opts.open;
+    }
+    onclick(e) {
+        if (this.opts.disabled)
+            return;
+        if (e.button !== 0)
+            return;
+        this.#openTimer.stop();
+        // On engines without showPopover({source})'s invoker exemption, the UA light-dismisses the auto
+        // popover at pointerdown — before this click — and the toggle below would instantly reopen it.
+        if (this.#wasOpenOnPointerDown && !this.root.opts.open) {
+            this.#wasOpenOnPointerDown = false;
+            return;
+        }
+        // if clicked while hovering and popover is open, convert to click-based open
+        if (this.#isHovering && this.root.opts.open && this.root.openedViaHover) {
+            this.root.openedViaHover = false;
+            this.root.hasInteractedWithContent = true;
+            return;
+        }
+        // if closing while hovering with openOnHover enabled, set cooldown to prevent
+        // immediate re-open via hover
+        if (this.#isHovering && this.opts.openOnHover && this.root.opts.open) {
+            this.root.hoverCooldown = true;
+        }
+        // if clicking to open while in cooldown, reset cooldown (explicit open)
+        if (this.root.hoverCooldown && !this.root.opts.open) {
+            this.root.hoverCooldown = false;
+        }
+        this.root.toggleOpen();
+    }
+    onkeydown(e) {
+        if (this.opts.disabled)
+            return;
+        if (!(e.key === kbd.ENTER || e.key === kbd.SPACE))
+            return;
+        e.preventDefault();
+        this.#openTimer.stop();
+        this.root.toggleOpen();
+    }
+    #getAriaControls() {
+        if (this.root.opts.open && this.root.contentNode?.id) {
+            return this.root.contentNode?.id;
+        }
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id,
+        'aria-haspopup': 'dialog',
+        'aria-expanded': boolToStr(this.root.opts.open),
+        'data-state': getDataOpenClosed(this.root.opts.open),
+        'aria-controls': this.#getAriaControls(),
+        [popoverAttrs.trigger]: '',
+        disabled: this.opts.disabled,
+        //
+        onkeydown: this.onkeydown,
+        onclick: this.onclick,
+        onpointerdown: this.onpointerdown,
+        onpointerenter: this.onpointerenter,
+        onpointerleave: this.onpointerleave,
+        ...this.attachment,
+    }));
+}
+export class PopoverContentState {
+    static create(opts) {
+        return new PopoverContentState(opts, getPopoverRoot());
+    }
+    opts;
+    root;
+    attachment;
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        this.attachment = attachRef((v) => (opts.ref = v), (v) => (this.root.contentNode = v));
+        this.onpointerdown = this.onpointerdown.bind(this);
+        this.onfocusin = this.onfocusin.bind(this);
+        this.onpointerenter = this.onpointerenter.bind(this);
+        this.onpointerleave = this.onpointerleave.bind(this);
+        new SafePolygon({
+            triggerNode: () => this.root.triggerNode,
+            contentNode: () => this.root.contentNode,
+            enabled: () => this.root.opts.open && this.root.openedViaHover && !this.root.hasInteractedWithContent,
+            onPointerExit: () => {
+                this.root.handleDelayedHoverClose();
+            },
+        });
+    }
+    onpointerdown(_) {
+        this.root.markInteraction();
+    }
+    onfocusin(e) {
+        const target = e.target;
+        if (isElement(target) && isTabbable(target)) {
+            this.root.markInteraction();
+        }
+    }
+    onpointerenter(e) {
+        if (e.pointerType === 'touch')
+            return;
+        this.root.cancelDelayedClose();
+    }
+    onpointerleave(e) {
+        if (e.pointerType === 'touch')
+            return;
+        // handled by grace area
+    }
+    // The UA owns dismissal (`popover="auto"` light dismiss + Escape); this is how state follows.
+    dismiss = () => {
+        this.root.handleClose();
+    };
+    snippetProps = $derived.by(() => ({ open: this.root.opts.open }));
+    props = $derived.by(() => ({
+        id: this.opts.id,
+        tabindex: -1,
+        'data-state': getDataOpenClosed(this.root.opts.open),
+        [popoverAttrs.content]: '',
+        onpointerdown: this.onpointerdown,
+        onfocusin: this.onfocusin,
+        onpointerenter: this.onpointerenter,
+        onpointerleave: this.onpointerleave,
+        ...this.attachment,
+    }));
+}
+export class PopoverCloseState {
+    static create(opts) {
+        return new PopoverCloseState(opts, getPopoverRoot());
+    }
+    opts;
+    root;
+    attachment;
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        this.attachment = attachRef((v) => (opts.ref = v));
+        this.onclick = this.onclick.bind(this);
+        this.onkeydown = this.onkeydown.bind(this);
+    }
+    onclick(_) {
+        this.root.handleClose();
+    }
+    onkeydown(e) {
+        if (!(e.key === kbd.ENTER || e.key === kbd.SPACE))
+            return;
+        e.preventDefault();
+        this.root.handleClose();
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id,
+        onclick: this.onclick,
+        onkeydown: this.onkeydown,
+        type: 'button',
+        [popoverAttrs.close]: '',
+        ...this.attachment,
+    }));
+}

package/dist/components/popover/types.d.ts

@@ -0,0 +1,69 @@
+import type { EscapeLayerProps } from '../../internal/escape-layer/types.js';
+import type { DismissibleLayerProps } from '../../internal/dismissible-layer/types.js';
+import type { FloatingLayerContentProps } from '../../internal/floating-layer/types.js';
+import type { TextSelectionGuardProps } from '../../internal/types.js';
+import type { PresenceProps } from '../../internal/types.js';
+import type { FocusScopeProps } from '../../internal/focus-scope/types.js';
+import type { ScrollLockProps } from '../../internal/body-scroll-lock.svelte.js';
+import type { OnChangeFn, WithChild, WithChildNoChildrenSnippetProps, Without } from '../../internal/types.js';
+import type { Snippet } from 'svelte';
+import type { OpenCell } from '../../internal/open-cell.svelte.js';
+import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes } from '../../internal/attribute-types.js';
+import type { FloatingContentSnippetProps } from '../../internal/types.js';
+import type { PortalProps } from '../../internal/portal/index.js';
+/**
+ * Content prop surface, composed from the same layer building blocks the (now-removed) Floating-UI
+ * `PopperLayer` aggregated. The component no longer renders any Floating-UI layer — positioning is
+ * native CSS `anchor()` — but the prop names are preserved so existing consumers keep type-checking;
+ * the Floating-UI-only positioning props are simply ignored at runtime.
+ */
+type PopoverFloatingProps = EscapeLayerProps & Omit<DismissibleLayerProps, 'onInteractOutsideStart'> & FloatingLayerContentProps & PresenceProps & TextSelectionGuardProps & FocusScopeProps & Omit<ScrollLockProps, 'restoreScrollDelay'>;
+export type PopoverRootPropsWithoutHTML = {
+    /**
+     * The derivation source for the popover's open state: the internal cell
+     * re-derives whenever this prop changes, and interactions (trigger, Escape,
+     * a snippet-cell write) override it until the next change. Reconcile
+     * dismissals via onOpenChangeComplete. Plain value — not bindable.
+     */
+    open?: boolean;
+    /**
+     * A callback that is called when the popover's open state changes and the animation is complete.
+     * This is an occurrence (animation settled), not a state mirror — depend on the cell instead.
+     */
+    onOpenChangeComplete?: OnChangeFn<boolean>;
+    /**
+     * A caller-constructed cell (own source and, optionally, a delegate writer)
+     * used instead of building one from `open`. When given, `open` is ignored.
+     */
+    state?: OpenCell;
+    /** Children receive the state cell, typed and guaranteed within the tree. */
+    children?: Snippet<[OpenCell]>;
+};
+export type PopoverRootProps = PopoverRootPropsWithoutHTML;
+export type PopoverContentPropsWithoutHTML = WithChildNoChildrenSnippetProps<Omit<PopoverFloatingProps, 'content' | 'loop'>, FloatingContentSnippetProps>;
+export type PopoverContentProps = PopoverContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, PopoverContentPropsWithoutHTML>;
+export type PopoverTriggerPropsWithoutHTML = WithChild<{
+    /**
+     * Whether the popover should open when the trigger is hovered.
+     * @default false
+     */
+    openOnHover?: boolean;
+    /**
+     * How long to wait before opening the popover on hover (ms).
+     * Only applies when `openOnHover` is `true`.
+     * @default 700
+     */
+    openDelay?: number;
+    /**
+     * How long to wait before closing the popover after hover ends (ms).
+     * Only applies when `openOnHover` is `true`.
+     * @default 300
+     */
+    closeDelay?: number;
+}>;
+export type PopoverTriggerProps = PopoverTriggerPropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, PopoverTriggerPropsWithoutHTML>;
+export type PopoverClosePropsWithoutHTML = WithChild;
+export type PopoverCloseProps = PopoverClosePropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, PopoverClosePropsWithoutHTML>;
+export type PopoverPortalPropsWithoutHTML = PortalProps;
+export type PopoverPortalProps = PortalProps;
+export {};

package/dist/components/popover/types.js

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

package/dist/components/progress/components/progress.svelte

@@ -0,0 +1,65 @@
+<script lang="ts">
+	import { mergeProps } from '../../../internal/merge-props.js';
+	import type { ProgressRootProps } from '../types.js';
+	import { getProgressPercent, ProgressRootState } from '../progress.svelte.js';
+	import { createId } from '../../../internal/create-id.js';
+
+	const uid = $props.id();
+
+	let {
+		child,
+		children,
+		value = 0,
+		max = 100,
+		min = 0,
+		id = createId(uid),
+		ref = $bindable(null),
+		...restProps
+	}: ProgressRootProps = $props();
+
+	const rootState = ProgressRootState.create({
+		get value() {
+			return value;
+		},
+		get max() {
+			return max;
+		},
+		get min() {
+			return min;
+		},
+		get id() {
+			return id;
+		},
+		get ref() {
+			return ref;
+		},
+		set ref(v) {
+			ref = v;
+		},
+	});
+
+	const mergedProps = $derived(
+		mergeProps(
+			{
+				'data-slot': 'progress',
+				class: 'bg-primary/20 relative h-2 w-full overflow-hidden rounded-full',
+			},
+			restProps,
+			rootState.props,
+		),
+	);
+	const percent = $derived(getProgressPercent(value, min, max));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps })}
+{:else}
+	<div {...mergedProps}>
+		<div
+			data-slot="progress-indicator"
+			class="bg-primary h-full w-full flex-1 transition-all"
+			style="transform: translateX(-{100 - (percent ?? 0)}%)">
+		</div>
+		{@render children?.()}
+	</div>
+{/if}

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

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

package/dist/components/progress/exports.d.ts

@@ -0,0 +1,2 @@
+export { default as Root } from './components/progress.svelte';
+export type { ProgressRootProps as RootProps } from './types.js';

package/dist/components/progress/exports.js

@@ -0,0 +1 @@
+export { default as Root } from './components/progress.svelte';

package/dist/components/progress/index.js

@@ -0,0 +1,2 @@
+export * as Progress from "./exports.js";
+export * from "./exports.js";

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

@@ -0,0 +1,26 @@
+import type { RefAttachment, RefOpts } from '../../internal/types.js';
+export declare function getProgressPercent(value: number | null, min: number, max: number): number | null;
+interface ProgressRootStateOpts extends RefOpts {
+    readonly value: number | null;
+    readonly max: number;
+    readonly min: number;
+}
+export declare class ProgressRootState {
+    static create(opts: ProgressRootStateOpts): ProgressRootState;
+    readonly opts: ProgressRootStateOpts;
+    readonly attachment: RefAttachment;
+    constructor(opts: ProgressRootStateOpts);
+    readonly props: {
+        readonly role: "progressbar";
+        readonly value: number | null;
+        readonly 'aria-valuemin': number;
+        readonly 'aria-valuemax': number;
+        readonly 'aria-valuenow': number | undefined;
+        readonly 'data-value': number | undefined;
+        readonly 'data-state': "indeterminate" | "loading" | "loaded";
+        readonly 'data-max': number;
+        readonly 'data-min': number;
+        readonly 'data-indeterminate': "" | undefined;
+    };
+}
+export {};

package/dist/components/progress/progress.svelte.js

@@ -0,0 +1,44 @@
+import { attachRef } from '../../internal/tools/index.js';
+import { createBitsAttrs } from '../../internal/attrs.js';
+const progressAttrs = createBitsAttrs({
+    component: 'progress',
+    parts: ['root'],
+});
+export function getProgressPercent(value, min, max) {
+    if (value === null)
+        return null;
+    const range = max - min;
+    if (!Number.isFinite(value) || !Number.isFinite(min) || !Number.isFinite(max) || range <= 0)
+        return 0;
+    return Math.min(100, Math.max(0, ((value - min) / range) * 100));
+}
+export class ProgressRootState {
+    static create(opts) {
+        return new ProgressRootState(opts);
+    }
+    opts;
+    attachment;
+    constructor(opts) {
+        this.opts = opts;
+        this.attachment = attachRef((v) => (opts.ref = v));
+    }
+    props = $derived.by(() => {
+        const { value, min, max } = this.opts;
+        const percent = getProgressPercent(value, min, max);
+        const isIndeterminate = value === null;
+        return {
+            role: 'progressbar',
+            value,
+            'aria-valuemin': min,
+            'aria-valuemax': max,
+            'aria-valuenow': isIndeterminate ? undefined : value,
+            'data-value': isIndeterminate ? undefined : value,
+            'data-state': value === null ? 'indeterminate' : percent === 100 ? 'loaded' : 'loading',
+            'data-max': max,
+            'data-min': min,
+            'data-indeterminate': isIndeterminate ? '' : undefined,
+            [progressAttrs.root]: '',
+            ...this.attachment,
+        };
+    });
+}

package/dist/components/progress/types.d.ts

@@ -0,0 +1,24 @@
+import type { WithChild, Without } from '../../internal/types.js';
+import type { BitsPrimitiveDivAttributes } from '../../internal/attribute-types.js';
+export type ProgressRootPropsWithoutHTML = WithChild<{
+    /**
+     * The current value of the progress bar.
+     * If `null`, the progress bar will be in an indeterminate state.
+     *
+     * @default 0
+     */
+    value?: number | null;
+    /**
+     * The maximum value of the progress bar.
+     *
+     * @default 100
+     */
+    max?: number;
+    /**
+     * The minimum value of the progress bar.
+     *
+     * @default 0
+     */
+    min?: number;
+}>;
+export type ProgressRootProps = ProgressRootPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, ProgressRootPropsWithoutHTML>;

package/dist/components/progress/types.js

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

package/dist/components/radio-group/context.d.ts

@@ -0,0 +1,10 @@
+export type RadioGroupContext = {
+    /** Shared <input> name; native radios group by name (roving focus + single selection). */
+    readonly name: string;
+    readonly value: string;
+    readonly disabled: boolean;
+    readonly readonly: boolean;
+    readonly required: boolean;
+    select: (value: string) => void;
+};
+export declare const getRadioGroupContext: () => RadioGroupContext, setRadioGroupContext: (context: RadioGroupContext) => RadioGroupContext;

package/dist/components/radio-group/context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'svelte';
+export const [getRadioGroupContext, setRadioGroupContext] = createContext();

package/dist/components/radio-group/index.d.ts

@@ -0,0 +1,5 @@
+import Root from './radio-group.svelte';
+import Item from './radio-group-item.svelte';
+export type { RadioGroupProps } from './radio-group.svelte';
+export type { RadioGroupItemProps } from './radio-group-item.svelte';
+export { Root, Item, };

package/dist/components/radio-group/index.js

@@ -0,0 +1,3 @@
+import Root from './radio-group.svelte';
+import Item from './radio-group-item.svelte';
+export { Root, Item, };

package/dist/components/radio-group/radio-group-item.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { ClassValue, HTMLAttributes } from 'svelte/elements';
+export type RadioGroupItemProps = Omit<HTMLAttributes<HTMLSpanElement>, 'class'> & {
+    ref?: HTMLInputElement | null;
+    id?: string;
+    class?: ClassValue | null;
+    value: string;
+    disabled?: boolean | null;
+};
+declare const RadioGroupItem: import("svelte").Component<RadioGroupItemProps, {}, "ref">;
+type RadioGroupItem = ReturnType<typeof RadioGroupItem>;
+export default RadioGroupItem;

package/dist/components/radio-group/radio-group.svelte.d.ts

@@ -0,0 +1,19 @@
+import type { Snippet } from 'svelte';
+import type { ClassValue, HTMLAttributes } from 'svelte/elements';
+export type RadioGroupOrientation = 'horizontal' | 'vertical';
+export type RadioGroupProps = Omit<HTMLAttributes<HTMLDivElement>, 'class'> & {
+    ref?: HTMLDivElement | null;
+    id?: string;
+    class?: ClassValue | null;
+    value?: string;
+    name?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    orientation?: RadioGroupOrientation;
+    onValueChange?: (value: string) => void;
+    children?: Snippet;
+};
+declare const RadioGroup: import("svelte").Component<RadioGroupProps, {}, "ref" | "value">;
+type RadioGroup = ReturnType<typeof RadioGroup>;
+export default RadioGroup;

package/dist/components/range-calendar/components/range-calendar-cell.svelte.d.ts

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

package/dist/components/range-calendar/components/range-calendar-day.svelte.d.ts

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

package/dist/components/range-calendar/components/range-calendar.svelte.d.ts

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

package/dist/components/range-calendar/exports.d.ts

@@ -0,0 +1,15 @@
+export { default as Root } from "./components/range-calendar.svelte";
+export { default as Day } from "./components/range-calendar-day.svelte";
+export { default as Cell } from "./components/range-calendar-cell.svelte";
+export { default as Grid } from "../calendar/components/calendar-grid.svelte";
+export { default as GridBody } from "../calendar/components/calendar-grid-body.svelte";
+export { default as GridHead } from "../calendar/components/calendar-grid-head.svelte";
+export { default as HeadCell } from "../calendar/components/calendar-head-cell.svelte";
+export { default as GridRow } from "../calendar/components/calendar-grid-row.svelte";
+export { default as Header } from "../calendar/components/calendar-header.svelte";
+export { default as Heading } from "../calendar/components/calendar-heading.svelte";
+export { default as NextButton } from "../calendar/components/calendar-next-button.svelte";
+export { default as PrevButton } from "../calendar/components/calendar-prev-button.svelte";
+export { default as MonthSelect } from "../calendar/components/calendar-month-select.svelte";
+export { default as YearSelect } from "../calendar/components/calendar-year-select.svelte";
+export type { RangeCalendarRootProps as RootProps, RangeCalendarPrevButtonProps as PrevButtonProps, RangeCalendarNextButtonProps as NextButtonProps, RangeCalendarHeadingProps as HeadingProps, RangeCalendarHeaderProps as HeaderProps, RangeCalendarGridProps as GridProps, RangeCalendarGridHeadProps as GridHeadProps, RangeCalendarHeadCellProps as HeadCellProps, RangeCalendarGridBodyProps as GridBodyProps, RangeCalendarCellProps as CellProps, RangeCalendarGridRowProps as GridRowProps, RangeCalendarDayProps as DayProps, RangeCalendarMonthSelectProps as MonthSelectProps, RangeCalendarYearSelectProps as YearSelectProps, } from "./types.js";

package/dist/components/range-calendar/exports.js

@@ -0,0 +1,14 @@
+export { default as Root } from "./components/range-calendar.svelte";
+export { default as Day } from "./components/range-calendar-day.svelte";
+export { default as Cell } from "./components/range-calendar-cell.svelte";
+export { default as Grid } from "../calendar/components/calendar-grid.svelte";
+export { default as GridBody } from "../calendar/components/calendar-grid-body.svelte";
+export { default as GridHead } from "../calendar/components/calendar-grid-head.svelte";
+export { default as HeadCell } from "../calendar/components/calendar-head-cell.svelte";
+export { default as GridRow } from "../calendar/components/calendar-grid-row.svelte";
+export { default as Header } from "../calendar/components/calendar-header.svelte";
+export { default as Heading } from "../calendar/components/calendar-heading.svelte";
+export { default as NextButton } from "../calendar/components/calendar-next-button.svelte";
+export { default as PrevButton } from "../calendar/components/calendar-prev-button.svelte";
+export { default as MonthSelect } from "../calendar/components/calendar-month-select.svelte";
+export { default as YearSelect } from "../calendar/components/calendar-year-select.svelte";