@stll/ui 0.0.1-placeholder.0 → 0.3.0

package/dist/kanban/column-header.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from "react";
+//#region src/kanban/column-header.d.ts
+type KanbanColumnHeaderProps = {
+  /** Colour swatch, or the control that changes it. */
+  swatch?: ReactNode;
+  /** The column name, or the editor that has taken its place. */
+  title: ReactNode;
+  /** Short text after the name, such as the card count the caller formatted. */
+  meta?: ReactNode;
+  /** Column calculation, rendered after the count. */
+  calculation?: ReactNode;
+  /** Drag affordance, revealed on hover over the column. */
+  dragHandle?: ReactNode;
+  /** Column menu. */
+  actions?: ReactNode;
+};
+/**
+ * The column header row: one rhythm for the swatch, the name, the count, the
+ * calculation, and the column's controls, so every board's header lines up.
+ */
+declare const KanbanColumnHeader: ({ swatch, title, meta, calculation, dragHandle, actions }: KanbanColumnHeaderProps) => import("react").JSX.Element;
+//#endregion
+export { KanbanColumnHeader, KanbanColumnHeaderProps };

package/dist/kanban/column-header.js

@@ -0,0 +1,24 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/kanban/column-header.tsx
+/**
+* The column header row: one rhythm for the swatch, the name, the count, the
+* calculation, and the column's controls, so every board's header lines up.
+*/
+const KanbanColumnHeader = ({ swatch, title, meta, calculation, dragHandle, actions }) => /* @__PURE__ */ jsxs("div", {
+	className: "flex items-center gap-2 px-3 py-2",
+	children: [
+		swatch,
+		/* @__PURE__ */ jsxs("span", {
+			className: "flex min-w-0 flex-1 items-center gap-1.5 truncate",
+			children: [title, meta !== void 0 && /* @__PURE__ */ jsx("span", {
+				className: "text-muted-foreground text-xs",
+				children: meta
+			})]
+		}),
+		calculation,
+		dragHandle,
+		actions
+	]
+});
+//#endregion
+export { KanbanColumnHeader };

package/dist/kanban/grouping.d.ts

@@ -0,0 +1,84 @@
+import { OptionColor } from "../lib/option-color.js";
+//#region src/kanban/grouping.d.ts
+/** One column, before the uncategorized bucket is appended. */
+type KanbanGroupOption = {
+  value: string;
+  label: string;
+  color?: string | undefined;
+  colorBg?: string | undefined;
+  optionColor?: OptionColor | undefined;
+};
+/** A column, including the uncategorized bucket (`value: null`). */
+type KanbanGroup = {
+  value: string | null;
+  label: string;
+  color?: string | undefined;
+  colorBg?: string | undefined;
+  optionColor?: OptionColor | undefined;
+};
+/**
+ * A column source that is not a schema property, addressed by a reserved id.
+ *
+ * The board's columns are the caller's `options`, in the caller's order, so a
+ * built-in grouping is a data declaration rather than a branch this module has
+ * to know about.
+ */
+type KanbanBuiltInGroup<TRow> = {
+  /** Reserved group id, distinct from any property id. */
+  id: string;
+  /** Ordered columns, without the uncategorized bucket. */
+  options: readonly KanbanGroupOption[];
+  /**
+   * Narrows the board to the rows this grouping can place. Omit when every row
+   * belongs on the board.
+   */
+  selectRows?: ((rows: readonly TRow[]) => TRow[]) | undefined;
+};
+/**
+ * Everything the grouping needs to know about a board.
+ *
+ * `getPropertyOptions` returns `null` for a property that cannot carry columns,
+ * which keeps the decision — and the property model it depends on — with the
+ * caller.
+ */
+type KanbanSchema<TRow, TProperty> = {
+  builtInGroups: readonly KanbanBuiltInGroup<TRow>[];
+  properties: readonly TProperty[];
+  getPropertyId: (property: TProperty) => string;
+  getPropertyOptions: (property: TProperty) => readonly KanbanGroupOption[] | null;
+};
+type KanbanGrouping<TRow, TProperty> = {
+  type: "none";
+} | {
+  type: "built-in";
+  propertyId: string;
+  group: KanbanBuiltInGroup<TRow>;
+} | {
+  type: "property";
+  propertyId: string;
+  property: TProperty;
+  options: readonly KanbanGroupOption[];
+};
+type ResolveKanbanGroupingParams<TRow, TProperty> = {
+  /** The group-by id the view carries; empty means no grouping. */
+  groupBy: string;
+  schema: KanbanSchema<TRow, TProperty>;
+};
+/** Resolve a stored group-by id against a schema. */
+declare const resolveKanbanGrouping: <TRow, TProperty>({ groupBy, schema }: ResolveKanbanGroupingParams<TRow, TProperty>) => KanbanGrouping<TRow, TProperty>;
+declare const getKanbanGroupingPropertyId: <TRow, TProperty>(grouping: KanbanGrouping<TRow, TProperty>) => string | null;
+/**
+ * A grouping with no columns is not a board. A built-in grouping declares its
+ * columns up front, so an empty declaration is the signal that the board cannot
+ * be drawn; a property grouping always draws, even when the property has no
+ * options yet, because rows still land in the uncategorized bucket.
+ */
+declare const isKanbanGroupingRenderable: <TRow, TProperty>(grouping: KanbanGrouping<TRow, TProperty>) => boolean;
+/** The rows a grouping can place on the board, in their incoming order. */
+declare const selectKanbanRows: <TRow, TProperty>(rows: readonly TRow[], grouping: KanbanGrouping<TRow, TProperty>) => TRow[];
+/** The static column options for a grouping, excluding uncategorized. */
+declare const resolveKanbanGroupOptions: <TRow, TProperty>(grouping: KanbanGrouping<TRow, TProperty>) => readonly KanbanGroupOption[];
+/** Append the uncategorized bucket (null value) after the options. */
+declare const getKanbanGroups: (options: readonly KanbanGroupOption[], uncategorizedLabel: string) => KanbanGroup[];
+//#endregion
+export { KanbanBuiltInGroup, KanbanGroup, KanbanGroupOption, KanbanGrouping, KanbanSchema, ResolveKanbanGroupingParams, getKanbanGroupingPropertyId, getKanbanGroups, isKanbanGroupingRenderable, resolveKanbanGroupOptions, resolveKanbanGrouping, selectKanbanRows };

package/dist/kanban/grouping.js

@@ -0,0 +1,76 @@
+//#region src/kanban/grouping.ts
+/** Resolve a stored group-by id against a schema. */
+const resolveKanbanGrouping = ({ groupBy, schema }) => {
+	if (groupBy === "") return { type: "none" };
+	const builtIn = schema.builtInGroups.find((group) => group.id === groupBy);
+	if (builtIn !== void 0) return {
+		type: "built-in",
+		propertyId: groupBy,
+		group: builtIn
+	};
+	const property = schema.properties.find((candidate) => schema.getPropertyId(candidate) === groupBy);
+	if (property === void 0) return { type: "none" };
+	return {
+		type: "property",
+		propertyId: groupBy,
+		property,
+		options: schema.getPropertyOptions(property) ?? []
+	};
+};
+const getKanbanGroupingPropertyId = (grouping) => {
+	switch (grouping.type) {
+		case "none": return null;
+		case "built-in":
+		case "property": return grouping.propertyId;
+		default: return grouping;
+	}
+};
+/**
+* A grouping with no columns is not a board. A built-in grouping declares its
+* columns up front, so an empty declaration is the signal that the board cannot
+* be drawn; a property grouping always draws, even when the property has no
+* options yet, because rows still land in the uncategorized bucket.
+*/
+const isKanbanGroupingRenderable = (grouping) => {
+	switch (grouping.type) {
+		case "none": return false;
+		case "built-in": return grouping.group.options.length > 0;
+		case "property": return true;
+		default: return grouping;
+	}
+};
+/** The rows a grouping can place on the board, in their incoming order. */
+const selectKanbanRows = (rows, grouping) => {
+	switch (grouping.type) {
+		case "none": return [];
+		case "built-in": return grouping.group.selectRows ? grouping.group.selectRows(rows) : [...rows];
+		case "property": return [...rows];
+		default: return grouping;
+	}
+};
+/** The static column options for a grouping, excluding uncategorized. */
+const resolveKanbanGroupOptions = (grouping) => {
+	switch (grouping.type) {
+		case "none": return [];
+		case "built-in": return grouping.group.options;
+		case "property": return grouping.options;
+		default: return grouping;
+	}
+};
+/** Append the uncategorized bucket (null value) after the options. */
+const getKanbanGroups = (options, uncategorizedLabel) => {
+	const result = options.map((option) => ({
+		value: option.value,
+		label: option.label,
+		color: option.color,
+		colorBg: option.colorBg,
+		optionColor: option.optionColor
+	}));
+	result.push({
+		value: null,
+		label: uncategorizedLabel
+	});
+	return result;
+};
+//#endregion
+export { getKanbanGroupingPropertyId, getKanbanGroups, isKanbanGroupingRenderable, resolveKanbanGroupOptions, resolveKanbanGrouping, selectKanbanRows };

package/dist/kanban/index.d.ts

@@ -0,0 +1,5 @@
+import { KanbanCardFieldSelection, selectKanbanCardFieldIds } from "./card-properties.js";
+import { KanbanCardShell, KanbanCardShellProps } from "./card-shell.js";
+import { KanbanColumnHeader, KanbanColumnHeaderProps } from "./column-header.js";
+import { KanbanBuiltInGroup, KanbanGroup, KanbanGroupOption, KanbanGrouping, KanbanSchema, ResolveKanbanGroupingParams, getKanbanGroupingPropertyId, getKanbanGroups, isKanbanGroupingRenderable, resolveKanbanGroupOptions, resolveKanbanGrouping, selectKanbanRows } from "./grouping.js";
+export { type KanbanBuiltInGroup, type KanbanCardFieldSelection, KanbanCardShell, type KanbanCardShellProps, KanbanColumnHeader, type KanbanColumnHeaderProps, type KanbanGroup, type KanbanGroupOption, type KanbanGrouping, type KanbanSchema, type ResolveKanbanGroupingParams, getKanbanGroupingPropertyId, getKanbanGroups, isKanbanGroupingRenderable, resolveKanbanGroupOptions, resolveKanbanGrouping, selectKanbanCardFieldIds, selectKanbanRows };

package/dist/kanban/index.js

@@ -0,0 +1,5 @@
+import { selectKanbanCardFieldIds } from "./card-properties.js";
+import { KanbanCardShell } from "./card-shell.js";
+import { KanbanColumnHeader } from "./column-header.js";
+import { getKanbanGroupingPropertyId, getKanbanGroups, isKanbanGroupingRenderable, resolveKanbanGroupOptions, resolveKanbanGrouping, selectKanbanRows } from "./grouping.js";
+export { KanbanCardShell, KanbanColumnHeader, getKanbanGroupingPropertyId, getKanbanGroups, isKanbanGroupingRenderable, resolveKanbanGroupOptions, resolveKanbanGrouping, selectKanbanCardFieldIds, selectKanbanRows };

package/dist/lib/button-disposition.d.ts

@@ -0,0 +1,63 @@
+import * as React$1 from "react";
+//#region src/lib/button-disposition.d.ts
+/**
+ * How a button expresses "unavailable".
+ *
+ * `buttonVariants` carries `disabled:pointer-events-none`, and the browser
+ * suppresses pointer and focus events on a natively disabled control anyway, so
+ * a disabled button never receives hover or focus. A tooltip attached to it can
+ * therefore never open, which is exactly when the user most needs to be told
+ * why the action is unavailable. When there is a tooltip to show, the button
+ * switches to the ARIA accessible-disabled pattern instead: it stays in the tab
+ * order and keeps receiving pointer events, while every activation path is
+ * blocked (see `blockDisabledActivation`).
+ *
+ * This mirrors Base UI's own `focusableWhenDisabled` disposition
+ * (`useFocusableWhenDisabled`): `aria-disabled` instead of `disabled`, focusable,
+ * and non-`Tab` key defaults suppressed.
+ */
+declare const BUTTON_DISPOSITION: {
+  readonly enabled: "enabled";
+  /** Native `disabled`: out of the tab order, inert to pointer and keyboard. */
+  readonly nativeDisabled: "native-disabled";
+  /** `aria-disabled`: focusable and hoverable so its tooltip can still open. */
+  readonly accessibleDisabled: "accessible-disabled";
+};
+type ButtonDisposition = (typeof BUTTON_DISPOSITION)[keyof typeof BUTTON_DISPOSITION];
+type ButtonDispositionInput = {
+  disabled: boolean | undefined;
+  loading: boolean | undefined;
+  /** Resolved tooltip content, i.e. what `renderTooltipTrigger` would mount. */
+  tooltip: React$1.ReactNode;
+};
+declare const resolveButtonDisposition: ({ disabled, loading, tooltip }: ButtonDispositionInput) => ButtonDisposition;
+/**
+ * The parts of a React synthetic event these blockers touch.
+ *
+ * `preventBaseUIHandler` is added by Base UI's `mergeProps` to the rightmost
+ * handler in a merged chain; calling it stops the handlers merged to its left,
+ * which is how a caller's own `onClick` is suppressed.
+ */
+type BlockableEvent = {
+  preventDefault: () => void;
+  preventBaseUIHandler?: (() => void) | undefined;
+};
+/**
+ * Swallow an activation on an `aria-disabled` control.
+ *
+ * `preventDefault()` is what keeps a `type="submit"` button from submitting its
+ * form: the browser's form-submission default runs off the click event, and
+ * implicit submission (Enter in a text field) dispatches a click at the form's
+ * default button, so both paths funnel through here.
+ */
+declare const blockDisabledActivation: (event: BlockableEvent) => void;
+/**
+ * The keyboard counterpart. `Tab` keeps its default so focus can leave the
+ * control; suppressing the default on `Enter`/`Space` stops the browser from
+ * synthesizing the click that would activate or submit.
+ */
+declare const blockDisabledKeyActivation: (event: BlockableEvent & {
+  key: string;
+}) => void;
+//#endregion
+export { BUTTON_DISPOSITION, ButtonDisposition, blockDisabledActivation, blockDisabledKeyActivation, resolveButtonDisposition };

package/dist/lib/button-disposition.js

@@ -0,0 +1,52 @@
+import { hasTooltipContent } from "./tooltip-content.js";
+//#region src/lib/button-disposition.ts
+/**
+* How a button expresses "unavailable".
+*
+* `buttonVariants` carries `disabled:pointer-events-none`, and the browser
+* suppresses pointer and focus events on a natively disabled control anyway, so
+* a disabled button never receives hover or focus. A tooltip attached to it can
+* therefore never open, which is exactly when the user most needs to be told
+* why the action is unavailable. When there is a tooltip to show, the button
+* switches to the ARIA accessible-disabled pattern instead: it stays in the tab
+* order and keeps receiving pointer events, while every activation path is
+* blocked (see `blockDisabledActivation`).
+*
+* This mirrors Base UI's own `focusableWhenDisabled` disposition
+* (`useFocusableWhenDisabled`): `aria-disabled` instead of `disabled`, focusable,
+* and non-`Tab` key defaults suppressed.
+*/
+const BUTTON_DISPOSITION = {
+	enabled: "enabled",
+	/** Native `disabled`: out of the tab order, inert to pointer and keyboard. */
+	nativeDisabled: "native-disabled",
+	/** `aria-disabled`: focusable and hoverable so its tooltip can still open. */
+	accessibleDisabled: "accessible-disabled"
+};
+const resolveButtonDisposition = ({ disabled, loading, tooltip }) => {
+	if (disabled !== true && loading !== true) return BUTTON_DISPOSITION.enabled;
+	return hasTooltipContent(tooltip) ? BUTTON_DISPOSITION.accessibleDisabled : BUTTON_DISPOSITION.nativeDisabled;
+};
+/**
+* Swallow an activation on an `aria-disabled` control.
+*
+* `preventDefault()` is what keeps a `type="submit"` button from submitting its
+* form: the browser's form-submission default runs off the click event, and
+* implicit submission (Enter in a text field) dispatches a click at the form's
+* default button, so both paths funnel through here.
+*/
+const blockDisabledActivation = (event) => {
+	event.preventBaseUIHandler?.();
+	event.preventDefault();
+};
+/**
+* The keyboard counterpart. `Tab` keeps its default so focus can leave the
+* control; suppressing the default on `Enter`/`Space` stops the browser from
+* synthesizing the click that would activate or submit.
+*/
+const blockDisabledKeyActivation = (event) => {
+	event.preventBaseUIHandler?.();
+	if (event.key !== "Tab") event.preventDefault();
+};
+//#endregion
+export { BUTTON_DISPOSITION, blockDisabledActivation, blockDisabledKeyActivation, resolveButtonDisposition };

package/dist/lib/option-color.d.ts

@@ -0,0 +1,28 @@
+//#region src/lib/option-color.d.ts
+/**
+ * The kit's colour token for user-chosen option colours.
+ *
+ * A token is either one of the sixteen named presets, which resolve to the
+ * theme's `--option-*` custom properties, or a six-character hex string, which
+ * resolves to a `color-mix` against the current background and foreground. The
+ * indirection is what keeps a stored colour theme-aware: nothing persists a
+ * literal colour the palette cannot re-tint.
+ *
+ * This lives in the kit rather than beside a data model because the resolver is
+ * pure presentation: it maps a token to CSS, and knows nothing about what the
+ * token was chosen for.
+ */
+/** Named preset or arbitrary 6-character hex colour (e.g. "FF0000"). */
+type OptionColor = "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "emerald" | "teal" | "cyan" | "sky" | "blue" | "indigo" | "violet" | "purple" | "fuchsia" | "gray" | (string & Record<never, never>);
+type ColorVariants = {
+  background: string;
+  foreground: string;
+  color: string;
+};
+declare const emptyColor: ColorVariants;
+/** Resolve any OptionColor (named or hex) to CSS color variants. */
+declare const resolveOptionColor: (color: OptionColor) => ColorVariants;
+/** The 16 named preset color keys. */
+declare const optionColors: readonly OptionColor[];
+//#endregion
+export { ColorVariants, OptionColor, emptyColor, optionColors, resolveOptionColor };

package/dist/lib/option-color.js

@@ -0,0 +1,59 @@
+//#region src/lib/option-color.ts
+/** Named preset colors with CSS variable references. */
+const NAMED_COLORS = Object.freeze([
+	"red",
+	"orange",
+	"amber",
+	"yellow",
+	"lime",
+	"green",
+	"emerald",
+	"teal",
+	"cyan",
+	"sky",
+	"blue",
+	"indigo",
+	"violet",
+	"purple",
+	"fuchsia",
+	"gray"
+]);
+const optionVar = (name) => ({
+	background: `var(--option-${name}-bg)`,
+	foreground: `var(--option-${name}-fg)`,
+	color: `var(--option-${name})`
+});
+const hexVar = (hex) => ({
+	background: `color-mix(in srgb, #${hex} 12%, var(--background))`,
+	foreground: `color-mix(in srgb, #${hex} 50%, var(--foreground))`,
+	color: `#${hex}`
+});
+const namedColorsMap = {
+	red: optionVar("red"),
+	orange: optionVar("orange"),
+	amber: optionVar("amber"),
+	yellow: optionVar("yellow"),
+	lime: optionVar("lime"),
+	green: optionVar("green"),
+	emerald: optionVar("emerald"),
+	teal: optionVar("teal"),
+	cyan: optionVar("cyan"),
+	sky: optionVar("sky"),
+	blue: optionVar("blue"),
+	indigo: optionVar("indigo"),
+	violet: optionVar("violet"),
+	purple: optionVar("purple"),
+	fuchsia: optionVar("fuchsia"),
+	gray: optionVar("gray")
+};
+const emptyColor = optionVar("empty");
+/** Resolve any OptionColor (named or hex) to CSS color variants. */
+const resolveOptionColor = (color) => {
+	const namedColor = NAMED_COLORS.find((candidate) => candidate === color);
+	if (namedColor !== void 0) return namedColorsMap[namedColor];
+	return hexVar(color);
+};
+/** The 16 named preset color keys. */
+const optionColors = NAMED_COLORS;
+//#endregion
+export { emptyColor, optionColors, resolveOptionColor };

package/dist/lib/overlay-layer.d.ts

@@ -0,0 +1,22 @@
+//#region src/lib/overlay-layer.d.ts
+declare const OVERLAY_LAYER_CLASS_NAMES: {
+  /** Docked composer, suggestion chips, and other in-pane floating chrome. */
+  readonly chrome: "z-[80]";
+  /** Dialogs, sheets, popovers, tooltips: above chrome, below toasts. */
+  readonly default: "z-[85]";
+  /** Search sits a hair above a plain dialog so its own popup wins. */
+  readonly search: "z-[86]";
+  /**
+   * Transient popups — menu, select, combobox, context menus. Above everything
+   * including the toast viewport (z-[90]), because any of them can be opened
+   * *from* a dialog, a popover or a toast action and must cover its opener.
+   * They sat at z-50 alongside dialogs, so which one won was decided by portal
+   * mount order: a select inside a filter popover rendered behind it.
+   */
+  readonly popup: "z-[100]";
+  /** Historical alias for `popup`; Search's own menus use the same band. */
+  readonly "search-child": "z-[100]";
+};
+type OverlayLayer = keyof typeof OVERLAY_LAYER_CLASS_NAMES;
+//#endregion
+export { OVERLAY_LAYER_CLASS_NAMES, OverlayLayer };

package/dist/lib/overlay-layer.js

@@ -0,0 +1,21 @@
+//#region src/lib/overlay-layer.ts
+const OVERLAY_LAYER_CLASS_NAMES = {
+	/** Docked composer, suggestion chips, and other in-pane floating chrome. */
+	chrome: "z-[80]",
+	/** Dialogs, sheets, popovers, tooltips: above chrome, below toasts. */
+	default: "z-[85]",
+	/** Search sits a hair above a plain dialog so its own popup wins. */
+	search: "z-[86]",
+	/**
+	* Transient popups — menu, select, combobox, context menus. Above everything
+	* including the toast viewport (z-[90]), because any of them can be opened
+	* *from* a dialog, a popover or a toast action and must cover its opener.
+	* They sat at z-50 alongside dialogs, so which one won was decided by portal
+	* mount order: a select inside a filter popover rendered behind it.
+	*/
+	popup: "z-[100]",
+	/** Historical alias for `popup`; Search's own menus use the same band. */
+	"search-child": "z-[100]"
+};
+//#endregion
+export { OVERLAY_LAYER_CLASS_NAMES };

package/dist/lib/tab-order.d.ts

@@ -0,0 +1,15 @@
+//#region src/lib/tab-order.d.ts
+/**
+ * Whether a committed tab list holds different elements, or the same elements
+ * in a different order, than the previous commit.
+ *
+ * Base UI measures the tabs indicator during render, so it reads the DOM as it
+ * stood before the commit. Its correction is a `ResizeObserver`, which catches
+ * an insertion or a removal (the list's own width changes) but not a reorder:
+ * there the tabs swap places without anything changing size. Detecting that is
+ * the whole of the workaround, so compare identity rather than count, because
+ * React moves the same nodes when it reorders keyed children.
+ */
+declare const hasTabOrderChanged: <T>(previous: readonly T[], next: readonly T[]) => boolean;
+//#endregion
+export { hasTabOrderChanged };

package/dist/lib/tab-order.js

@@ -0,0 +1,15 @@
+//#region src/lib/tab-order.ts
+/**
+* Whether a committed tab list holds different elements, or the same elements
+* in a different order, than the previous commit.
+*
+* Base UI measures the tabs indicator during render, so it reads the DOM as it
+* stood before the commit. Its correction is a `ResizeObserver`, which catches
+* an insertion or a removal (the list's own width changes) but not a reorder:
+* there the tabs swap places without anything changing size. Detecting that is
+* the whole of the workaround, so compare identity rather than count, because
+* React moves the same nodes when it reorders keyed children.
+*/
+const hasTabOrderChanged = (previous, next) => previous.length !== next.length || next.some((tab, index) => tab !== previous[index]);
+//#endregion
+export { hasTabOrderChanged };

package/dist/lib/tooltip-content.d.ts

@@ -0,0 +1,13 @@
+import * as React$1 from "react";
+//#region src/lib/tooltip-content.d.ts
+/**
+ * Whether a tooltip value would actually render a popup.
+ *
+ * Single source of truth for "there is a tooltip": `renderTooltipTrigger`
+ * decides whether to mount one, and `resolveButtonDisposition` decides whether
+ * a disabled button has to stay hoverable so that popup can open. Two copies of
+ * this predicate would drift into a button that suppresses its own tooltip.
+ */
+declare const hasTooltipContent: (content: React$1.ReactNode) => boolean;
+//#endregion
+export { hasTooltipContent };

package/dist/lib/tooltip-content.js

@@ -0,0 +1,12 @@
+//#region src/lib/tooltip-content.ts
+/**
+* Whether a tooltip value would actually render a popup.
+*
+* Single source of truth for "there is a tooltip": `renderTooltipTrigger`
+* decides whether to mount one, and `resolveButtonDisposition` decides whether
+* a disabled button has to stay hoverable so that popup can open. Two copies of
+* this predicate would drift into a button that suppresses its own tooltip.
+*/
+const hasTooltipContent = (content) => content !== void 0 && content !== null && content !== "" && content !== false;
+//#endregion
+export { hasTooltipContent };

package/dist/lib/utils.d.ts

@@ -0,0 +1,20 @@
+import { ClassValue } from "clsx";
+import * as React$1 from "react";
+//#region src/lib/utils.d.ts
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Compose multiple refs into a single ref callback.
+ * Adapted from `@radix-ui/react-compose-refs` (MIT).
+ *
+ * Collects cleanup functions returned by React 19 ref
+ * callbacks and returns a combined cleanup so React can
+ * invoke it on unmount instead of re-calling with `null`.
+ *
+ * Use this rather than merging refs inline: forwarding a
+ * caller's return value verbatim makes React read whatever
+ * their callback happened to return as a cleanup, and warn
+ * when it is neither a function nor `undefined`.
+ */
+declare const composeRefs: <T>(...refs: (React$1.Ref<T> | undefined)[]) => ((node: T | null) => (() => void) | undefined);
+//#endregion
+export { cn, composeRefs };

package/dist/lib/utils.js

@@ -0,0 +1,41 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+//#region src/lib/utils.ts
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+/**
+* Compose multiple refs into a single ref callback.
+* Adapted from `@radix-ui/react-compose-refs` (MIT).
+*
+* Collects cleanup functions returned by React 19 ref
+* callbacks and returns a combined cleanup so React can
+* invoke it on unmount instead of re-calling with `null`.
+*
+* Use this rather than merging refs inline: forwarding a
+* caller's return value verbatim makes React read whatever
+* their callback happened to return as a cleanup, and warn
+* when it is neither a function nor `undefined`.
+*/
+const composeRefs = (...refs) => (node) => {
+	const cleanups = [];
+	for (const ref of refs) if (typeof ref === "function") {
+		const cleanup = ref(node);
+		if (typeof cleanup === "function") cleanups.push(() => {
+			cleanup();
+		});
+		else if (node !== null) cleanups.push(() => {
+			ref(null);
+		});
+	} else if (ref !== void 0 && ref !== null) {
+		ref.current = node;
+		if (node !== null) cleanups.push(() => {
+			ref.current = null;
+		});
+	}
+	if (cleanups.length > 0) return () => {
+		for (const cleanup of cleanups) cleanup();
+	};
+};
+//#endregion
+export { cn, composeRefs };

package/dist/lib/week.d.ts

@@ -0,0 +1,25 @@
+//#region src/lib/week.d.ts
+/**
+ * Locale week data (first weekday, weekend) derived from CLDR via Intl.
+ * Shared so the app shell and the date picker resolve week starts identically.
+ */
+/**
+ * Read CLDR week info for a locale, tolerating the legacy `weekInfo` accessor
+ * on engines that predate `getWeekInfo()`. Returns undefined when unavailable
+ * so callers can apply their own fallback.
+ */
+declare const getLocaleWeekInfo: (locale: string) => Intl.WeekInfo | undefined;
+/**
+ * First weekday as a `Date.getDay()` value (0 = Sunday … 6 = Saturday): Monday
+ * across most of Europe, Sunday in the US, Saturday across much of the Gulf.
+ * Falls back to Monday when the runtime lacks week info.
+ */
+declare const getFirstWeekday: (locale: string) => number;
+/**
+ * Weekend weekdays as `Date.getDay()` values (0 = Sunday … 6 = Saturday):
+ * Saturday/Sunday across the West, Friday/Saturday across much of the Gulf.
+ * Falls back to Saturday/Sunday when the runtime lacks week info.
+ */
+declare const getWeekendDays: (locale: string) => ReadonlySet<number>;
+//#endregion
+export { getFirstWeekday, getLocaleWeekInfo, getWeekendDays };