sheer-ui 0.4.2 → 0.5.0

package/src/lib/components/tooltip/types.ts

@@ -1,175 +0,0 @@
-import type { OpenCell } from '../../internal/open-cell.svelte.js';
-import type { FloatingLayerContentProps } from '../../internal/floating-layer/types.js';
-import type { DismissibleLayerProps } from '../../internal/dismissible-layer/types.js';
-import type { EscapeLayerProps } from '../../internal/escape-layer/types.js';
-import type { Snippet } from 'svelte';
-import type { OnChangeFn, WithChild, WithChildNoChildrenSnippetProps, WithChildren, Without } from '../../internal/types.js';
-import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes } from '../../internal/attribute-types.js';
-import type { PortalProps } from '../../internal/portal/index.js';
-import type { FloatingContentSnippetProps } from '../../internal/types.js';
-import type { TooltipTether as TooltipTetherImpl } from './tooltip.svelte.js';
-
-export type TooltipTether<Payload = never> = TooltipTetherImpl<Payload>;
-
-export type TooltipRootSnippetProps<Payload = never> = {
-	open: boolean;
-	triggerId: string | null;
-	payload: [Payload] extends [never] ? null : Payload | null;
-};
-
-export type TooltipProviderPropsWithoutHTML = WithChildren<{
-	/**
-	 * The delay in milliseconds before the tooltip opens.
-	 *
-	 * @defaultValue 700
-	 */
-	delayDuration?: number;
-
-	/**
-	 * How much time a user has to enter another trigger without
-	 * incurring a delay again.
-	 * @defaultValue 300
-	 */
-	skipDelayDuration?: number;
-
-	/**
-	 * Prevents tooltip from remaining open when hovering over the content.
-	 *
-	 * @defaultValue false
-	 */
-	disableHoverableContent?: boolean;
-
-	/**
-	 * When `true`, the tooltip will not close when you click on the trigger.
-	 *
-	 * @defaultValue false
-	 */
-	disableCloseOnTriggerClick?: boolean;
-
-	/**
-	 * When `true`, the tooltip will be disabled and will not open.
-	 *
-	 * @defaultValue false
-	 */
-	disabled?: boolean;
-
-	/**
-	 * Prevent the tooltip from opening if the focus did not come using
-	 * the keyboard.
-	 *
-	 * @defaultValue false
-	 */
-	ignoreNonKeyboardFocus?: boolean;
-}>;
-
-export type TooltipProviderProps = TooltipProviderPropsWithoutHTML;
-
-export type TooltipRootPropsWithoutHTML<Payload = never> = Omit<
-	WithChildren<{
-		/**
-		 * The derivation source for the tooltip's open state: the internal cell
-		 * re-derives whenever this prop changes, and interactions override it
-		 * until the next change. Plain value — not bindable.
-		 */
-		open?: 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;
-
-		/**
-		 * A callback that will be called when the tooltip finishes opening/closing animations.
-		 */
-		onOpenChangeComplete?: OnChangeFn<boolean>;
-
-		/**
-		 * The delay in milliseconds before the tooltip opens.
-		 *
-		 * @defaultValue 700
-		 */
-		delayDuration?: number;
-
-		/**
-		 * Prevents tooltip from remaining open when hovering over the content.
-		 *
-		 * @defaultValue false
-		 */
-		disableHoverableContent?: boolean;
-
-		/**
-		 * When `true`, the tooltip will not close when you click on the trigger.
-		 *
-		 * @defaultValue false
-		 */
-		disableCloseOnTriggerClick?: boolean;
-
-		/**
-		 * When `true`, the tooltip will be disabled and will not open.
-		 *
-		 * @defaultValue false
-		 */
-		disabled?: boolean;
-
-		/**
-		 * Prevent the tooltip from opening if the focus did not come using
-		 * the keyboard.
-		 *
-		 * @defaultValue false
-		 */
-		ignoreNonKeyboardFocus?: boolean;
-		/**
-		 * The active trigger id for controlled single tooltip mode.
-		 */
-		triggerId?: string | null;
-		/**
-		 * Shared tether used to connect detached triggers and infer payload types.
-		 */
-		tether?: TooltipTether<Payload> | undefined;
-	}>,
-	'children'
-> & {
-	children?: Snippet | Snippet<[TooltipRootSnippetProps<Payload>]>;
-};
-
-export type TooltipRootProps<Payload = never> = TooltipRootPropsWithoutHTML<Payload>;
-
-export type TooltipContentPropsWithoutHTML = WithChildNoChildrenSnippetProps<
-	Omit<FloatingLayerContentProps, 'content' | 'preventScroll'> &
-		Omit<DismissibleLayerProps, 'onInteractOutsideStart'> &
-		EscapeLayerProps & {
-			/**
-			 * When `true`, the tooltip will be forced to mount in the DOM.
-			 *
-			 * Useful for more control over the transition behavior.
-			 */
-			forceMount?: boolean;
-		},
-	FloatingContentSnippetProps
->;
-
-export type TooltipContentProps = TooltipContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, TooltipContentPropsWithoutHTML>;
-
-export type TooltipPortalPropsWithoutHTML = PortalProps;
-export type TooltipPortalProps = PortalProps;
-
-export type TooltipTriggerPropsWithoutHTML<Payload = never> = WithChild<{
-	/**
-	 * Whether the tooltip trigger is disabled or not.
-	 *
-	 * @defaultValue false
-	 */
-	disabled?: boolean | null | undefined;
-	/**
-	 * Payload for the trigger used by singleton tooltip root snippets.
-	 */
-	payload?: [Payload] extends [never] ? unknown : Payload;
-	/**
-	 * Shared tether used to connect detached triggers and infer payload types.
-	 */
-	tether?: TooltipTether<Payload> | undefined;
-}>;
-
-export type TooltipTriggerProps<Payload = never> = TooltipTriggerPropsWithoutHTML<Payload> &
-	Without<BitsPrimitiveButtonAttributes, TooltipTriggerPropsWithoutHTML<Payload>>;

package/src/lib/internal/animations-settled.svelte.ts

@@ -1,119 +0,0 @@
-import { untrack } from 'svelte';
-import type { Getter } from './tools/index.js';
-
-/**
- * Resolves once the node's running animations/transitions finish (descendants included
- * unless `subtree: false`) — `frames` frames first so a transition triggered by the current
- * render has started. Environments without getAnimations (jsdom) resolve immediately
- * after the frames.
- * Infinite animations (Skeleton pulse, caret-blink, animate-spin) are excluded — their
- * `finished` never resolves and would strand the caller.
- *
- * TODO(revisit ~mid-2027): ::details-content + `content-visibility allow-discrete` lets the
- * browser hold content rendered through the close, deleting the disclosure use (83% 2026-07).
- */
-export const animationsSettled = async (node: HTMLElement, { subtree = true, frames = 1 } = {}): Promise<void> => {
-	for (let i = 0; i < frames; i++) await new Promise(requestAnimationFrame);
-	if (typeof node.getAnimations !== 'function') return;
-
-	// A close during an enter retargets the transition: the browser cancels the enter (its
-	// `finished` rejects) and starts the exit, so re-query — one pass per frame. Bounded: a
-	// descendant whose transition is continuously retargeted (live progress bar, hover colour
-	// under a moving pointer) rejects every pass and must not hold the settle open forever.
-	for (let pass = 0; ; pass++) {
-		const running = node
-			.getAnimations({ subtree })
-			.filter((animation) => animation.effect?.getComputedTiming().iterations !== Infinity && isInFlight(animation));
-		if (running.length === 0) return;
-
-		const results = await Promise.allSettled(running.map((animation) => animation.finished));
-		if (pass === MAX_RETARGET_PASSES || !results.some((result) => result.status === 'rejected')) return;
-		await new Promise(requestAnimationFrame);
-	}
-};
-
-const MAX_RETARGET_PASSES = 3;
-
-// `finished` only ever resolves for an animation that is running (or about to be, `pending`);
-// paused/idle finite animations (animation-play-state: paused, a reduced-motion override) would
-// strand the caller exactly like an infinite one.
-const isInFlight = (animation: Animation) => animation.pending || animation.playState === 'running';
-
-export interface SettleRunner {
-	/** Runs `fn` once `node` settles, superseding any pending run. A null node cancels and drops. */
-	run(node: HTMLElement | null, fn: () => void): void;
-	cancel(): void;
-}
-
-/**
- * The one supersession idiom for settle-deferred work: a monotonic token, so the newest
- * `run` wins and everything older is dropped. Cancels when the owning effect is destroyed,
- * which works at component init and inside an attachment body alike.
- */
-export function createSettleRunner(options?: { subtree?: boolean; frames?: number }): SettleRunner {
-	let token = 0;
-
-	const cancel = () => {
-		token++;
-	};
-
-	const run = (node: HTMLElement | null, fn: () => void) => {
-		const current = ++token;
-		if (!node) return;
-		void animationsSettled(node, options).then(() => {
-			if (current === token) fn();
-		});
-	};
-
-	$effect(() => cancel);
-
-	return { run, cancel };
-}
-
-/**
- * Fires `onComplete` after an open/close flip once the surface's own animations settle.
- * Settle-based rather than transitionend so completion still fires when no transition
- * runs (duration-0 override, reduced motion, jsdom). A flip while a settle is pending
- * supersedes it; a flip while the surface has no node cancels and is dropped.
- * `skipSettle` answers per flip: true completes synchronously and drops any pending settle
- * (a menubar swap, where the outgoing menu's exit is zeroed).
- * `pending` is true from a flip until its completion fires — an always-mounted surface is still
- * rendered while a close is pending, which is what its locks key on. It flips in a pre-effect so
- * it is already set when the surface's own effects and attachments run in the same flush; set a
- * pass later, `open || pending` would read false for that pass, and a scroll lock would tear
- * down and re-create itself mid-exit (and capture the locked body as the style to restore).
- */
-export function useOpenChangeComplete(
-	open: Getter<boolean>,
-	ref: Getter<HTMLElement | null>,
-	onComplete: (open: boolean) => void,
-	skipSettle: (open: boolean) => boolean = () => false,
-): { readonly pending: boolean } {
-	let prevOpen = open();
-	let pending = $state(false);
-	const settle = createSettleRunner({ subtree: false });
-	$effect.pre(() => {
-		const el = ref();
-		const isOpen = open();
-		if (isOpen === prevOpen) return;
-		prevOpen = isOpen;
-		untrack(() => {
-			if (!el || skipSettle(isOpen)) {
-				settle.cancel();
-				pending = false;
-				if (el) onComplete(isOpen);
-				return;
-			}
-			pending = true;
-			settle.run(el, () => {
-				pending = false;
-				onComplete(isOpen);
-			});
-		});
-	});
-	return {
-		get pending() {
-			return pending;
-		},
-	};
-}

package/src/lib/internal/arrays.ts

@@ -1,253 +0,0 @@
-/**
- * Checks if two arrays are equal by comparing their values.
- */
-export const arraysAreEqual = <T extends Array<unknown>>(arr1: T, arr2: T): boolean =>
-	arr1.length === arr2.length && arr1.every((value, index) => isEqual(value, arr2[index]));
-
-/**
- * A utility function that compares two values for equality.
- */
-function isEqual(a: unknown, b: unknown): boolean {
-	if (Number.isNaN(a as number) && Number.isNaN(b as number)) return true;
-
-	if (Array.isArray(a) && Array.isArray(b)) return arraysAreEqual(a as unknown[], b as unknown[]);
-
-	if (typeof a === 'object' && typeof b === 'object') return isDeepEqual(a, b);
-
-	return Object.is(a, b);
-}
-
-/**
- * A utility function that compares two values for deep equality.
- */
-function isDeepEqual(a: unknown, b: unknown): boolean {
-	if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;
-
-	const aKeys = Object.keys(a);
-	const bKeys = Object.keys(b);
-
-	if (aKeys.length !== bKeys.length) return false;
-
-	for (const key of aKeys) {
-		if (!bKeys.includes(key)) return false;
-		if (!isEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key])) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
- * Splits an array into chunks of a given size.
- * @param arr The array to split.
- * @param size The size of each chunk.
- * @returns An array of arrays, where each sub-array has `size` elements from the original array.
- * @example ```ts
- * const arr = [1, 2, 3, 4, 5, 6, 7, 8];
- * const chunks = chunk(arr, 3);
- * // chunks = [[1, 2, 3], [4, 5, 6], [7, 8]]
- * ```
- */
-export function chunk<T>(arr: T[], size: number): T[][] {
-	if (size <= 0) return [];
-
-	const result = [];
-	for (let i = 0; i < arr.length; i += size) {
-		result.push(arr.slice(i, i + size));
-	}
-	return result;
-}
-
-/**
- * Checks if the given index is valid for the given array.
- *
- * @param index - The index to check
- * @param arr - The array to check
- */
-
-export const isValidIndex = (index: number, arr: unknown[]) => index >= 0 && index < arr.length;
-
-/**
- * Returns the array element after the given index, or undefined for out-of-bounds or empty arrays.
- * @param array the array.
- * @param index the index of the current element.
- * @param loop loop to the beginning of the array if the next index is out of bounds?
- */
-/**
- * Returns the array element after the given index, or undefined for out-of-bounds or empty arrays.
- * For single-element arrays, returns the element if the index is 0.
- * @param array the array.
- * @param index the index of the current element.
- * @param loop loop to the beginning of the array if the next index is out of bounds?
- */
-export function next<T>(array: T[], index: number, loop = true): T | undefined {
-	if (array.length === 0 || index < 0 || index >= array.length) return;
-	if (array.length === 1 && index === 0) return array[0];
-	if (index === array.length - 1) return loop ? array[0] : undefined;
-	return array[index + 1];
-}
-
-/**
- * Returns the array element prior to the given index, or undefined for out-of-bounds or empty arrays.
- * For single-element arrays, returns the element if the index is 0.
- * @param array the array.
- * @param index the index of the current element.
- * @param loop loop to the end of the array if the previous index is out of bounds?
- */
-export function prev<T>(array: T[], index: number, loop = true): T | undefined {
-	if (array.length === 0 || index < 0 || index >= array.length) return;
-	if (array.length === 1 && index === 0) return array[0];
-	if (index === 0) return loop ? array[array.length - 1] : undefined;
-	return array[index - 1];
-}
-
-/**
- * Returns the element some number after the given index. If the target index is out of bounds:
- *   - If looping is disabled, the first or last element will be returned.
- *   - If looping is enabled, it will wrap around the array.
- * Returns undefined for empty arrays or out-of-bounds initial indices.
- * @param array the array.
- * @param index the index of the current element.
- * @param increment the number of elements to move forward (can be negative).
- * @param loop loop around the array if the target index is out of bounds?
- */
-export function forward<T>(array: T[], index: number, increment: number, loop = true): T | undefined {
-	if (array.length === 0 || index < 0 || index >= array.length) return;
-
-	let targetIndex = index + increment;
-
-	if (loop) {
-		// Ensure positive modulus
-		targetIndex = ((targetIndex % array.length) + array.length) % array.length;
-	} else {
-		// Clamp to array bounds when not looping
-		targetIndex = Math.max(0, Math.min(targetIndex, array.length - 1));
-	}
-
-	return array[targetIndex];
-}
-
-/**
- * Returns the element some number before the given index. If the target index is out of bounds:
- *   - If looping is disabled, the first or last element will be returned.
- *   - If looping is enabled, it will wrap around the array.
- * Returns undefined for empty arrays or out-of-bounds initial indices.
- * @param array the array.
- * @param index the index of the current element.
- * @param decrement the number of elements to move backward (can be negative).
- * @param loop loop around the array if the target index is out of bounds?
- */
-export function backward<T>(array: T[], index: number, decrement: number, loop = true): T | undefined {
-	if (array.length === 0 || index < 0 || index >= array.length) return;
-
-	let targetIndex = index - decrement;
-
-	if (loop) {
-		// Ensure positive modulus
-		targetIndex = ((targetIndex % array.length) + array.length) % array.length;
-	} else {
-		// Clamp to array bounds when not looping
-		targetIndex = Math.max(0, Math.min(targetIndex, array.length - 1));
-	}
-
-	return array[targetIndex];
-}
-
-/**
- * Finds the next matching item from a list of values based on a search string.
- *
- * This function handles several special cases in typeahead behavior:
- *
- * 1. Space handling: When a search string ends with a space, it handles it specially:
- *    - If there's only one match for the text before the space, it ignores the space
- *    - If there are multiple matches and the current match already starts with the search prefix
- *      followed by a space, it keeps the current match (doesn't change selection on space)
- *    - Only after typing characters beyond the space will it move to a more specific match
- *
- * 2. Repeated character handling: If a search consists of repeated characters (e.g., "aaa"),
- *    it treats it as a single character for matching purposes
- *
- * 3. Cycling behavior: The function wraps around the values array starting from the current match
- *    to find the next appropriate match, creating a cycling selection behavior
- *
- * @param values - Array of string values to search through (e.g., the text content of menu items)
- * @param search - The current search string typed by the user
- * @param currentMatch - The currently selected/matched item, if any
- * @returns The next matching value that should be selected, or undefined if no match is found
- */
-export function getNextMatch(values: string[], search: string, currentMatch?: string) {
-	const lowerSearch = search.toLowerCase();
-
-	if (lowerSearch.endsWith(' ')) {
-		const searchWithoutSpace = lowerSearch.slice(0, -1);
-		const matchesWithoutSpace = values.filter((value) => value.toLowerCase().startsWith(searchWithoutSpace));
-
-		/**
-		 * If there's only one match for the prefix without space, we don't
-		 * watch to match with space.
-		 */
-		if (matchesWithoutSpace.length <= 1) {
-			return getNextMatch(values, searchWithoutSpace, currentMatch);
-		}
-
-		const currentMatchLowercase = currentMatch?.toLowerCase();
-
-		/**
-		 * If the current match already starts with the search prefix and has a space afterward,
-		 * and the user has only typed up to that space, keep the current match until they
-		 * disambiguate.
-		 */
-		if (
-			currentMatchLowercase &&
-			currentMatchLowercase.startsWith(searchWithoutSpace) &&
-			currentMatchLowercase.charAt(searchWithoutSpace.length) === ' ' &&
-			search.trim() === searchWithoutSpace
-		) {
-			return currentMatch;
-		}
-
-		/**
-		 * With multiple matches, find items that match the full search string with space
-		 */
-		const spacedMatches = values.filter((value) => value.toLowerCase().startsWith(lowerSearch));
-
-		/**
-		 * If we found matches with the space, use the first one that's not the current match
-		 */
-		if (spacedMatches.length > 0) {
-			const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
-
-			// the first match that is not the current one, falling back to current if no other is found.
-			const nextMatch = findWrapped(spacedMatches, Math.max(currentMatchIndex, 0), (match) => match !== currentMatch);
-			return nextMatch || currentMatch;
-		}
-	}
-
-	const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);
-	const normalizedSearch = isRepeated ? search[0]! : search;
-	const normalizedLowerSearch = normalizedSearch.toLowerCase();
-
-	const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
-	const excludeCurrentMatch = normalizedSearch.length === 1;
-	const nextMatch = findWrapped(
-		values,
-		Math.max(currentMatchIndex, 0),
-		(value) => (!excludeCurrentMatch || value !== currentMatch) && value.toLowerCase().startsWith(normalizedLowerSearch),
-	);
-
-	return nextMatch !== currentMatch ? nextMatch : undefined;
-}
-
-/**
- * Circular find: scans `array` from `startIndex` (wrapping past the end) and returns the first element
- * satisfying `predicate`. What every caller of the old rotate-copy (`wrapArray`) actually consumed —
- * same visit order, without allocating the rotation.
- */
-export const findWrapped = <T>(array: T[], startIndex: number, predicate: (item: T) => boolean): T | undefined => {
-	for (let step = 0; step < array.length; step++) {
-		const item = array[(startIndex + step) % array.length]!;
-		if (predicate(item)) return item;
-	}
-	return undefined;
-};

package/src/lib/internal/attribute-types.ts

@@ -1,53 +0,0 @@
-import type {
-	HTMLAnchorAttributes,
-	HTMLAttributes,
-	HTMLButtonAttributes,
-	HTMLImgAttributes,
-	HTMLInputAttributes,
-	HTMLLabelAttributes,
-	HTMLLiAttributes,
-	HTMLSelectAttributes,
-	HTMLTableAttributes,
-	HTMLTdAttributes,
-	HTMLThAttributes,
-	SVGAttributes,
-} from 'svelte/elements';
-
-export type BitsDivAttributes = HTMLAttributes<HTMLDivElement>;
-export type BitsSpanAttributes = HTMLAttributes<HTMLSpanElement>;
-export type BitsHeadingAttributes = HTMLAttributes<HTMLHeadingElement>;
-export type BitsUListAttributes = HTMLAttributes<HTMLUListElement>;
-export type BitsElementAttributes = HTMLAttributes<HTMLElement>;
-export type BitsTableSectionAttributes = HTMLAttributes<HTMLTableSectionElement>;
-export type BitsTableRowAttributes = HTMLAttributes<HTMLTableRowElement>;
-export type BitsSVGElementAttributes = SVGAttributes<SVGElement>;
-export type BitsSelectAttributes = HTMLSelectAttributes;
-
-/**
- * We override the `id` prop type to not allow it to be `null`. We rely on the
- * `id` heavily in the internals of Bits UI for node references. We also override
- * children to allow for custom children snippet props. We extend `style` to allow
- * for either a `StyleProperties` object or a string of CSS properties.
- */
-type BitsPrimitive<T> = Omit<T, 'style' | 'id' | 'children'> & { id?: string };
-
-export type BitsPrimitiveButtonAttributes = BitsPrimitive<HTMLButtonAttributes>;
-export type BitsPrimitiveDivAttributes = BitsPrimitive<BitsDivAttributes>;
-export type BitsPrimitiveInputAttributes = BitsPrimitive<HTMLInputAttributes>;
-export type BitsPrimitiveSpanAttributes = BitsPrimitive<BitsSpanAttributes>;
-export type BitsPrimitiveImgAttributes = BitsPrimitive<HTMLImgAttributes>;
-export type BitsPrimitiveHeadingAttributes = BitsPrimitive<BitsHeadingAttributes>;
-export type BitsPrimitiveLabelAttributes = BitsPrimitive<HTMLLabelAttributes>;
-export type BitsPrimitiveSVGAttributes = BitsPrimitive<BitsSVGElementAttributes>;
-export type BitsPrimitiveAnchorAttributes = BitsPrimitive<HTMLAnchorAttributes>;
-export type BitsPrimitiveLiAttributes = BitsPrimitive<HTMLLiAttributes>;
-export type BitsPrimitiveElementAttributes = BitsPrimitive<BitsElementAttributes>;
-export type BitsPrimitiveUListAttributes = BitsPrimitive<BitsUListAttributes>;
-export type BitsPrimitiveTdAttributes = BitsPrimitive<HTMLTdAttributes>;
-export type BitsPrimitiveThAttributes = BitsPrimitive<HTMLThAttributes>;
-export type BitsPrimitiveTableAttributes = BitsPrimitive<HTMLTableAttributes>;
-export type BitsPrimitiveTbodyAttributes = BitsPrimitive<BitsTableSectionAttributes>;
-export type BitsPrimitiveTrAttributes = BitsPrimitive<BitsTableRowAttributes>;
-export type BitsPrimitiveTheadAttributes = BitsPrimitive<BitsTableSectionAttributes>;
-export type BitsPrimitiveHeaderAttributes = BitsPrimitive<BitsElementAttributes>;
-export type BitsPrimitiveSelectAttributes = BitsPrimitive<BitsSelectAttributes>;

package/src/lib/internal/attrs.ts

@@ -1,64 +0,0 @@
-export const boolToStr = (condition: boolean): 'true' | 'false' => condition ? 'true' : 'false';
-
-export const boolToStrTrueOrUndef = (condition: boolean): 'true' | undefined => condition ? 'true' : undefined;
-
-export const boolToEmptyStrOrUndef = (condition: boolean): '' | undefined => condition ? '' : undefined;
-
-export const boolToTrueOrUndef = (condition: boolean): true | undefined => condition ? true : undefined;
-
-export const getDataOpenClosed = (condition: boolean): 'open' | 'closed' => condition ? 'open' : 'closed';
-
-export type TransitionState = 'starting' | 'ending' | 'idle' | undefined;
-
-export const getAriaChecked = (checked: boolean, indeterminate: boolean): 'true' | 'false' | 'mixed' =>
-	indeterminate ? 'mixed' : checked ? 'true' : 'false';
-
-export type BitsAttrsConfig<T extends readonly string[]> = {
-	component: string;
-	parts: T;
-	getVariant?: () => string | null;
-};
-
-export type CreateBitsAttrsReturn<T extends readonly string[]> = {
-	[K in T[number]]: string;
-} & {
-	selector: (part: T[number]) => string;
-	getAttr: (part: T[number], variant?: string) => string;
-};
-
-export class BitsAttrs<T extends readonly string[]> {
-	readonly #variant: string | null;
-	readonly #prefix: string;
-	attrs: Record<T[number], string>;
-
-	constructor(config: BitsAttrsConfig<T>) {
-		this.#variant = config.getVariant ? config.getVariant() : null;
-		this.#prefix = this.#variant ? `data-${this.#variant}-` : `data-${config.component}-`;
-
-		this.getAttr = this.getAttr.bind(this);
-		this.selector = this.selector.bind(this);
-
-		this.attrs = Object.fromEntries(config.parts.map((part) => [part, this.getAttr(part)])) as Record<T[number], string>;
-	}
-
-	getAttr(part: T[number], variantOverride?: string): string {
-		if (variantOverride) return `data-${variantOverride}-${part}`;
-		return `${this.#prefix}${part}`;
-	}
-
-	selector(part: T[number], variantOverride?: string): string {
-		return `[${this.getAttr(part, variantOverride)}]`;
-	}
-}
-
-export function createBitsAttrs<const T extends readonly string[]>(
-	config: Omit<BitsAttrsConfig<T>, 'parts'> & { parts: T },
-): CreateBitsAttrsReturn<T> {
-	const bitsAttrs = new BitsAttrs(config);
-
-	return {
-		...bitsAttrs.attrs,
-		selector: bitsAttrs.selector,
-		getAttr: bitsAttrs.getAttr,
-	} as CreateBitsAttrsReturn<T>;
-}