@mkbabb/glass-ui 4.2.0 → 6.0.0

package/dist/components/custom/search/SearchBar.vue.d.ts

@@ -1,38 +0,0 @@
-import { type Component } from "vue";
-import type { Surface } from "../../ui/_shared/useSurfaceAxis";
-import { type ControlSize, type SearchVariant } from "./searchVariants";
-type __VLS_Props = {
-    modelValue?: string;
-    placeholder?: string;
-    icon?: Component;
-    tag?: string;
-    size?: ControlSize;
-    surface?: Surface;
-    variant?: SearchVariant;
-};
-declare var __VLS_13: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_13) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    inputRef: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-}>, {
-    size: ControlSize;
-    variant: SearchVariant;
-    surface: Surface;
-    modelValue: string;
-    placeholder: string;
-    tag: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/custom/search/searchVariants.d.ts

@@ -1,19 +0,0 @@
-import { type VariantProps } from "class-variance-authority";
-import { type ControlSize, controlSizeClass } from "../../ui/_shared/useControlSize";
-/**
- * The search field-CHROME variant. `inline` is the boxed glass pill (identity over
- * the `.input-bar` recipe); `bare`/`floating` strip the box to a chromeless field —
- * the real CVA rung the `!important` cluster was fighting (clean break, no `!`).
- *
- *   searchFieldVariants()                    → ""                                          (the boxed pill)
- *   searchFieldVariants({ variant: "bare" }) → "border-none bg-transparent p-0 rounded-none"
- */
-export declare const searchFieldVariants: (props?: ({
-    variant?: "floating" | "inline" | "bare" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export type SearchVariant = NonNullable<VariantProps<typeof searchFieldVariants>["variant"]>;
-/** The CVA's variant-prop shape — the `/api` discovery surface (the SFCs cannot
- *  re-export a type, so this CVA home is the type source). */
-export type SearchVariants = VariantProps<typeof searchFieldVariants>;
-export { controlSizeClass };
-export type { ControlSize };

package/dist/components/custom/selectable-chip/SelectableChip.vue.d.ts

@@ -1,50 +0,0 @@
-/**
- * SelectableChip — the public face of the BC.W-ACCENT-TONE tonal-accent register.
- * A reka-`Toggle` selectable chip whose COLOUR identity comes from ONE `:tone` (a
- * complete `<color>`): the chip reads the `.accent-tone` register — a faint idle
- * FILL floored ≥3:1 (legible at rest, the load-bearing fourier ask), a bolder active
- * BAND + EDGE rim, and a contrast-safe INK label (auto-darkened/lightened by value.js
- * `safeAccentColor` so the text never drops below AA over the resolved band).
- *
- * Usage:
- *   <SelectableChip v-model="on" :tone="'var(--section-color-7)'">React</SelectableChip>
- *
- * The toggle state is the reka-ui Toggle `modelValue` contract — bind via `v-model`
- * (or `:model-value` / `@update:model-value`). For an exclusive picker, wire the chips
- * via direct refs (deliberately unopinionated about ToggleGroup — the ToggleChip
- * precedent).
- *
- * VALUE.JS-BEARING: this SFC STATICALLY imports `useAccentTone` (the contrast-safe-ink
- * composable, which reaches value.js `safeAccentColor`/`computeSafeAccent`), so the
- * chip chunk transitively reaches value.js — it ships on `/selectable-chip` ONLY, OFF
- * the value.js-free root barrel (the BorderProgress/EasingPicker SCC-trap precedent).
- */
-import type { HTMLAttributes } from "vue";
-import { type ToggleProps } from "reka-ui";
-import { type SelectableChipVariants } from "./selectableChipVariants";
-type __VLS_Props = ToggleProps & {
-    /** The accent COLOUR identity — a complete `<color>` (e.g. `var(--section-color-7)`
-     *  or a concrete `oklch(…)`). Defaults to `var(--primary)` via the register. The
-     *  SEMANTIC choice is a prop; the strength MAGNITUDES are tokens (no over-prop). */
-    tone?: string;
-    /** The structural size rung. Default `md`. */
-    size?: SelectableChipVariants["size"];
-    class?: HTMLAttributes["class"];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/custom/selectable-chip/chipVariants.d.ts

@@ -1,39 +0,0 @@
-import { type VariantProps } from "class-variance-authority";
-/**
- * chipVariants — the ONE congruent chip recipe (BD.W-CHIP-CONGRUENT-GLASS).
- *
- * The chip family (ToggleChip · SelectableChip + the toggle-group children)
- * collapses to ONE `chipVariants({ size })`: a stadium-pill warm-glass LENS that
- * PUNCHES when you pick it. Survival of the fittest — `selectableChipVariants`
- * (`sm`/`md`/`lg`) + the `ToggleChip` `chip`/`cell` axis collapse here (clean
- * break, no alias — the no-legacy law). The three SFCs stay DISTINCT (bool toggle
- * vs tonal picker vs glyph tile) but render the SAME register.
- *
- * The recipe is STRUCTURE + the shared-register hooks: it COMPOSES the read-only
- * shared registers, never re-forks a parallel glass/cartoon/motion system —
- *   · `.glass-chip`         — the chip-family material/motion layer (the warm idle
- *                             floor + the `--glass-fill-tint` plate tint + the ONE
- *                             scale write + the `::after` colour-flood punch).
- *   · `.glass-capsule`      — the warm-transmissive lozenge BODY (fill + rim +
- *                             shadow + blur, on `--radius-pill` → the stadium
- *                             end-cap at every rung). Radius is INVARIANT — the
- *                             capsule re-rounds itself at every height; no
- *                             `rounded-*` rung (retires the 4/6/10px grab-bag).
- *   · `.glass-capsule-hover`— the SHARED specular-lift + press-snap on hover.
- *   · `.accent-tone`        — the contrast-floored tonal channels (idle fill /
- *                             active band / active edge / contrast-safe ink).
- *
- * The geometry: radius invariant (the capsule's `--radius-pill`); only padding/
- * text vary, on a √φ ladder (φ≈1.618). The `cell` is the ONE documented exception
- * (`.glass-chip--cell` → `--radius-card`): a 72px icon+label tile is a CARD, not a
- * pill — a DELIBERATE 2-silhouette family, composing the SAME material + motion.
- *
- * NO scale CVA — the ONE `scale` write lives on `.glass-chip` (hover/press/punch
- * folded into a single source of truth; a CVA `hover:scale-*` would collide).
- * The CVA carries no `color-mix(…--primary…)` literal — the tonal COLOUR is the
- * `.accent-tone` register's.
- */
-export declare const chipVariants: (props?: ({
-    size?: "cell" | "sm" | "lg" | "md" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export type ChipVariants = VariantProps<typeof chipVariants>;

package/dist/components/custom/selectable-chip/index.d.ts

@@ -1,2 +0,0 @@
-export { default as SelectableChip } from "./SelectableChip.vue";
-export { selectableChipVariants, type SelectableChipVariants, } from "./selectableChipVariants";

package/dist/components/custom/selectable-chip/selectableChipVariants.d.ts

@@ -1,15 +0,0 @@
-/**
- * selectableChipVariants — the public name for the SelectableChip face of the ONE
- * shared `chipVariants` recipe (BD.W-CHIP-CONGRUENT-GLASS).
- *
- * The chip family collapsed to ONE congruent stadium-pill warm-glass register
- * (`./chipVariants`). SelectableChip reads it through this stable name; the
- * `size` axis (`sm`/`md`/`lg`/`cell`) IS the shared axis. No second recipe, no
- * grab-bag — the tonal channels are the `.accent-tone` register's, the lens is
- * `.glass-chip` over `.glass-capsule`. Clean break: the prior per-state
- * `color-mix(…--primary…)` literals + the `rounded-sm`/`-md`/`-lg` grab-bag are
- * GONE (no alias — the no-legacy law); this file is the public re-point, not a
- * parallel CVA.
- */
-export { chipVariants as selectableChipVariants } from "./chipVariants";
-export type { ChipVariants as SelectableChipVariants } from "./chipVariants";

package/dist/components/custom/sortable-list/SortableHandle.vue.d.ts

@@ -1,38 +0,0 @@
-/**
- * SortableHandle — marks an element as a drag grip.
- *
- * Inside a <SortableItem>, any `[data-sortable-handle]`
- * descendant is the only pointerdown surface that starts a
- * drag. Consumers can either use this component or add the
- * data attribute directly on their own element. Using this
- * wrapper gives you sensible default cursor + touch-action CSS.
- *
- * The default slot renders inside the handle — typically a
- * grip glyph like `⋮⋮`.
- */
-import { type ButtonHTMLAttributes, type Component } from "vue";
-type __VLS_Props = {
-    /** Root element tag. Default `"span"`. */
-    as?: string | Component;
-    /**
-     * `<button>` type attribute — emitted only when the host is a `button`
-     * (an anchor/span grip carries no `type`). Spread through `$attrs`
-     * since `<component :is>` does not type element-specific attributes.
-     */
-    type?: ButtonHTMLAttributes["type"];
-};
-declare var __VLS_8: {};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    as: string | Component;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/custom/sortable-list/SortableItem.vue.d.ts

@@ -1,38 +0,0 @@
-/**
- * SortableItem — a draggable row within a <SortableList>.
- *
- * Injects the sortable context, registers itself by its
- * stable `id`, and binds the returned ref / pointerdown / data
- * attrs / drop-target classes on its root element. The default
- * slot renders the row's content; styling is the consumer's
- * concern.
- *
- * The root is a `<div>` by default but consumers can swap via
- * the `as` prop if they need a semantic element (`<li>`, etc).
- * The binding spread works on any native element.
- */
-import { type Component } from "vue";
-import type { SortableId } from "../../../composables/sortable";
-type __VLS_Props = {
-    /** Stable id for this row — must match the parent list. */
-    id: SortableId;
-    /** Root element tag. Default `"div"`. */
-    as?: string | Component;
-};
-declare var __VLS_10: {
-    isBeingDragged: boolean;
-};
-type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_10) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    as: string | Component;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/custom/sortable-list/SortableList.vue.d.ts

@@ -1,76 +0,0 @@
-/**
- * SortableList — headless root of the sortable composition.
- *
- * Calls `useSortable` against the consumer's reactive items +
- * reorder callback, then provides the composable's return value
- * to descendant <SortableItem> + <SortableHandle> via
- * provide/inject. The root is a configurable element that
- * receives the sortable container binding so cross-list drop
- * detection can hit-test it.
- *
- * Drag ghost is auto-generated by cloning the source row's DOM
- * — no per-consumer markup required. The clone inherits scoped
- * `data-v-*` attributes so stylesheet selectors still match,
- * giving a pixel-faithful preview.
- *
- * Cross-list drops: pass the same `group` id to two or more
- * `<SortableList>` instances and they'll accept items from each
- * other. The `@insert` event fires on the target with
- * `(index, item)` whenever a foreign item lands on it; the
- * source's `@reorder` emits with the item removed.
- *
- * Slots:
- *   - default — list rows wrapped in `<SortableItem>` components.
- */
-import { type Component } from "vue";
-import { type SortableId } from "../../../composables/sortable";
-declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-        /** The reactive list being reordered. */
-        items: readonly T[];
-        /** Extract a stable id from an item. */
-        getId: (item: T) => SortableId;
-        /**
-         * Cross-list group id. Instances that share a group
-         * accept drops from each other. Undefined (default)
-         * isolates this instance to its own items.
-         */
-        group?: string;
-        /**
-         * Handle selector. `null` enables drag-from-anywhere.
-         * Default `[data-sortable-handle]` matches what the
-         * <SortableHandle> component emits.
-         */
-        handleSelector?: string | null;
-        /** Axis constraint for drop resolution. Default `"y"`. */
-        axis?: "x" | "y";
-        /** Root element tag. Default `"div"`. */
-        as?: string | Component;
-    } & {
-        onInsert?: ((index: number, item: unknown) => any) | undefined;
-        onReorder?: ((next: T[]) => any) | undefined;
-    }> & (typeof globalThis extends {
-        __VLS_PROPS_FALLBACK: infer P;
-    } ? P : {});
-    expose: (exposed: import("vue").ShallowUnwrapRef<{
-        isDragging: import("vue").ComputedRef<boolean>;
-        dragId: import("vue").ComputedRef<SortableId | null>;
-    }>) => void;
-    attrs: any;
-    slots: {
-        default?: (props: {
-            isDragging: boolean;
-            dragId: SortableId | null;
-        }) => any;
-    };
-    emit: ((evt: "insert", index: number, item: unknown) => void) & ((evt: "reorder", next: T[]) => void);
-}>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_PrettifyLocal<T> = (T extends any ? {
-    [K in keyof T]: T[K];
-} : {
-    [K in keyof T as K]: T[K];
-}) & {};

package/dist/components/custom/sortable-list/context.d.ts

@@ -1,25 +0,0 @@
-/**
- * Shared provide/inject key + paired helpers for the <SortableList> hierarchy.
- *
- * Lives in its own module so SortableItem + SortableHandle can
- * both import the symbol without triggering a component cycle
- * through their .vue files.
- *
- * P.W2 Lane B — canonical typed-key + helper-pair DI shape per
- * invariant 25. Strict-only by intent: <SortableItem> is meaningless
- * without a parent <SortableList>, so an optional counterpart would
- * be invalid per Pδ §2.2 + invariant 25's "per intent" clause.
- *
- * Paired helpers:
- *  - `provideSortableContext(sortable)` — wraps the raw provide call.
- *  - `useSortableContext()` — strict; throws when used outside <SortableList>.
- *
- * No `useOptionalSortableContext()` is shipped — a <SortableItem>
- * rendered outside a <SortableList> has no registration target and
- * cannot function. The optional helper would be dead code.
- */
-import type { UseSortableReturn } from "../../../composables/sortable";
-export declare const SORTABLE_CONTEXT: import("vue").InjectionKey<UseSortableReturn>;
-export declare function provideSortableContext(sortable: UseSortableReturn): void;
-/** Strict — throws when used outside `<SortableList>`. */
-export declare const useSortableContext: () => UseSortableReturn;

package/dist/components/custom/sortable-list/index.d.ts

@@ -1,4 +0,0 @@
-export { default as SortableList } from "./SortableList.vue";
-export { default as SortableItem } from "./SortableItem.vue";
-export { default as SortableHandle } from "./SortableHandle.vue";
-export { SORTABLE_CONTEXT, provideSortableContext, useSortableContext, } from "./context";

package/dist/components/custom/split-chars/SplitChars.vue.d.ts

@@ -1,39 +0,0 @@
-/**
- * SplitChars — the component face of the per-glyph split. It renders the `text`
- * prop into per-glyph `.char` spans (each carrying `--char-index`), wraps them in
- * the shipped `.char-stagger` host (so the library CSS staggers them into a
- * kinetic entrance on the per-spring `--spring-smooth` clock), and — by
- * construction — keeps the word as ONE accessible name: the wrapper carries
- * `aria-label="{text}"`, every glyph span is `aria-hidden`. AT hears "Fourier",
- * never the spell-out.
- *
- * Usage:
- *   <SplitChars text="Fourier" />
- *   <SplitChars text="Hello World" by="word" as="h1" />
- *
- * The `text` PROP is the single source for BOTH the split AND the label — there
- * is NO default slot (a slot would split arbitrary markup, so the accessible name
- * would be ambiguous). The split re-runs on a `text` change (the watcher →
- * `split()`). Engine-free: it composes `useCharStagger` (vue-only) + the shipped
- * CSS; it adds NO animation engine and NO PRM logic (it inherits the recipe's
- * carve — the split is structural, only the CSS `fade-in` is PRM-gated).
- */
-import { type Component, type HTMLAttributes } from "vue";
-import { type UseCharStaggerOptions } from "../../../composables/motion/useCharStagger";
-type __VLS_Props = {
-    /** The word to split — REQUIRED. It is the single source for both the
-     *  per-glyph split AND the accessible label (the load-bearing a11y fact). */
-    text: string;
-    /** The split unit. Default `"char"`. */
-    by?: UseCharStaggerOptions["by"];
-    /** Host tag/component (reka-ui Primitive `as`; default `"span"`) — set
-     *  `as="h1"` to render the kinetic word as a heading. */
-    as?: string | Component;
-    class?: HTMLAttributes["class"];
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    as: string | Component;
-    by: "char" | "word" | "grapheme";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/custom/stacked-icons/StackedIconGroup.vue.d.ts

@@ -1,30 +0,0 @@
-import type { StackedIconGroupProps } from './types';
-declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").PublicProps & __VLS_PrettifyLocal<StackedIconGroupProps<T>> & (typeof globalThis extends {
-        __VLS_PROPS_FALLBACK: infer P;
-    } ? P : {});
-    expose: (exposed: {}) => void;
-    attrs: any;
-    slots: {
-        icon?: (props: {
-            item: T;
-            index: number;
-        }) => any;
-    } & {
-        overflow?: (props: {
-            count: number;
-        }) => any;
-    } & {
-        info?: (props: {}) => any;
-    };
-    emit: {};
-}>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_PrettifyLocal<T> = (T extends any ? {
-    [K in keyof T]: T[K];
-} : {
-    [K in keyof T as K]: T[K];
-}) & {};

package/dist/components/custom/stacked-icons/index.d.ts

@@ -1,2 +0,0 @@
-export { default as StackedIconGroup } from "./StackedIconGroup.vue";
-export type { StackedIconGroupProps } from "./types";

package/dist/components/custom/stacked-icons/types.d.ts

@@ -1,18 +0,0 @@
-export interface StackedIconGroupProps<TItem> {
-    /** Items to display */
-    items: TItem[];
-    /** Max visible icons before showing +N overflow */
-    maxVisible?: number;
-    /** Stack direction */
-    direction?: "horizontal" | "vertical";
-    /** Reverse the visual order */
-    reversed?: boolean;
-    /** Icon size */
-    size?: "sm" | "md" | "lg";
-    /** Expand icons on group hover */
-    expandOnHover?: boolean;
-    /** Root element tag */
-    as?: string;
-    /** Key extraction function for v-for */
-    keyFn?: (item: TItem, index: number) => string | number;
-}

package/dist/components/custom/tabs/SegmentedTabs.vue.d.ts

@@ -1,99 +0,0 @@
-import { type HTMLAttributes } from "vue";
-/** The canonical tab/option shape — one descriptor across both materials. */
-export interface SegmentedTabOption {
-    label: string;
-    value: string;
-    icon?: string;
-    disabled?: boolean;
-    tooltip?: string;
-}
-/** The two materials. `pill` (DEFAULT) = the glass-track slider (absorbs the
- *  retired `segmented`); `underline` = the paper ink-hairline rule. */
-export type SegmentedTabsVariant = "pill" | "underline";
-/** The orientation axis — `horizontal` (default) lays children in a row + tracks
- *  the indicator on the inline axis; `vertical` stacks a column + tracks the
- *  block axis (the vertical underline is the leading-edge ink rail). */
-export type SegmentedTabsOrientation = "horizontal" | "vertical";
-export interface SegmentedTabsResponsive {
-    /**
-     * CSS length consumed inside `(min-width: <breakpoint>)`. BELOW it the
-     * strip collapses to a `<Select>`; at/above it renders the tab strip.
-     * Defaults to `"640px"` (Tailwind `sm:`).
-     */
-    breakpoint?: string;
-    /**
-     * Optional subset shown in the desktop strip (the mobile Select keeps the
-     * full option list). Falls back to `options`.
-     */
-    desktopOptions?: SegmentedTabOption[] | null;
-    /** Accessible name for the mobile `<SelectTrigger>`. */
-    ariaLabel?: string;
-    /** Class merged onto the mobile `<SelectTrigger>` only. */
-    triggerClass?: HTMLAttributes["class"];
-}
-export interface SegmentedTabsProps {
-    options: SegmentedTabOption[];
-    /**
-     * The material — `pill` (DEFAULT, the glass-track slider) or `underline`
-     * (the paper ink-hairline rule).
-     */
-    variant?: SegmentedTabsVariant;
-    /**
-     * Orientation — `horizontal` (default) or `vertical`. Axis-derived on the
-     * one indicator engine.
-     */
-    orientation?: SegmentedTabsOrientation;
-    /**
-     * Responsive collapse — below the breakpoint the strip becomes a `<Select>`.
-     * `true` uses defaults; an object tunes the breakpoint / desktop subset /
-     * accessible name.
-     */
-    responsive?: boolean | SegmentedTabsResponsive;
-    /**
-     * BC.W-LIQUID-TAB — the LIQUID TAB. The `pill` indicator is a physical lozenge
-     * you can GRAB and PULL: it follows the finger ~1:1, squishes on drag velocity,
-     * and flings to the nearest tab on release (`useDragMorph`). DEFAULT `true` — the
-     * pull is the iOS-27 primary affordance, ADDITIVE OVER the click/keyboard path
-     * (which stays byte-identical + fully operable — the drag is a pointer
-     * ENHANCEMENT, never the sole selection mechanism, WCAG 2.1.1). A consumer who
-     * wants click-only opts out with `:draggable="false"`. No-op on `underline` (the
-     * ink hairline has no indicator element to deform — `dragEnabled` gates it).
-     */
-    draggable?: boolean;
-    class?: HTMLAttributes["class"];
-}
-type __VLS_Props = SegmentedTabsProps;
-type __VLS_ModelProps = {
-    modelValue: string;
-};
-type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_50: {
-    option: SegmentedTabOption;
-    active: boolean;
-}, __VLS_58: {
-    option: SegmentedTabOption;
-    active: boolean;
-};
-type __VLS_Slots = {} & {
-    option?: (props: typeof __VLS_50) => any;
-} & {
-    option?: (props: typeof __VLS_58) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-}>, {
-    orientation: SegmentedTabsOrientation;
-    variant: SegmentedTabsVariant;
-    draggable: boolean;
-    responsive: boolean | SegmentedTabsResponsive;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/components/custom/tabs/composables/useTabDragMorph.d.ts

@@ -1,42 +0,0 @@
-import type { ComputedRef, Ref } from "vue";
-import { type UseDragMorphReturn } from "../../../../composables/motion/useDragMorph";
-import type { SegmentedTabOption } from "../SegmentedTabs.vue";
-/**
- * Package-private composable for `SegmentedTabs.vue` — BB.W-DRAG-MORPH, the LIQUID
- * TAB (the `:draggable` axis). Carved out of the SFC at BB.W-CARVE4 to hold the
- * no-god-module bound, mirroring the `useTabIndicator` colocation sibling; the SFC
- * IMPORTS it and binds `drag.dragStyle`/`drag.dragging` in its template.
- *
- * When `:draggable`, the `pill` indicator is wired to `useDragMorph` with the snap
- * targets resolved off the CENTER-ANCHORED button geometry (the SAME measure
- * `useTabIndicator` runs — reused, never re-measured). Dragging the indicator follows
- * the finger, squishes on velocity, and flings to the nearest tab center on release →
- * `onSnap` writes the `model`. The drag is the `pill` material ONLY (the `underline`
- * ink hairline has no `indicatorRef` element to deform). The squish reads the SAME
- * `--tab-indicator-max-stretch` live cap the click squish does (the SOLE cap source);
- * the drag's `--stretch` write composes the existing reciprocal CSS pairing — no
- * second squish recipe.
- */
-export interface UseTabDragMorphParams {
-    /** The active indicator element (the drag follow + squish target). */
-    indicatorRef: Ref<HTMLElement | null>;
-    /** True for the vertical (block-axis) orientation. */
-    isVertical: ComputedRef<boolean>;
-    /** True for the underline material (drag is a no-op there). */
-    isUnderline: ComputedRef<boolean>;
-    /** The `:draggable` prop (ADDITIVE, default false). */
-    draggable: () => boolean;
-    /** The strip's rendered options (the snap targets + the refresh trigger). */
-    stripOptions: ComputedRef<SegmentedTabOption[]>;
-    /** Per-option button refs, index-aligned to `stripOptions`. */
-    buttonRefs: Ref<HTMLElement[]>;
-    /** The single-select model — the fling-to-nearest commits the selection. */
-    model: Ref<string | undefined>;
-}
-export interface UseTabDragMorphReturn {
-    /** True when the drag is live (the `pill` material + the `:draggable` prop). */
-    dragEnabled: ComputedRef<boolean>;
-    /** The `useDragMorph` handle (the SFC binds `dragStyle`/`dragging`). */
-    drag: UseDragMorphReturn;
-}
-export declare function useTabDragMorph(params: UseTabDragMorphParams): UseTabDragMorphReturn;

package/dist/components/custom/tabs/composables/useTabIndicator.d.ts

@@ -1,58 +0,0 @@
-import { type Ref, type ComputedRef } from "vue";
-import type { SegmentedTabOption } from "../SegmentedTabs.vue";
-/**
- * Package-private composable for `SegmentedTabs.vue` — owns the JS-measured
- * single-select indicator path: the slider style, the offset measure, the
- * model/options re-measure watchers, and the ResizeObserver lifecycle. It ALSO
- * owns the AX.W53 travel-squish: a velocity-driven, volume-preserving `--stretch`
- * scalar the active indicator reads so it STRETCHES along its travel axis as it
- * glides between tabs and settles to fit (the Material 3 ELASTIC / Apple
- * Liquid-Glass register, capped LOW).
- *
- * BA.W-TABS — the engine is AXIS-DERIVED (the `vertical` param): the JS slider
- * writes width/translateX on the inline axis (horizontal) OR height/translateY on
- * the block axis (vertical). It is CENTER-ANCHORED (the BA-VJS-3 / valuejs-fold A-5
- * fix): the indicator is positioned by its CENTER == the active button's center
- * (translate = buttonCenter − indicatorSize/2), so the squish (which scales from
- * `transform-origin: center`) keeps the indicator center pinned to the label
- * center — the prior `translateX(offsetLeft)` left-edge write is GONE.
- *
- * The composable is the SOLE writer of the JS slider style. The measure path runs
- * only on the `@supports not (anchor)` branch — on an anchor-supporting engine the
- * CSS `anchor-name` owns the slider position and that path stays dormant (no RO is
- * constructed, no measure runs). The squish is independent of the position path: it
- * is a transient `--stretch` write driven on EVERY selection (anchor or JS engine)
- * and reads from `--tab-indicator-max-stretch`, and RELEASES AT ARRIVAL (keyed to
- * the calibrated clock, not a fixed mid-glide timer). Honors
- * `prefers-reduced-motion` (no squish under reduce). The underline material SLIDES
- * (no squish — a hairline does not deform), gated by the `vertical`/underline
- * early-return at the SFC's `squishOnTravel` call shape (the underline has no
- * `indicatorRef` element).
- */
-export interface UseTabIndicatorParams {
-    /** The container scroller root (observed by the ResizeObserver). */
-    containerRef: Ref<HTMLElement | null>;
-    /** The active indicator element (the squish `--stretch` write target). */
-    indicatorRef: Ref<HTMLElement | null>;
-    /** Per-option button refs, index-aligned to `options`. */
-    buttonRefs: Ref<HTMLElement[]>;
-    /** The tab options (re-measure on change). */
-    options: ComputedRef<SegmentedTabOption[]>;
-    /** The defineModel value (re-measure on change). */
-    model: Ref<string | undefined>;
-    /** Whether the browser supports CSS anchor positioning. */
-    anchorSupported: boolean;
-    /** True when the JS slider writer is live (gates RO/watcher attach). */
-    jsSliderActive: ComputedRef<boolean>;
-    /** The active option values (used by the measure). */
-    activeValues: ComputedRef<string[]>;
-    /** True for the vertical (block-axis) orientation. */
-    vertical: ComputedRef<boolean>;
-}
-export interface UseTabIndicatorReturn {
-    /** Inline style for the single-select JS slider. */
-    singleSliderStyle: Ref<Record<string, string>>;
-    /** Imperatively kick the travel-squish on a selection at `idx`. */
-    squishOnTravel: (toIdx: number) => void;
-}
-export declare function useTabIndicator(params: UseTabIndicatorParams): UseTabIndicatorReturn;