@mkbabb/glass-ui 6.0.0 → 8.0.0

package/dist/components/data-table/DataTable.vue.d.ts

@@ -1,89 +1,41 @@
-import type { DataTableColumn, DataTableRowAttrs, DataTableRowRef, DataTableSort } from "./types";
+import type { DataTableProps, DataTableSort } from "./types.js";
 declare const __VLS_export: <T extends Record<string, any>>(__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<({
-        columns: DataTableColumn<T>[];
-        rows: T[];
-        total: number;
-        pageSize: number;
-        isLoading?: boolean;
-        rowKey?: string;
-        getRowId?: (row: T) => PropertyKey | null | undefined;
-        role?: "grid";
-        ariaLabel?: string;
-        ariaColCount?: number;
-        ariaRowCount?: number;
-        getRowAttrs?: DataTableRowAttrs<T>;
-        rowRef?: DataTableRowRef<T>;
-        tabbableRowId?: PropertyKey | null;
-        sort?: DataTableSort;
-        /** Enables the controlled single-row selection contract. */
-        selectable?: boolean;
-        /** Stable identity of the selected row when `selectable` is true. */
-        selectedRowId?: PropertyKey | null;
-        infinite?: boolean;
-        hasMore?: boolean;
-        /**
-         * When true, the table collapses to a stacked card-per-row
-         * projection once its own container measures below
-         * `cardBreakpoint`. A dense multi-column table has no responsive
-         * story at narrow widths — a horizontal-scroll wrapper leaves
-         * half the columns invisible. The card projection keeps every
-         * field reachable: the first column becomes the card header
-         * (with the row-actions menu docked beside it), every other
-         * column renders as a label/value pair below. At/above the
-         * breakpoint the unchanged tabular layout renders.
-         */
-        responsive?: boolean;
-        /**
-         * Container-width (CSS px) below which `responsive` swaps to the
-         * card projection. Container-driven (not viewport-driven) so a
-         * table inside a narrow column collapses at any viewport width.
-         */
-        cardBreakpoint?: number;
-        class?: string;
-    } & {
-        page: number;
-    }) & {
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<DataTableProps<T> & {
         onSelect?: ((row: T) => any) | undefined;
-        "onUpdate:page"?: ((value: number) => any) | undefined;
         "onUpdate:sort"?: ((sort: DataTableSort) => any) | undefined;
         "onUpdate:selectedRowId"?: ((id: PropertyKey) => any) | undefined;
-        "onLoad-more"?: (() => any) | undefined;
+        "onUpdate:tabbableRowId"?: ((id: PropertyKey) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: {}) => void;
     attrs: any;
     slots: {
+        error?: (props: {}) => any;
+    } & {
         'row-actions'?: (props: {
             row: T;
         }) => any;
     } & {
-        'row-context-menu'?: (props: {
-            row: T;
-        }) => any;
+        'filtered-empty'?: (props: {}) => any;
     } & {
         empty?: (props: {}) => any;
     } & {
-        'row-actions'?: (props: {
-            row: T;
-        }) => any;
-    } & {
-        'row-context-menu'?: (props: {
-            row: T;
-        }) => any;
+        error?: (props: {}) => any;
     } & {
         'row-actions'?: (props: {
             row: T;
         }) => any;
+    } & {
+        'filtered-empty'?: (props: {}) => any;
     } & {
         empty?: (props: {}) => any;
     } & {
         sentinel?: (props: {}) => any;
     };
-    emit: (((evt: "select", row: T) => void) & ((evt: "update:sort", sort: DataTableSort) => void) & ((evt: "update:selectedRowId", id: PropertyKey) => void) & ((evt: "load-more") => void)) & ((event: "update:page", value: number) => void);
+    emit: ((evt: "select", row: T) => void) & ((evt: "update:sort", sort: DataTableSort) => void) & ((evt: "update:selectedRowId", id: PropertyKey) => void) & ((evt: "update:tabbableRowId", id: PropertyKey) => void);
 }>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/data-table/composables/useDataTableResponsive.d.ts

@@ -1,5 +1,5 @@
 import { type ComputedRef, type MaybeRefOrGetter } from "vue";
-import type { DataTableColumn } from "../types";
+import type { DataTableColumn } from "../types.js";
 export interface UseDataTableResponsiveOptions<T> {
     /** The column set being projected. */
     columns: MaybeRefOrGetter<DataTableColumn<T>[]>;

package/dist/components/data-table/composables/useDataTableRowIdentity.d.ts

@@ -1,33 +1,15 @@
-import { type ComputedRef, type MaybeRefOrGetter } from "vue";
-/** A row paired with its stable iteration key. */
+import { type ComputedRef, type MaybeRefOrGetter, type Ref } from "vue";
 export interface RowEntry<T> {
     row: T;
     key: PropertyKey;
 }
-/** An explicit per-row id resolver — wins over the `rowKey` lookup. */
 export type RowIdResolver<T> = (row: T) => PropertyKey | null | undefined;
 export interface UseDataTableRowIdentityOptions<T> {
-    /** The reactive row set. */
     rows: MaybeRefOrGetter<readonly T[]>;
-    /** Dotted-path key into each row resolving its stable id (default `_id`). */
     rowKey: MaybeRefOrGetter<string>;
-    /**
-     * Explicit id resolver — wins over `rowKey` when supplied. Pass either the
-     * resolver itself OR a getter returning it (a getter lets the SFC thread the
-     * reactive `props.getRowId`). NOT a `MaybeRefOrGetter`: the resolver is
-     * itself a function, which `toValue` would mis-invoke as a getter.
-     */
-    getRowId?: RowIdResolver<T> | (() => RowIdResolver<T> | undefined);
+    getRowId?: RowIdResolver<T> | Readonly<Ref<RowIdResolver<T> | undefined>>;
 }
-export interface UseDataTableRowIdentityReturn<T> {
-    /** Rows paired with stable iteration keys (validated; generated fallback). */
+/** Resolve the stable, unique identities required by keyed interactive rows. */
+export declare function useDataTableRowIdentity<T extends Record<string, any>>(options: UseDataTableRowIdentityOptions<T>): {
     rowEntries: ComputedRef<RowEntry<T>[]>;
-}
-/**
- * Resolve stable iteration keys for a DataTable's rows.
- *
- * Explicit ids (via `getRowId` or the dotted `rowKey`) win when present AND
- * unique; missing / duplicate ids fall back to a per-object generated symbol
- * (object identity), with a one-shot dev warning per distinct issue.
- */
-export declare function useDataTableRowIdentity<T extends Record<string, any>>(options: UseDataTableRowIdentityOptions<T>): UseDataTableRowIdentityReturn<T>;
+};

package/dist/components/data-table/index.d.ts

@@ -1,2 +1,2 @@
-export { default as DataTable } from "./DataTable.vue";
-export type { DataTableColumn, DataTableSort, DataTableProps, DataTableRowAttrs, DataTableRowRef, } from "./types";
+export { default as DataTable } from "./DataTable.vue.js";
+export type { DataTableColumn, DataTableSort, DataTableProps, DataTableRowAttrs, DataTableRowIndex, DataTableRowRef, DataTableStatus, } from "./types.js";

package/dist/components/data-table/types.d.ts

@@ -21,23 +21,22 @@ export interface DataTableSort {
     key: string;
     direction: "asc" | "desc";
 }
+export type DataTableStatus = "ready" | "loading" | "error";
 /** Caller-owned bindings for a mounted data row. */
 export type DataTableRowAttrs<T> = (row: T, index: number) => HTMLAttributes | undefined;
 /** Receives each mounted row element and `null` when that row leaves the DOM. */
 export type DataTableRowRef<T> = (element: HTMLElement | null, row: T, index: number) => void;
+/** One-based absolute row index, including the header row at index 1. */
+export type DataTableRowIndex<T> = (row: T, mountedIndex: number) => number;
 export interface DataTableProps<T = any> {
     /** Column definitions */
     columns: DataTableColumn<T>[];
     /** Row data to display */
     rows: T[];
-    /** Total number of rows across all pages (for pagination display) */
-    total: number;
-    /** Current page number (1-indexed) */
-    page: number;
-    /** Number of rows per page */
-    pageSize: number;
-    /** Whether data is currently loading */
-    isLoading?: boolean;
+    /** Current renderer state. Empty rows remain a distinct derived state. */
+    status?: DataTableStatus;
+    /** Distinguishes an empty filtered result from an empty data set. */
+    filtered?: boolean;
     /** Unique key field on each row (defaults to "_id") */
     rowKey?: string;
     /** Optional resolver for stable unique row identities. Takes precedence over rowKey. */
@@ -55,6 +54,8 @@ export interface DataTableProps<T = any> {
      * applies only to the native-table projection and is omitted from cards.
      */
     getRowAttrs?: DataTableRowAttrs<T>;
+    /** Absolute ARIA row index for each caller-windowed row. */
+    getRowIndex?: DataTableRowIndex<T>;
     /** Mounted row element callback for measurement or focus. */
     rowRef?: DataTableRowRef<T>;
     /** Stable id of the sole mounted row placed in the tab order. */
@@ -65,10 +66,6 @@ export interface DataTableProps<T = any> {
     selectable?: boolean;
     /** Stable identity of the selected row when selection is enabled. */
     selectedRowId?: PropertyKey | null;
-    /** When true, hides pagination and shows infinite scroll sentinel */
-    infinite?: boolean;
-    /** Whether more data is available (for infinite scroll mode) */
-    hasMore?: boolean;
     /**
      * When true, the table collapses to a stacked card-per-row
      * projection once its container measures below `cardBreakpoint` —
@@ -78,4 +75,5 @@ export interface DataTableProps<T = any> {
     responsive?: boolean;
     /** Container-width (CSS px) below which `responsive` swaps to cards. Defaults to 640. */
     cardBreakpoint?: number;
+    class?: HTMLAttributes["class"];
 }

package/dist/components/{card/CardAction.vue.d.ts → deck/DeckSlide.vue.d.ts}

@@ -1,15 +1,19 @@
 import type { HTMLAttributes } from "vue";
-/**
- * <CardAction> — the shadcn-2025 top-right action slot of the Card family.
- * When present inside a <CardHeader>, the header reflows to a two-column grid
- * (title/description column + this action column) via the `@container/card-header`
- * `has-data-[slot=card-action]` query on CardHeader. Self-aligns to the start of
- * the header's first two rows, justified to the end.
- */
+import type { DeckState, SlideEntry } from "./types.js";
 type __VLS_Props = {
+    /** This member's 0-based index in the sequence. */
+    index: number;
+    /** The manifest entry — carries `dark`, the accessible name, the id. */
+    entry?: SlideEntry;
+    /** Force the state (a member rendered outside a stage). */
+    state?: DeckState;
     class?: HTMLAttributes["class"];
 };
-declare var __VLS_1: {};
+declare var __VLS_1: {
+    index: number;
+    total: number;
+    active: boolean;
+};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };

package/dist/components/deck/DeckStage.vue.d.ts

@@ -0,0 +1,36 @@
+import type { HTMLAttributes } from "vue";
+import type { DeckCore } from "./composables/useDeck.js";
+type __VLS_Props = {
+    /** The sequence core (`useDeck`). */
+    deck: DeckCore;
+    /** Which motion register the stage runs. Default `"turn"`. */
+    register?: "turn" | "snap";
+    /** The letterbox aspect ratio. Default 16 / 9. Set `null` to fill the host. */
+    ratio?: number | null;
+    /** Cover the viewport (a presentation) rather than the parent box. */
+    fullscreen?: boolean;
+    /** Accessible name for the sequence region. */
+    ariaLabel?: string;
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    ground?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    chrome?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    register: "turn" | "snap";
+    ratio: number | null;
+    fullscreen: boolean;
+}, {}, {}, {}, 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/deck/composables/useDeck.d.ts

@@ -1,27 +1,52 @@
-import { type ComputedRef, type Ref } from "vue";
+import { type ComputedRef, type MaybeRefOrGetter, type Ref } from "vue";
+import type { DeckAxis, DeckState } from "../types.js";
 export interface DeckCore {
-    /** The 0-based active slide index (clamped to [0, total-1]). */
+    /** The 0-based active member index (clamped). The ONE authority. */
     index: Ref<number>;
-    /** The total slide count. */
-    total: number;
-    /** 1-based completion as a percentage (slide 1 of N → 100/N), for a bar. */
+    /** The live member count. */
+    total: ComputedRef<number>;
+    /** The travel axis. */
+    axis: ComputedRef<DeckAxis>;
+    /** 1-based completion as a percentage (member 1 of N → 100/N), for a bar. */
     progress: ComputedRef<number>;
-    /** The accessible "Slide N of M" announcement off the live index (§3 — the
-        portable aria-live seam; surface it in an `sr-only` polite region). */
+    /** Whether a forward step exists (the clamp, published once). */
+    canNext: ComputedRef<boolean>;
+    /** Whether a backward step exists. */
+    canPrev: ComputedRef<boolean>;
+    /**
+     * The OPTIONAL continuous position, in members (2.4 = 40% past member 2).
+     * Mirrors `index` until a producer feeds it.
+     */
+    position: Readonly<Ref<number>>;
+    /** The OPTIONAL continuous velocity, in members per second. 0 unless fed. */
+    velocity: Readonly<Ref<number>>;
+    /** Whether a continuous producer has opened the channel. */
+    continuous: Readonly<Ref<boolean>>;
+    /** The accessible "Slide N of M[: name]" announcement off the live index. */
     liveMessage: ComputedRef<string>;
+    /** The ONE `[data-state]` vocabulary for member `i`. */
+    stateFor: (i: number) => DeckState;
     go: (i: number) => void;
     next: () => void;
     prev: () => void;
     first: () => void;
     last: () => void;
+    /**
+     * The producer's channel writer — a scroll-snap strip, a drag scrub, a
+     * transform stage. Feeding it opens the continuous channel for this core's
+     * lifetime; the integer authority is untouched (a producer commits an index
+     * through `go`, never through here).
+     */
+    feed: (position: number, velocity?: number) => void;
 }
 export interface UseDeckOptions {
     /** The initial 0-based index (clamped). Default 0. */
     initial?: number;
+    /** The travel axis. Default horizontal. */
+    axis?: MaybeRefOrGetter<DeckAxis>;
     /** Fired AFTER a navigation commits, with the new + previous index. */
     onChange?: (to: number, from: number) => void;
-    /** Resolve a per-slide accessible name for the live announcement (e.g. the
-        manifest title). When set, `liveMessage` reads "Slide N of M: <name>". */
+    /** Resolve a per-member accessible name for the live announcement. */
     label?: (index: number) => string;
 }
-export declare function useDeck(total: number, opts?: UseDeckOptions): DeckCore;
+export declare function useDeck(total: MaybeRefOrGetter<number>, opts?: UseDeckOptions): DeckCore;

package/dist/components/deck/composables/useDeckCapture.d.ts

@@ -0,0 +1,26 @@
+import { type Ref } from "vue";
+export type DeckCaptureMode = "live" | "print" | "export" | "freeze";
+/** The document-element attribute a capture tool waits on. */
+export declare const DECK_SETTLED_ATTR = "data-deck-settled";
+/**
+ * Read the capture mode from a query string — the ONE reader. Defaults to `live`
+ * for an absent or unknown value, so a stray query never silently freezes a deck.
+ */
+export declare function deckCaptureMode(search?: string): DeckCaptureMode;
+export interface UseDeckCaptureOptions {
+    /** Override the URL-read mode (a story, a test, an SSR host). */
+    mode?: DeckCaptureMode;
+    /** Settlers to await before the deck declares itself still. */
+    settlers?: ReadonlyArray<() => void | Promise<void>>;
+}
+export interface UseDeckCapture {
+    /** The resolved mode. */
+    mode: DeckCaptureMode;
+    /** True once `settle()` has completed. */
+    settled: Readonly<Ref<boolean>>;
+    /** Register one more settler (a member's count-up, a viz's first stable frame). */
+    onSettle(fn: () => void | Promise<void>): void;
+    /** Await every settler + two quiet frames, then stamp the document. */
+    settle(): Promise<void>;
+}
+export declare function useDeckCapture(options?: UseDeckCaptureOptions): UseDeckCapture;

package/dist/components/deck/composables/useDeckHashSync.d.ts

@@ -0,0 +1,8 @@
+import type { DeckCore } from "./useDeck.js";
+export interface UseDeckHashSyncOptions {
+    /** Member ids, index-aligned. Falls back to the 1-based number. */
+    ids?: readonly string[];
+    /** Read the fragment at mount and jump to it. Default true. */
+    initial?: boolean;
+}
+export declare function useDeckHashSync(deck: DeckCore, options?: UseDeckHashSyncOptions): void;

package/dist/components/deck/composables/useDeckKeyboard.d.ts

@@ -1,6 +1,6 @@
 import { type MaybeRefOrGetter } from "vue";
-/** The minimal move surface the handler drives (a structural subset of DeckCore,
-    so the consumer can pass its `DeckCore` directly). */
+import type { DeckAxis } from "../types.js";
+/** The minimal move surface the handler drives (a structural subset of DeckCore). */
 export interface DeckMoves {
     next(): void;
     prev(): void;
@@ -9,17 +9,25 @@ export interface DeckMoves {
     go(i: number): void;
 }
 export interface DeckKeyOptions {
+    /** The travel axis the arrows derive from. Default horizontal. */
+    axis?: MaybeRefOrGetter<DeckAxis>;
     /** Override the focused-control test (defaults to `target.closest(controls)`). */
     isControl?: (target: EventTarget | null) => boolean;
+    /** Digit jumps `1`–`9`. Default true. */
+    digits?: boolean;
 }
-/** Handle ONE keydown against the deck. Returns true if it navigated (and called
-    `preventDefault`), false if the key was left for the page/control. */
+/**
+ * Handle ONE keydown against a sequence. Returns true if it navigated (and called
+ * `preventDefault`), false if the key was left for the page or the focused control.
+ */
 export declare function handleDeckKey(e: KeyboardEvent, deck: DeckMoves, opts?: DeckKeyOptions): boolean;
 export interface UseDeckKeyboardOptions extends DeckKeyOptions {
-    /** The element the listener binds to. Default `window` (deck-global paging). */
+    /** The element the listener binds to. Default `window` (the presentation register). */
     target?: MaybeRefOrGetter<EventTarget | null | undefined>;
 }
-/** Bind the focus-guarded deck keyboard contract to a target (default `window`)
-    for the component lifetime. The `target` may be a ref/getter so a not-yet-mounted
-    element resolves at `onMounted`. */
+/**
+ * Bind the guarded paging contract to a target (default `window`) for the
+ * component lifetime. The `target` may be a ref/getter so a not-yet-mounted
+ * element resolves at `onMounted`.
+ */
 export declare function useDeckKeyboard(deck: DeckMoves, opts?: UseDeckKeyboardOptions): void;

package/dist/components/deck/composables/useDeckSnap.d.ts

@@ -0,0 +1,20 @@
+import { type Ref } from "vue";
+import type { DeckCore } from "./useDeck.js";
+export interface UseDeckSnapOptions {
+    /** The scroll container (the strip). Its element children are the members. */
+    strip: Ref<HTMLElement | null>;
+    /** The core this arm drives and is driven by. */
+    deck: DeckCore;
+    /**
+     * Feed the core's continuous position/velocity channel off the live scroll.
+     * Default true; a consumer whose seam admits no continuous scalar turns it off.
+     */
+    continuous?: boolean;
+}
+export interface UseDeckSnap {
+    /** Scroll a member into view. `smooth` rides the platform's own inertia. */
+    scrollTo(index: number, behavior?: ScrollBehavior): void;
+    /** Re-measure the member extent (a resize, a member count change). */
+    measure(): void;
+}
+export declare function useDeckSnap(options: UseDeckSnapOptions): UseDeckSnap;

package/dist/components/deck/composables/useDeckSwipe.d.ts

@@ -0,0 +1,13 @@
+import { type Ref } from "vue";
+import type { DeckMoves } from "./useDeckKeyboard.js";
+import type { DeckAxis } from "../types.js";
+export interface UseDeckSwipeOptions {
+    /** The travel axis. Default horizontal. */
+    axis?: () => DeckAxis;
+    /** The commit distance in px. Default 44 (the coarse-target rung). */
+    threshold?: number;
+    /** Enabled. Default true. */
+    enabled?: () => boolean;
+}
+export declare const DECK_SWIPE_THRESHOLD_PX = 44;
+export declare function useDeckSwipe(host: Ref<HTMLElement | null>, deck: DeckMoves, options?: UseDeckSwipeOptions): void;

package/dist/components/deck/composables/useEdgeZones.d.ts

@@ -0,0 +1,14 @@
+import { type Ref } from "vue";
+export interface UseEdgeZonesOptions {
+    /** The edge band width, as a fraction of the host's inline size. Default 0.12. */
+    band?: number;
+    /** The minimum band in px, so a narrow stage still has a reachable edge. Default 64. */
+    minBand?: number;
+}
+export interface UseEdgeZones {
+    /** The pointer is inside the leading edge band. */
+    atStart: Ref<boolean>;
+    /** The pointer is inside the trailing edge band. */
+    atEnd: Ref<boolean>;
+}
+export declare function useEdgeZones(host: Ref<HTMLElement | null>, options?: UseEdgeZonesOptions): UseEdgeZones;

package/dist/components/deck/constants.d.ts

@@ -1,4 +1 @@
-/** The focused-control selector the keyboard handler tests: when a control (button
-    / link / field) is focused, Space + digit jumps reach that control's native
-    activation instead of being stolen for navigation (the C6 correctness fix). */
 export declare const CONTROL_SELECTOR = "button, a, input, textarea, select, [role=button]";

package/dist/components/deck/index.d.ts

@@ -1,7 +1,22 @@
-export { useDeck } from "./composables/useDeck";
-export type { DeckCore, UseDeckOptions } from "./composables/useDeck";
-export { useDeckKeyboard, handleDeckKey } from "./composables/useDeckKeyboard";
-export type { DeckMoves, DeckKeyOptions, UseDeckKeyboardOptions, } from "./composables/useDeckKeyboard";
-export { default as DeckPager } from "./DeckPager.vue";
-export { CONTROL_SELECTOR } from "./constants";
-export type { PagerWindow } from "../pager-dots/pagerWindow";
+export { useDeck } from "./composables/useDeck.js";
+export type { DeckCore, UseDeckOptions } from "./composables/useDeck.js";
+export { useDeckKeyboard, handleDeckKey } from "./composables/useDeckKeyboard.js";
+export type { DeckMoves, DeckKeyOptions, UseDeckKeyboardOptions, } from "./composables/useDeckKeyboard.js";
+export { useDeckSnap } from "./composables/useDeckSnap.js";
+export type { UseDeckSnap, UseDeckSnapOptions } from "./composables/useDeckSnap.js";
+export { useDeckHashSync } from "./composables/useDeckHashSync.js";
+export type { UseDeckHashSyncOptions } from "./composables/useDeckHashSync.js";
+export { useDeckSwipe, DECK_SWIPE_THRESHOLD_PX } from "./composables/useDeckSwipe.js";
+export type { UseDeckSwipeOptions } from "./composables/useDeckSwipe.js";
+export { useEdgeZones } from "./composables/useEdgeZones.js";
+export type { UseEdgeZones, UseEdgeZonesOptions } from "./composables/useEdgeZones.js";
+export { useDeckCapture, deckCaptureMode, DECK_SETTLED_ATTR, } from "./composables/useDeckCapture.js";
+export type { DeckCaptureMode, UseDeckCapture, UseDeckCaptureOptions, } from "./composables/useDeckCapture.js";
+export { sequenceWindow } from "./window.js";
+export type { SequenceWindow, SequenceWindowOptions, SequenceWindowPolicy, } from "./window.js";
+export { default as DeckStage } from "./DeckStage.vue.js";
+export { default as DeckSlide } from "./DeckSlide.vue.js";
+export { provideDeck, useDeckStage, provideSlideContext, useSlideContext, } from "./slideContext.js";
+export type { SlideContext } from "./slideContext.js";
+export type { DeckAxis, DeckState, DeckContent, SlideEntry } from "./types.js";
+export { CONTROL_SELECTOR } from "./constants.js";

package/dist/components/deck/slideContext.d.ts

@@ -0,0 +1,21 @@
+import { type ComputedRef } from "vue";
+import type { DeckCore } from "./composables/useDeck.js";
+export interface SlideContext {
+    /** The member's 0-based index in the sequence. */
+    index: ComputedRef<number>;
+    /** The sequence's member count. */
+    total: ComputedRef<number>;
+    /** Whether this member is the active one. */
+    active: ComputedRef<boolean>;
+}
+/** Provide the per-member context (called by `<DeckSlide>`). */
+export declare function provideSlideContext(context: SlideContext): void;
+/**
+ * Read the per-member context. Outside a deck this answers member 0 of 1, active —
+ * a lone card IS its own whole sequence, so consumers need no `if (inDeck)` branch.
+ */
+export declare function useSlideContext(): SlideContext;
+/** Provide the sequence core (called by `<DeckStage>`). */
+export declare function provideDeck(core: DeckCore): void;
+/** Read the sequence core provided by an enclosing `<DeckStage>`, or `null`. */
+export declare function useDeckStage(): DeckCore | null;

package/dist/components/deck/styles/capture.css

@@ -0,0 +1 @@
+@layer components{[data-deck-capture="export"] .deck-stage{--deck-export-inline: 1280px;--deck-export-block: 720px;position: relative;inset: auto;margin: 0;aspect-ratio: auto;inline-size: var(--deck-export-inline);block-size: var(--deck-export-block);max-inline-size: none;max-block-size: none;border-radius: 0;}[data-deck-capture="export"] .deck-slide{border-radius: 0;box-shadow: none;}[data-deck-capture="export"] .deck-ground,[data-deck-capture="freeze"] .deck-ground,[data-deck-capture="export"] .deck-slide,[data-deck-capture="freeze"] .deck-slide{transition: none !important;animation: none !important;}[data-deck-capture="export"] .deck-slide[data-state="active"],[data-deck-capture="freeze"] .deck-slide[data-state="active"]{--turn-x: 0px !important;--turn-s: 1 !important;--turn-r: 0deg !important;}[data-deck-capture="export"] .deck-slide::before,[data-deck-capture="export"] .deck-slide::after,[data-deck-capture="freeze"] .deck-slide::before,[data-deck-capture="freeze"] .deck-slide::after{opacity: 0 !important;animation: none !important;}[data-deck-capture="export"] [data-reveal],[data-deck-capture="freeze"] [data-reveal],[data-deck-capture="print"] [data-reveal]{opacity: 1 !important;animation: none !important;}[data-deck-capture="print"] .deck-stage{position: static;display: block;aspect-ratio: auto;inline-size: auto;block-size: auto;overflow: visible;}[data-deck-capture="print"] .deck-strip{display: block;overflow: visible;perspective: none;}[data-deck-capture="print"] .deck-ground{display: none;}[data-deck-capture="print"] .deck-slide{position: relative;opacity: 1 !important;visibility: visible !important;transform: none !important;pointer-events: auto;margin-block: var(--space-family);background: var(--background);}[data-deck-capture="print"] .deck-slide::before,[data-deck-capture="print"] .deck-slide::after{opacity: 0 !important;}}@media print{@page{size: 1280px 720px;margin: 0;}html,body{overflow: visible !important;margin: 0 !important;padding: 0 !important;print-color-adjust: exact;-webkit-print-color-adjust: exact;}html,body,#app{block-size: auto !important;min-block-size: 0 !important;}.deck-stage{position: static !important;display: block !important;aspect-ratio: auto !important;inline-size: auto !important;block-size: auto !important;overflow: visible !important;}.deck-strip{display: block !important;overflow: visible !important;perspective: none !important;}.deck-ground{display: none !important;}.deck-slide{position: relative !important;opacity: 1 !important;visibility: visible !important;transform: none !important;box-shadow: none !important;border-radius: 0 !important;margin: 0 !important;block-size: 719px !important;overflow: hidden !important;background: var(--background) !important;}.deck-slide::before,.deck-slide::after{opacity: 0 !important;}.deck-slide:not(:last-child){break-after: page;}.deck-stage .sr-only{display: none !important;}}

package/dist/components/deck/styles/index.css

@@ -0,0 +1 @@
+@import "./stage.css";@import "./turn.css";@import "./capture.css";@import "./reveal.css";

package/dist/components/deck/styles/reveal.css

@@ -0,0 +1 @@
+@layer components{.deck-stage [data-reveal]{animation-fill-mode: both;}.deck-stage .deck-slide[data-state="active"] [data-reveal]{animation-name: deck-reveal-rise;animation-duration: var(--duration-normal);animation-timing-function: var(--ease-out);animation-delay: calc(var(--d,0) * var(--motion-stagger-default));}.deck-stage .deck-slide[data-state="active"] [data-reveal="fade"]{animation-name: deck-reveal-fade;}@media (prefers-reduced-motion: reduce){.deck-stage [data-reveal],.deck-stage .deck-slide[data-state="active"] [data-reveal]{animation: none;opacity: 1;}}}@keyframes deck-reveal-rise{from{opacity: 0;translate: 0 var(--space-body);}to{opacity: 1;translate: 0 0;}}@keyframes deck-reveal-fade{from{opacity: 0;}to{opacity: 1;}}

package/dist/components/deck/styles/stage.css

@@ -0,0 +1 @@
+@layer components{.deck-stage{--deck-ratio: calc(16 / 9);--deck-z-ground: 0;--deck-z-slide: 1;--deck-z-chrome: 2;--deck-safe-inline: max(env(safe-area-inset-left),env(safe-area-inset-right));--deck-safe-block: max(env(safe-area-inset-top),env(safe-area-inset-bottom));--deck-dock-clearance: calc(var(--touch-target) + var(--space-family));position: relative;container-type: inline-size;--cqx: 1cqi;overflow: clip;border-radius: var(--radius-card);}.deck-stage[data-fullscreen]{position: fixed;inset: 0;margin: auto;border-radius: 0;}.deck-stage[data-fullscreen][data-ratio]{aspect-ratio: var(--deck-ratio);inline-size: 100%;max-inline-size: 100%;max-block-size: 100%;}.deck-stage:not([data-fullscreen])[data-ratio]{aspect-ratio: var(--deck-ratio);}.deck-ground{position: absolute;inset: 0;z-index: var(--deck-z-ground);pointer-events: none;transition: opacity var(--spring-world-duration) var(--spring-world);}.deck-strip{position: relative;z-index: var(--deck-z-slide);block-size: 100%;}.deck-stage[data-register="turn"] .deck-strip{display: grid;grid-template-areas: "stack";block-size: 100%;perspective: calc(120 * var(--cqx));perspective-origin: 50% 50%;}.deck-stage[data-register="turn"] .deck-slide{grid-area: stack;}.deck-stage[data-register="snap"] .deck-strip{display: flex;overflow: auto;overscroll-behavior: contain;scroll-snap-type: x mandatory;scrollbar-width: none;}.deck-stage[data-register="snap"][data-axis="vertical"] .deck-strip{flex-direction: column;scroll-snap-type: y mandatory;}.deck-stage[data-register="snap"] .deck-strip::-webkit-scrollbar{display: none;}.deck-stage[data-register="snap"] .deck-slide{flex: 0 0 100%;scroll-snap-align: start;scroll-snap-stop: always;}.deck-slide{position: relative;min-inline-size: 0;padding-inline: max(var(--deck-safe-inline),var(--space-section));padding-block: max(var(--deck-safe-block),var(--space-section));}.deck-stage > :where([data-slot="deck-chrome"]){position: relative;z-index: var(--deck-z-chrome);}@media (max-aspect-ratio: 1 / 1),(max-height: 480px){.deck-stage[data-fullscreen][data-ratio],.deck-stage:not([data-fullscreen])[data-ratio]{aspect-ratio: auto;block-size: 100%;}.deck-slide{padding-inline: max(var(--deck-safe-inline),var(--space-family));padding-block: max(var(--deck-safe-block),var(--space-family));overflow-y: auto;}}}

package/dist/components/deck/styles/turn.css

@@ -0,0 +1 @@
+@layer components{.deck-stage[data-register="turn"]{--turn-travel: 100cqi;--turn-dur: var(--spring-world-duration);--turn-fade: var(--duration-normal);--turn-lift: 6deg;--turn-perspective: calc(190 * var(--cqx));--turn-dip-scale: 0.985;--turn-gutter-width: 7cqi;--turn-gutter-strength: 0.2;--turn-scrim: 0.14;--turn-gutter-hue: var(--foreground);}.deck-stage[data-register="turn"] .deck-strip{perspective: var(--turn-perspective);}.deck-stage[data-register="turn"] .deck-slide{--turn-gutter-ink: color-mix( in oklab,var(--turn-gutter-hue) calc(var(--turn-gutter-strength) * 100%),transparent );--turn-gutter: linear-gradient( to right,var(--turn-gutter-ink),transparent var(--turn-gutter-width),transparent calc(100% - var(--turn-gutter-width)),var(--turn-gutter-ink) );--turn-scrim-fill: color-mix( in oklab,var(--foreground) calc(var(--turn-scrim) * 100%),transparent );border-radius: var(--radius-card);overflow: hidden;isolation: isolate;opacity: 0;visibility: hidden;pointer-events: none;transform-style: preserve-3d;transform: translate3d(var(--turn-x,0),0,0) scale(var(--turn-s,1)) rotateY(var(--turn-r,0deg));transform-origin: var(--turn-origin,0% 50%);transition: opacity var(--turn-fade) var(--ease-standard),visibility 0s linear var(--turn-dur),transform var(--turn-dur) var(--spring-world);will-change: opacity,transform;}.deck-stage[data-register="turn"] .deck-slide[data-state="prev"]{--turn-x: calc(var(--turn-travel) * -1);--turn-s: var(--turn-dip-scale);}.deck-stage[data-register="turn"] .deck-slide[data-state="next"]{--turn-x: var(--turn-travel);--turn-r: var(--turn-lift);}.deck-stage[data-register="turn"] .deck-slide[data-state="active"]{--turn-x: 0px;--turn-s: 1;--turn-r: 0deg;opacity: 1;visibility: visible;pointer-events: auto;z-index: var(--deck-z-slide);transition: opacity var(--turn-fade) var(--ease-standard),visibility 0s linear 0s,transform var(--turn-dur) var(--spring-world);}.deck-stage[data-register="turn"] .deck-slide::before{content: "";position: absolute;inset: 0;z-index: 1;pointer-events: none;border-radius: inherit;background: var(--turn-gutter);}.deck-stage[data-register="turn"] .deck-slide::after{content: "";position: absolute;inset: 0;z-index: 1;pointer-events: none;border-radius: inherit;background: var(--turn-scrim-fill);opacity: 1;transition: opacity var(--turn-fade) var(--ease-standard);}.deck-stage[data-register="turn"] .deck-slide[data-state="active"]::after{opacity: 0;}.dark .deck-stage[data-register="turn"],.deck-stage[data-register="turn"] .deck-slide[data-dark]{--turn-gutter-hue: var(--background);--turn-gutter-strength: 0.3;}@media (max-aspect-ratio: 1 / 1),(max-height: 480px){.deck-stage[data-register="turn"]{--turn-lift: 0deg;--turn-perspective: none;--turn-travel: 88cqi;--turn-dur: var(--spring-panel-duration);--turn-fade: var(--duration-fast);--turn-dip-scale: 1;--turn-gutter-width: 9cqi;--turn-gutter-strength: 0.14;}.deck-stage[data-register="turn"] .deck-slide{transform-style: flat;backface-visibility: visible;}.dark .deck-stage[data-register="turn"],.deck-stage[data-register="turn"] .deck-slide[data-dark]{--turn-gutter-strength: 0.22;}}@media (prefers-reduced-motion: reduce){.deck-stage[data-register="turn"] .deck-slide,.deck-stage[data-register="turn"] .deck-slide[data-state="active"]{--turn-x: 0px;--turn-s: 1;--turn-r: 0deg;transition: opacity var(--duration-fast) var(--ease-out),visibility 0s linear 0s;}}}

package/dist/components/deck/types.d.ts

@@ -0,0 +1,26 @@
+/** The travel axis a sequence pages along. */
+export type DeckAxis = "horizontal" | "vertical";
+/** The ONE member-state vocabulary. Direction is derived, never stored. */
+export type DeckState = "active" | "prev" | "next";
+/**
+ * One member of a deck manifest. The dark flag and the accessible name live HERE
+ * rather than on the rendered node so a reorder cannot desynchronise them from
+ * their slide — the reorder-safety ruling that makes the manifest engine-grade.
+ */
+export interface SlideEntry {
+    /** The routable id (the hash-sync fragment, when hash sync is on). */
+    id: string;
+    /** The accessible name — the live announcement's "…: <name>" tail. */
+    title?: string;
+    /** Render this member against the dark arm regardless of the page mode. */
+    dark?: boolean;
+    /** An explicit `aria-label` override when the title is not the spoken name. */
+    ariaLabel?: string;
+}
+/** A deck manifest: the ordered members plus the deck's own accessible name. */
+export interface DeckContent {
+    /** The deck's accessible name (the region label). */
+    title?: string;
+    /** The ordered members. */
+    slides: readonly SlideEntry[];
+}

package/dist/components/deck/window.d.ts

@@ -0,0 +1,27 @@
+/** Which window a recompute is allowed to choose. */
+export type SequenceWindowPolicy = "recentre" | "nudge";
+export interface SequenceWindowOptions {
+    /** The window start the caller is coming FROM (the `"nudge"` policy's anchor). */
+    from?: number;
+    /** Default `"recentre"`. */
+    policy?: SequenceWindowPolicy;
+}
+export interface SequenceWindow {
+    /** The 0-based member indices inside the window, in order. */
+    shown: number[];
+    /** The window's first index — the FLIP delta is a difference of these. */
+    start: number;
+    /** Members exist before the window (a dimmed leading edge cue). */
+    clippedStart: boolean;
+    /** Members exist after the window (a dimmed trailing edge cue). */
+    clippedEnd: boolean;
+}
+/**
+ * The window of members around `active`.
+ *
+ * @param total   the member count
+ * @param active  the active 0-based index
+ * @param fit     how many members the window holds
+ * @param options the policy + the window the caller is coming from
+ */
+export declare function sequenceWindow(total: number, active: number, fit: number, options?: SequenceWindowOptions): SequenceWindow;