origam 0.3.10 → 2.3.0

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

@@ -0,0 +1,51 @@
+import type { TIcon } from '../../types';
+/**
+ * A single command/action exposed by `OrigamCommandPalette`.
+ *
+ * Commands are registered either declaratively through the
+ * `commands` prop on `<OrigamCommandPalette>` OR programmatically
+ * via the `useCommand().register(cmd)` composable. The composable
+ * route is preferred when commands need to spawn from feature code
+ * that owns the side-effect (router push, store mutation, …).
+ */
+export interface ICommand {
+    /**
+     * Stable identifier. Used as the v-for key, the ARIA
+     * `aria-activedescendant` target and as the dedup key in the
+     * registry — registering twice with the same `id` overwrites
+     * the previous entry instead of duplicating it.
+     */
+    id: string;
+    /** Visible primary label. Drives the default fuzzy-match input. */
+    label: string;
+    /** Secondary line shown under the label (optional). */
+    description?: string;
+    /** Optional prepend icon. */
+    icon?: TIcon;
+    /**
+     * Keyboard shortcut hint rendered through `<OrigamKbd>` next to
+     * the action. Display-only — it does NOT bind a global listener.
+     * (To bind a shortcut globally, use the `hotkey` prop on the
+     * palette OR the `useHotkey` composable on the call site.)
+     */
+    kbd?: ReadonlyArray<string>;
+    /**
+     * Group label (e.g. "Navigation", "Settings"). Commands sharing
+     * the same group render under the same subheader. Commands
+     * without a group fall back to a default bucket rendered first.
+     */
+    group?: string;
+    /**
+     * Extra search terms that should match the command (e.g.
+     * `['preferences', 'config']` for a "Settings" entry).
+     */
+    keywords?: ReadonlyArray<string>;
+    /**
+     * Handler invoked when the command is selected. May be async — the
+     * palette awaits the returned promise before closing (when
+     * `closeOnSelect` is `true`).
+     */
+    perform: () => void | Promise<void>;
+    /** Disabled commands stay visible but cannot be selected. */
+    disabled?: boolean;
+}

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

@@ -1,4 +1,25 @@
+import type { IActiveState } from '../../interfaces';
+/**
+ * The `active` prop accepts three shapes — same grammar as `hover`:
+ *
+ *   • `undefined` / `false` → `isActive` is driven by interaction
+ *     (click / `useVModel(props, 'active')` toggle). Default.
+ *
+ *   • `true` → `isActive` is FORCED to `true`. Useful for stories,
+ *     screenshot tests, or parent-controlled selected states. No visual
+ *     override — the state-aware styles fall back to resting tokens.
+ *
+ *   • `IActiveState` (object) → `isActive` stays reactive to clicks
+ *     (unless `enabled: true` is set inside, which forces it on). The
+ *     object's keys (`color`, `bgColor`, `border`, `rounded`, `elevation`,
+ *     `padding`, `margin`, `gap`) override the resting props ONLY while
+ *     the state is engaged.
+ */
 export interface IActiveProps {
-    active?: boolean;
+    active?: boolean | IActiveState;
     activeClass?: string;
 }
+/** Emit signature for components that propagate their active state. */
+export interface IActiveEmits {
+    (e: 'update:active', event: any): void;
+}

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

@@ -13,3 +13,29 @@ export interface IAdjacentInnerProps {
     clearIcon?: TIcon;
     clearable?: boolean;
 }
+/** Click events emitted when the user clicks the prepend/append slots. */
+export interface IAdjacentEmits {
+    (e: 'click:append', event: MouseEvent): void;
+    (e: 'click:prepend', event: MouseEvent): void;
+}
+/** Slot signatures for adjacent prepend/append content. */
+export interface IAdjacentSlots {
+    prepend?: () => any;
+    append?: () => any;
+}
+/**
+ * Click events for the inner adjacent surface — these fire from icons
+ * rendered INSIDE the input chrome (clear button, password toggle, etc.)
+ * rather than from the outer prepend/append slots.
+ */
+export interface IAdjacentInnerEmits {
+    (e: 'click:appendInner', event: MouseEvent): void;
+    (e: 'click:prependInner', event: MouseEvent): void;
+    (e: 'click:clear', event: MouseEvent): void;
+}
+/** Slot signatures for inner adjacent content (renders inside the input). */
+export interface IAdjacentInnerSlots {
+    prependInner?: () => any;
+    appendInner?: () => any;
+    clear?: () => any;
+}

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

@@ -1,9 +1,49 @@
 import type { TColor } from "../../types";
+/**
+ * Foreground-only color contract.
+ *
+ * Use this interface on components whose only colour-related concern is
+ * the **text** / icon (`color`). Pure typographic components (Title,
+ * Caption, Subtitle, Tooltip text, …) and any chrome that doesn't paint
+ * its own surface should extend this interface — NOT the combined
+ * version below.
+ *
+ *   ┌──────────────────────────────────────────────────────────────┐
+ *   │  IF the component paints a background → also extend          │
+ *   │     IBgColorProps                                            │
+ *   │  ELSE → keep IColorProps only.                               │
+ *   └──────────────────────────────────────────────────────────────┘
+ *
+ * State-aware overrides (`hoverColor`, `activeColor`) have been folded
+ * into the `hover` / `active` object props of `IHoverProps` /
+ * `IActiveProps`:
+ *
+ *     <Btn :hover="{ color: 'success' }" />          (was hover-color)
+ *     <Btn :active="{ color: 'success' }" />         (was active-color)
+ */
 export interface IColorProps {
     color?: TColor;
+}
+/**
+ * Background-only color contract.
+ *
+ * Combine with {@link IColorProps} on components that own a surface
+ * (Btn, Card, Badge, Alert, Pagination, …). The two interfaces stay
+ * orthogonal so a component can opt into one axis without inheriting
+ * unused props on the other.
+ *
+ *   // Btn paints both surface and text.
+ *   interface IBtnProps extends IColorProps, IBgColorProps { … }
+ *
+ *   // Title only paints text.
+ *   interface ITitleProps extends IColorProps { … }
+ *
+ * State-aware bg overrides (`hoverBgColor`, `activeBgColor`) have been
+ * folded into the `hover` / `active` object props:
+ *
+ *     <Card :hover="{ bgColor: 'success' }" />       (was hover-bg-color)
+ *     <Card :active="{ bgColor: 'success' }" />      (was active-bg-color)
+ */
+export interface IBgColorProps {
     bgColor?: TColor;
-    activeColor?: TColor;
-    activeBgColor?: TColor;
-    hoverColor?: TColor;
-    hoverBgColor?: TColor;
 }

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

@@ -28,6 +28,14 @@ export interface ICommonsComponentProps {
     class?: string | Array<string> | object;
     style?: string | Array<string> | object | StyleValue;
 }
+/** Default v-model emit shape shared by every input-style component. */
+export interface ICommonsComponentEmits {
+    (e: 'update:modelValue', event: any): void;
+}
+/** Default slot signature shared by container components. */
+export interface ICommonsComponentSlots {
+    default?: () => any;
+}
 export interface ITagProps {
     tag?: string;
 }

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

@@ -1,3 +1,7 @@
 export interface IFocusProps {
     focused?: boolean;
 }
+/** Emit signature for components that propagate focus state changes. */
+export interface IFocusEmits {
+    (e: 'update:focused', event: any): void;
+}

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

@@ -1,6 +1,25 @@
 import type { DirectiveBinding } from 'vue';
+import type { IHoverState } from '../../interfaces';
+/**
+ * The `hover` prop accepts three shapes:
+ *
+ *   • `undefined` / `false` → `isHover` reflects the actual mouseenter/leave
+ *     state of the element (no override). Default behaviour.
+ *
+ *   • `true` → `isHover` is FORCED to `true` regardless of pointer events.
+ *     Useful for stories, screenshot tests, or parent-controlled states.
+ *     No visual override — the state-aware styles in `useStateEffect`
+ *     fall back to the resting tokens.
+ *
+ *   • `IHoverState` (object) → `isHover` stays reactive to mouseenter/leave
+ *     (unless `enabled: true` is set inside the object, which forces it on
+ *     like the bare `true` case). The object's keys (`color`, `bgColor`,
+ *     `border`, `rounded`, `elevation`, `padding`, `margin`, `gap`) override
+ *     the resting props ONLY while the state is engaged. See
+ *     `IStateEffectConfig` for the full key set.
+ */
 export interface IHoverProps {
-    hover?: boolean;
+    hover?: boolean | IHoverState;
 }
 export interface IHoverDirectiveBinding extends Omit<DirectiveBinding, 'modifiers' | 'value'> {
     value?: boolean | {

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

@@ -42,7 +42,14 @@ export interface ILayoutProps extends ICommonsComponentProps {
 }
 export interface ILayoutItemProps extends ICommonsComponentProps {
     name?: string;
-    order: string | number;
+    /**
+     * Stacking order in the parent OrigamLayout. Optional — components
+     * that consume `useLayoutItem` (Drawer, BottomNav, AppBar, …)
+     * fall back to a unique-ID-based order when the consumer omits
+     * the prop. Marking it required here triggered a `[Vue warn]:
+     * Missing required prop: "order"` on every standalone usage.
+     */
+    order?: string | number;
     absolute?: boolean;
     location?: TDirectionBoth;
 }

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

@@ -1,5 +1,6 @@
 import type { IColorProps, ICommonsComponentProps, ITagProps } from '../../interfaces';
+import type { TLoadingValue } from '../../types';
 export interface ILoaderProps extends ICommonsComponentProps, ITagProps, IColorProps {
-    loading?: boolean | number;
+    loading?: TLoadingValue;
     loadingText?: string;
 }

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

@@ -9,6 +9,17 @@ export interface ILocationStrategyProps extends IDimensionProps {
     location?: TAnchor;
     origin?: TAnchor | 'auto' | 'overlap';
     offset?: number | string | Array<number>;
+    /**
+     * Pixels of breathing room enforced between the floating content and
+     * each viewport edge by the connected location strategy. Defaults to
+     * `12` so dropdowns / menus / tooltips never touch the browser chrome.
+     *
+     * Components where the activator legitimately spans the full viewport
+     * (e.g. an `<origam-select>` taking the full row width) should pass
+     * `0` — otherwise the guard's inward shift produces a visible offset
+     * between the activator's left edge and the dropdown's left edge.
+     */
+    viewportMargin?: number;
 }
 export interface ILocationStrategyData {
     contentEl: Ref<HTMLElement | undefined>;

package/dist/src/interfaces/Commons/options.interface.cjs

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,12 @@
+/**
+ * Generic select-option shape used across origam stories AND components
+ * (Select, RadioGroup, ChipGroup, BtnToggle…). Reusable everywhere a
+ * label/value pair is needed.
+ *
+ * `value` is `T | undefined` so consumers can model an explicit "no value"
+ * row without leaving the typed union.
+ */
+export interface IOptions<T> {
+    label: string;
+    value: T | undefined;
+}

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

@@ -1,5 +1,17 @@
+import type { TRounded } from '../../types';
 export interface IRoundedProps {
-    rounded?: boolean | string | number | null | undefined;
+    /**
+     * Corner-radius selector. Three modes:
+     *  - **named variant** (`'small' | 'default' | 'large' | …`,
+     *    cf. `ROUNDED` enum) → emits `--rounded-{name}` class so the
+     *    component's SCSS can pick the right token rung.
+     *  - **boolean `true`** (or empty string `''`) → emits the legacy
+     *    `--rounded` class for components that only have a single rounded
+     *    state (e.g. `OrigamBtn` defaulting to `radius.2xl`).
+     *  - **CSS value** (`'4px'`, `'4px 0 4px 0'`, `100`) → emits inline
+     *    `border-radius` declarations via `useRounded.roundedStyles`.
+     */
+    rounded?: boolean | number | string | TRounded | null | undefined;
     roundedTopRight?: boolean | number | string;
     roundedTopLeft?: boolean | number | string;
     roundedBottomLeft?: boolean | number | string;

package/dist/src/interfaces/Commons/state-effect.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/Commons/state-effect.interface.d.ts

@@ -0,0 +1,61 @@
+import type { IBorderProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps } from '../../interfaces';
+import type { TColor } from '../../types';
+/**
+ * Shared shape for state-aware visual overrides (`hover`, `active`).
+ *
+ * When the consumer passes an OBJECT to the `hover` or `active` prop,
+ * its keys override the corresponding resting props ONLY while the
+ * state is engaged:
+ *
+ *     <OrigamCard
+ *         bgColor="primary"
+ *         :hover="{ bgColor: 'success', border: 'thick', rounded: 'lg' }"
+ *     />
+ *
+ * Resting → bgColor primary, no border, default rounded.
+ * On hover → bgColor success, thick border, large rounded.
+ *
+ * Each axis maps to the property the existing per-axis composable
+ * (`useBorder`, `useRounded`, `useElevation`, `usePadding`, `useMargin`,
+ * `useColor`) already consumes. `useStateEffect` swaps these inputs
+ * reactively per state via `computed`.
+ *
+ * NOTE: `enabled` exists for the "force-the-state-on AND override
+ * styles" case — e.g. a controlled `hover` toggled by parent state
+ * that still wants its own colour palette:
+ *
+ *     <X :hover="{ enabled: forceHover, bgColor: 'success' }" />
+ *
+ * For the pure force-on case without overrides, pass `hover` as a
+ * plain `true` boolean.
+ */
+export interface IStateEffectConfig {
+    /** Force the state on regardless of mouse / pointer events. */
+    enabled?: boolean;
+    /** Foreground (text / icon) colour override while the state is engaged. */
+    color?: TColor;
+    /** Surface background colour override. */
+    bgColor?: TColor;
+    /** Border width / style / direction override. */
+    border?: IBorderProps['border'];
+    /** Corner radius override. */
+    rounded?: IRoundedProps['rounded'];
+    /** Box-shadow elevation override. */
+    elevation?: IElevationProps['elevation'];
+    /** Padding scalar override (paddingTop/Block/Inline NOT supported in state overrides — keep it simple). */
+    padding?: IPaddingProps['padding'];
+    /** Margin scalar override. */
+    margin?: IMarginProps['margin'];
+    /** Gap (flex/grid) override. Components that expose a `gap` prop pick it up. */
+    gap?: boolean | number | string;
+}
+/**
+ * Hover-state configuration. Same shape as the generic state config —
+ * the alias exists so consumer code reads as `IHoverState` (clearer
+ * intent than the bare `IStateEffectConfig`).
+ */
+export type IHoverState = IStateEffectConfig;
+/**
+ * Active-state configuration. Same shape as `IHoverState`.
+ */
+export type IActiveState = IStateEffectConfig;

package/dist/src/interfaces/Commons/variant.interface.cjs

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,10 @@
+import type { TVariant, TVariantInput } from '../../types';
+/**
+ * Mixin props for components that expose a visual variant. The union accepts
+ * both action-style variants (`text/flat/elevated/tonal/outlined/plain`) and
+ * input-style variants (`solo/filled/underlined/...`) so a single prop type
+ * fits every consumer.
+ */
+export interface IVariantProps {
+    variant?: TVariant | TVariantInput;
+}

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

@@ -1,4 +1,15 @@
 export interface IVirtualProps {
     itemHeight?: number | string;
     height?: number | string;
+    /**
+     * Animation duration (ms) applied to imperative scroll calls
+     * (e.g. `scrollToIndex`). Set to `0` to jump instantly.
+     * Default: 300.
+     */
+    scrollDuration?: number;
+    /**
+     * Easing function name forwarded to `useGoTo` (`easeInOutCubic`,
+     * `easeOutQuart`, …). Default: 'easeInOutCubic'.
+     */
+    scrollEasing?: string;
 }

package/dist/src/interfaces/ConfirmWrapper/confirm-wrapper.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/ConfirmWrapper/confirm-wrapper.interface.d.ts

@@ -0,0 +1,52 @@
+import type { IAdjacentEmits, IAdjacentProps, IAdjacentSlots, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IDirectionProps, IElevationProps, IFocusEmits, IFocusProps, IRoundedProps, IVariantProps } from '../../interfaces';
+/**
+ * Props for `<OrigamConfirmWrapper>` — a "type-it-twice" form helper that
+ * pairs a primary input with a confirmation input and lights up only when
+ * both values match. Common pattern for password creation, email change,
+ * destructive confirmations, etc.
+ *
+ * Inherits the standard form mixins so it slots into a Field/Form pipeline
+ * alongside any other input control.
+ */
+export interface IConfirmWrapperProps extends ICommonsComponentProps, IAdjacentProps, IDirectionProps, IColorProps, IDensityProps, IRoundedProps, IElevationProps, IVariantProps, IFocusProps {
+    modelValue?: any;
+    confirm?: any;
+    field?: string;
+    defaults?: Record<string, any>;
+    confirmLabel?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    error?: boolean;
+    errorMessages?: string | string[];
+    hideDetails?: boolean | 'auto';
+    messages?: string | string[];
+    hint?: string;
+    persistentHint?: boolean;
+    centerAffix?: boolean;
+    label?: string;
+}
+export interface IConfirmWrapperEmits extends ICommonsComponentEmits, IAdjacentEmits, IFocusEmits {
+    (e: 'update:confirm', value: any): void;
+}
+export interface IConfirmWrapperSlots extends IAdjacentSlots {
+    default?: () => any;
+    confirm?: () => any;
+    header?: () => any;
+    title?: (props: any) => any;
+    messages?: (data: {
+        hasMessages: boolean;
+        messages: string[];
+        messagesId: string;
+    }) => any;
+    message?: (data: {
+        message: string;
+    }) => any;
+    details?: (data: {
+        id: string;
+        messagesId: string;
+        isDirty: boolean;
+        isDisabled: boolean;
+        isReadonly: boolean;
+    }) => any;
+}

package/dist/src/interfaces/DataList/data-list-kv-item-value-component.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/DataList/data-list-kv-item-value-component.interface.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dynamic-component descriptor for a KV row value.
+ *
+ * Used when a consumer wants the value cell of `<OrigamDataList mode="kv">`
+ * to render a registered Origam component (chip, avatar, link, …)
+ * without writing a slot. The `component` field accepts either:
+ *   - the Vue component itself (imported), or
+ *   - a registered global tag name (e.g. `'origam-chip'`).
+ *
+ * `props` is forwarded as-is to the resolved component. `children`,
+ * when provided, is rendered inside the component's default slot —
+ * handy for components that take their text as a slot rather than a
+ * prop (e.g. `<origam-chip>{{ label }}</origam-chip>`).
+ */
+export interface IDataListKVItemValueComponent {
+    component: string | object;
+    props?: Record<string, unknown>;
+    children?: string | number;
+}

package/dist/src/interfaces/DataList/data-list-kv-item.interface.cjs

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,34 @@
+import type { VNode } from 'vue';
+import type { IDataListKVItemValueComponent } from './data-list-kv-item-value-component.interface';
+/**
+ * Shape of a single key/value row when the parent `<OrigamDataList>` runs
+ * in `mode="kv"`.
+ *
+ * - `key` is the visible label rendered in the `<dt>` cell. The component
+ *   also kebab-cases it to build the row's `data-cy` selector
+ *   (`data-list-kv-row-{kebab(key)}`).
+ * - `value` is what fills the `<dd>` cell:
+ *   • `string | number` → rendered as plain text;
+ *   • `VNode` → rendered as-is (use `h(...)` from a render function);
+ *   • `IDataListKVItemValueComponent` → resolved via `<component :is>`.
+ *
+ * For per-row overrides beyond what this contract exposes, use the
+ * `#value` / `#key` slots — they receive the full item.
+ *
+ * The `IDataListKVItemValueComponent` interface lives in its own file
+ * (`data-list-kv-item-value-component.interface.ts`) per the project
+ * convention "one interface per file under `src/interfaces/`".
+ *
+ * The companion type-guard `isDataListKVItemValueComponent` lives in
+ * `src/utils/DataList/` (functions belong in utils, not interfaces).
+ */
+export interface IDataListKVItem {
+    key: string;
+    value: string | number | VNode | IDataListKVItemValueComponent;
+    /**
+     * Optional stable id for the row. When omitted the component falls
+     * back to `key` for slot keying — fine for unique-key datasets, but
+     * supply your own when keys may repeat across instances.
+     */
+    id?: string | number;
+}

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

@@ -1,7 +1,38 @@
-import type { IAdjacentProps, IBorderProps, IColorProps, ICommonsComponentProps, IDataTextProps, IDataTitleProps, IDensityProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps } from "../../interfaces";
-export interface IDataListProps extends ICommonsComponentProps, IAdjacentProps, IColorProps, IMarginProps, IPaddingProps, IDensityProps, IBorderProps, IRoundedProps, IElevationProps {
+import type { IAdjacentProps, IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDataListKVItem, IDataTextProps, IDataTitleProps, IDensityProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps } 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';
+export interface IDataListProps extends ICommonsComponentProps, IAdjacentProps, IColorProps, IBgColorProps, IMarginProps, IPaddingProps, IDensityProps, IBorderProps, IRoundedProps, IElevationProps {
+    /**
+     * Selects the layout. Defaults to `"avatar"` so existing call sites
+     * keep their current rendering. Set to `"kv"` for the PDF-aligned
+     * key/value rows.
+     */
+    mode?: TDataListMode;
+    /**
+     * Source list. The runtime shape is gated by `mode`:
+     *   • `mode="avatar"` → array (or keyed object) of {@link IDataItem};
+     *   • `mode="kv"`     → array (or keyed object) of {@link IDataListKVItem}.
+     *
+     * The TS union accepts both — the component branches on `mode` to
+     * decide which renderer takes over.
+     */
     items?: Array<IDataItem> | {
         [key: string]: IDataItem;
+    } | Array<IDataListKVItem> | {
+        [key: string]: IDataListKVItem;
     };
 }
 export interface IDataItem extends IAdjacentProps {

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

@@ -1,4 +1,4 @@
-import type { IAdjacentProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
-export interface IDataTextProps extends ICommonsComponentProps, IAdjacentProps, IDensityProps, IMarginProps, IPaddingProps, IColorProps {
+import type { IAdjacentProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
+export interface IDataTextProps extends ICommonsComponentProps, IAdjacentProps, IDensityProps, IMarginProps, IPaddingProps, IColorProps, IBgColorProps {
     text: string | number;
 }

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

@@ -1,4 +1,4 @@
-import type { IAdjacentProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
-export interface IDataTitleProps extends ICommonsComponentProps, IAdjacentProps, IDensityProps, IMarginProps, IPaddingProps, IColorProps {
+import type { IAdjacentProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IMarginProps, IPaddingProps } from "../../interfaces";
+export interface IDataTitleProps extends ICommonsComponentProps, IAdjacentProps, IDensityProps, IMarginProps, IPaddingProps, IColorProps, IBgColorProps {
     text: string | number;
 }

package/dist/src/interfaces/DatePickerField/date-picker-field.interface.d.ts

@@ -1,5 +1,5 @@
-import type { IAdjacentInnerProps, IAdjacentProps, IBorderProps, IChipProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IFieldProps, IInputProps, IMarginProps, IMenuProps, IPaddingProps, IRoundedProps, ITextFieldProps, ITransitionComponentProps } from "../../interfaces";
-export interface IDatePickerFieldProps extends ICommonsComponentProps, IColorProps, ITextFieldProps, IDensityProps, IAdjacentProps, IAdjacentInnerProps, IFieldProps, IInputProps, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IElevationProps, ITransitionComponentProps {
+import type { IAdjacentInnerProps, IAdjacentProps, IBorderProps, IChipProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IFieldProps, IInputProps, IMarginProps, IMenuProps, IPaddingProps, IRoundedProps, ITextFieldProps, ITransitionComponentProps } from "../../interfaces";
+export interface IDatePickerFieldProps extends ICommonsComponentProps, IColorProps, IBgColorProps, ITextFieldProps, IDensityProps, IAdjacentProps, IAdjacentInnerProps, IFieldProps, IInputProps, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IElevationProps, ITransitionComponentProps {
     menu?: boolean;
     menuProps?: IMenuProps;
     range?: boolean;

package/dist/src/interfaces/DefaultProvider/default-provider.interface.cjs

@@ -0,0 +1 @@
+"use strict";