@johly/bits-ui 2.18.1

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

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

package/dist/bits/radio-group/components/radio-group.svelte

@@ -0,0 +1,60 @@
+<script lang="ts">
+	import { boxWith, mergeProps } from "svelte-toolbelt";
+	import type { RadioGroupRootProps } from "../types.js";
+	import { RadioGroupRootState } from "../radio-group.svelte.js";
+	import RadioGroupInput from "./radio-group-input.svelte";
+	import { createId } from "../../../internal/create-id.js";
+	import { noop } from "../../../internal/noop.js";
+
+	const uid = $props.id();
+
+	let {
+		disabled = false,
+		children,
+		child,
+		value = $bindable(""),
+		ref = $bindable(null),
+		orientation = "vertical",
+		loop = true,
+		name = undefined,
+		required = false,
+		readonly = false,
+		id = createId(uid),
+		onValueChange = noop,
+		...restProps
+	}: RadioGroupRootProps = $props();
+
+	const rootState = RadioGroupRootState.create({
+		orientation: boxWith(() => orientation),
+		disabled: boxWith(() => disabled),
+		loop: boxWith(() => loop),
+		name: boxWith(() => name),
+		required: boxWith(() => required),
+		readonly: boxWith(() => readonly),
+		id: boxWith(() => id),
+		value: boxWith(
+			() => value,
+			(v) => {
+				if (v === value) return;
+				value = v;
+				onValueChange?.(v);
+			}
+		),
+		ref: boxWith(
+			() => ref,
+			(v) => (ref = v)
+		),
+	});
+
+	const mergedProps = $derived(mergeProps(restProps, rootState.props));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps })}
+{:else}
+	<div {...mergedProps}>
+		{@render children?.()}
+	</div>
+{/if}
+
+<RadioGroupInput />

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

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

package/dist/bits/radio-group/exports.d.ts

@@ -0,0 +1,3 @@
+export { default as Root } from "./components/radio-group.svelte";
+export { default as Item } from "./components/radio-group-item.svelte";
+export type { RadioGroupRootProps as RootProps, RadioGroupItemProps as ItemProps, } from "./types.js";

package/dist/bits/radio-group/exports.js

@@ -0,0 +1,2 @@
+export { default as Root } from "./components/radio-group.svelte";
+export { default as Item } from "./components/radio-group-item.svelte";

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

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

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

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

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

@@ -0,0 +1,86 @@
+import { type ReadableBoxedValues, type WritableBoxedValues } from "svelte-toolbelt";
+import type { BitsFocusEvent, BitsKeyboardEvent, BitsMouseEvent, RefAttachment, WithRefOpts } from "../../internal/types.js";
+import type { Orientation } from "../../shared/index.js";
+import { RovingFocusGroup } from "../../internal/roving-focus-group.js";
+interface RadioGroupRootStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    disabled: boolean;
+    required: boolean;
+    loop: boolean;
+    orientation: Orientation;
+    name: string | undefined;
+    readonly: boolean;
+}>, WritableBoxedValues<{
+    value: string;
+}> {
+}
+export declare class RadioGroupRootState {
+    static create(opts: RadioGroupRootStateOpts): RadioGroupRootState;
+    readonly opts: RadioGroupRootStateOpts;
+    readonly hasValue: boolean;
+    readonly rovingFocusGroup: RovingFocusGroup;
+    readonly attachment: RefAttachment;
+    constructor(opts: RadioGroupRootStateOpts);
+    isChecked(value: string): boolean;
+    setValue(value: string): void;
+    readonly props: {
+        readonly id: string;
+        readonly role: "radiogroup";
+        readonly "aria-required": "true" | "false";
+        readonly "aria-disabled": "true" | "false";
+        readonly "aria-readonly": "true" | undefined;
+        readonly "data-disabled": "" | undefined;
+        readonly "data-readonly": "" | undefined;
+        readonly "data-orientation": Orientation;
+    };
+}
+interface RadioGroupItemStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    disabled: boolean;
+    value: string;
+}> {
+}
+export declare class RadioGroupItemState {
+    #private;
+    static create(opts: RadioGroupItemStateOpts): RadioGroupItemState;
+    readonly opts: RadioGroupItemStateOpts;
+    readonly root: RadioGroupRootState;
+    readonly attachment: RefAttachment;
+    readonly checked: boolean;
+    constructor(opts: RadioGroupItemStateOpts, root: RadioGroupRootState);
+    onclick(_: BitsMouseEvent): void;
+    onfocus(_: BitsFocusEvent): void;
+    onkeydown(e: BitsKeyboardEvent): void;
+    readonly snippetProps: {
+        checked: boolean;
+    };
+    readonly props: {
+        readonly id: string;
+        readonly disabled: true | undefined;
+        readonly "data-value": string;
+        readonly "data-orientation": Orientation;
+        readonly "data-disabled": "" | undefined;
+        readonly "data-readonly": "" | undefined;
+        readonly "data-state": "checked" | "unchecked";
+        readonly "aria-checked": "true" | "false" | "mixed";
+        readonly type: "button";
+        readonly role: "radio";
+        readonly tabindex: number;
+        readonly onkeydown: (e: BitsKeyboardEvent) => void;
+        readonly onfocus: (_: BitsFocusEvent) => void;
+        readonly onclick: (_: BitsMouseEvent) => void;
+    };
+}
+export declare class RadioGroupInputState {
+    static create(): RadioGroupInputState;
+    readonly root: RadioGroupRootState;
+    readonly shouldRender: boolean;
+    constructor(root: RadioGroupRootState);
+    onfocus(_: BitsFocusEvent): void;
+    readonly props: {
+        readonly name: string | undefined;
+        readonly value: string;
+        readonly required: boolean;
+        readonly disabled: boolean;
+        readonly onfocus: (_: BitsFocusEvent) => void;
+    };
+}
+export {};

package/dist/bits/radio-group/radio-group.svelte.js

@@ -0,0 +1,147 @@
+import { attachRef } from "svelte-toolbelt";
+import { Context, watch } from "runed";
+import { createBitsAttrs, getAriaChecked, boolToEmptyStrOrUndef, boolToStr, } from "../../internal/attrs.js";
+import { kbd } from "../../internal/kbd.js";
+import { RovingFocusGroup } from "../../internal/roving-focus-group.js";
+const radioGroupAttrs = createBitsAttrs({
+    component: "radio-group",
+    parts: ["root", "item"],
+});
+const RadioGroupRootContext = new Context("RadioGroup.Root");
+export class RadioGroupRootState {
+    static create(opts) {
+        return RadioGroupRootContext.set(new RadioGroupRootState(opts));
+    }
+    opts;
+    hasValue = $derived.by(() => this.opts.value.current !== "");
+    rovingFocusGroup;
+    attachment;
+    constructor(opts) {
+        this.opts = opts;
+        this.attachment = attachRef(this.opts.ref);
+        this.rovingFocusGroup = new RovingFocusGroup({
+            rootNode: this.opts.ref,
+            candidateAttr: radioGroupAttrs.item,
+            loop: this.opts.loop,
+            orientation: this.opts.orientation,
+        });
+    }
+    isChecked(value) {
+        return this.opts.value.current === value;
+    }
+    setValue(value) {
+        this.opts.value.current = value;
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        role: "radiogroup",
+        "aria-required": boolToStr(this.opts.required.current),
+        "aria-disabled": boolToStr(this.opts.disabled.current),
+        "aria-readonly": this.opts.readonly.current ? "true" : undefined,
+        "data-disabled": boolToEmptyStrOrUndef(this.opts.disabled.current),
+        "data-readonly": boolToEmptyStrOrUndef(this.opts.readonly.current),
+        "data-orientation": this.opts.orientation.current,
+        [radioGroupAttrs.root]: "",
+        ...this.attachment,
+    }));
+}
+export class RadioGroupItemState {
+    static create(opts) {
+        return new RadioGroupItemState(opts, RadioGroupRootContext.get());
+    }
+    opts;
+    root;
+    attachment;
+    checked = $derived.by(() => this.root.opts.value.current === this.opts.value.current);
+    #isDisabled = $derived.by(() => this.opts.disabled.current || this.root.opts.disabled.current);
+    #isReadonly = $derived.by(() => this.root.opts.readonly.current);
+    #isChecked = $derived.by(() => this.root.isChecked(this.opts.value.current));
+    #tabIndex = $state(-1);
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        this.attachment = attachRef(this.opts.ref);
+        if (this.opts.value.current === this.root.opts.value.current) {
+            this.root.rovingFocusGroup.setCurrentTabStopId(this.opts.id.current);
+            this.#tabIndex = 0;
+        }
+        else if (!this.root.opts.value.current) {
+            this.#tabIndex = 0;
+        }
+        $effect(() => {
+            this.#tabIndex = this.root.rovingFocusGroup.getTabIndex(this.opts.ref.current);
+        });
+        watch([() => this.opts.value.current, () => this.root.opts.value.current], () => {
+            if (this.opts.value.current === this.root.opts.value.current) {
+                this.root.rovingFocusGroup.setCurrentTabStopId(this.opts.id.current);
+                this.#tabIndex = 0;
+            }
+        });
+        this.onclick = this.onclick.bind(this);
+        this.onkeydown = this.onkeydown.bind(this);
+        this.onfocus = this.onfocus.bind(this);
+    }
+    onclick(_) {
+        if (this.opts.disabled.current || this.#isReadonly)
+            return;
+        this.root.setValue(this.opts.value.current);
+    }
+    onfocus(_) {
+        if (!this.root.hasValue || this.#isReadonly)
+            return;
+        this.root.setValue(this.opts.value.current);
+    }
+    onkeydown(e) {
+        if (this.#isDisabled)
+            return;
+        if (e.key === kbd.SPACE) {
+            e.preventDefault();
+            if (!this.#isReadonly) {
+                this.root.setValue(this.opts.value.current);
+            }
+            return;
+        }
+        this.root.rovingFocusGroup.handleKeydown(this.opts.ref.current, e, true);
+    }
+    snippetProps = $derived.by(() => ({ checked: this.#isChecked }));
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        disabled: this.#isDisabled ? true : undefined,
+        "data-value": this.opts.value.current,
+        "data-orientation": this.root.opts.orientation.current,
+        "data-disabled": boolToEmptyStrOrUndef(this.#isDisabled),
+        "data-readonly": boolToEmptyStrOrUndef(this.#isReadonly),
+        "data-state": this.#isChecked ? "checked" : "unchecked",
+        "aria-checked": getAriaChecked(this.#isChecked, false),
+        [radioGroupAttrs.item]: "",
+        type: "button",
+        role: "radio",
+        tabindex: this.#tabIndex,
+        //
+        onkeydown: this.onkeydown,
+        onfocus: this.onfocus,
+        onclick: this.onclick,
+        ...this.attachment,
+    }));
+}
+export class RadioGroupInputState {
+    static create() {
+        return new RadioGroupInputState(RadioGroupRootContext.get());
+    }
+    root;
+    shouldRender = $derived.by(() => this.root.opts.name.current !== undefined);
+    constructor(root) {
+        this.root = root;
+        this.onfocus = this.onfocus.bind(this);
+    }
+    onfocus(_) {
+        this.root.rovingFocusGroup.focusCurrentTabStop();
+    }
+    props = $derived.by(() => ({
+        name: this.root.opts.name.current,
+        value: this.root.opts.value.current,
+        required: this.root.opts.required.current,
+        disabled: this.root.opts.disabled.current,
+        onfocus: this.onfocus,
+    }));
+}

package/dist/bits/radio-group/types.d.ts

@@ -0,0 +1,73 @@
+import type { OnChangeFn, WithChild, Without } from "../../internal/types.js";
+import type { Orientation } from "../../index.js";
+import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes } from "../../shared/attributes.js";
+export type RadioGroupRootPropsWithoutHTML = WithChild<{
+    /**
+     * The orientation of the radio group. Used to determine
+     * how keyboard navigation should work.
+     *
+     * @default "vertical"
+     */
+    orientation?: Orientation;
+    /**
+     * Whether to loop around the radio items when navigating
+     * with the keyboard.
+     *
+     * @default true
+     */
+    loop?: boolean;
+    /**
+     * The value of the selected radio item.
+     *
+     * @default ""
+     */
+    value?: string;
+    /**
+     * The callback to call when the selected radio item changes.
+     */
+    onValueChange?: OnChangeFn<string>;
+    /**
+     * The name to apply to the radio group's input element for
+     * form submission. If not provided, a hidden input will not
+     * be rendered and the radio group will not be part of a form.
+     *
+     * @default undefined
+     */
+    name?: string;
+    /**
+     * Whether the radio group is disabled.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Whether the radio group is required for form submission.
+     * If `true`, ensure you provide a `name` prop so the hidden
+     * input is rendered.
+     */
+    required?: boolean;
+    /**
+     * Whether the radio group is readonly. When readonly, users can
+     * focus and navigate through items but cannot change the value.
+     *
+     * @default false
+     */
+    readonly?: boolean;
+}>;
+export type RadioGroupRootProps = RadioGroupRootPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, RadioGroupRootPropsWithoutHTML>;
+export type RadioGroupItemSnippetProps = {
+    checked: boolean;
+};
+export type RadioGroupItemPropsWithoutHTML = WithChild<{
+    /**
+     * The value of the radio item.
+     */
+    value: string;
+    /**
+     * Whether the radio item is disabled.
+     *
+     * @default false
+     */
+    disabled?: boolean | null | undefined;
+}, RadioGroupItemSnippetProps>;
+export type RadioGroupItemProps = RadioGroupItemPropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, RadioGroupItemPropsWithoutHTML>;

package/dist/bits/radio-group/types.js

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

package/dist/bits/range-calendar/components/range-calendar-cell.svelte

@@ -0,0 +1,38 @@
+<script lang="ts">
+	import { boxWith, mergeProps } from "svelte-toolbelt";
+	import type { RangeCalendarCellProps } from "../types.js";
+	import { RangeCalendarCellState } from "../range-calendar.svelte.js";
+	import { createId } from "../../../internal/create-id.js";
+
+	const uid = $props.id();
+
+	let {
+		children,
+		child,
+		id = createId(uid),
+		ref = $bindable(null),
+		date,
+		month,
+		...restProps
+	}: RangeCalendarCellProps = $props();
+
+	const cellState = RangeCalendarCellState.create({
+		id: boxWith(() => id),
+		ref: boxWith(
+			() => ref,
+			(v) => (ref = v)
+		),
+		date: boxWith(() => date),
+		month: boxWith(() => month),
+	});
+
+	const mergedProps = $derived(mergeProps(restProps, cellState.props));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps, ...cellState.snippetProps })}
+{:else}
+	<td {...mergedProps}>
+		{@render children?.(cellState.snippetProps)}
+	</td>
+{/if}

package/dist/bits/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/bits/range-calendar/components/range-calendar-day.svelte

@@ -0,0 +1,38 @@
+<script lang="ts">
+	import { boxWith, mergeProps } from "svelte-toolbelt";
+	import type { RangeCalendarDayProps } from "../types.js";
+	import { RangeCalendarDayState } from "../range-calendar.svelte.js";
+	import { createId } from "../../../internal/create-id.js";
+
+	const uid = $props.id();
+
+	let {
+		children,
+		child,
+		id = createId(uid),
+		ref = $bindable(null),
+		...restProps
+	}: RangeCalendarDayProps = $props();
+
+	const dayState = RangeCalendarDayState.create({
+		id: boxWith(() => id),
+		ref: boxWith(
+			() => ref,
+			(v) => (ref = v)
+		),
+	});
+
+	const mergedProps = $derived(mergeProps(restProps, dayState.props));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps, ...dayState.snippetProps })}
+{:else}
+	<div {...mergedProps}>
+		{#if children}
+			{@render children?.(dayState.snippetProps)}
+		{:else}
+			{dayState.cell.opts.date.current.day}
+		{/if}
+	</div>
+{/if}

package/dist/bits/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/bits/range-calendar/components/range-calendar.svelte

@@ -0,0 +1,153 @@
+<script lang="ts">
+	import { watch } from "runed";
+	import { boxWith, mergeProps } from "svelte-toolbelt";
+	import { type DateValue } from "@internationalized/date";
+	import type { RangeCalendarRootProps } from "../types.js";
+	import { RangeCalendarRootState } from "../range-calendar.svelte.js";
+	import { noop } from "../../../internal/noop.js";
+	import { createId } from "../../../internal/create-id.js";
+	import { getDefaultDate } from "../../../internal/date-time/utils.js";
+	import { resolveLocaleProp } from "../../utilities/config/prop-resolvers.js";
+
+	const uid = $props.id();
+
+	let {
+		children,
+		child,
+		id = createId(uid),
+		ref = $bindable(null),
+		value = $bindable(),
+		onValueChange = noop,
+		placeholder = $bindable(),
+		onPlaceholderChange = noop,
+		weekdayFormat = "narrow",
+		weekStartsOn,
+		pagedNavigation = false,
+		isDateDisabled = () => false,
+		isDateUnavailable = () => false,
+		fixedWeeks = false,
+		numberOfMonths = 1,
+		locale,
+		calendarLabel = "Event",
+		disabled = false,
+		readonly = false,
+		minValue = undefined,
+		maxValue = undefined,
+		preventDeselect = false,
+		disableDaysOutsideMonth = true,
+		minDays,
+		maxDays,
+		onStartValueChange = noop,
+		onEndValueChange = noop,
+		excludeDisabled = false,
+		monthFormat = "long",
+		yearFormat = "numeric",
+		...restProps
+	}: RangeCalendarRootProps = $props();
+
+	let startValue = $state<DateValue | undefined>(value?.start);
+	let endValue = $state<DateValue | undefined>(value?.end);
+
+	const defaultPlaceholder = getDefaultDate({
+		defaultValue: value?.start,
+		minValue,
+		maxValue,
+	});
+
+	function handleDefaultPlaceholder() {
+		if (placeholder !== undefined) return;
+		placeholder = defaultPlaceholder;
+	}
+
+	// SSR
+	handleDefaultPlaceholder();
+
+	watch.pre(
+		() => placeholder,
+		() => {
+			handleDefaultPlaceholder();
+		}
+	);
+
+	function handleDefaultValue() {
+		if (value !== undefined) return;
+		value = { start: undefined, end: undefined };
+	}
+
+	// SSR
+	handleDefaultValue();
+
+	watch.pre(
+		() => value,
+		() => {
+			handleDefaultValue();
+		}
+	);
+
+	const rootState = RangeCalendarRootState.create({
+		id: boxWith(() => id),
+		ref: boxWith(
+			() => ref,
+			(v) => (ref = v)
+		),
+		value: boxWith(
+			() => value!,
+			(v) => {
+				value = v;
+				onValueChange(v);
+			}
+		),
+		placeholder: boxWith(
+			() => placeholder!,
+			(v) => {
+				placeholder = v;
+				onPlaceholderChange(v);
+			}
+		),
+		disabled: boxWith(() => disabled),
+		readonly: boxWith(() => readonly),
+		preventDeselect: boxWith(() => preventDeselect),
+		minValue: boxWith(() => minValue),
+		maxValue: boxWith(() => maxValue),
+		isDateUnavailable: boxWith(() => isDateUnavailable),
+		isDateDisabled: boxWith(() => isDateDisabled),
+		pagedNavigation: boxWith(() => pagedNavigation),
+		weekStartsOn: boxWith(() => weekStartsOn),
+		weekdayFormat: boxWith(() => weekdayFormat),
+		numberOfMonths: boxWith(() => numberOfMonths),
+		locale: resolveLocaleProp(() => locale),
+		calendarLabel: boxWith(() => calendarLabel),
+		fixedWeeks: boxWith(() => fixedWeeks),
+		disableDaysOutsideMonth: boxWith(() => disableDaysOutsideMonth),
+		minDays: boxWith(() => minDays),
+		maxDays: boxWith(() => maxDays),
+		excludeDisabled: boxWith(() => excludeDisabled),
+		startValue: boxWith(
+			() => startValue,
+			(v) => {
+				startValue = v;
+				onStartValueChange(v);
+			}
+		),
+		endValue: boxWith(
+			() => endValue,
+			(v) => {
+				endValue = v;
+				onEndValueChange(v);
+			}
+		),
+		monthFormat: boxWith(() => monthFormat),
+		yearFormat: boxWith(() => yearFormat),
+		defaultPlaceholder,
+	});
+
+	const mergedProps = $derived(mergeProps(restProps, rootState.props));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps, ...rootState.snippetProps })}
+{:else}
+	<div {...mergedProps}>
+		{@render children?.(rootState.snippetProps)}
+	</div>
+{/if}

package/dist/bits/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, {}, "value" | "placeholder" | "ref">;
+type RangeCalendar = ReturnType<typeof RangeCalendar>;
+export default RangeCalendar;

package/dist/bits/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/bits/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";