origam 2.3.0 → 2.6.1

package/dist/src/interfaces/Chart/chart.interface.d.ts

@@ -0,0 +1,287 @@
+import type { IBgColorProps, IChartAnnotation, IChartDrilldownProps, IChartPlotBand, IChartPlotLine, IChartPoint, IChartSecondaryYAxis, IChartSeries, ICommonsComponentProps, IDimensionProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps } from '../../interfaces';
+import type { TChartLegendPosition, TChartSmoothing, TChartStacking, TChartType, TIntent } from '../../types';
+/**
+ * Props accepted by `<OrigamChart>`. Single component for eight
+ * visualisation primitives — the `type` prop selects the path
+ * generator inside `useChart`. Defaults are inlined in the SFC via
+ * `withDefaults(defineProps<IChartProps>(), { … })` per the
+ * project's "literals-only" rule.
+ */
+export interface IChartProps extends ICommonsComponentProps, IDimensionProps, IMarginProps, IPaddingProps, IRoundedProps, IElevationProps, IBgColorProps {
+    /** Visualisation primitive. Default `'line'`. */
+    type?: TChartType;
+    /** Data series — one or more. Empty array renders the `#empty` slot. */
+    series: Array<IChartSeries>;
+    /**
+     * X axis labels (for line/area/bar/column/radar). Length should
+     * match the longest series; missing entries fall back to the
+     * numeric index.
+     */
+    categories?: Array<string>;
+    /** Optional title rendered above the plotting area. */
+    title?: string;
+    /** Optional subtitle rendered below the title. */
+    subtitle?: string;
+    /** Toggle the legend block. Default `true`. */
+    showLegend?: boolean;
+    /** Anchor of the legend block. Default `'bottom'`. */
+    legendPosition?: TChartLegendPosition;
+    /** Toggle the hover tooltip. Default `true`. */
+    showTooltip?: boolean;
+    /**
+     * Render grid lines behind the plot. Ignored for pie/donut/radar.
+     * Default `true`.
+     */
+    showGrid?: boolean;
+    /** Render X / Y axes + tick labels. Ignored for pie/donut. Default `true`. */
+    showAxis?: boolean;
+    /**
+     * Animate paths / bars / slices on first paint and on data
+     * changes. Respects `prefers-reduced-motion`. Default `true`.
+     */
+    animated?: boolean;
+    /** Animation duration in ms. Default `600`. */
+    animationDuration?: number;
+    /** Stack series on `bar` / `column`. Default `false`. */
+    stacked?: boolean;
+    /**
+     * Stacking mode applied when `stacked=true`.
+     *
+     * - `'normal'`  — raw absolute values (default, matches pre-v2
+     *                 `stacked=true` behaviour).
+     * - `'percent'` — every stack is normalised to 100 %; Y-axis
+     *                 fixed at `0 → 100`, tick labels use `${v}%`.
+     */
+    stacking?: TChartStacking;
+    /**
+     * Inner-radius proportion for `donut`. `0` collapses to a pie,
+     * `1` to a ring of zero thickness. Default `0.6` when
+     * `type === 'donut'`, ignored otherwise.
+     */
+    donutHoleSize?: number;
+    /**
+     * Palette used when a series does not pin its own `color`.
+     * Pass intent strings (cycled in order) or raw CSS colours.
+     * Default cycles through the 8 origam intents.
+     */
+    colorScheme?: Array<TIntent | string>;
+    /** Formatter applied to X-axis tick labels. */
+    xAxisFormat?: (value: string | number) => string;
+    /** Formatter applied to Y-axis tick labels. */
+    yAxisFormat?: (value: number) => string;
+    /**
+     * CSS `aspect-ratio` shortcut (`'16/9'`, `'4/3'`, `'1/1'`…). When
+     * set, overrides `height` and lets the chart breathe with the
+     * container width.
+     */
+    aspectRatio?: string;
+    /**
+     * Smoothing strategy for line/area. Default `'none'` —
+     * Cartesian segments between points. `'curve'` uses cubic
+     * Bezier with Catmull-Rom tangents.
+     */
+    smoothing?: TChartSmoothing;
+    /**
+     * Override the auto-computed Y min. Useful when the data
+     * starts well above zero and you want the visual baseline.
+     */
+    yMin?: number;
+    /** Override the auto-computed Y max. */
+    yMax?: number;
+    /**
+     * Lower bound of the gauge range. Ignored unless `type='gauge'`.
+     * Default `0`.
+     */
+    gaugeMin?: number;
+    /**
+     * Upper bound of the gauge range. Ignored unless `type='gauge'`.
+     * Default `100`.
+     */
+    gaugeMax?: number;
+    /**
+     * Optional unit appended to the gauge centre label
+     * (e.g. `'%'`, `' km/h'`). Ignored unless `type='gauge'`.
+     */
+    gaugeUnit?: string;
+    /**
+     * Coloured rectangular zones drawn behind (or above) the chart
+     * data. Forwarded to `<OrigamChartCartesian>` only — ignored for
+     * polar / radar / gauge families.
+     */
+    plotBands?: Array<IChartPlotBand>;
+    /**
+     * Threshold lines drawn at a fixed axis value. Forwarded to
+     * `<OrigamChartCartesian>` only — ignored for polar / radar / gauge.
+     */
+    plotLines?: Array<IChartPlotLine>;
+    /**
+     * Overlay annotations drawn on top of the series layer. Forwarded to
+     * `<OrigamChartCartesian>` only — ignored for polar / radar / gauge /
+     * other non-cartesian families. Annotations are positioned in data
+     * coordinates. Four kinds: `'arrow'`, `'label'`, `'circle'`, `'bracket'`.
+     */
+    annotations?: Array<IChartAnnotation>;
+    /**
+     * Drilldown configuration forwarded to `<OrigamChartCartesian>` and
+     * `<OrigamChartPolar>`. Ignored by other families (radar, gauge, …).
+     */
+    drilldown?: IChartDrilldownProps;
+    /**
+     * Secondary (right-hand) Y axis configuration. Forwarded to
+     * `<OrigamChartCartesian>` only — ignored for other families.
+     * When absent the engine ignores `series.yAxis === 1` assignments.
+     */
+    secondaryYAxis?: IChartSecondaryYAxis;
+}
+/**
+ * Emits surfaced by `<OrigamChart>`. All payloads are plain
+ * serialisable data (no DOM refs), so callers can forward to a
+ * store / websocket / analytics layer without unwrapping.
+ */
+export interface IChartEmits {
+    /** Mouse / keyboard activation on a data point. */
+    (e: 'point-click', point: IChartPoint, originalEvent: MouseEvent | KeyboardEvent): void;
+    /** Click on a legend entry — pair with `series-toggle` for state. */
+    (e: 'legend-click', series: IChartSeries, index: number): void;
+    /** Resulting visibility flip after a legend click. */
+    (e: 'series-toggle', series: IChartSeries, visible: boolean): void;
+}
+/**
+ * Slot signatures. Replace the default tooltip card, legend
+ * entry, title block, or empty state without losing the rest of
+ * the chart chrome.
+ */
+export interface IChartSlots {
+    /** Replace the default tooltip body. */
+    tooltip?: (bindings: {
+        point: IChartPoint;
+        series: IChartSeries;
+        category: string | number;
+    }) => any;
+    /** Replace one legend entry. */
+    'legend-item'?: (bindings: {
+        series: IChartSeries;
+        index: number;
+        visible: boolean;
+    }) => any;
+    /** Replace the title block (title + subtitle). */
+    title?: () => any;
+    /** Render when `series` is empty / every series is hidden. */
+    empty?: () => any;
+}
+/**
+ * Single tick rendered along an axis. `position` is the SVG
+ * pixel coordinate, `label` the already-formatted string.
+ */
+export interface IChartTick {
+    position: number;
+    label: string;
+    value: number | string;
+}
+/**
+ * Pair of pixel-mapping functions. Pure — produced from the data
+ * range + viewBox size; safe to call from inside computeds.
+ */
+export interface IChartScales {
+    x: (value: number | string, dataIndex?: number, categoryCount?: number) => number;
+    y: (value: number) => number;
+}
+/**
+ * Output of `useChart` — one path descriptor per series (per
+ * data point for bar/column/scatter/pie). The component renders
+ * each entry inside a `<g>` according to `kind`.
+ */
+export interface IChartPath {
+    seriesIndex: number;
+    /**
+     * SVG element kind to emit. `path` for line/area/pie/donut/
+     * radar, `rect` for bar/column, `circle` for scatter +
+     * line/area markers.
+     */
+    kind: 'path' | 'rect' | 'circle' | 'polygon';
+    /** Pre-computed `d` attribute for `kind === 'path' | 'polygon'`. */
+    d?: string;
+    /** Geometry for `kind === 'rect'`. */
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Geometry for `kind === 'circle'`. */
+    circle?: {
+        cx: number;
+        cy: number;
+        r: number;
+    };
+    /** Resolved CSS colour string. */
+    color: string;
+    /** Original series reference (for tooltip / legend). */
+    series: IChartSeries;
+    /** Optional data index when the path represents a single point. */
+    dataIndex?: number;
+    /** Length of the path (used by stroke-dashoffset animation). */
+    pathLength?: number;
+    /**
+     * Sub-kind for `kind === 'path'`. Area charts emit two paths per
+     * series — the filled area down to the baseline (`variant: 'fill'`)
+     * and the overlaid stroke (`variant: 'stroke'`). The component reads
+     * the variant to decide whether to paint `fill` or `stroke`.
+     */
+    variant?: 'fill' | 'stroke';
+}
+/**
+ * Aggregated legend entry — one per series. Pre-resolved colour
+ * so the legend doesn't have to re-look-up the palette.
+ */
+export interface IChartLegendItem {
+    series: IChartSeries;
+    index: number;
+    color: string;
+    visible: boolean;
+}
+/**
+ * Strict, defaulted options consumed by `useChart`. The SFC
+ * derives this from props via thunks so the composable stays
+ * reactive without owning the prop reference.
+ */
+export interface IUseChartOptions {
+    type: () => TChartType;
+    series: () => Array<IChartSeries>;
+    categories: () => Array<string>;
+    stacked: () => boolean;
+    /**
+     * Stacking mode when `stacked()` is `true`. Optional — defaults
+     * to `'normal'` so callers that don't expose the prop yet are
+     * unaffected.
+     */
+    stacking?: () => TChartStacking;
+    donutHoleSize: () => number;
+    colorScheme: () => Array<TIntent | string>;
+    smoothing: () => TChartSmoothing;
+    yMin: () => number | undefined;
+    yMax: () => number | undefined;
+    width: () => number;
+    height: () => number;
+    padding: () => {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /**
+     * Per-label hidden set. Used by the single-pie / donut path to
+     * skip slices whose category label was toggled OFF in the
+     * legend. Cartesian / radar / gauge / multi-pie use `series.visible`
+     * for the same purpose; this option exists for the pie/donut
+     * "category as slice" mode where there's no per-slice series to
+     * attach visibility to. Optional — defaults to an empty Set.
+     */
+    hiddenLabels?: () => Set<string>;
+    /**
+     * Secondary (right-hand) Y axis configuration. Optional — when
+     * absent the engine ignores `series.yAxis === 1` assignments and
+     * plots everything against the primary left axis.
+     */
+    secondaryYAxis?: () => IChartSecondaryYAxis | undefined;
+}

package/dist/src/interfaces/Checkbox/checkbox-btn.interface.d.ts

@@ -11,9 +11,9 @@ export interface ICheckboxBtnSlots extends ICommonsComponentSlots {
     label?: () => any;
     input?: (data: {
         props: any;
-        icon: TIcon;
-        textColorStyles: TColor;
-        backgroundColorStyles: TColor;
+        icon?: TIcon;
+        textColorStyles?: TColor;
+        backgroundColorStyles?: TColor;
         model: any;
     }) => any;
 }

package/dist/src/interfaces/Checkbox/checkbox.interface.d.ts

@@ -5,19 +5,20 @@ export interface ICheckboxProps extends ICommonsComponentProps, IInputProps, ICh
 export interface ICheckboxEmits extends ICommonsComponentEmits, IFocusEmits, ISelectionControlEmits {
 }
 export interface ICheckboxSlots {
-    default?: (data: {
-        id: string;
-        messagesId: string;
-        isDisabled: boolean;
-        isReadonly: boolean;
-        isValid: boolean;
+    /** Slot data is provided when called from OrigamInput; absent when re-forwarded from OrigamCheckboxBtn. */
+    default?: (data?: {
+        id?: string;
+        messagesId?: string;
+        isDisabled?: boolean;
+        isReadonly?: boolean;
+        isValid?: boolean | undefined;
     }) => any;
     label?: () => any;
     input?: (data: {
         props: any;
-        icon: TIcon;
-        textColorStyles: TColor;
-        backgroundColorStyles: TColor;
+        icon?: TIcon;
+        textColorStyles?: TColor;
+        backgroundColorStyles?: TColor;
         model: any;
     }) => any;
 }

package/dist/src/interfaces/Chip/chip-group.interface.d.ts

@@ -1,6 +1,11 @@
-import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps, IGroupProps, IMarginProps, IPaddingProps, IRoundedProps, ISlideGroupProps, ITagProps } from '../../interfaces';
+import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IGroupProps, IMarginProps, IPaddingProps, IRoundedProps, ISlideGroupProps, ITagProps, IActiveState, IHoverState } from '../../interfaces';
 export interface IChipGroupProps extends ICommonsComponentProps, ITagProps, IGroupProps, IColorProps, IBgColorProps, IMarginProps, IPaddingProps, IBorderProps, IRoundedProps, ISlideGroupProps {
     column?: boolean;
     filter?: boolean;
     valueComparator?: (a: any, b: any) => boolean;
+    active?: IActiveState;
+    hover?: IHoverState;
+}
+/** Emits fired by `<OrigamChipGroup>` — v-model on the active chip set. */
+export interface IChipGroupEmits extends ICommonsComponentEmits {
 }

package/dist/src/interfaces/Chip/chip.interface.d.ts

@@ -1,6 +1,6 @@
-import type { IActiveProps, IAdjacentProps, IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IGroupItemProps, IHoverProps, ILinkProps, IMarginProps, IPaddingProps, IRippleProps, IRoundedProps, ISizeProps, ITagProps } from '../../interfaces';
+import type { IActiveProps, IAdjacentEmits, IAdjacentProps, IBorderProps, IBgColorProps, IClickCloseEmits, IClickEmits, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IGroupEmits, IGroupItemProps, IHoverProps, ILinkProps, IMarginProps, IPaddingProps, IRippleProps, IRoundedProps, ISizeProps, ITagProps, ITypographyProps } from '../../interfaces';
 import type { TIcon } from '../../types';
-export interface IChipProps extends ICommonsComponentProps, IAdjacentProps, ITagProps, IColorProps, IBgColorProps, IRippleProps, IBorderProps, IRoundedProps, IPaddingProps, IMarginProps, IDensityProps, IGroupItemProps, ILinkProps, ISizeProps, IElevationProps, IActiveProps, IHoverProps {
+export interface IChipProps extends ICommonsComponentProps, IAdjacentProps, ITagProps, IColorProps, IBgColorProps, IRippleProps, IBorderProps, IRoundedProps, IPaddingProps, IMarginProps, IDensityProps, IGroupItemProps, ILinkProps, ISizeProps, IElevationProps, IActiveProps, IHoverProps, ITypographyProps {
     closable?: boolean;
     closeIcon?: TIcon;
     closeLabel?: string;
@@ -13,3 +13,7 @@ export interface IChipProps extends ICommonsComponentProps, IAdjacentProps, ITag
     text?: string;
     modelValue?: boolean;
 }
+/** Emits fired by `<OrigamChip>` — generic click, close button, group
+ *  membership, prepend/append icons, and v-model on dismissal. */
+export interface IChipEmits extends ICommonsComponentEmits, IClickEmits, IClickCloseEmits, IAdjacentEmits, IGroupEmits {
+}

package/dist/src/interfaces/Clipboard/clipboard.interface.cjs

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

package/dist/src/interfaces/Clipboard/clipboard.interface.d.ts

@@ -0,0 +1,106 @@
+import type { IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps, ITypographyProps } from '../../interfaces';
+/**
+ * Props for `<OrigamClipboard>` — copy-to-clipboard wrapper.
+ *
+ * The component is intentionally chrome-less: it owns the copy
+ * pipeline (`navigator.clipboard.writeText` + `execCommand` fallback)
+ * and the auto-resetting `copied` flag, but it does NOT impose any
+ * visual on the trigger. The built-in trigger (rendered when no slot
+ * is provided) is a single button whose label flips to `feedbackText`
+ * while `copied` is true — that's the only feedback surface the
+ * component owns. Consumers needing a different feedback shape (toast,
+ * inline pill, animation, …) pass a `#default` scoped slot exposing
+ * `{ copy, copied, error }` and render whatever they want.
+ */
+export interface IClipboardProps extends ICommonsComponentProps, ITagProps, IColorProps, IBgColorProps, IBorderProps, IRoundedProps, IMarginProps, IPaddingProps, ITypographyProps {
+    /**
+     * Text payload written to the clipboard on `copy()`. Required.
+     * Re-read each time the trigger fires, so a parent that mutates
+     * the value between mounts still copies the up-to-date string.
+     */
+    value: string;
+    /**
+     * Duration (ms) the `copied` flag stays true after a successful
+     * write. The state auto-resets after this window — there is no
+     * need to clear it from the consumer side.
+     *
+     * @default 2000
+     */
+    feedbackDuration?: number;
+    /**
+     * Label rendered inside the built-in feedback overlay (and the
+     * auto-rendered button label when no slot is provided). Consumers
+     * wrap with `t()` if they need full i18n.
+     *
+     * @default 'Copied!'
+     */
+    feedbackText?: string;
+    /**
+     * Alias for `feedbackText`. Takes precedence when both are passed.
+     * Provided for callers who prefer the "success" framing in their
+     * codebase.
+     */
+    successText?: string;
+    /**
+     * Disables the copy action. The default trigger becomes
+     * non-interactive (`disabled` attribute) and `copy()` becomes a
+     * no-op. The scoped slot still receives the `copy` function so
+     * consumers can decide what to render — but it will short-circuit.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+}
+/**
+ * Emits for `<OrigamClipboard>`.
+ */
+export interface IClipboardEmits {
+    /** Fired after a successful write. Carries the payload string. */
+    (e: 'copy', value: string): void;
+    /** Fired after a failed write (clipboard API denied, no permission, …). */
+    (e: 'error', err: Error): void;
+}
+/**
+ * Bindings exposed via the `#default` scoped slot. Consumers use these
+ * to wire any trigger — button, icon, span, custom widget — to the
+ * copy pipeline without re-implementing the timing logic.
+ */
+export interface IClipboardScopedSlotBindings {
+    /** Triggers the copy pipeline. Promise resolves true on success. */
+    copy: () => Promise<boolean>;
+    /** True for `feedbackDuration` ms after a successful copy. */
+    copied: boolean;
+    /** Set when the last copy attempt threw, null otherwise. */
+    error: Error | null;
+}
+/**
+ * Slot signatures for `<OrigamClipboard>`.
+ */
+export interface IClipboardSlots {
+    /**
+     * Custom trigger. Scoped — receives `{ copy, copied, error }`.
+     * When omitted, the component renders a default icon button with
+     * `mdi:mdi-content-copy`.
+     */
+    default?: (bindings: IClipboardScopedSlotBindings) => any;
+    /**
+     * Custom feedback marker rendered when `showFeedback` is true and
+     * `copied` is true. Scoped — receives the boolean for symmetry
+     * with the default slot.
+     */
+    feedback?: (bindings: {
+        copied: boolean;
+    }) => any;
+}
+/**
+ * Options for the `useClipboard` composable.
+ */
+export interface IUseClipboardOptions {
+    /**
+     * Duration (ms) the returned `copied` ref stays true after a
+     * successful write before auto-resetting.
+     *
+     * @default 2000
+     */
+    feedbackDuration?: number;
+}

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

@@ -1,5 +1,5 @@
-import type { IBorderProps, ICommonsComponentProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../index';
-import type { TCodeLang, TCodeTheme } from '../../types';
+import type { IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDimensionProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps, ITypographyProps } from '../index';
+import type { TCodeLang } from '../../types';
 /**
  * Props for `<OrigamCode>` — a shiki-powered code block with line numbers,
  * line highlighting, copy button and theme awareness.
@@ -9,7 +9,7 @@ import type { TCodeLang, TCodeTheme } from '../../types';
  * 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 {
+export interface ICodeProps extends ICommonsComponentProps, ITagProps, IBorderProps, IRoundedProps, IElevationProps, IPaddingProps, IMarginProps, IDimensionProps, IColorProps, IBgColorProps, ITypographyProps {
     /**
      * 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
@@ -40,16 +40,6 @@ export interface ICodeProps extends ICommonsComponentProps, ITagProps, IBorderPr
      * 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.
@@ -69,6 +59,23 @@ export interface ICodeProps extends ICommonsComponentProps, ITagProps, IBorderPr
      * top-right corner of the code surface.
      */
     filename?: string;
+    /**
+     * Render the block as a single-line **pill** instead of a multi-line
+     * surface — ideal for a copyable install command (`npm install origam`).
+     * In compact mode the header, filename and line-numbers are suppressed,
+     * vertical padding shrinks to one line, the surface keeps its themed
+     * tokens, and the copy control collapses to a small icon button anchored
+     * inline at the end of the row (not a floating text "Copy"). The `<figure>
+     * <pre><code>` semantics are preserved.
+     */
+    compact?: boolean;
+    /**
+     * Decorative prompt prefix rendered BEFORE the code (e.g. `'$'` for a
+     * shell command). Purely visual: it is NOT part of the highlighted code
+     * and is NEVER included in the clipboard copy (only `code` is copied).
+     * Most useful paired with `compact` for an install-command pill.
+     */
+    prompt?: string;
 }
 /**
  * Public surface of the `useCode` composable. Lazily instantiates a shiki
@@ -81,7 +88,7 @@ export interface IUseCodeReturn {
      * 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>;
+    highlight(code: string, lang: TCodeLang): Promise<string>;
     /**
      * Force the highlighter to load. Useful for stories / tests that want
      * to warm the cache before mounting consumers.

package/dist/src/interfaces/ColorPicker/color-picker-canvas.interface.d.ts

@@ -1,7 +1,11 @@
-import type { ICommonsComponentProps, IDimensionProps } from "../../interfaces";
+import type { IColorHsvEmits, ICommonsComponentProps, IDimensionProps } from "../../interfaces";
 import type { THSVA } from "../../types";
 export interface IColorPickerCanvasProps extends ICommonsComponentProps, IDimensionProps {
     colorHsv?: THSVA | null;
     disabled?: boolean;
     dotSize?: string | number;
+    ariaLabel?: string;
+}
+/** Emits fired by `<OrigamColorPickerCanvas>` — drag/click updates the HSVA. */
+export interface IColorPickerCanvasEmits extends IColorHsvEmits {
 }

package/dist/src/interfaces/ColorPicker/color-picker-edit.interface.d.ts

@@ -1,4 +1,4 @@
-import type { ICommonsComponentProps } from "../../interfaces";
+import type { IColorHsvEmits, IColorModeEmits, ICommonsComponentProps } from "../../interfaces";
 import type { TColorModes, THSVA } from "../../types";
 export interface IColorPickerEditProps extends ICommonsComponentProps {
     colorHsv?: THSVA | null;
@@ -6,3 +6,7 @@ export interface IColorPickerEditProps extends ICommonsComponentProps {
     mode?: TColorModes;
     modes?: Array<TColorModes>;
 }
+/** Emits fired by `<OrigamColorPickerEdit>` — input edits the HSVA and
+ *  flips between the active mode. */
+export interface IColorPickerEditEmits extends IColorHsvEmits, IColorModeEmits {
+}

package/dist/src/interfaces/ColorPicker/color-picker-preview.interface.d.ts

@@ -1,7 +1,10 @@
-import type { ICommonsComponentProps, IDimensionProps } from "../../interfaces";
+import type { IColorHsvEmits, ICommonsComponentProps, IDimensionProps } from "../../interfaces";
 import type { THSVA } from "../../types";
 export interface IColorPickerPreviewProps extends ICommonsComponentProps, IDimensionProps {
     colorHsv?: THSVA | null;
     disabled?: boolean;
     hideAlpha?: boolean;
 }
+/** Emits fired by `<OrigamColorPickerPreview>` — alpha slider updates the HSVA. */
+export interface IColorPickerPreviewEmits extends IColorHsvEmits {
+}

package/dist/src/interfaces/ColorPicker/color-picker-swatches.interface.d.ts

@@ -1,7 +1,11 @@
-import type { ICommonsComponentProps, IDimensionProps } from "../../interfaces";
+import type { IColorHsvEmits, ICommonsComponentProps, IDimensionProps } from "../../interfaces";
 import type { TColorType, THSVA } from "../../types";
 export interface IColorPickerSwatchesProps extends ICommonsComponentProps, IDimensionProps {
     colorHsv?: THSVA | null;
     disabled?: boolean;
     swatches?: Array<Array<TColorType>>;
 }
+/** Emits fired by `<OrigamColorPickerSwatches>` — click on a swatch tile
+ *  pushes the colour up the HSVA channel. */
+export interface IColorPickerSwatchesEmits extends IColorHsvEmits {
+}

package/dist/src/interfaces/ColorPicker/color-picker.interface.d.ts

@@ -1,5 +1,17 @@
-import type { IBorderProps, IColorPickerCanvasProps, IColorPickerEditProps, IColorPickerPreviewProps, IColorPickerSwatchesProps, IColorProps, ICommonsComponentProps, IElevationProps, IMarginProps, IPaddingProps, IPickerProps, IRoundedProps } from "../../interfaces";
-import type { THSVA } from "../../types";
+import type { IBorderProps, IColorPickerCanvasProps, IColorPickerEditProps, IColorPickerPreviewProps, IColorPickerSwatchesProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IElevationProps, IMarginProps, IPaddingProps, IPickerProps, IRoundedProps } from "../../interfaces";
+import type { TColorModes, THSVA } from "../../types";
+/** Shared emit shape for sub-components driving the HSVA model
+ *  (Canvas / Edit / Preview / Swatches all push their changes up the
+ *  same channel). Factored here so the four sub-component interfaces
+ *  can extend it without redeclaring. */
+export interface IColorHsvEmits {
+    (e: 'update:colorHsv', value: THSVA): void;
+}
+/** Shared emit shape for sub-components that flip between color modes
+ *  (RGB / HSL / HSV / HEX, …). */
+export interface IColorModeEmits {
+    (e: 'update:mode', value: TColorModes): void;
+}
 export interface IColorPickerProps extends ICommonsComponentProps, IBorderProps, IRoundedProps, IElevationProps, IPaddingProps, IMarginProps, IPickerProps, IColorProps, IColorPickerCanvasProps, IColorPickerPreviewProps, IColorPickerEditProps, IColorPickerSwatchesProps {
     canvasHeight?: string | number;
     canvasWidth?: string | number;
@@ -21,3 +33,7 @@ export interface IColorPickerMode {
     from: (color: any) => THSVA;
     to: (color: THSVA) => any;
 }
+/** Emits fired by `<OrigamColorPicker>` — v-model on the resolved colour
+ *  plus the active input mode. */
+export interface IColorPickerEmits extends ICommonsComponentEmits, IColorModeEmits {
+}

package/dist/src/interfaces/ColorPickerField/color-picker-field.interface.d.ts

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

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

@@ -1,5 +1,6 @@
 import type { ICommand } from './command.interface';
 import type { ICommonsComponentProps } from '../Commons/commons.interface';
+import type { ITypographyProps } from '../Commons/typography.interface';
 /**
  * A hotkey is either a single combination (`['meta', 'k']`) or an
  * array of alternatives — every entry being a list of normalised key
@@ -10,7 +11,7 @@ import type { ICommonsComponentProps } from '../Commons/commons.interface';
  * the listeners so consumers can pass either form interchangeably.
  */
 export type TCommandPaletteHotkey = ReadonlyArray<string> | ReadonlyArray<ReadonlyArray<string>>;
-export interface ICommandPaletteProps extends ICommonsComponentProps {
+export interface ICommandPaletteProps extends ICommonsComponentProps, ITypographyProps {
     /** v-model — whether the palette is open. */
     modelValue?: boolean;
     /**