origam 2.3.0 → 2.5.0

package/dist/src/interfaces/List/list-group.interface.d.ts

@@ -9,3 +9,8 @@ export interface IListGroupProps extends ITagProps, ICommonsComponentProps, ICol
 }
 export interface IListActivatorProps extends ICommonsComponentProps, ITagProps {
 }
+/** Emits fired by `<OrigamListGroup>` — click on the activator chrome
+ *  (used by parents to toggle the open state). */
+export interface IListGroupEmits {
+    (e: 'click:activator', event: MouseEvent): void;
+}

package/dist/src/interfaces/List/list-item.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IActiveProps, IAdjacentProps, IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDensityProps, IDimensionProps, IElevationProps, IHoverProps, ILinkProps, IMarginProps, IPaddingProps, IRippleProps, IRoundedProps, ITagProps } from '../../interfaces';
+import type { IActiveProps, IAdjacentEmits, IAdjacentProps, IBgColorProps, IBorderProps, IClickEmits, IColorProps, ICommonsComponentProps, IDensityProps, IDimensionProps, IElevationProps, IHoverProps, ILinkProps, IMarginProps, IPaddingProps, IRippleProps, IRoundedProps, ITagProps } from '../../interfaces';
 import type { TLines } from '../../types';
 export interface IListItemProps extends IBorderProps, ICommonsComponentProps, IDensityProps, IDimensionProps, IElevationProps, IRoundedProps, ITagProps, ILinkProps, IColorProps, IBgColorProps, IRippleProps, IPaddingProps, IMarginProps, IAdjacentProps, IActiveProps, IHoverProps {
     active?: boolean;
@@ -12,3 +12,6 @@ export interface IListItemProps extends IBorderProps, ICommonsComponentProps, ID
     title?: string | number;
     value?: any;
 }
+/** Emits fired by `<OrigamListItem>` — generic click + prepend/append slot clicks. */
+export interface IListItemEmits extends IClickEmits, IAdjacentEmits {
+}

package/dist/src/interfaces/List/list.interface.d.ts

@@ -20,3 +20,19 @@ export interface IItemProps {
     returnObject?: boolean;
     valueComparator?: typeof deepEqual;
 }
+/** Emits fired by `<OrigamList>` — selection / open state propagation and
+ *  user-driven click events on items. */
+export interface IListEmits {
+    (e: 'update:selected', value: Array<unknown>): void;
+    (e: 'update:opened', value: Array<unknown>): void;
+    (e: 'click:open', value: {
+        id: unknown;
+        value: boolean;
+        path: Array<unknown>;
+    }): void;
+    (e: 'click:select', value: {
+        id: unknown;
+        value: boolean;
+        path: Array<unknown>;
+    }): void;
+}

package/dist/src/interfaces/Main/main.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IBorderProps, ICommonsComponentProps, IDimensionProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
-export interface IMainProps extends ITagProps, ICommonsComponentProps, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IDimensionProps {
+import type { IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDimensionProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
+export interface IMainProps extends ITagProps, ICommonsComponentProps, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IDimensionProps, IElevationProps, IBgColorProps, IColorProps {
     scrollable?: boolean;
 }

package/dist/src/interfaces/Masonry/masonry.interface.cjs

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

package/dist/src/interfaces/Masonry/masonry.interface.d.ts

@@ -0,0 +1,80 @@
+import type { IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDimensionProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
+import type { TGridGapSize, TMasonryAlign } from '../../types';
+/**
+ * Map of `min-width` (px) → number of columns to apply when the
+ * container is at least that wide. Container-query based (NOT viewport),
+ * so a masonry placed in a 600 px sidebar will pick the breakpoint that
+ * matches 600 px, regardless of viewport width.
+ *
+ * Example:
+ *   { 600: 2, 900: 3, 1200: 4 }
+ *
+ * → < 600 px : `columns` prop value (default 3).
+ * → ≥ 600 px : 2.
+ * → ≥ 900 px : 3.
+ * → ≥ 1200 px: 4.
+ *
+ * Keys must be positive integers (pixel widths). Values must be positive
+ * integers (column counts). Order is irrelevant — the composable sorts
+ * the entries by key ascending and picks the largest key ≤ container
+ * width.
+ */
+export type TMasonryColumnBreakpoints = Record<number, number>;
+/**
+ * Props for `<OrigamMasonry>` — Pinterest-style masonry layout.
+ *
+ * `<OrigamMasonry>` ships a CSS-first implementation gated on
+ * `grid-template-rows: masonry` (detected via `useCssSupport`). When
+ * the browser supports it the layout is pure CSS; when it doesn't, a
+ * `useMasonry` JS fallback runs (`ResizeObserver` + bucket-fill
+ * algorithm). The runtime decision is transparent to the consumer.
+ */
+export interface IMasonryProps extends ICommonsComponentProps, ITagProps, IDimensionProps, IMarginProps, IPaddingProps, IRoundedProps, IElevationProps, IBgColorProps, IColorProps, IBorderProps {
+    /**
+     * Number of columns to use when no breakpoint matches the container
+     * width. Must be a positive integer ≥ 1.
+     *
+     * @default 3
+     */
+    columns?: number;
+    /**
+     * Container-query column breakpoints. See `TMasonryColumnBreakpoints`.
+     * When provided, the masonry observes its own size via
+     * `ResizeObserver` and picks the matching column count automatically.
+     *
+     * Pass `undefined` (or an empty object) to disable container-query
+     * resolution and use the `columns` prop verbatim.
+     */
+    columnBreakpoints?: TMasonryColumnBreakpoints;
+    /**
+     * Gap between items, both vertically and horizontally. Accepts:
+     *
+     * - one of the grid size tokens `'xs' | 'sm' | 'md' | 'lg' | 'xl'`
+     *   (resolved via `tokens/component/grid.json`, same matrix as
+     *   `<OrigamGrid>` for visual consistency).
+     * - any CSS length string (`'24px'`, `'1rem'`).
+     * - a plain `number` interpreted as pixels.
+     *
+     * @default 'md'
+     */
+    gap?: TGridGapSize | string | number;
+    /**
+     * Animate `transform` when an item moves to a different position on
+     * column-count change. CSS-only — the transition is applied to the
+     * item children, so the consumer's content doesn't need to know.
+     *
+     * @default true
+     */
+    animated?: boolean;
+    /**
+     * Vertical alignment of items inside a column. `'top'` is the
+     * standard Pinterest layout; `'center'` centres each column's
+     * cumulative content inside the container height.
+     *
+     * Only the JS fallback honours `'center'` — the CSS-native path
+     * always packs to the top. See `TMasonryAlign`.
+     *
+     * @default 'top'
+     */
+    align?: TMasonryAlign;
+}

package/dist/src/interfaces/Media/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _mediaController = require("./media-controller.interface.cjs");
+Object.keys(_mediaController).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mediaController[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _mediaController[key];
+    }
+  });
+});
+var _mediaPlayer = require("./media-player.interface.cjs");
+Object.keys(_mediaPlayer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mediaPlayer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _mediaPlayer[key];
+    }
+  });
+});
+var _mediaScrubber = require("./media-scrubber.interface.cjs");
+Object.keys(_mediaScrubber).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mediaScrubber[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _mediaScrubber[key];
+    }
+  });
+});
+var _mediaVolumeControl = require("./media-volume-control.interface.cjs");
+Object.keys(_mediaVolumeControl).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mediaVolumeControl[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _mediaVolumeControl[key];
+    }
+  });
+});

package/dist/src/interfaces/Media/index.d.ts

@@ -0,0 +1,4 @@
+export * from './media-controller.interface';
+export * from './media-player.interface';
+export * from './media-scrubber.interface';
+export * from './media-volume-control.interface';

package/dist/src/interfaces/Media/index.js

@@ -0,0 +1,4 @@
+export * from "./media-controller.interface.js";
+export * from "./media-player.interface.js";
+export * from "./media-scrubber.interface.js";
+export * from "./media-volume-control.interface.js";

package/dist/src/interfaces/Media/media-controller.interface.cjs

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

package/dist/src/interfaces/Media/media-controller.interface.d.ts

@@ -0,0 +1,159 @@
+import type { ICommonsComponentProps, IMediaPlayerMethods, IMediaPlayerState } from '../../interfaces';
+import type { TAudioLoopMode, TQualityOption } from '../../types';
+/**
+ * Props for `<OrigamMediaController>` — the universal media-controls
+ * shell consumed by `<OrigamVideo>` and `<OrigamAudio>`. Both parents
+ * own the `<video>` / `<audio>` element AND the playlist (when one);
+ * the Controller is purely presentational and emits intents the
+ * parent acts on.
+ *
+ * The audio-specific contracts (playlist navigation, tri-state loop,
+ * shuffle) ship as opt-in props so video consumers see zero
+ * regression — pass `:show-loop="false"` etc to keep the legacy
+ * video toolbar unchanged.
+ *
+ * Defaults are inlined inside `withDefaults` (cf. CLAUDE.md
+ * `withDefaults` rule) — this interface only types the public API.
+ */
+export interface IMediaControllerProps extends ICommonsComponentProps {
+    /** Reactive media state from `useMediaPlayer()` (or any
+     *  specialisation: `useVideoPlayer`, `useAudioPlayer`). Required. */
+    state: IMediaPlayerState;
+    /** Imperative methods from `useMediaPlayer()`. Required. */
+    methods: IMediaPlayerMethods;
+    /** YouTube-style overlay mode: the shell sits on top of the media
+     *  surface with a dark gradient and auto-hides on `visible=false`.
+     *  When `false`, the shell renders as a regular always-on toolbar.
+     *
+     *  @default false */
+    inset?: boolean;
+    /** Visibility flag driven by the parent's autohide logic.
+     *
+     *  @default true */
+    visible?: boolean;
+    /** Available playback rates exposed via the config menu.
+     *
+     *  @default [0.5, 0.75, 1, 1.25, 1.5, 2] */
+    playbackRates?: ReadonlyArray<number>;
+    /** Enable the cast / AirPlay button (Remote Playback API).
+     *
+     *  @default false */
+    allowRemotePlayback?: boolean;
+    /** Adds a "Download" row to the config menu.
+     *
+     *  @default false */
+    downloadable?: boolean;
+    /** URL surfaced to the consumer when "Download" is clicked.
+     *
+     *  @default null */
+    downloadUrl?: string | null;
+    /** Suggested filename written to the `<a download="…">` attribute.
+     *
+     *  @default undefined */
+    downloadFilename?: string;
+    /** Optional list of quality variants. When the array exposes ≥ 2
+     *  entries, a "Quality" drill-down appears in the config menu.
+     *
+     *  @default [] */
+    qualityOptions?: ReadonlyArray<TQualityOption>;
+    /** Currently-active quality identifier.
+     *
+     *  @default null */
+    currentQuality?: string | null;
+    /** Show the "previous" transport button. The parent listens to
+     *  the `previous` emit and decides whether to skip back 10s
+     *  (single-track) or jump to the previous playlist track.
+     *
+     *  @default false */
+    showPrevious?: boolean;
+    /** Show the "next" transport button. Parent owns the action.
+     *
+     *  @default false */
+    showNext?: boolean;
+    /** Show the tri-state loop button (none → all → one → none).
+     *
+     *  @default false */
+    showLoop?: boolean;
+    /** Show the shuffle toggle button.
+     *
+     *  @default false */
+    showShuffle?: boolean;
+    /** Current loop mode. Supports `v-model:loopMode`. The Controller
+     *  cycles this on click; the parent observes and applies its
+     *  playlist / `<audio loop>` policy.
+     *
+     *  @default 'none' */
+    loopMode?: TAudioLoopMode;
+    /** Current shuffle state. Supports `v-model:shuffle`. The
+     *  Controller toggles on click; the parent reads and switches its
+     *  next-track resolution accordingly.
+     *
+     *  @default false */
+    shuffle?: boolean;
+}
+/**
+ * Emits surfaced by `<OrigamMediaController>`. The shell calls
+ * `methods.*` directly for the basic ops (toggle play, seek, set
+ * volume, set rate, toggle mute, request cast) — those don't bubble.
+ *
+ * The emits below are the ones the PARENT must handle because the
+ * Controller doesn't own enough context:
+ *   - `quality-change` — parent owns the `<source>` swap logic.
+ *   - `download`       — parent owns the URL fetch / anchor click.
+ *   - `previous` / `next` — parent owns the playlist or skip-time
+ *                            policy.
+ *   - `update:loopMode` / `update:shuffle` — two-way binding for the
+ *                                            transport toggles.
+ */
+export interface IMediaControllerEmits {
+    (e: 'quality-change', quality: string): void;
+    (e: 'download'): void;
+    (e: 'previous'): void;
+    (e: 'next'): void;
+    (e: 'update:loopMode', mode: TAudioLoopMode): void;
+    (e: 'update:shuffle', shuffle: boolean): void;
+}
+/**
+ * Scoped slots exposed by `<OrigamMediaController>`. Consumers
+ * inject media-specific blocks (`<OrigamAudio>` injects header +
+ * waveform + footer; `<OrigamVideo>` injects captions/PiP/fullscreen
+ * through `extraControlsRight`).
+ */
+export interface IMediaControllerSlots {
+    /** Block rendered ABOVE the scrubber row. `<OrigamAudio>` injects
+     *  the cover + metadata strip here; `<OrigamVideo>` typically
+     *  leaves it empty. */
+    header?: () => any;
+    /** Replaces the default `<OrigamMediaScrubber>` scrubber row.
+     *  Receives `{ state, methods }` so the consumer can paint a
+     *  custom scrubber (audio waveform via SliderField variant=audio,
+     *  for example) while still routing seeks through `methods.seek`. */
+    waveform?: (bindings: {
+        state: IMediaPlayerState;
+        methods: IMediaPlayerMethods;
+    }) => any;
+    /** Block rendered BELOW the transport row. `<OrigamAudio>` injects
+     *  the playlist list here. */
+    footer?: () => any;
+    /** Buttons rendered at the start of the transport row, before the
+     *  play button. `<OrigamAudio>` can inject custom shuffle / queue
+     *  buttons here when the default `showShuffle` placement doesn't
+     *  fit. */
+    'prepend-transport'?: () => any;
+    /** Buttons rendered at the end of the transport row, after the
+     *  config menu. Consumers add custom buttons (favourite, queue,
+     *  …) here. */
+    'append-transport'?: () => any;
+    /** Additional buttons rendered on the left side of the toolbar,
+     *  AFTER the time display. Legacy slot — prefer `prepend-transport`. */
+    extraControlsLeft?: () => any;
+    /** Additional buttons rendered on the right side of the toolbar,
+     *  BEFORE the config menu. `<OrigamVideo>` injects its captions /
+     *  PiP / fullscreen buttons here. */
+    extraControlsRight?: () => any;
+    /** Extra rows in the config menu (audio output device, subtitle
+     *  track selector, …). Receives `{ closeMenu }`. */
+    configExtra?: (bindings: {
+        closeMenu: () => void;
+    }) => any;
+}

package/dist/src/interfaces/Media/media-player.interface.cjs

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

package/dist/src/interfaces/Media/media-player.interface.d.ts

@@ -0,0 +1,121 @@
+import type { Ref } from 'vue';
+/**
+ * Reactive state surface returned by `useMediaPlayer` — the
+ * media-agnostic base shared between `useVideoPlayer` and
+ * `useAudioPlayer`. Fields below describe state that applies to both
+ * `HTMLVideoElement` and `HTMLAudioElement`; video-specific extensions
+ * (`fullscreen`, `pip`) live in `IVideoPlayerState`.
+ */
+export interface IMediaPlayerState {
+    /** True while the element is decoding frames / producing audio. */
+    playing: Ref<boolean>;
+    /** True when playback is paused (or has not started yet). */
+    paused: Ref<boolean>;
+    /** Current playhead position in seconds. */
+    currentTime: Ref<number>;
+    /**
+     * Total duration in seconds. `NaN` until metadata loads. Can be
+     * `Infinity` for live streams — consumers must guard `max` UI
+     * bindings with `Number.isFinite()`.
+     */
+    duration: Ref<number>;
+    /**
+     * End of the buffered range in seconds (the right edge of the last
+     * contiguous chunk the browser can play without stalling).
+     */
+    buffered: Ref<number>;
+    /** Volume between 0 and 1 — independent from `muted`. */
+    volume: Ref<number>;
+    /** True when the output is muted. Independent from `volume`. */
+    muted: Ref<boolean>;
+    /** True once metadata has loaded and `duration` is finite. */
+    ready: Ref<boolean>;
+    /** True between `loadstart` and `loadedmetadata` (or `waiting`). */
+    loading: Ref<boolean>;
+    /** Last media error captured by the composable, if any. */
+    error: Ref<MediaError | Error | null>;
+    /** Current playback rate. `1` = normal speed. */
+    playbackRate: Ref<number>;
+    /** True when at least one Remote Playback device is reachable. */
+    remoteAvailable: Ref<boolean>;
+    /** Connection state of the Remote Playback session. */
+    remoteState: Ref<'disconnected' | 'connecting' | 'connected'>;
+}
+/**
+ * Imperative methods returned by `useMediaPlayer`. Media-agnostic
+ * subset — every method maps 1:1 to the standard `HTMLMediaElement`
+ * API. Video-specific commands (`toggleFullscreen`, `togglePip`,
+ * `enterFullscreen`, …) live in `IVideoPlayerMethods`.
+ */
+export interface IMediaPlayerMethods {
+    /** Resolve once `el.play()` has settled (or the call has been
+     *  swallowed into `state.error`). */
+    play: () => Promise<void>;
+    /** Pause playback. Returns synchronously. */
+    pause: () => void;
+    /** Toggle between play and pause based on the current `playing`
+     *  state. Convenience over `if (playing) pause() else play()`. */
+    toggle: () => Promise<void>;
+    /** Seek to `seconds`, clamped to `[0, duration]`. */
+    seek: (seconds: number) => void;
+    /** Set the volume, clamped to `[0, 1]`. Un-mutes when raising
+     *  the volume from zero. */
+    setVolume: (value: number) => void;
+    /** Flip the muted flag on the element. */
+    toggleMute: () => void;
+    /** Force a reload of the underlying media element. */
+    load: () => void;
+    /** Jump backward by `seconds`, clamped to [0, duration]. */
+    skipBackward: (seconds: number) => void;
+    /** Jump forward by `seconds`, clamped to [0, duration]. */
+    skipForward: (seconds: number) => void;
+    /** Set the playback rate, clamped to `[0.25, 4]`. */
+    setPlaybackRate: (rate: number) => void;
+    /** Open the native cast / AirPlay device picker. No-op when the
+     *  Remote Playback API is unavailable. */
+    requestRemotePlayback: () => Promise<void>;
+    /** Force-disconnect any active Remote Playback session. No-op
+     *  when no session is active or the API is unavailable. */
+    stopRemotePlayback: () => Promise<void>;
+}
+/**
+ * Shared media event signatures. Composables themselves do NOT emit —
+ * consumers wire their own emits from the state refs. This interface
+ * is kept for documentation + for components that want to surface
+ * the same shape on their public emit contract.
+ */
+export interface IMediaPlayerEmits {
+    (e: 'play'): void;
+    (e: 'pause'): void;
+    (e: 'ended'): void;
+    (e: 'timeupdate', currentTime: number): void;
+    (e: 'volumechange', volume: number): void;
+    (e: 'loadedmetadata', payload: {
+        duration: number;
+    }): void;
+    (e: 'error', err: MediaError | Error): void;
+    /** Two-way binding for the playback rate. The component DOES NOT
+     *  set this in response to the consumer's prop changes — only when
+     *  the user picks a rate from the config menu. */
+    (e: 'update:playbackRate', rate: number): void;
+}
+/**
+ * Options accepted by `useMediaPlayer`. The composable is media-agnostic
+ * — `mediaRef` accepts any `HTMLMediaElement` (audio OR video).
+ */
+export interface IUseMediaPlayerOptions {
+    /** Suppress autoplay when the user has requested reduced motion. */
+    autoplay?: boolean;
+    /** Initial muted state. */
+    muted?: boolean;
+    /** Loop on `ended`. */
+    loop?: boolean;
+    /** Buffering hint. */
+    preload?: 'none' | 'metadata' | 'auto';
+    /**
+     * Resolves to the `HTMLMediaElement` to drive. When omitted, the
+     * composable creates an empty ref and expects the consumer to
+     * `bind` it on a `<video ref>` / `<audio ref>` themselves.
+     */
+    mediaRef?: Ref<HTMLMediaElement | null>;
+}

package/dist/src/interfaces/Media/media-scrubber.interface.cjs

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

package/dist/src/interfaces/Media/media-scrubber.interface.d.ts

@@ -0,0 +1,129 @@
+import type { IColorProps, ICommonsComponentProps, IRoundedProps } from '../../interfaces';
+import type { TMediaScrubberOrientation } from '../../types';
+/**
+ * Props for `<OrigamMediaScrubber>` — a headless, media-agnostic
+ * value-on-a-track widget. Owns NO state: the parent controls
+ * `modelValue` and listens to `update:modelValue` / `change` / `drag*`
+ * / `hover` events. Used internally by `<OrigamVideo>` (and soon
+ * `<OrigamAudio>`) for the timeline AND the volume slider — both share
+ * the exact same drag / keyboard / ARIA pipeline; only the orientation
+ * and the `buffered` channel differ.
+ *
+ * Defaults are inlined inside `withDefaults` (cf. CLAUDE.md
+ * `withDefaults` rule) — this interface only types the public API.
+ */
+export interface IMediaScrubberProps extends ICommonsComponentProps, IColorProps, IRoundedProps {
+    /**
+     * Current value, between `min` and `max`. Supports `v-model`.
+     * The component never mutates this directly — every change is
+     * surfaced via `update:modelValue` so the parent stays the
+     * single source of truth.
+     */
+    modelValue: number;
+    /**
+     * Lower bound of the value range.
+     *
+     * @default 0
+     */
+    min?: number;
+    /**
+     * Upper bound of the value range. Required to compute the thumb
+     * position. Passing `0` (or any value `<= min`) freezes the
+     * scrubber at the start.
+     */
+    max: number;
+    /**
+     * Discrete step. `0` (default) means continuous — pointer events
+     * emit the raw float; positive values snap each emission to the
+     * nearest multiple.
+     *
+     * @default 0
+     */
+    step?: number;
+    /**
+     * Optional buffered position (typically the end of the browser's
+     * media buffer). Renders the `__buffer` bar from `min` up to
+     * `buffered`. Pass `undefined` to hide the bar entirely.
+     */
+    buffered?: number;
+    /**
+     * Layout axis. Horizontal = YouTube timeline shape, Vertical =
+     * volume / level meter shape (top of track = `max`,
+     * bottom of track = `min`).
+     *
+     * @default 'horizontal'
+     */
+    orientation?: TMediaScrubberOrientation;
+    /**
+     * Disables pointer + keyboard interaction. The element drops out
+     * of the tab order (`tabindex="-1"`) and pointer events become
+     * no-ops; styling stays untouched so consumers can paint their
+     * own disabled state via `:has(.origam-media-scrubber--disabled)`
+     * or similar.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Hides the thumb at rest and reveals it on hover / focus / drag —
+     * the YouTube pattern. When `false`, the thumb is always visible.
+     *
+     * @default false
+     */
+    showThumbOnHoverOnly?: boolean;
+    /**
+     * Shows a tooltip above the cursor (horizontal only) reflecting
+     * the hovered value. Content can be overridden via the `#tooltip`
+     * slot.
+     *
+     * @default false
+     */
+    showHoverTooltip?: boolean;
+    /**
+     * Formatter for the default hover tooltip label. Receives the
+     * hovered value, returns the string to render.
+     *
+     * @default value => String(value)
+     */
+    formatHoverTooltip?: (value: number) => string;
+    /**
+     * Required accessibility label — read by screen readers when the
+     * scrubber gains focus. Always pass a translated string here.
+     */
+    ariaLabel: string;
+    /**
+     * Optional human-readable representation of the current value
+     * (e.g. `"1:23"` for a timestamp, `"45 %"` for a volume).
+     * Mapped to `aria-valuetext`.
+     */
+    ariaValueText?: string;
+}
+/**
+ * Emits for `<OrigamMediaScrubber>`.
+ */
+export interface IMediaScrubberEmits {
+    /** Live value update — fires during drag, keyboard, and click. */
+    (e: 'update:modelValue', value: number): void;
+    /** Commit event — fires on pointerup / pointercancel after a drag. */
+    (e: 'change', value: number): void;
+    /** Drag has started (pointerdown captured). */
+    (e: 'dragstart'): void;
+    /** Drag has ended (pointerup / pointercancel). */
+    (e: 'dragend'): void;
+    /** Hover position — fires with the hovered value on pointermove,
+     *  and with `null` on pointerleave (cursor left the track). */
+    (e: 'hover', value: number | null): void;
+}
+/**
+ * Slot signatures for `<OrigamMediaScrubber>`.
+ */
+export interface IMediaScrubberSlots {
+    /**
+     * Hover-tooltip body. Receives the hovered value. Only rendered
+     * when `showHoverTooltip=true` AND the cursor sits over the
+     * track (horizontal orientation).
+     */
+    tooltip?: (bindings: {
+        value: number;
+    }) => any;
+}

package/dist/src/interfaces/Media/media-volume-control.interface.cjs

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