origam 2.2.1 → 2.3.0

package/dist/src/interfaces/Code/code.interface.d.ts

@@ -0,0 +1,99 @@
+import type { IBorderProps, ICommonsComponentProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../index';
+import type { TCodeLang, TCodeTheme } from '../../types';
+/**
+ * Props for `<OrigamCode>` — a shiki-powered code block with line numbers,
+ * line highlighting, copy button and theme awareness.
+ *
+ * Backward-compat note: the v2.x `<OrigamCode>` was a thin `<pre>` wrapper
+ * with a `code` prop only. Every new prop below is optional with a
+ * conservative default so existing call sites keep their behaviour
+ * (plain-text, no line numbers, copy button visible).
+ */
+export interface ICodeProps extends ICommonsComponentProps, ITagProps, IBorderProps, IRoundedProps, IElevationProps, IPaddingProps, IMarginProps {
+    /**
+     * The code to highlight. When omitted, the default slot is used as the
+     * source — useful for multi-line snippets that are nicer to read in
+     * the template than as a JS string literal. When both are provided,
+     * the prop wins.
+     */
+    code?: string;
+    /**
+     * Language grammar to apply. One of the values in `SUPPORTED_LANGS`.
+     * Unknown values fall back to `plaintext` (with a one-shot console
+     * warning).
+     */
+    lang?: TCodeLang;
+    /**
+     * Show a left gutter with line numbers. Pure CSS — uses a CSS counter
+     * incremented per `.origam-code__row`, no JS layout work.
+     */
+    lineNumbers?: boolean;
+    /**
+     * Lines to highlight. Accepts either a pre-computed array of 1-based
+     * line numbers (`[2, 5, 6, 7]`) or a comma/range string (`'2,5-7'`)
+     * that the component parses via `parseHighlightLines()`. `null` /
+     * empty disables the feature.
+     */
+    highlightLines?: number[] | string | null;
+    /**
+     * Show the copy-to-clipboard button in the top-right corner. Defaults
+     * to `true` — most code blocks benefit from it.
+     */
+    copyable?: boolean;
+    /**
+     * Cap the rendered block at this height and enable vertical scroll
+     * past it. `null` (default) lets the block grow to fit its content.
+     */
+    maxHeight?: number | string | null;
+    /**
+     * Theme override. `'auto'` (default) follows the document theme,
+     * `'light'` / `'dark'` force a specific shiki theme.
+     */
+    theme?: TCodeTheme;
+    /**
+     * Auto-format the code before highlighting. Reserved for v3 — prettier
+     * is intentionally NOT bundled at runtime to keep the tarball small.
+     * Currently a no-op; passing `true` warns once in dev and pre-formats
+     * via a best-effort whitespace trim only.
+     */
+    format?: boolean;
+    /**
+     * Wrap long lines instead of scrolling horizontally. Off by default so
+     * the visual column matches the source file.
+     */
+    wrap?: boolean;
+    /**
+     * Optional filename rendered in the header bar (e.g. `'App.vue'`).
+     * When provided AND `copyable` is true, the header also hosts the copy
+     * button; otherwise the copy button is absolutely positioned in the
+     * top-right corner of the code surface.
+     */
+    filename?: string;
+}
+/**
+ * Public surface of the `useCode` composable. Lazily instantiates a shiki
+ * highlighter on first call and reuses it across every `OrigamCode`
+ * instance for the lifetime of the page.
+ */
+export interface IUseCodeReturn {
+    /**
+     * Render `code` to a pre-tokenised HTML string. Resolves once the
+     * underlying shiki highlighter has loaded the requested language /
+     * theme (lazy; ~200 ms cold, instant on subsequent calls).
+     */
+    highlight(code: string, lang: TCodeLang, themeName: 'light' | 'dark'): Promise<string>;
+    /**
+     * Force the highlighter to load. Useful for stories / tests that want
+     * to warm the cache before mounting consumers.
+     */
+    prime(): Promise<void>;
+    /**
+     * Whether the singleton highlighter is ready. `false` on first paint,
+     * flips to `true` once the dynamic import finishes.
+     */
+    isReady(): boolean;
+    /**
+     * Wipe the LRU cache. Test-only — production code never needs this.
+     */
+    resetCacheForTesting(): void;
+}

package/dist/src/interfaces/CommandPalette/command-palette.interface.cjs

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

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

@@ -0,0 +1,57 @@
+import type { ICommand } from './command.interface';
+import type { ICommonsComponentProps } from '../Commons/commons.interface';
+/**
+ * A hotkey is either a single combination (`['meta', 'k']`) or an
+ * array of alternatives — every entry being a list of normalised key
+ * tokens compatible with `useHotkey` (e.g. `[['meta', 'k'], ['ctrl', 'k']]`).
+ *
+ * The component normalises a single-combination input (`['meta', 'k']`)
+ * to the multi-combination shape (`[['meta', 'k']]`) before installing
+ * the listeners so consumers can pass either form interchangeably.
+ */
+export type TCommandPaletteHotkey = ReadonlyArray<string> | ReadonlyArray<ReadonlyArray<string>>;
+export interface ICommandPaletteProps extends ICommonsComponentProps {
+    /** v-model — whether the palette is open. */
+    modelValue?: boolean;
+    /**
+     * Global hotkey(s) that toggle the palette open. Defaults to
+     * `[['meta', 'k'], ['ctrl', 'k']]` (⌘K / Ctrl+K). Pass `null`
+     * to disable the global listener entirely.
+     */
+    hotkey?: TCommandPaletteHotkey | null;
+    /**
+     * Static command list. When omitted, the palette renders commands
+     * registered via the `useCommand()` global registry instead.
+     */
+    commands?: ReadonlyArray<ICommand>;
+    /** Placeholder of the search input (already-translated string). */
+    placeholder?: string;
+    /** Empty-state message when no command matches the query. */
+    emptyText?: string;
+    /** Max height of the result list. Number → px. */
+    maxHeight?: number | string;
+    /** Width of the palette dialog. Number → px. */
+    width?: number | string;
+    /** Display a loader inside the result list (use during async fetches). */
+    loading?: boolean;
+    /** Close the palette automatically when a command is selected. */
+    closeOnSelect?: boolean;
+    /** Close when the user presses Escape. */
+    closeOnEscape?: boolean;
+    /** Close when the user clicks the backdrop. */
+    closeOnBackdrop?: boolean;
+}
+export interface ICommandPaletteEmits {
+    (e: 'update:modelValue', value: boolean): void;
+    (e: 'select', command: ICommand): void;
+    (e: 'query', text: string): void;
+}
+export interface ICommandPaletteSlotProps {
+    command: ICommand;
+    isActive: boolean;
+}
+export interface ICommandPaletteSlots {
+    item?: (props: ICommandPaletteSlotProps) => any;
+    empty?: () => any;
+    footer?: () => any;
+}

package/dist/src/interfaces/CommandPalette/command.interface.cjs

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

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/Mask/mask-options.interface.cjs

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

package/dist/src/interfaces/Mask/mask-options.interface.d.ts

@@ -0,0 +1,48 @@
+import type { TPatternValidator } from '../../types';
+/**
+ * Configuration object accepted by `useMask` / the
+ * `OrigamTextField.mask` prop in its long form.
+ *
+ * - `pattern`   — token-walker template. `#` = digit,
+ *                 `A` = letter, `*` = any char, anything
+ *                 else is a literal preserved verbatim.
+ * - `validator` — optional secondary check on the UNMASKED
+ *                 value (e.g. Luhn for credit cards).
+ * - `required`  — when `true`, `isValid` is `false` until
+ *                 every consumer token is filled.
+ */
+export interface IMaskOptions {
+    pattern: string;
+    validator?: TPatternValidator | null;
+    required?: boolean;
+}
+/**
+ * Resolved config returned by `resolveMaskConfig` after
+ * normalising a string / preset key / IMaskOptions input.
+ * `pattern` is always a raw template string at this layer.
+ */
+export interface IResolvedMaskConfig {
+    pattern: string;
+    validator: TPatternValidator | null;
+    required: boolean;
+}
+/**
+ * Output shape of `applyMask`. `masked` is the formatted
+ * display string (literals interleaved); `unmasked` is the
+ * raw user-provided characters (consumer slots only).
+ */
+export interface IMaskApplyResult {
+    masked: string;
+    unmasked: string;
+    complete: boolean;
+}
+/**
+ * Token emitted by the pattern parser. `consumer` flags
+ * whether the token consumes one character from the input
+ * (`#`, `A`, `*`) or is a literal kept verbatim.
+ */
+export interface IMaskToken {
+    kind: 'digit' | 'letter' | 'any' | 'literal';
+    char: string;
+    consumer: boolean;
+}

package/dist/src/interfaces/Nuxt/nuxt-module.interface.cjs

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

package/dist/src/interfaces/Nuxt/nuxt-module.interface.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Options passed by a consumer in `nuxt.config.ts` under the `origam` key.
+ *
+ * All fields are optional — the module applies sensible defaults (see
+ * `DEFAULTS` in `src/nuxt/module.ts`). Themes are auto-injected as CSS
+ * imports; the active theme is resolved SSR-side via cookie and the
+ * `Sec-CH-Prefers-Color-Scheme` client hint to avoid FOUC and hydration
+ * mismatches.
+ */
+export interface IOrigamNuxtModuleOptions {
+    /**
+     * Theme names whose CSS file must be loaded. Each name must match a
+     * generated `dist/src/assets/css/tokens/{theme}.css` exposed via
+     * `origam/tokens/css/{theme}`.
+     *
+     * @default ['light', 'dark']
+     */
+    themes?: string[];
+    /**
+     * Theme applied when no cookie is set and no usable
+     * `Sec-CH-Prefers-Color-Scheme` hint is sent. Use `'auto'` to let the
+     * server fall back to the client hint (or `'light'` if absent).
+     *
+     * @default 'auto'
+     */
+    defaultTheme?: string;
+    /**
+     * Cookie name used to persist the user's chosen theme across sessions.
+     *
+     * @default 'origam-theme'
+     */
+    cookieName?: string;
+    /**
+     * Cookie `max-age` in seconds.
+     *
+     * @default 31_536_000 (1 year)
+     */
+    cookieMaxAge?: number;
+    /**
+     * Register components and composables as Nuxt auto-imports. Disable if
+     * you want to opt-out and import everything explicitly (or namespace
+     * the imports to avoid conflicts with another design system).
+     *
+     * @default true
+     */
+    autoImport?: boolean;
+    /**
+     * Inject the generated utility classes stylesheet (`origam-utilities.css`).
+     * Keep it on unless the consumer ships their own utility layer.
+     *
+     * @default true
+     */
+    includeUtilities?: boolean;
+    /**
+     * Prefix applied to auto-imported components. Origam ships components
+     * already prefixed `Origam*` so the default is an empty prefix — set
+     * this to override if you need a custom namespace.
+     *
+     * @default 'Origam'
+     */
+    prefix?: string;
+}
+/**
+ * Shape of the public runtime config exposed by the module on
+ * `useRuntimeConfig().public.origam`. The plugins read this at boot to
+ * resolve the active theme and configure the cookie.
+ */
+export interface IOrigamNuxtRuntimeConfig {
+    themes: string[];
+    defaultTheme: string;
+    cookieName: string;
+    cookieMaxAge: number;
+}

package/dist/src/interfaces/Parallax/parallax-layer.interface.cjs

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

package/dist/src/interfaces/Parallax/parallax-layer.interface.d.ts

@@ -0,0 +1,39 @@
+import type { ICommonsComponentProps, ITagProps } from '../../interfaces';
+export interface IParallaxLayerProps extends ICommonsComponentProps, ITagProps {
+    /**
+     * Parallax speed multiplier for this layer.
+     *  - `0`   → fixed (no movement, sticks to host)
+     *  - `0.5` → half the scroll speed (background — far)
+     *  - `1`   → moves with the scroll (neutral)
+     *  - `>1`  → faster than the scroll (foreground — near)
+     *
+     * Negative values reverse the direction.
+     */
+    speed?: number;
+    /**
+     * Static X-axis offset (px) applied on top of the parallax translation.
+     * Useful to nudge a layer without changing its speed.
+     */
+    offsetX?: number;
+    /**
+     * Static Y-axis offset (px) applied on top of the parallax translation.
+     */
+    offsetY?: number;
+    /**
+     * Optional `z-index` override. By default layers stack in document order.
+     */
+    zIndex?: number;
+}
+export interface IParallaxLayerRegistry {
+    /**
+     * Internal layer descriptor as registered into the parent OrigamParallax
+     * via `provide` / `inject`. The parent reads `speed`, `offsetX`,
+     * `offsetY` to compute the per-frame transform, then applies it via the
+     * shared `target` HTMLElement.
+     */
+    id: symbol;
+    speed: number;
+    offsetX: number;
+    offsetY: number;
+    target: HTMLElement;
+}

package/dist/src/interfaces/Parallax/parallax.interface.d.ts

@@ -1,5 +1,5 @@
-import type { IAudioProps, IBorderProps, IBox, IBgColorProps, IColorProps, ICommonsComponentProps, IDimensionProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
-import type { TParallaxEvent, TPoint } from '../../types';
+import type { IAudioProps, IBorderProps, IBox, IBgColorProps, IColorProps, ICommonsComponentProps, IDimensionProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps, IParallaxLayerRegistry } from '../../interfaces';
+import type { TParallaxDirection, TParallaxEasing, TParallaxEvent, TPoint } from '../../types';
 import type { Ref } from 'vue';
 export interface IParallaxProps extends ICommonsComponentProps, ITagProps, IColorProps, IBgColorProps, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IElevationProps, IDimensionProps, IAudioProps {
     /**
@@ -10,11 +10,49 @@ export interface IParallaxProps extends ICommonsComponentProps, ITagProps, IColo
      * console warning is emitted at runtime to flag the migration.
      */
     animationDuration?: number;
-    easing?: string;
+    /**
+     * Easing curve. Accepts either:
+     *  - a TParallaxEasing keyword (`'linear' | 'ease-out' | 'spring'`),
+     *    routed through the scroll-driven multi-layer code path,
+     *  - or any raw CSS timing-function string (legacy mouse / scroll
+     *    transition path, e.g. `'cubic-bezier(...)'`).
+     *
+     * The keyword form is preferred for new code; the raw string form is
+     * kept for backwards compatibility with v2.x.
+     */
+    easing?: TParallaxEasing | string;
     perspective?: number;
     event?: TParallaxEvent;
     active?: boolean;
     duration?: number;
+    /**
+     * Direction of the parallax effect.
+     *  - `'vertical'` (default) → translateY based on vertical scroll progress.
+     *  - `'horizontal'`         → translateX based on vertical scroll progress.
+     *  - `'both'`               → translate on both axes; on `event="move"`
+     *                            this maps to a 2D mouse ratio.
+     */
+    direction?: TParallaxDirection;
+    /**
+     * Global parallax speed multiplier when no `<OrigamParallaxLayer>` is
+     * provided (single-layer mode). Equivalent to wrapping the slot in a
+     * single layer with this speed. Default `0.5`.
+     */
+    speed?: number;
+    /**
+     * Force the parallax effect OFF (translate stays at 0 regardless of
+     * scroll / events). Distinct from `active` which only freezes the
+     * mouse-driven mode. Useful for SSR, snapshot tests, or `prefers-
+     * reduced-motion` integrations.
+     */
+    disabled?: boolean;
+    /**
+     * Proportion (0 → 1) of the host that must enter the viewport before
+     * the parallax effect activates. `0` (default) starts the effect the
+     * moment the host's top edge crosses the bottom of the viewport;
+     * `0.3` waits until 30% of the host is visible.
+     */
+    threshold?: number;
 }
 export interface IParallaxProvide {
     audioData: Ref<any>;
@@ -30,3 +68,45 @@ export interface IParallaxProvide {
     easing: Ref<string>;
     shape: Ref<IBox | null>;
 }
+/**
+ * Provide context exposed by the enriched OrigamParallax to its
+ * `<OrigamParallaxLayer>` children. Distinct from the legacy
+ * `IParallaxProvide` consumed by `<OrigamParallaxElement>` (kept
+ * separate to avoid coupling the two APIs).
+ */
+export interface IParallaxLayerProvide {
+    direction: Ref<TParallaxDirection>;
+    easing: Ref<TParallaxEasing | string>;
+    disabled: Ref<boolean>;
+    /**
+     * Live scroll progress, normalised to `[0, 1]`. `0` = host just entered
+     * the viewport, `1` = host just left.
+     */
+    progress: Ref<number>;
+    /**
+     * Live mouse-ratio for `direction="both"` on `event="move"` —
+     * `{ x: 0..1, y: 0..1 }`. Falls back to `{ x: 0.5, y: 0.5 }` when no
+     * mouse data is available.
+     */
+    mouseRatio: Ref<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Whether the runtime is using the CSS scroll-driven path (true) or the
+     * JS rAF fallback (false). Layers may opt out of the JS work when the
+     * CSS path is active.
+     */
+    cssScrollDriven: Ref<boolean>;
+    /**
+     * Whether `prefers-reduced-motion: reduce` is honoured — layers MUST
+     * stay at offset 0 when this is true.
+     */
+    reducedMotion: Ref<boolean>;
+    /**
+     * Register / unregister a layer with the parent. The parent reads the
+     * registry to compute and apply per-layer transforms each frame.
+     */
+    register: (layer: IParallaxLayerRegistry) => void;
+    unregister: (id: symbol) => void;
+}

package/dist/src/interfaces/SnackbarStack/snackbar-stack-item.interface.cjs

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

package/dist/src/interfaces/SnackbarStack/snackbar-stack-item.interface.d.ts

@@ -0,0 +1,60 @@
+import type { TIcon, TIntent } from '../../types';
+/**
+ * Action button descriptor attached to a snackbar stack item.
+ *
+ * Surfaces in the rendered snackbar as a button — clicking it invokes
+ * `handler` and (by default) dismisses the item. Set `keepOpen: true`
+ * to keep the snackbar visible after the click (e.g. for a multi-step
+ * confirmation).
+ */
+export interface ISnackbarStackItemAction {
+    label: string;
+    handler: () => void;
+    intent?: TIntent;
+    keepOpen?: boolean;
+}
+/**
+ * Options accepted by `useSnackbarStack().notify(opts)`.
+ *
+ * Every field is optional except that the resulting item must surface
+ * SOMETHING to the user — either a `title`, a `message`, or both.
+ * The composable does not enforce this at runtime; emitting an empty
+ * item is a no-op but is allowed for programmatic flexibility.
+ */
+export interface ISnackbarStackItemOptions {
+    /** Bold first line. Useful for short labels (e.g. "Saved"). */
+    title?: string;
+    /** Body text under the title (or sole line when `title` absent). */
+    message?: string;
+    /**
+     * Semantic intent driving icon defaults, `role=status|alert`, and
+     * surface coloring. Defaults to `info`.
+     */
+    intent?: TIntent;
+    /**
+     * Auto-dismiss timeout in milliseconds. Overrides the stack-level
+     * `defaultDuration`. Pass `0` to make the item sticky (no auto
+     * dismiss — user has to dismiss it manually or programmatically).
+     */
+    duration?: number;
+    /**
+     * Prepend icon override. Defaults to the per-intent icon
+     * (`mdiCheckCircle` for success, `mdiAlertCircle` for danger, …).
+     */
+    icon?: TIcon;
+    /** Optional action buttons rendered in the snackbar footer. */
+    actions?: ReadonlyArray<ISnackbarStackItemAction>;
+    /** Whether to show the close (`X`) button. Default `true`. */
+    dismissible?: boolean;
+    /** Callback fired once the item leaves the stack. */
+    onDismiss?: () => void;
+}
+/**
+ * Materialised item held inside the stack store. Adds the auto-generated
+ * `id` to the option shape so callers can address the item afterwards
+ * (`dismiss(id)`).
+ */
+export interface ISnackbarStackItem extends ISnackbarStackItemOptions {
+    id: string;
+    createdAt: number;
+}

package/dist/src/interfaces/SnackbarStack/snackbar-stack.interface.cjs

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

package/dist/src/interfaces/SnackbarStack/snackbar-stack.interface.d.ts

@@ -0,0 +1,60 @@
+import type { ICommonsComponentProps, ITagProps } from '../../interfaces';
+import type { TSnackbarStackDirection, TSnackbarStackLocation } from '../../types';
+/**
+ * Props for `<OrigamSnackbarStack>` — a multi-toast container that
+ * orchestrates a queue of `OrigamSnackbar` instances driven through
+ * the `useSnackbarStack({ id })` composable.
+ *
+ * The component itself owns NO local visual state — every notification
+ * is added via `notify()` and removed via `dismiss()` or auto-timeout.
+ * The component subscribes to its registered stack `id` and re-renders
+ * when the underlying `items` ref changes.
+ */
+export interface ISnackbarStackProps extends ICommonsComponentProps, ITagProps {
+    /**
+     * Identifier of the stack this container renders. Pair with
+     * `useSnackbarStack({ id })` to spawn items into the same stack.
+     * Multiple stacks can coexist (e.g. a global one + a per-region
+     * one) — each one is keyed independently.
+     *
+     * @default 'default'
+     */
+    id?: string;
+    /**
+     * Anchor location on the viewport. Drives both the absolute
+     * positioning (top/bottom + left/right/center pinning) and the
+     * `direction` default.
+     *
+     * @default 'bottom-right'
+     */
+    location?: TSnackbarStackLocation;
+    /**
+     * Maximum number of items rendered concurrently. When `notify()`
+     * pushes a new item past `max`, the oldest item in the stack is
+     * evicted FIFO (its `onDismiss` callback still fires).
+     *
+     * @default 5
+     */
+    max?: number;
+    /**
+     * Default auto-dismiss timeout (ms) applied to items that do not
+     * supply their own `duration`. Pass `0` to make all items sticky
+     * by default.
+     *
+     * @default 5000
+     */
+    defaultDuration?: number;
+    /**
+     * Gap between stacked items (CSS dimension — `'12px'`, `'1rem'`,
+     * `8`, …).
+     *
+     * @default '12px'
+     */
+    spacing?: string | number;
+    /**
+     * Stacking order. When unset, defaults to `'top-down'` for
+     * `top-*` locations and `'bottom-up'` for `bottom-*` locations
+     * — matching the natural reading direction of fresh items.
+     */
+    direction?: TSnackbarStackDirection;
+}

package/dist/src/interfaces/Tabs/tab-panel.interface.cjs

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

package/dist/src/interfaces/Tabs/tab-panel.interface.d.ts

@@ -0,0 +1,12 @@
+import type { ICommonsComponentProps, IGroupItemProps, ILazyProps, ITagProps } from '../../interfaces';
+/**
+ * Props for `<OrigamTabPanel>` — a single tab content panel.
+ *
+ *  - `value`   identifier matching the sibling `<OrigamTab>`.
+ *  - `eager`   if `false` (default) the panel content is mounted
+ *              only when first activated and kept alive afterwards.
+ *              If `true`, the content is mounted from the start.
+ */
+export interface ITabPanelProps extends ICommonsComponentProps, ITagProps, IGroupItemProps, ILazyProps {
+    tag?: string;
+}

package/dist/src/interfaces/Tabs/tab-panels.interface.cjs

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