sheer-ui 0.4.2 → 0.5.0

package/dist/components/chart/chart-container.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { WithElementRef } from '../../internal/utils.js';
+import type { HTMLAttributes } from 'svelte/elements';
+import { type ChartConfig } from './chart-utils.js';
+type $$ComponentProps = WithElementRef<HTMLAttributes<HTMLElement>> & {
+    config: ChartConfig;
+};
+declare const ChartContainer: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type ChartContainer = ReturnType<typeof ChartContainer>;
+export default ChartContainer;

package/dist/components/chart/chart-style.svelte.d.ts

@@ -0,0 +1,8 @@
+import { type ChartConfig } from './chart-utils.js';
+type $$ComponentProps = {
+    id: string;
+    config: ChartConfig;
+};
+declare const ChartStyle: import("svelte").Component<$$ComponentProps, {}, "">;
+type ChartStyle = ReturnType<typeof ChartStyle>;
+export default ChartStyle;

package/dist/components/chart/chart-tooltip.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { WithElementRef, WithoutChildren } from '../../internal/utils.js';
+import type { HTMLAttributes } from 'svelte/elements';
+import { type TooltipPayload } from './chart-utils.js';
+import type { Snippet } from 'svelte';
+type $$ComponentProps = WithoutChildren<WithElementRef<HTMLAttributes<HTMLDivElement>>> & {
+    hideLabel?: boolean;
+    label?: string;
+    indicator?: 'line' | 'dot' | 'dashed';
+    nameKey?: string;
+    labelKey?: string;
+    hideIndicator?: boolean;
+    labelClassName?: string;
+    labelFormatter?: ((value: any, payload: TooltipPayload[]) => string | number | Snippet) | null;
+    formatter?: Snippet<[
+        {
+            value: unknown;
+            name: string;
+            item: TooltipPayload;
+            index: number;
+            payload: TooltipPayload[];
+        }
+    ]>;
+};
+declare const ChartTooltip: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type ChartTooltip = ReturnType<typeof ChartTooltip>;
+export default ChartTooltip;

package/dist/components/chart/chart-utils.d.ts

@@ -0,0 +1,34 @@
+import type { Tooltip } from 'layerchart';
+import { type Component } from 'svelte';
+export declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+export type ChartConfig = {
+    [k in string]: {
+        label?: string;
+        icon?: Component;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+export type TooltipPayload = Tooltip.TooltipSeries;
+export declare function getPayloadConfigFromPayload(config: ChartConfig, payload: TooltipPayload, key: string, data?: Record<string, any> | null): ({
+    label?: string;
+    icon?: Component;
+} & ({
+    color?: string;
+    theme?: never;
+} | {
+    color?: never;
+    theme: Record<keyof typeof THEMES, string>;
+})) | undefined;
+type ChartContextValue = {
+    config: ChartConfig;
+};
+export declare const useChart: () => ChartContextValue, setChartContext: (context: ChartContextValue) => ChartContextValue;
+export {};

package/dist/components/chart/chart-utils.js

@@ -0,0 +1,30 @@
+import { createContext } from 'svelte';
+export const THEMES = { light: '', dark: '.dark' };
+// Helper to extract item config from a payload.
+export function getPayloadConfigFromPayload(config, payload, key, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+data) {
+    if (typeof payload !== 'object' || payload === null)
+        return undefined;
+    const payloadConfig = 'config' in payload && typeof payload.config === 'object' && payload.config !== null ? payload.config : undefined;
+    let configLabelKey = key;
+    if (payload.key === key) {
+        configLabelKey = payload.key;
+    }
+    else if (payload.label === key) {
+        configLabelKey = payload.label;
+    }
+    else if (key in payload && typeof payload[key] === 'string') {
+        configLabelKey = payload[key];
+    }
+    else if (payloadConfig !== undefined && key in payloadConfig && typeof payloadConfig[key] === 'string') {
+        configLabelKey = payloadConfig[key];
+    }
+    else if (data != null && key in data && typeof data[key] === 'string') {
+        configLabelKey = data[key];
+    }
+    return configLabelKey in config ? config[configLabelKey] : config[key];
+}
+// The getter throws missing_context when no Chart.Container is above, instead of
+// returning undefined and failing later on `.config`.
+export const [useChart, setChartContext] = createContext();

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

@@ -0,0 +1,4 @@
+import ChartContainer from './chart-container.svelte';
+import ChartTooltip from './chart-tooltip.svelte';
+export { getPayloadConfigFromPayload, type ChartConfig } from './chart-utils.js';
+export { ChartContainer, ChartTooltip, ChartContainer as Container, ChartTooltip as Tooltip };

package/dist/components/chart/index.js

@@ -0,0 +1,4 @@
+import ChartContainer from './chart-container.svelte';
+import ChartTooltip from './chart-tooltip.svelte';
+export { getPayloadConfigFromPayload } from './chart-utils.js';
+export { ChartContainer, ChartTooltip, ChartContainer as Container, ChartTooltip as Tooltip };

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

@@ -0,0 +1,77 @@
+import type { HTMLButtonAttributes } from 'svelte/elements';
+import type { BitsKeyboardEvent, BitsMouseEvent, RefAttachment, RefOpts } from '../../internal/types.js';
+interface CheckboxGroupStateOpts extends RefOpts {
+    readonly disabled: boolean;
+    readonly required: boolean;
+    readonly readonly: boolean;
+    value: string[];
+}
+export declare class CheckboxGroupState {
+    static create(opts: CheckboxGroupStateOpts): CheckboxGroupState;
+    readonly opts: CheckboxGroupStateOpts;
+    readonly attachment: RefAttachment;
+    labelState: CheckboxGroupLabelState | null;
+    readonly labelId: string | undefined;
+    constructor(opts: CheckboxGroupStateOpts);
+    readonly props: {
+        readonly id: string;
+        readonly role: "group";
+        readonly 'aria-labelledby': string | undefined;
+        readonly 'data-disabled': "" | undefined;
+    };
+}
+interface CheckboxGroupLabelStateOpts extends RefOpts {
+}
+export declare class CheckboxGroupLabelState {
+    static create(opts: CheckboxGroupLabelStateOpts): CheckboxGroupLabelState;
+    readonly opts: CheckboxGroupLabelStateOpts;
+    readonly group: CheckboxGroupState;
+    readonly attachment: RefAttachment;
+    constructor(opts: CheckboxGroupLabelStateOpts, group: CheckboxGroupState);
+    readonly props: {
+        readonly id: string;
+        readonly 'data-disabled': "" | undefined;
+    };
+}
+interface CheckboxRootStateOpts extends RefOpts {
+    readonly disabled: boolean;
+    readonly required: boolean;
+    readonly readonly: boolean;
+    readonly value: string | undefined;
+    readonly type: HTMLButtonAttributes['type'];
+    checked: boolean;
+    indeterminate: boolean;
+}
+export declare class CheckboxRootState {
+    #private;
+    static create(opts: CheckboxRootStateOpts): CheckboxRootState;
+    readonly opts: CheckboxRootStateOpts;
+    readonly group: CheckboxGroupState | null;
+    readonly groupChecked: () => boolean | undefined;
+    readonly trueRequired: boolean;
+    readonly trueDisabled: boolean;
+    readonly trueReadonly: boolean;
+    readonly attachment: RefAttachment;
+    constructor(opts: CheckboxRootStateOpts, group: CheckboxGroupState | null);
+    onkeydown(e: BitsKeyboardEvent): void;
+    onclick(e: BitsMouseEvent): void;
+    readonly snippetProps: {
+        checked: boolean;
+        indeterminate: boolean;
+    };
+    readonly props: {
+        readonly id: string;
+        readonly role: "checkbox";
+        readonly type: "button" | "reset" | "submit" | null | undefined;
+        readonly disabled: boolean;
+        readonly 'aria-checked': "true" | "false" | "mixed";
+        readonly 'aria-required': "true" | "false";
+        readonly 'aria-readonly': "true" | "false";
+        readonly 'data-disabled': "" | undefined;
+        readonly 'data-readonly': "" | undefined;
+        readonly 'data-state': "checked" | "indeterminate" | "unchecked";
+        readonly onclick: (e: BitsMouseEvent) => void;
+        readonly onkeydown: (e: BitsKeyboardEvent) => void;
+    };
+}
+export {};

package/dist/components/checkbox/checkbox.svelte.js

@@ -0,0 +1,146 @@
+import { createContext } from 'svelte';
+import { joinGroup } from '../../internal/group-value.svelte.js';
+import { attachRef } from '../../internal/tools/index.js';
+import { boolToStr, createBitsAttrs, getAriaChecked, boolToEmptyStrOrUndef } from '../../internal/attrs.js';
+import { kbd } from '../../internal/kbd.js';
+const checkboxAttrs = createBitsAttrs({
+    component: 'checkbox',
+    parts: ['root', 'group', 'group-label', 'input'],
+});
+const [getCheckboxGroup, setCheckboxGroup, hasCheckboxGroup] = createContext();
+export class CheckboxGroupState {
+    static create(opts) {
+        return setCheckboxGroup(new CheckboxGroupState(opts));
+    }
+    opts;
+    attachment;
+    labelState = $state(null);
+    labelId = $derived.by(() => this.labelState?.opts.id);
+    constructor(opts) {
+        this.opts = opts;
+        this.attachment = attachRef((v) => (opts.ref = v));
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id,
+        role: 'group',
+        'aria-labelledby': this.labelId,
+        'data-disabled': boolToEmptyStrOrUndef(this.opts.disabled),
+        [checkboxAttrs.group]: '',
+        ...this.attachment,
+    }));
+}
+export class CheckboxGroupLabelState {
+    static create(opts) {
+        return new CheckboxGroupLabelState(opts, getCheckboxGroup());
+    }
+    opts;
+    group;
+    attachment;
+    constructor(opts, group) {
+        this.opts = opts;
+        this.group = group;
+        this.group.labelState = this;
+        this.attachment = attachRef((v) => (opts.ref = v));
+    }
+    props = $derived.by(() => ({
+        id: this.opts.id,
+        'data-disabled': boolToEmptyStrOrUndef(this.group.opts.disabled),
+        [checkboxAttrs['group-label']]: '',
+        ...this.attachment,
+    }));
+}
+const [, setCheckboxRoot] = createContext();
+export class CheckboxRootState {
+    static create(opts) {
+        const group = hasCheckboxGroup() ? getCheckboxGroup() : null;
+        return setCheckboxRoot(new CheckboxRootState(opts, group));
+    }
+    opts;
+    group;
+    groupChecked;
+    trueRequired = $derived.by(() => {
+        if (this.group && this.group.opts.required)
+            return true;
+        return this.opts.required;
+    });
+    trueDisabled = $derived.by(() => {
+        if (this.group && this.group.opts.disabled)
+            return true;
+        return this.opts.disabled;
+    });
+    trueReadonly = $derived.by(() => {
+        if (this.group && this.group.opts.readonly)
+            return true;
+        return this.opts.readonly;
+    });
+    attachment;
+    constructor(opts, group) {
+        this.opts = opts;
+        this.group = group;
+        this.attachment = attachRef((v) => (opts.ref = v));
+        this.onkeydown = this.onkeydown.bind(this);
+        this.onclick = this.onclick.bind(this);
+        this.groupChecked = joinGroup(group?.opts ?? null, opts);
+    }
+    onkeydown(e) {
+        if (this.trueDisabled || this.trueReadonly)
+            return;
+        if (e.key === kbd.ENTER) {
+            e.preventDefault();
+            if (this.opts.type === 'submit') {
+                const form = e.currentTarget.closest('form');
+                form?.requestSubmit();
+            }
+            return;
+        }
+        if (e.key === kbd.SPACE) {
+            e.preventDefault();
+            this.#toggle();
+        }
+    }
+    #toggle() {
+        if (this.opts.indeterminate) {
+            this.opts.indeterminate = false;
+            this.opts.checked = true;
+        }
+        else {
+            this.opts.checked = !this.opts.checked;
+        }
+    }
+    onclick(e) {
+        if (this.trueDisabled || this.trueReadonly)
+            return;
+        if (this.opts.type === 'submit') {
+            this.#toggle();
+            return;
+        }
+        e.preventDefault();
+        this.#toggle();
+    }
+    snippetProps = $derived.by(() => ({
+        checked: this.opts.checked,
+        indeterminate: this.opts.indeterminate,
+    }));
+    props = $derived.by(() => ({
+        id: this.opts.id,
+        role: 'checkbox',
+        type: this.opts.type,
+        disabled: this.trueDisabled,
+        'aria-checked': getAriaChecked(this.opts.checked, this.opts.indeterminate),
+        'aria-required': boolToStr(this.trueRequired),
+        'aria-readonly': boolToStr(this.trueReadonly),
+        'data-disabled': boolToEmptyStrOrUndef(this.trueDisabled),
+        'data-readonly': boolToEmptyStrOrUndef(this.trueReadonly),
+        'data-state': getCheckboxDataState(this.opts.checked, this.opts.indeterminate),
+        [checkboxAttrs.root]: '',
+        //
+        onclick: this.onclick,
+        onkeydown: this.onkeydown,
+        ...this.attachment,
+    }));
+}
+function getCheckboxDataState(checked, indeterminate) {
+    if (indeterminate)
+        return 'indeterminate';
+    return checked ? 'checked' : 'unchecked';
+}

package/dist/components/checkbox/components/checkbox-group-label.svelte

@@ -0,0 +1,32 @@
+<script lang="ts">
+	import { mergeProps } from '../../../internal/merge-props.js';
+	import type { CheckboxGroupLabelProps } from '../types.js';
+	import { CheckboxGroupLabelState } from '../checkbox.svelte.js';
+	import { createId } from '../../../internal/create-id.js';
+
+	const uid = $props.id();
+
+	let { ref = $bindable(null), id = createId(uid), child, children, ...restProps }: CheckboxGroupLabelProps = $props();
+
+	const labelState = CheckboxGroupLabelState.create({
+		get id() {
+			return id;
+		},
+		get ref() {
+			return ref;
+		},
+		set ref(v) {
+			ref = v;
+		},
+	});
+
+	const mergedProps = $derived(mergeProps(restProps, labelState.props));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps })}
+{:else}
+	<span {...mergedProps}>
+		{@render children?.()}
+	</span>
+{/if}

package/dist/components/checkbox/components/checkbox-group-label.svelte.d.ts

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

package/dist/components/checkbox/components/checkbox-group.svelte

@@ -0,0 +1,59 @@
+<script lang="ts">
+	import { mergeProps } from '../../../internal/merge-props.js';
+	import type { CheckboxGroupProps } from '../types.js';
+	import { CheckboxGroupState } from '../checkbox.svelte.js';
+	import { createId } from '../../../internal/create-id.js';
+
+	const uid = $props.id();
+
+	let {
+		ref = $bindable(null),
+		id = createId(uid),
+		value = $bindable([]),
+		onValueChange = () => {},
+		required,
+		disabled,
+		children,
+		child,
+		readonly,
+		...restProps
+	}: CheckboxGroupProps = $props();
+
+	const groupState = CheckboxGroupState.create({
+		get id() {
+			return id;
+		},
+		get disabled() {
+			return Boolean(disabled);
+		},
+		get required() {
+			return Boolean(required);
+		},
+		get readonly() {
+			return Boolean(readonly);
+		},
+		get value() {
+			return $state.snapshot(value);
+		},
+		set value(v) {
+			value = $state.snapshot(v);
+			onValueChange(v);
+		},
+		get ref() {
+			return ref;
+		},
+		set ref(v) {
+			ref = v;
+		},
+	});
+
+	const mergedProps = $derived(mergeProps(restProps, groupState.props));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps })}
+{:else}
+	<div {...mergedProps}>
+		{@render children?.()}
+	</div>
+{/if}

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

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

package/dist/components/checkbox/components/checkbox.svelte

@@ -0,0 +1,103 @@
+<script lang="ts">
+	// Checkbox (button): controlled / headless. A <button role=checkbox> for table
+	// select-all, JS-owned state, and Checkbox.Group. It does NOT submit in a form;
+	// use `CheckboxNative` (name/value) for form fields.
+	import { repairBindable } from '../../../internal/tools/index.js';
+	import { mergeProps } from '../../../internal/merge-props.js';
+	import type { CheckboxRootProps } from '../types.js';
+	import { CheckboxRootState } from '../checkbox.svelte.js';
+	import { createId } from '../../../internal/create-id.js';
+	import CheckIcon from '@lucide/svelte/icons/check';
+	import MinusIcon from '@lucide/svelte/icons/minus';
+
+	const uid = $props.id();
+
+	let {
+		checked = $bindable(false),
+		ref = $bindable(null),
+		onCheckedChange,
+		children,
+		disabled = false,
+		required = false,
+		value = 'on',
+		id = createId(uid),
+		indeterminate = $bindable(false),
+		onIndeterminateChange,
+		child,
+		type = 'button',
+		readonly,
+		...restProps
+	}: CheckboxRootProps = $props();
+
+	const rootState = CheckboxRootState.create({
+		get checked() {
+			return checked;
+		},
+		set checked(v) {
+			checked = v;
+			onCheckedChange?.(v);
+		},
+		get indeterminate() {
+			return indeterminate;
+		},
+		set indeterminate(v) {
+			indeterminate = v;
+			onIndeterminateChange?.(v);
+		},
+		get disabled() {
+			return disabled ?? false;
+		},
+		get required() {
+			return required;
+		},
+		get readonly() {
+			return Boolean(readonly);
+		},
+		get value() {
+			return value;
+		},
+		get type() {
+			return type;
+		},
+		get id() {
+			return id;
+		},
+		get ref() {
+			return ref;
+		},
+		set ref(v) {
+			ref = v;
+		},
+	});
+
+	repairBindable(rootState.groupChecked, () => (checked = rootState.groupChecked() ?? checked));
+
+	const mergedProps = $derived(
+		mergeProps(
+			{
+				'data-slot': 'checkbox',
+				class:
+					'border-border dark:bg-border/30 data-checked:bg-primary data-checked:text-primary-foreground dark:data-checked:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive peer grid size-4 shrink-0 place-items-center rounded-[4px] border shadow-xs transition-shadow outline-none focus-visible:ring-3 disabled:cursor-not-allowed disabled:opacity-50',
+			},
+			restProps,
+			rootState.props,
+		),
+	);
+</script>
+
+{#if child}
+	{@render child({
+		props: mergedProps,
+		...rootState.snippetProps,
+	})}
+{:else}
+	<button {...mergedProps}>
+		<div data-slot="checkbox-indicator" class="text-current transition-none">
+			{#if checked}
+				<CheckIcon class="size-3.5" />
+			{:else if indeterminate}
+				<MinusIcon class="size-3.5" />
+			{/if}
+		</div>
+	</button>
+{/if}

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

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

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

@@ -0,0 +1,4 @@
+export { default as Root, default as Checkbox } from './components/checkbox.svelte';
+export { default as Group } from './components/checkbox-group.svelte';
+export { default as GroupLabel } from './components/checkbox-group-label.svelte';
+export type { CheckboxRootProps as RootProps, CheckboxGroupProps as GroupProps, CheckboxGroupLabelProps as GroupLabelProps, } from './types.js';

package/dist/components/checkbox/index.js

@@ -0,0 +1,3 @@
+export { default as Root, default as Checkbox } from './components/checkbox.svelte';
+export { default as Group } from './components/checkbox-group.svelte';
+export { default as GroupLabel } from './components/checkbox-group-label.svelte';

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

@@ -0,0 +1,105 @@
+import type { OnChangeFn, WithChild, Without } from "../../internal/types.js";
+import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes, BitsPrimitiveSpanAttributes } from "../../internal/attribute-types.js";
+export type CheckboxRootSnippetProps = {
+    checked: boolean;
+    indeterminate: boolean;
+};
+export type CheckboxRootPropsWithoutHTML = WithChild<{
+    /**
+     * Whether the checkbox is disabled.
+     *
+     * @default false
+     */
+    disabled?: boolean | null | undefined;
+    /**
+     * Whether the checkbox is required (for form validation).
+     *
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * Whether the checkbox is read only.
+     *
+     * If readonly, the checkbox will be focusable by the user,
+     * but will not be able to be checked/unchecked.
+     *
+     * @default false
+     */
+    readonly?: boolean | null | undefined;
+    /**
+     * The value used to identify the checkbox when in a `Checkbox.Group`. If
+     * not provided while in a `Checkbox.Group`, the checkbox uses a random
+     * identifier.
+     *
+     * @default undefined
+     */
+    value?: string;
+    /**
+     * The checked state of the checkbox. It can be one of:
+     * - `true` for checked
+     * - `false` for unchecked
+     *
+     * @default false
+     */
+    checked?: boolean;
+    /**
+     * A callback function called when the checked state changes.
+     */
+    onCheckedChange?: OnChangeFn<boolean>;
+    /**
+     * Whether the checkbox is in an indeterminate state or not.
+     *
+     * @default false
+     */
+    indeterminate?: boolean;
+    /**
+     * A callback function called when the indeterminate state changes.
+     */
+    onIndeterminateChange?: OnChangeFn<boolean>;
+    /**
+     * Not supported: this checkbox renders a `<button>` and never submits.
+     * Use `CheckboxNative` (with `name`/`value`) for form fields.
+     */
+    name?: never;
+}, CheckboxRootSnippetProps>;
+export type CheckboxRootProps = CheckboxRootPropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, CheckboxRootPropsWithoutHTML>;
+export type CheckboxGroupPropsWithoutHTML = WithChild<{
+    /**
+     * Whether the checkbox group is disabled.
+     * This will disable all checkboxes in the group.
+     *
+     * @default false
+     */
+    disabled?: boolean | null | undefined;
+    /**
+     * Whether the checkbox group is read only.
+     *
+     * If readonly, the group will be focusable by the user,
+     * but the checkboxes not be able to be checked/unchecked.
+     *
+     * @default false
+     */
+    readonly?: boolean | null | undefined;
+    /**
+     * Whether the checkbox group is required (for form validation).
+     * This will mark all checkboxes in the group as required.
+     *
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * The value of the checkbox group, indicating which
+     * of the checkboxes in the group are checked.
+     *
+     * @bindable
+     * @default []
+     */
+    value?: string[];
+    /**
+     * A callback function called when the value changes.
+     */
+    onValueChange?: OnChangeFn<string[]>;
+}>;
+export type CheckboxGroupProps = CheckboxGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, CheckboxGroupPropsWithoutHTML>;
+export type CheckboxGroupLabelPropsWithoutHTML = WithChild;
+export type CheckboxGroupLabelProps = CheckboxGroupLabelPropsWithoutHTML & Without<BitsPrimitiveSpanAttributes, CheckboxGroupLabelPropsWithoutHTML>;

package/dist/components/checkbox/types.js

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