origam 2.14.1 → 2.16.0

package/dist/src/interfaces/CommandPalette/command.interface.d.ts

@@ -1,3 +1,4 @@
+import type { ComputedRef, Ref } from 'vue';
 import type { TIcon } from '../../types';
 /**
  * A single command/action exposed by `OrigamCommandPalette`.
@@ -49,3 +50,49 @@ export interface ICommand {
     /** Disabled commands stay visible but cannot be selected. */
     disabled?: boolean;
 }
+/**
+ * Backing store of `useCommand`'s process-wide singleton registry.
+ *
+ * Module-scoped rather than provide/inject on purpose: commands are
+ * spawned from anywhere — feature code, plugins, background services —
+ * without coupling to a Vue tree.
+ */
+export interface ICommandRegistry {
+    /** Live array of registered commands. Dedup by id is enforced at write time. */
+    items: Ref<Array<ICommand>>;
+    /** Whether the global palette singleton is currently open. */
+    isOpen: Ref<boolean>;
+}
+/** Public API returned by `useCommand`. */
+export interface IUseCommandReturn {
+    /**
+     * Register a command. Returns an `unregister()` closure so callers
+     * can drop the entry imperatively. When called from inside a Vue
+     * effect scope, the entry is auto-unregistered on scope dispose
+     * (component unmount, route leave, …) via `tryOnScopeDispose`.
+     */
+    register: (cmd: ICommand) => () => void;
+    /** Drop the entry with the matching `id`. No-op if unknown. */
+    unregister: (id: string) => void;
+    /**
+     * Reactive read-only view of every registered command, deduplicated
+     * by id.
+     */
+    commands: ComputedRef<ReadonlyArray<ICommand>>;
+    /** Open the global palette singleton. */
+    open: () => void;
+    /** Close the global palette singleton. */
+    close: () => void;
+    /** Reactive open/close state of the global palette singleton. */
+    isOpen: Ref<boolean>;
+}
+/**
+ * Output of `fuzzyMatch` — the matched item carries its score so callers
+ * can short-circuit a re-sort on cached input.
+ */
+export interface IFuzzyMatchResult<T> {
+    /** Original item passed in. */
+    item: T;
+    /** Higher = better fit. `0` is the floor for a successful match. */
+    score: number;
+}

package/dist/src/interfaces/Commons/border.interface.d.ts

@@ -5,7 +5,23 @@ export interface IBorderProps {
     borderLeft?: boolean | number | string;
     borderBottom?: boolean | number | string;
     borderRight?: boolean | number | string;
+    /**
+     * Logical-axis shorthand for the block-start + block-end edges (top +
+     * bottom in the default horizontal-tb writing mode). Resolves to the
+     * native CSS `border-block-{width,style,color}` properties — same
+     * value grammar as `borderTop` / `borderRight` / `borderBottom` /
+     * `borderLeft` (boolean opt-in, bare width number, or a free-form
+     * `"width style color"` string). Precedence: beats the global `border`
+     * shorthand for the edges it targets, but a physical `borderTop` /
+     * `borderBottom` still wins over it for that specific edge — see
+     * `useBorder` JSDoc for the full precedence table.
+     */
     borderBlock?: boolean | number | string;
+    /**
+     * Logical-axis shorthand for the inline-start + inline-end edges (left
+     * + right in LTR). Same grammar and precedence rules as `borderBlock`,
+     * mapped onto `border-inline-{width,style,color}`.
+     */
     borderInline?: boolean | number | string;
     borderColor?: string;
     borderStyle?: string;

package/dist/src/interfaces/Commons/lazy.interface.d.ts

@@ -10,3 +10,7 @@ export interface ILazyComponentProps extends ICommonsComponentProps, IDimensionP
  *  observer flips the wrapper to "visible". */
 export interface ILazyEmits extends ICommonsComponentEmits {
 }
+/** Slot signatures for `<OrigamLazy>`. */
+export interface ILazySlots {
+    default?: () => any;
+}

package/dist/src/interfaces/Commons/loader.interface.d.ts

@@ -1,6 +1,33 @@
 import type { IColorProps, ICommonsComponentProps, ITagProps } from '../../interfaces';
-import type { TLoadingValue } from '../../types';
+import type { TLoaderConfig, TLoaderKind, TLoadingValue } from '../../types';
 export interface ILoaderProps extends ICommonsComponentProps, ITagProps, IColorProps {
     loading?: TLoadingValue;
     loadingText?: string;
 }
+/** Slot signatures for `<OrigamLoader>`. */
+export interface ILoaderSlots {
+    loader?: () => any;
+    default?: () => any;
+}
+/**
+ * Resolved loader state — what each consumer component reads to decide
+ * which renderer to mount and with which props.
+ *
+ * @remarks
+ * `overrides` is intentionally typed as `Omit<TLoaderConfig, 'type'>`. After
+ * the discriminant `type` is destructured at runtime, TypeScript can no
+ * longer narrow the union. Consumer components must access optional fields
+ * defensively (e.g. `(overrides as { modelValue?: number }).modelValue`).
+ */
+export interface IResolvedLoader {
+    /** Whether ANY loading state is active. */
+    isActive: boolean;
+    /** Which renderer to use ('line' / 'circular' / 'skeleton'). */
+    kind: TLoaderKind;
+    /** Determinate progress value (0..100) when the user passed a number; else undefined. */
+    modelValue: number | undefined;
+    /** Indeterminate when `true`, determinate when a number was passed. */
+    indeterminate: boolean;
+    /** Per-kind override props the consumer should v-bind on the renderer. */
+    overrides: Omit<TLoaderConfig, 'type'>;
+}

package/dist/src/interfaces/Commons/margin.interface.d.ts

@@ -1,9 +1,39 @@
+/**
+ * Outer-spacing surface.
+ *
+ * Precedence — SPECIFIC beats GLOBAL, same grammar as `IPaddingProps` /
+ * `IBorderProps` / `IRoundedProps`:
+ *
+ *   1. `margin`                       — global shorthand
+ *   2. `marginBlock` / `marginInline` — logical axis
+ *   3. `marginTop` / `marginRight` / `marginBottom` / `marginLeft`
+ *
+ * Each rung only overrides the edge(s) it targets. See
+ * `resolveSpacingValue` for the accepted value forms (the directionals
+ * also take the `auto` keyword), and
+ * `packages/docs/guide/spacing-and-corners.md` for the full reference.
+ *
+ * ⚠️ The 4-value `margin` shorthand distributes as
+ * **Haut/Gauche/Bas/Droite**, NOT the CSS clockwise order (issue #216).
+ * The per-side props exist so you never have to know that.
+ */
 export interface IMarginProps {
+    /**
+     * Global shorthand. `16` → `16px`; `"4"` → the `--origam-space---4`
+     * design rung; `"8px 16px"` → block / inline; `true` → the legacy
+     * `--marged` class.
+     */
     margin?: boolean | number | string;
+    /** Overrides `margin` and `marginBlock` for the top edge. */
     marginTop?: boolean | number | string;
+    /** Overrides `margin` and `marginInline` for the left edge. */
     marginLeft?: boolean | number | string;
+    /** Overrides `margin` and `marginBlock` for the bottom edge. */
     marginBottom?: boolean | number | string;
+    /** Overrides `margin` and `marginInline` for the right edge. */
     marginRight?: boolean | number | string;
+    /** Top + bottom. Overrides `margin`; beaten by `marginTop` / `marginBottom`. */
     marginBlock?: boolean | number | string;
+    /** Left + right. Overrides `margin`; beaten by `marginLeft` / `marginRight`. */
     marginInline?: boolean | number | string;
 }

package/dist/src/interfaces/Commons/padding.interface.d.ts

@@ -1,9 +1,38 @@
+/**
+ * Inner-spacing surface.
+ *
+ * Precedence — SPECIFIC beats GLOBAL, same grammar as `IMarginProps` /
+ * `IBorderProps` / `IRoundedProps`:
+ *
+ *   1. `padding`                        — global shorthand
+ *   2. `paddingBlock` / `paddingInline` — logical axis
+ *   3. `paddingTop` / `paddingRight` / `paddingBottom` / `paddingLeft`
+ *
+ * Each rung only overrides the edge(s) it targets. See
+ * `resolveSpacingValue` for the accepted value forms, and
+ * `packages/docs/guide/spacing-and-corners.md` for the full reference.
+ *
+ * ⚠️ The 4-value `padding` shorthand distributes as
+ * **Haut/Gauche/Bas/Droite**, NOT the CSS clockwise order (issue #216).
+ * The per-side props exist so you never have to know that.
+ */
 export interface IPaddingProps {
+    /**
+     * Global shorthand. `16` → `16px`; `"4"` → the `--origam-space---4`
+     * design rung; `"8px 16px"` → block / inline; `true` → the legacy
+     * `--padded` class.
+     */
     padding?: boolean | number | string;
+    /** Overrides `padding` and `paddingBlock` for the top edge. */
     paddingTop?: boolean | number | string;
+    /** Overrides `padding` and `paddingInline` for the left edge. */
     paddingLeft?: boolean | number | string;
+    /** Overrides `padding` and `paddingBlock` for the bottom edge. */
     paddingBottom?: boolean | number | string;
+    /** Overrides `padding` and `paddingInline` for the right edge. */
     paddingRight?: boolean | number | string;
+    /** Top + bottom. Overrides `padding`; beaten by `paddingTop` / `paddingBottom`. */
     paddingBlock?: boolean | number | string;
+    /** Left + right. Overrides `padding`; beaten by `paddingLeft` / `paddingRight`. */
     paddingInline?: boolean | number | string;
 }

package/dist/src/interfaces/Commons/rounded.interface.d.ts

@@ -1,4 +1,20 @@
 import type { TRounded } from '../../types';
+/**
+ * Corner-radius surface.
+ *
+ * Precedence — SPECIFIC beats GLOBAL, same grammar as `IPaddingProps` /
+ * `IMarginProps` / `IBorderProps`, with two rungs instead of three (there
+ * is no logical-axis form for corners):
+ *
+ *   1. `rounded`                   — global shorthand
+ *   2. `roundedTopLeft` / `roundedTopRight` /
+ *      `roundedBottomLeft` / `roundedBottomRight`
+ *
+ * A corner prop only overrides the corner it targets — `rounded="lg"` plus
+ * `roundedTopLeft="0px"` flattens one corner and leaves the other three at
+ * `lg`. See `resolveRoundedCornerValue` for the accepted value forms and
+ * `packages/docs/guide/spacing-and-corners.md` for the full reference.
+ */
 export interface IRoundedProps {
     /**
      * Corner-radius selector. Three modes:
@@ -12,8 +28,16 @@ export interface IRoundedProps {
      *    `border-radius` declarations via `useRounded.roundedStyles`.
      */
     rounded?: boolean | number | string | TRounded | null | undefined;
+    /**
+     * Top-right corner only. Takes the same vocabulary as `rounded`
+     * (`8`, `'8px'`, `'md'`, `'large'`, `'var(…)'`), minus `shaped` /
+     * `shaped-invert` which are asymmetric by definition.
+     */
     roundedTopRight?: boolean | number | string;
+    /** Top-left corner only. Same vocabulary as `roundedTopRight`. */
     roundedTopLeft?: boolean | number | string;
+    /** Bottom-left corner only. Same vocabulary as `roundedTopRight`. */
     roundedBottomLeft?: boolean | number | string;
+    /** Bottom-right corner only. Same vocabulary as `roundedTopRight`. */
     roundedBottomRight?: boolean | number | string;
 }

package/dist/src/interfaces/Counter/counter.interface.d.ts

@@ -5,3 +5,13 @@ export interface ICounterProps extends ICommonsComponentProps, ITagProps, IPaddi
     max?: string | number;
     value?: string | number;
 }
+/** Slot signatures for `<OrigamCounter>`. `value` defaults to `0`
+ *  (`withDefaults`) so it's always defined at runtime; `max` has no
+ *  default and stays optional. */
+export interface ICounterSlots {
+    default?: (data: {
+        counter: string;
+        max?: string | number;
+        value: string | number;
+    }) => any;
+}

package/dist/src/interfaces/CssSupport/css-support.interface.d.ts

@@ -0,0 +1,43 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { TCssFeatureName, TCssSupportMap } from '../../types';
+/** Public API returned by `useCssSupport`. */
+export interface IUseCssSupport {
+    /**
+     * Reactive map of feature → `boolean`. Computed once on first browser-
+     * side call; subsequent calls share the same frozen snapshot.
+     */
+    css: Readonly<Ref<TCssSupportMap>>;
+    /**
+     * Free-form query support. Pass any string accepted by `CSS.supports()`.
+     * Result is cached per-query.
+     *
+     * @example
+     *   supports('display: grid')                  // true on modern browsers
+     *   supports('selector(:has(*))')              // selector query
+     *   supports('width: clamp(1px, 50%, 100px)')  // math function
+     */
+    supports: (query: string) => boolean;
+    /**
+     * `true` if at least ONE of the queries is supported.
+     */
+    supportsAny: (...queries: string[]) => boolean;
+    /**
+     * `true` if EVERY query is supported.
+     */
+    supportsAll: (...queries: string[]) => boolean;
+    /**
+     * Reactive `ComputedRef<boolean>` for a single named feature. Useful in
+     * templates: `<div v-if="hasGrid">…`.
+     */
+    has: (feature: TCssFeatureName) => ComputedRef<boolean>;
+}
+/** Options accepted by `useCssSupportClient`. */
+export interface IUseCssSupportClientOptions {
+    /**
+     * Value returned during SSR and on the first client render (before
+     * `onMounted` fires). Pick the side of the branch that produces the
+     * smaller / safer markup — typically `false` (= JS fallback) so the
+     * server output stays universally compatible.
+     */
+    defaultValue?: boolean;
+}

package/dist/src/interfaces/DataList/data-list.interface.d.ts

@@ -1,19 +1,6 @@
 import type { IAdjacentProps, IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDataListKVItem, IDataTextProps, IDataTitleProps, IDensityProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITypographyProps } from "../../interfaces";
-/**
- * Layout mode of `<OrigamDataList>`.
- *
- * - `"avatar"` (default, back-compat) — the historical `<dl>` layout
- *   where each item stacks a `<dt>` (title) above one or more `<dd>`
- *   rows (text). Items conform to {@link IDataItem}. The naming reflects
- *   the most common usage: a `prependAvatar` per title, with a stack of
- *   labels below — the Vuetify `v-list`-flavoured shape.
- *
- * - `"kv"` — the PDF-aligned key/value table where each row renders a
- *   key on the left (muted) and a value on the right (primary text or
- *   an inline component such as `<origam-chip>` / `<origam-avatar>`).
- *   Items conform to {@link IDataListKVItem}.
- */
-export type TDataListMode = 'avatar' | 'kv';
+import type { TDataListMode } from "../../types";
+export type { TDataListMode } from "../../types/DataList/data-list.type";
 export interface IDataListProps extends ICommonsComponentProps, IAdjacentProps, IColorProps, IBgColorProps, IMarginProps, IPaddingProps, IDensityProps, IBorderProps, IRoundedProps, IElevationProps, ITypographyProps {
     /**
      * Selects the layout. Defaults to `"avatar"` so existing call sites
@@ -41,3 +28,62 @@ export interface IDataItem extends IAdjacentProps {
         [key: string]: IDataTextProps;
     };
 }
+/**
+ * Slot signatures for `<OrigamDataList>`.
+ *
+ * Both layout modes (`avatar` / `kv`) share the same `default` slot name
+ * but a different scope shape, so `default` widens to the union of both.
+ * Per-row overrides are only known at runtime (`item-{index}` / `item-
+ * {index}.key` / …), so they're expressed as template-literal index
+ * signatures alongside the un-indexed fallback names (`item`, `key`,
+ * `value`, `item.title`, …) the template also checks.
+ */
+export interface IDataListSlots {
+    default?: (data: {
+        items: Array<IDataItem>;
+    } | {
+        items: Array<IDataListKVItem>;
+    }) => any;
+    key?: (data: {
+        key: string;
+        item: IDataListKVItem;
+        index: number;
+    }) => any;
+    value?: (data: {
+        key: string;
+        value: IDataListKVItem['value'];
+        item: IDataListKVItem;
+        index: number;
+    }) => any;
+    item?: (data: {
+        item: IDataItem;
+        index: number;
+    }) => any;
+    'item.title'?: (data: Record<string, unknown>) => any;
+    'item.title.append'?: () => any;
+    'item.title.prepend'?: () => any;
+    'item.text'?: () => any;
+    'item.text.append'?: () => any;
+    'item.text.prepend'?: () => any;
+    [key: `item-${number}.key`]: ((data: {
+        key: string;
+        item: IDataListKVItem;
+        index: number;
+    }) => any) | undefined;
+    [key: `item-${number}.value`]: ((data: {
+        key: string;
+        value: IDataListKVItem['value'];
+        item: IDataListKVItem;
+        index: number;
+    }) => any) | undefined;
+    [key: `item-${number}.title.append`]: (() => any) | undefined;
+    [key: `item-${number}.title.prepend`]: (() => any) | undefined;
+    [key: `item-${number}.title`]: ((data: Record<string, unknown>) => any) | undefined;
+    [key: `item-${number}.text.append`]: (() => any) | undefined;
+    [key: `item-${number}.text.prepend`]: (() => any) | undefined;
+    [key: `item-${number}.text`]: (() => any) | undefined;
+    [key: `item-${number}`]: ((data: {
+        item: IDataItem;
+        index: number;
+    }) => any) | undefined;
+}

package/dist/src/interfaces/DataList/data-text.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IAdjacentProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
+import type { IAdjacentProps, IAdjacentSlots, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
 import type { TColor } from "../../types";
 export interface IDataTextProps extends ICommonsComponentProps, IAdjacentProps, IDensityProps, IMarginProps, IPaddingProps, IColorProps, IBgColorProps {
     text: string | number;
@@ -7,3 +7,7 @@ export interface IDataTextProps extends ICommonsComponentProps, IAdjacentProps,
     /** @deprecated Use the `hover` object prop instead. Kept for back-compat. */
     hoverBgColor?: TColor;
 }
+/** Slot signatures for `<OrigamDataText>`. */
+export interface IDataTextSlots extends IAdjacentSlots {
+    default?: () => any;
+}

package/dist/src/interfaces/DataList/data-title.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IAdjacentProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
+import type { IAdjacentProps, IAdjacentSlots, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
 import type { TColor } from "../../types";
 export interface IDataTitleProps extends ICommonsComponentProps, IAdjacentProps, IDensityProps, IMarginProps, IPaddingProps, IColorProps, IBgColorProps {
     text: string | number;
@@ -7,3 +7,9 @@ export interface IDataTitleProps extends ICommonsComponentProps, IAdjacentProps,
     /** @deprecated Use the `hover` object prop instead. Kept for back-compat. */
     hoverBgColor?: TColor;
 }
+/** Slot signatures for `<OrigamDataTitle>`. */
+export interface IDataTitleSlots extends IAdjacentSlots {
+    default?: (data: {
+        text: string | number;
+    }) => any;
+}

package/dist/src/interfaces/DataTable/column.interface.d.ts

@@ -7,3 +7,9 @@ export interface IDataTableColumnProps extends ICommonsComponentProps, ITagProps
     lastFixed?: boolean;
     nowrap?: boolean;
 }
+/** Slot signature for `<OrigamDataTableColumnCell>` — a plain content cell,
+ *  no scope passed through (the header/row callers compute their own
+ *  scoped props before forwarding into this wrapper). */
+export interface IDataTableColumnCellSlots {
+    default?: () => any;
+}

package/dist/src/interfaces/DataTable/data-table.interface.d.ts

@@ -1,5 +1,5 @@
 import type { UnwrapRef } from 'vue';
-import type { ICommonsComponentEmits, IDataTableExpandProps, IDataTableFooterProps, IDataTableGroup, IDataTableGroupProps, IDataTableHeaderProps, IDataTableHeadersProps, IDataTableItem, IDataTableItemsProps, IDataTablePaginationProps, IDataTableProvideExpanded, IDataTableProvideGroup, IDataTableProvidePagination, IDataTableProvideSelection, IDataTableProvideSort, IDataTableRowProps, IDataTableSelectProps, IDataTableSortProps, IFiltersProps, IInternalDataTableHeader, ITableProps } from '../../interfaces';
+import type { ICommonsComponentEmits, IDataTableExpandProps, IDataTableFooterProps, IDataTableGroup, IDataTableGroupableItem, IDataTableGroupProps, IDataTableHeaderProps, IDataTableHeadersProps, IDataTableHeadersSlotProps, IDataTableItem, IDataTableItemsProps, IDataTablePaginationProps, IDataTableProvideExpanded, IDataTableProvideGroup, IDataTableProvidePagination, IDataTableProvideSelection, IDataTableProvideSort, IDataTableRowProps, IDataTableSelectProps, IDataTableSortItem, IDataTableSortProps, IFiltersProps, IInternalDataTableHeader, ITableProps } from '../../interfaces';
 export interface IDataTableProps extends ITableProps, IDataTableRowProps, IDataTableExpandProps, IDataTableGroupProps, IDataTableHeaderProps, IDataTableItemsProps, IDataTableSelectProps, IDataTableSortProps, IDataTableHeadersProps, IDataTablePaginationProps, IFiltersProps, IDataTableFooterProps {
     hideDefaultBody?: boolean;
     hideDefaultFooter?: boolean;
@@ -9,7 +9,15 @@ export interface IDataTableProps extends ITableProps, IDataTableRowProps, IDataT
 export interface IDataTableSlotProps<T> {
     page: number;
     itemsPerPage: number;
-    sortBy: UnwrapRef<IDataTableProvideSort['sortBy']>;
+    /**
+     * `readonly … | undefined`, not `UnwrapRef<IDataTableProvideSort['sortBy']>`:
+     * this is the pre-`provide()` value straight out of `createSort()`'s
+     * `useVModel(props, 'sortBy', [])`, which mirrors the OPTIONAL
+     * `IDataTableSortProps.sortBy` prop type — not the always-defined,
+     * mutable array `IDataTableProvideSort` exposes to descendants after
+     * `provideSort()` runs.
+     */
+    sortBy: readonly IDataTableSortItem[] | undefined;
     pageCount: number;
     toggleSort: IDataTableProvideSort['toggleSort'];
     setItemsPerPage: IDataTableProvidePagination['setItemsPerPage'];
@@ -24,8 +32,17 @@ export interface IDataTableSlotProps<T> {
     isGroupOpen: IDataTableProvideGroup['isGroupOpen'];
     toggleGroup: IDataTableProvideGroup['toggleGroup'];
     items: T[];
-    internalItems: Array<IDataTableItem>;
-    groupedItems: Array<IDataTableItem<T> | IDataTableGroup<IDataTableItem<T>>>;
+    /**
+     * `IDataTableGroupableItem<T>`, not `IDataTableItem<T>`: this is
+     * `extractRows()`'s return type (flattened groups, no `key` / `index` /
+     * `columns` guaranteed by the type system — those DO exist on the real
+     * objects at runtime, but only because `OrigamDataTable`'s call site
+     * narrows the generic through an `as unknown as` cast upstream of
+     * `extractRows`, which this field can't see through).
+     */
+    internalItems: Array<IDataTableGroupableItem<T>>;
+    /** `readonly`: straight from `usePaginatedItems()`'s `Ref<readonly (T | IDataTableGroup<T>)[]>`. */
+    groupedItems: ReadonlyArray<IDataTableItem<T> | IDataTableGroup<IDataTableItem<T>>>;
     columns: Array<IInternalDataTableHeader>;
     headers: Array<Array<IInternalDataTableHeader>>;
 }
@@ -40,3 +57,23 @@ export interface IDataTableEmits extends ICommonsComponentEmits {
     (e: 'update:expanded', value: ReadonlySet<unknown>): void;
     (e: 'update:currentItems', value: Array<IDataTableItem>): void;
 }
+/** Slot signatures for `<OrigamDataTable>`. `default` / `colgroup` /
+ *  `thead` / `prepend` / `body` / `append` all share `IDataTableSlotProps`
+ *  (pagination, sort, selection and expansion state + actions). `header`
+ *  and `header.mobile` forward `<OrigamDataTableHeaders>`'s own scope
+ *  1:1. `top`, `header.loader` and `bottom` render with no scope — the
+ *  header's own `loader` slot (forwarded as `header.loader`) never binds
+ *  props from its default `<origam-progress>` render either. */
+export interface IDataTableSlots<T = any> {
+    top?: () => any;
+    default?: (props: IDataTableSlotProps<T>) => any;
+    colgroup?: (props: IDataTableSlotProps<T>) => any;
+    header?: (props: IDataTableHeadersSlotProps) => any;
+    'header.mobile'?: (props: IDataTableHeadersSlotProps) => any;
+    'header.loader'?: () => any;
+    thead?: (props: IDataTableSlotProps<T>) => any;
+    prepend?: (props: IDataTableSlotProps<T>) => any;
+    body?: (props: IDataTableSlotProps<T>) => any;
+    append?: (props: IDataTableSlotProps<T>) => any;
+    bottom?: () => any;
+}

package/dist/src/interfaces/DataTable/footer.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IAlignProps, IColorProps, ICommonsComponentProps, IPaddingProps } from "../../interfaces";
+import type { IAdjacentSlots, IAlignProps, IColorProps, ICommonsComponentProps, IPaddingProps } from "../../interfaces";
 import type { TIcon } from "../../types";
 export interface IDataTableFooterProps extends ICommonsComponentProps, IColorProps, IPaddingProps, IAlignProps {
     prevIcon?: TIcon;
@@ -17,3 +17,8 @@ export interface IDataTableFooterProps extends ICommonsComponentProps, IColorPro
     }>;
     showCurrentPage?: boolean;
 }
+/** Slot signatures for `<OrigamDataTableFooter>` — both `prepend` and
+ *  `append` render with no scope (bracket the items-per-page / pagination
+ *  row), so the shared `IAdjacentSlots` contract applies unchanged. */
+export interface IDataTableFooterSlots extends IAdjacentSlots {
+}

package/dist/src/interfaces/DataTable/group.interface.d.ts

@@ -1,5 +1,6 @@
 import type { ComputedRef, Ref } from 'vue';
 import type { IColorProps, ICommonsComponentProps, IDataTableItem, IDataTableItemBase, IDataTableSelectableItem, IDataTableSortItem, IInternalDataTableHeader, IPaddingProps } from '../../interfaces';
+import type { TIcon } from '../../types';
 export interface IDataTableGroupProps {
     groupBy?: Array<IDataTableSortItem>;
 }
@@ -45,3 +46,27 @@ export interface IDataTableGroupHeaderRowProps<T = IDataTableGroup> extends ICom
     toggleSelect: (item: IDataTableSelectableItem) => void;
     toggleGroup: (group: IDataTableGroup) => void;
 }
+/** Scope for the `data-table-group` slot — the group's own toggle button
+ *  (`props`) is pre-wired so a custom render can spread it onto any
+ *  trigger element and still collapse/expand correctly. */
+export interface IDataTableGroupHeaderRowGroupSlot<T = IDataTableGroup> {
+    item: T;
+    count: number;
+    props: {
+        icon: TIcon;
+        onClick: () => void;
+    };
+}
+/** Scope for the `data-table-select` slot — mirrors the group's row-select
+ *  checkbox binding (`v-bind="props"` reproduces the default checkbox). */
+export interface IDataTableGroupHeaderRowSelectSlot {
+    props: {
+        modelValue: boolean;
+        indeterminate: boolean;
+        'onUpdate:modelValue': (value: boolean) => void;
+    };
+}
+export interface IDataTableGroupHeaderRowSlots<T = IDataTableGroup> {
+    'data-table-group'?: (props: IDataTableGroupHeaderRowGroupSlot<T>) => any;
+    'data-table-select'?: (props: IDataTableGroupHeaderRowSelectSlot) => any;
+}

package/dist/src/interfaces/DataTable/headers.interface.d.ts

@@ -1,6 +1,6 @@
 import type { ComputedRef, Ref, UnwrapRef } from 'vue';
 import { ALIGN } from '../../enums';
-import type { IAdjacentEmits, IBgColorProps, IColorProps, ICommonsComponentProps, IDataTableItem, IDataTableSortItem, IDisplayProps, ILoaderProps } from '../../interfaces';
+import type { IAdjacentEmits, IBgColorProps, IColorProps, ICommonsComponentProps, IDataTableHeaderCellColumnSlot, IDataTableItem, IDataTableSortItem, IDisplayProps, IInternalListItem, ILoaderProps } from '../../interfaces';
 import type { TDataTableCompareFunction, TDataTableHeaderCell, TFilterFunction, TIcon, TSelectItemKey } from '../../types';
 export interface IHeaderCellProps extends ICommonsComponentProps, IColorProps {
     disableSort?: boolean;
@@ -12,6 +12,16 @@ export interface IHeaderCellProps extends ICommonsComponentProps, IColorProps {
 }
 export interface IDataTableHeadersProps extends ICommonsComponentProps, IColorProps, IDisplayProps, ILoaderProps, IHeaderCellProps {
 }
+/**
+ * Deliberately NOT `extends IAdjacentProps`. This cell has no
+ * consumer-facing prepend/append icon prop — the `appendIcon` rendered
+ * inside it is a purely internal computed (the multi-select checkbox
+ * glyph, see `appendIcon` in `OrigamDataTableHeadersCellMobile.vue`)
+ * forwarded to the nested `<OrigamSelect>`'s own `IAdjacentProps.appendIcon`.
+ * There is no `prependIcon` counterpart because there is nothing for a
+ * consumer to set — adding one would fabricate an API this component
+ * doesn't have a use for.
+ */
 export interface IDataTableHeadersCellMobileProps extends ICommonsComponentProps, IHeaderCellProps, IColorProps {
     columns: Array<IInternalDataTableHeader>;
     colspan?: number;
@@ -21,6 +31,42 @@ export interface IDataTableHeadersCellMobileProps extends ICommonsComponentProps
 export interface IDataTableHeadersCellMobileEmits extends IAdjacentEmits {
     (e: 'click:clear', event: MouseEvent): void;
 }
+/** Scope forwarded on the `select.chip` slot — the underlying list item
+ *  behind the chip, its index, and the draft props the default chip
+ *  render would receive (spread them to keep the built-in click/close
+ *  wiring when only restyling the chip). */
+export interface IDataTableHeadersCellMobileChipSlot {
+    item: IInternalListItem;
+    index: number;
+    chipProps: Record<string, unknown>;
+}
+/** Slot signatures for `<OrigamDataTableHeadersCellMobile>` — almost
+ *  entirely pass-through onto the internal `<origam-select>` /
+ *  `<origam-chip>` it renders (mobile "sort by" picker), so most slots
+ *  carry no scope of their own; only `select.chip` exposes one. */
+export interface IDataTableHeadersCellMobileSlots {
+    'select.prepend'?: () => any;
+    'select.loader'?: () => any;
+    'select.prependInner'?: () => any;
+    'select.floatingLabel'?: () => any;
+    'select.label'?: () => any;
+    'select.prefix'?: () => any;
+    'select.chip'?: (props: IDataTableHeadersCellMobileChipSlot) => any;
+    'select.selection'?: () => any;
+    'select.noData'?: () => any;
+    'select.prependItem'?: () => any;
+    'select.item'?: () => any;
+    'select.appendItem'?: () => any;
+    'select.suffix'?: () => any;
+    'select.appendInner'?: () => any;
+    clear?: () => any;
+    'select.append'?: () => any;
+    'chip:prepend'?: () => any;
+    'chip:default'?: () => any;
+    'chip:append'?: () => any;
+    'chip:close'?: () => any;
+    'chip:filter'?: () => any;
+}
 export interface IDataTableHeadersCellProps extends ICommonsComponentProps, IColorProps, IHeaderCellProps {
     headers: Array<Array<IInternalDataTableHeader>>;
 }
@@ -40,6 +86,21 @@ export interface IDataTableHeadersSlotProps {
     getSortIcon: (column: IInternalDataTableHeader) => TIcon | undefined;
     isSorted: (column: IInternalDataTableHeader) => boolean;
 }
+/** Slot signatures for `<OrigamDataTableHeaders>` — `mobile` renders
+ *  instead of `default` once `useDisplay` flips to the mobile layout;
+ *  `loader` (the in-progress sort indicator row) carries no scope. */
+export interface IDataTableHeadersSlots {
+    mobile?: (props: IDataTableHeadersSlotProps) => any;
+    default?: (props: IDataTableHeadersSlotProps) => any;
+    loader?: () => any;
+}
+/** Slot signature for `<OrigamDataTableHeaderCell>` — the column-driven
+ *  `header.{key}` name is only known at runtime (one column definition
+ *  per header), so it's expressed as a template-literal index signature
+ *  rather than a fixed key. */
+export interface IDataTableHeaderCellSlots {
+    [key: `header.${string}`]: ((props: IDataTableHeaderCellColumnSlot) => any) | undefined;
+}
 export interface IDataTableHeaderProps {
     headers?: Array<IDataTableHeader>;
     items?: Array<IDataTableItem>;