origam 2.16.0 → 2.17.0

package/dist/src/components/Section/OrigamSection.vue

@@ -1,9 +0,0 @@
-<template>
-	<div class="origam-section">
-
-	</div>
-</template>
-
-<script lang="ts" setup>
-
-</script>

package/dist/src/components/Section/index.cjs

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "OrigamSection", {
-  enumerable: true,
-  get: function () {
-    return _OrigamSection.default;
-  }
-});
-var _OrigamSection = _interopRequireDefault(require("./OrigamSection.vue"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/dist/src/components/Section/index.d.ts

@@ -1 +0,0 @@
-export { default as OrigamSection } from './OrigamSection.vue';

package/dist/src/components/Section/index.js

@@ -1 +0,0 @@
-export { default as OrigamSection } from "./OrigamSection.vue";

package/dist/src/composables/Commons/active.composable.cjs

@@ -1,53 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useActive = useActive;
-var _vue = require("vue");
-var _composables = require("../../composables/index.cjs");
-var _utils = require("../../utils/index.cjs");
-function useActive(props, prop = "active", name = (0, _utils.getCurrentInstanceName)()) {
-  const vmodel = (0, _composables.useVModel)(props, prop);
-  const activeState = (0, _vue.computed)(() => {
-    const v = props[prop];
-    return v && typeof v === "object" ? v : void 0;
-  });
-  const forced = (0, _vue.computed)(() => {
-    const v = props[prop];
-    if (v === true) return true;
-    if (v && typeof v === "object") return v.enabled === true;
-    return false;
-  });
-  const internalToggle = (0, _vue.ref)(false);
-  const isActive = (0, _vue.computed)(() => {
-    if (forced.value) return true;
-    const v = vmodel.value;
-    if (typeof v === "boolean") return v;
-    return internalToggle.value;
-  });
-  const activeClasses = (0, _vue.computed)(() => {
-    const classes = [];
-    if (isActive.value) {
-      classes.push(`${name}--active`);
-      if (props.activeClass) {
-        classes.push(props.activeClass);
-      }
-    }
-    return classes;
-  });
-  const onActive = () => {
-    const v = vmodel.value;
-    if (typeof v === "boolean" || v === void 0) {
-      vmodel.value = !isActive.value;
-    } else {
-      internalToggle.value = !internalToggle.value;
-    }
-  };
-  return {
-    isActive,
-    activeState,
-    activeClasses,
-    onActive
-  };
-}

package/dist/src/composables/Commons/active.composable.d.ts

@@ -1,41 +0,0 @@
-import type { ComputedRef } from "vue";
-import { IActiveProps } from "../../interfaces";
-/**
- * Track the active (pressed / selected) state of the host element AND
- * expose any style override the consumer attached to the `active` prop.
- *
- * `props.active` (or `props[prop]` when the caller binds a different
- * key like `modelValue`) accepts three shapes — mirrors `useHover`:
- *
- *   • `undefined` / `false` →
- *       isActive    : driven by `onActive()` toggle / v-model.
- *       activeState : undefined.
- *
- *   • `true` →
- *       isActive    : FORCED to `true`. (vmodel sync still works for
- *                     downstream emits, but `isActive` won't drop below
- *                     true while the prop is `true`.)
- *       activeState : undefined.
- *
- *   • `IActiveState` (object: `{ color?, bgColor?, border?, rounded?,
- *     elevation?, padding?, margin?, gap?, enabled? }`) →
- *       isActive    : reactive to `onActive()` (UNLESS `enabled: true`
- *                     is set, which forces it on).
- *       activeState : the object itself — consumed by `useStateEffect`.
- *
- * The `prop` argument lets callers bind a non-`active` key (e.g. Badge
- * and BottomNav use `'modelValue'`); the legacy v-model contract is
- * preserved on that key when it's a plain boolean.
- *
- * `activeClass` (legacy prop) still appends an extra class name when
- * the state is engaged — kept for compat with parent customisation.
- */
-/*********************************************************
- * useActive
- ********************************************************/
-export declare function useActive(props: IActiveProps & Record<string, any>, prop?: string, name?: string): {
-    isActive: ComputedRef<boolean>;
-    activeState: ComputedRef<import("../../interfaces").IStateEffectConfig | undefined>;
-    activeClasses: ComputedRef<string[]>;
-    onActive: () => void;
-};

package/dist/src/composables/Commons/active.composable.js

@@ -1,47 +0,0 @@
-import { computed, ref } from "vue";
-import { useVModel } from "../../composables/index.js";
-import { getCurrentInstanceName } from "../../utils/index.js";
-export function useActive(props, prop = "active", name = getCurrentInstanceName()) {
-  const vmodel = useVModel(props, prop);
-  const activeState = computed(() => {
-    const v = props[prop];
-    return v && typeof v === "object" ? v : void 0;
-  });
-  const forced = computed(() => {
-    const v = props[prop];
-    if (v === true) return true;
-    if (v && typeof v === "object") return v.enabled === true;
-    return false;
-  });
-  const internalToggle = ref(false);
-  const isActive = computed(() => {
-    if (forced.value) return true;
-    const v = vmodel.value;
-    if (typeof v === "boolean") return v;
-    return internalToggle.value;
-  });
-  const activeClasses = computed(() => {
-    const classes = [];
-    if (isActive.value) {
-      classes.push(`${name}--active`);
-      if (props.activeClass) {
-        classes.push(props.activeClass);
-      }
-    }
-    return classes;
-  });
-  const onActive = () => {
-    const v = vmodel.value;
-    if (typeof v === "boolean" || v === void 0) {
-      vmodel.value = !isActive.value;
-    } else {
-      internalToggle.value = !internalToggle.value;
-    }
-  };
-  return {
-    isActive,
-    activeState,
-    activeClasses,
-    onActive
-  };
-}

package/dist/src/composables/Commons/hover.composable.cjs

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useHover = useHover;
-var _vue = require("vue");
-var _utils = require("../../utils/index.cjs");
-function useHover(props, name = (0, _utils.getCurrentInstanceName)()) {
-  const isHovered = (0, _vue.ref)(false);
-  const forced = (0, _vue.computed)(() => {
-    const h = props.hover;
-    if (h === true) return true;
-    if (h && typeof h === "object") return h.enabled === true;
-    return false;
-  });
-  const hoverState = (0, _vue.computed)(() => {
-    const h = props.hover;
-    if (h && typeof h === "object") return h;
-    return void 0;
-  });
-  const isHover = (0, _vue.computed)(() => forced.value || isHovered.value);
-  const hoverClasses = (0, _vue.computed)(() => {
-    const classes = [];
-    if (isHover.value) {
-      classes.push(`${name}--hovered`);
-    }
-    return classes;
-  });
-  const onMouseenter = () => {
-    isHovered.value = true;
-  };
-  const onMouseleave = () => {
-    isHovered.value = false;
-  };
-  (0, _vue.watch)(() => props.hover, () => {});
-  return {
-    isHover,
-    hoverState,
-    hoverClasses,
-    onMouseenter,
-    onMouseleave
-  };
-}

package/dist/src/composables/Commons/hover.composable.d.ts

@@ -1,44 +0,0 @@
-import type { ComputedRef } from "vue";
-import type { IHoverProps } from "../../interfaces";
-/**
- * Track whether the host element is being hovered AND expose any
- * style override the consumer attached to the `hover` prop.
- *
- * `props.hover` accepts three shapes (mirrors `IHoverProps`):
- *
- *   • `undefined` / `false` →
- *       isHover    : reflects mouseenter/leave (default behaviour)
- *       hoverState : undefined (no style override — `useStateEffect`
- *                    falls back to resting tokens / auto-darkening)
- *
- *   • `true` →
- *       isHover    : FORCED to `true` regardless of pointer events
- *                    (stories, tests, parent-controlled state)
- *       hoverState : undefined
- *
- *   • `IHoverState` object (e.g. `{ bgColor: 'success', border: 'thick' }`) →
- *       isHover    : reactive to mouseenter/leave (UNLESS `enabled: true`
- *                    is set inside the object, which forces it on like
- *                    the bare `true` case)
- *       hoverState : the object itself — consumed by `useStateEffect`
- *                    to swap effective values per axis.
- *
- * `hoverClasses` stays in sync with `isHover` (`${name}--hovered`).
- *
- * Historical note: an earlier version required `props.hover === true`
- * as an opt-in gate before mouseenter/mouseleave would have any
- * effect. That meant every consumer of `hoverColor` / `hoverBgColor`
- * had to also pass `hover` — which nobody did, so the props were
- * silently dead. The current contract treats `props.hover` strictly
- * as a forcing / config override.
- */
-/*********************************************************
- * useHover
- ********************************************************/
-export declare function useHover(props: IHoverProps, name?: string): {
-    isHover: ComputedRef<boolean>;
-    hoverState: ComputedRef<import("../../interfaces").IStateEffectConfig | undefined>;
-    hoverClasses: ComputedRef<string[]>;
-    onMouseenter: () => void;
-    onMouseleave: () => void;
-};

package/dist/src/composables/Commons/hover.composable.js

@@ -1,39 +0,0 @@
-import { computed, ref, watch } from "vue";
-import { getCurrentInstanceName } from "../../utils/index.js";
-export function useHover(props, name = getCurrentInstanceName()) {
-  const isHovered = ref(false);
-  const forced = computed(() => {
-    const h = props.hover;
-    if (h === true) return true;
-    if (h && typeof h === "object") return h.enabled === true;
-    return false;
-  });
-  const hoverState = computed(() => {
-    const h = props.hover;
-    if (h && typeof h === "object") return h;
-    return void 0;
-  });
-  const isHover = computed(() => forced.value || isHovered.value);
-  const hoverClasses = computed(() => {
-    const classes = [];
-    if (isHover.value) {
-      classes.push(`${name}--hovered`);
-    }
-    return classes;
-  });
-  const onMouseenter = () => {
-    isHovered.value = true;
-  };
-  const onMouseleave = () => {
-    isHovered.value = false;
-  };
-  watch(() => props.hover, () => {
-  });
-  return {
-    isHover,
-    hoverState,
-    hoverClasses,
-    onMouseenter,
-    onMouseleave
-  };
-}

package/dist/src/composables/CssSupport/cssSupport.composable.d.ts

@@ -1,35 +0,0 @@
-import { type Ref } from 'vue';
-import type { IUseCssSupport, IUseCssSupportClientOptions } from '../../interfaces';
-import type { TCssFeatureName } from '../../types';
-export type { TCssFeatureName, TCssSupportMap } from '../../types';
-export type { IUseCssSupport, IUseCssSupportClientOptions } from '../../interfaces';
-/*********************************************************
- * useCssSupport
- ********************************************************/
-export declare function useCssSupport(): IUseCssSupport;
-/**
- * Test-only helper — clear the internal cache + re-detect on next call.
- * Not part of the public API; consumers must not depend on it.
- *
- * @internal
- */
-/*********************************************************
- * _resetCssSupportCache
- ********************************************************/
-export declare function _resetCssSupportCache(): void;
-/*********************************************************
- * useCssSupportClient
- *
- * @description
- * Hydration-safe single-feature gate. Returns a `Ref<boolean>` that
- * starts at `defaultValue` and flips to the real support result on
- * `onMounted`. Use to gate **markup**, not styles — for style-only
- * branches prefer `useCssSupport().css.value.X` directly.
- *
- * @example
- *   const supportsContainer = useCssSupportClient('containerQueries')
- *   // template:
- *   //   <div v-if="supportsContainer">…CSS path…</div>
- *   //   <div v-else>…JS fallback path…</div>
- ********************************************************/
-export declare function useCssSupportClient(feature: TCssFeatureName | string, options?: IUseCssSupportClientOptions): Ref<boolean>;

package/dist/src/composables/Mask/index.cjs

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _mask = require("./mask.composable.cjs");
-Object.keys(_mask).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _mask[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _mask[key];
-    }
-  });
-});

package/dist/src/composables/Mask/index.d.ts

@@ -1 +0,0 @@
-export * from './mask.composable';

package/dist/src/composables/Mask/index.js

@@ -1 +0,0 @@
-export * from "./mask.composable.js";

package/dist/src/composables/Mask/mask.composable.d.ts

@@ -1,19 +0,0 @@
-import { MaybeRef } from 'vue';
-import type { IMaskOptions, IUseMaskReturn } from '../../interfaces';
-import type { TMask } from '../../types';
-/**
- * Reactive mask engine — keeps `masked`, `unmasked`,
- * `isValid` and `complete` in sync with a source string
- * (`modelValue`) and a (possibly polymorphic) mask spec.
- *
- * Both the value and the mask are accepted as a `MaybeRef`
- * so the composable plays well with `props.modelValue` and
- * a static `props.mask` alike.
- *
- * Reactivity:
- *   - When `modelValue` changes → reformat + revalidate.
- *   - When `mask` changes      → re-resolve config, reformat
- *                                the current value.
- */
-export declare function useMask(modelValue: MaybeRef<string | null | undefined>, mask: MaybeRef<TMask | undefined>): IUseMaskReturn;
-export type { IMaskOptions, IUseMaskReturn };

package/dist/src/composables/Theme/installed-themes.composable.d.ts

@@ -1,19 +0,0 @@
-import type { TInstalledThemes } from '../../types';
-/**
- * `useInstalledThemes()` returns the list of brand themes installed via
- * `createOrigam({ themes })` — one entry per distinct brand `name`, each
- * listing the concrete modes it was installed for.
- *
- * Consumers (e.g. a theme switcher) map over this list instead of hard-coding
- * the available brands, so the UI stays in sync with whatever the app
- * installed. Returns an empty array when no themes were installed (or when
- * called outside an app that ran `createOrigam`), so callers never need a
- * null-guard.
- *
- * The list is static (snapshot at install time); pair it with `useTheme()` to
- * read / switch the active brand and mode.
- */
-/*********************************************************
- * useInstalledThemes
- ********************************************************/
-export declare function useInstalledThemes(): TInstalledThemes;

package/dist/src/composables/Theme/theme.composable.d.ts

@@ -1,85 +0,0 @@
-import type { Ref } from 'vue';
-import type { TMode, TModeResolved, TTheme, TThemeResolved } from '../../types/Theme/theme.type';
-/**
- * `useTheme()` returns a shared, reactive handle over the two theming axes.
- *
- * ### Brand axis (`theme` / `data-theme`)
- * - `theme` (read-only ref): the current brand — `'auto' | 'light' | 'dark' | string`.
- * - `setTheme(t)`: imperative setter. Persists to `localStorage` and applies
- *   `data-theme` to `<html>`.
- * - `resolved` (computed): the effective theme after resolving `'auto'`
- *   against `prefers-color-scheme`. Useful for SVG asset switching.
- * - `toggle()`: convenience to flip the brand light ↔ dark (treats `'auto'`
- *   as light). Kept for back-compat with the single-axis API.
- *
- * ### Mode axis (`mode` / `data-mode`)
- * - `mode` (read-only ref): the current color mode — `'auto' | 'light' | 'dark'`.
- * - `setMode(m)`: imperative setter. Persists to `localStorage` and applies
- *   `data-mode` to `<html>`.
- * - `resolvedMode` (computed): the effective mode after resolving `'auto'`
- *   against `prefers-color-scheme`.
- * - `toggleMode()`: flip the color mode light ↔ dark (treats `'auto'` as the
- *   current system preference).
- *
- * The media-query listener is a lazily-initialised SINGLETON (see
- * `ensureSystemPreference`) rather than an `onMounted` hook, so `resolvedMode`
- * is correct even when `useTheme()` is first called outside a component (e.g.
- * a Nuxt plugin). SSR stays safe — the init is a no-op without `window`.
- */
-/*********************************************************
- * useTheme
- ********************************************************/
-export declare function useTheme(): {
-    theme: Readonly<Ref<TTheme, TTheme>>;
-    resolved: Readonly<Ref<TThemeResolved, TThemeResolved>>;
-    setTheme: (next: TTheme) => void;
-    toggle: () => void;
-    mode: Readonly<Ref<"auto" | "light" | "dark", "auto" | "light" | "dark">>;
-    resolvedMode: Readonly<Ref<TModeResolved, TModeResolved>>;
-    setMode: (next: TMode) => void;
-    toggleMode: () => void;
-};
-/**
- * Internal helper for SSR / no-flash plugins: apply a theme (brand) to the
- * document synchronously (called BEFORE first render). Bypasses Vue reactivity.
- */
-/*********************************************************
- * applyThemeSync
- ********************************************************/
-export declare function applyThemeSync(theme: TTheme): void;
-/**
- * Internal helper for SSR / no-flash plugins: apply a CONCRETE mode to the
- * document synchronously. Bypasses Vue reactivity. An `'auto'` argument is
- * resolved against the current `prefers-color-scheme` (falling back to
- * `'light'` when unavailable) so `data-mode` always ends up concrete — the
- * token matrix has no mode-less fallback.
- */
-/*********************************************************
- * applyModeSync
- ********************************************************/
-export declare function applyModeSync(mode: TMode): void;
-/**
- * Internal helper for SSR / no-flash plugins: read the persisted theme (brand)
- * from localStorage without instantiating the composable.
- */
-/*********************************************************
- * readPersistedTheme
- ********************************************************/
-export declare function readPersistedTheme(): TTheme;
-/**
- * Internal helper for SSR / no-flash plugins: read the persisted mode from
- * localStorage without instantiating the composable.
- */
-/*********************************************************
- * readPersistedMode
- ********************************************************/
-export declare function readPersistedMode(): TMode;
-/**
- * Test-only: clear the module-level singletons (theme / mode refs and the
- * `prefers-color-scheme` cache) so each spec starts from a clean slate. Not
- * part of the public API.
- */
-/*********************************************************
- * _resetThemeForTesting
- ********************************************************/
-export declare function _resetThemeForTesting(): void;

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

@@ -1,33 +0,0 @@
-import type { TCalendarStrategy } from "../../types";
-export interface ICalendarProps {
-    allowedDates?: Array<unknown> | ((date: unknown) => boolean);
-    disabled?: boolean;
-    displayValue?: unknown;
-    date?: ReadonlyArray<unknown> | Array<unknown>;
-    month?: number;
-    max?: unknown;
-    min?: unknown;
-    showAdjacentMonths?: boolean;
-    year?: number;
-    weekdays?: Array<number>;
-    weeksInMonth?: TCalendarStrategy;
-    firstDayOfWeek?: number;
-}
-export interface IDay {
-    date: unknown;
-    isoDate: string;
-    formatted: string;
-    year: number;
-    month: number;
-    isDisabled: boolean;
-    isWeekStart: boolean;
-    isWeekEnd: boolean;
-    isToday: boolean;
-    isAdjacent: boolean;
-    isHidden: boolean;
-    isStart: boolean;
-    isSelected: boolean;
-    isEnd: boolean;
-    isSame: boolean;
-    localized: string;
-}

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

@@ -1,138 +0,0 @@
-import type { ComputedRef, Ref, UnwrapRef } from 'vue';
-import { ALIGN } from '../../enums';
-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;
-    headerProps?: any;
-    sticky?: boolean;
-    multiSort?: boolean;
-    sortAscIcon?: TIcon;
-    sortDescIcon?: TIcon;
-}
-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;
-}
-/** Emits fired by `<OrigamDataTableHeadersCellMobile>` — clear button +
- *  prepend / append slot clicks. */
-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>>;
-}
-export interface IDataTableHeaderCellProps extends ICommonsComponentProps, IHeaderCellProps, IColorProps, IBgColorProps {
-    column: IInternalDataTableHeader;
-    x: number;
-    y: number;
-}
-export interface IDataTableHeadersSlotProps {
-    headers: Array<Array<IInternalDataTableHeader>>;
-    columns: Array<IInternalDataTableHeader>;
-    sortBy: UnwrapRef<Ref<Array<IDataTableSortItem>>>;
-    someSelected: UnwrapRef<ComputedRef<boolean>>;
-    allSelected: UnwrapRef<ComputedRef<boolean>>;
-    toggleSort: (column: IInternalDataTableHeader) => void;
-    selectAll: (value: boolean) => void;
-    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>;
-}
-export interface IDataTableHeader<T = any> {
-    key?: 'data-table-group' | 'data-table-select' | 'data-table-expand' | (string & {});
-    value?: TSelectItemKey<T>;
-    title?: string;
-    fixed?: boolean;
-    align?: ALIGN.START | ALIGN.END | ALIGN.CENTER;
-    width?: number | string;
-    minWidth?: string;
-    maxWidth?: string;
-    nowrap?: boolean;
-    headerProps?: any;
-    cellProps?: TDataTableHeaderCell;
-    sortable?: boolean;
-    sort?: TDataTableCompareFunction;
-    sortRaw?: TDataTableCompareFunction;
-    filter?: TFilterFunction;
-    mobile?: boolean;
-    children?: Array<IDataTableHeader<T>>;
-}
-export interface IInternalDataTableHeader extends Omit<IDataTableHeader, 'key' | 'value' | 'children'> {
-    key: string | null;
-    value: TSelectItemKey | null;
-    sortable: boolean;
-    fixedOffset?: number;
-    lastFixed?: boolean;
-    nowrap?: boolean;
-    padding?: string | number;
-    colspan?: number;
-    rowspan?: number;
-    children?: Array<IInternalDataTableHeader>;
-}