@vizejs/ui 0.387.0 → 0.388.0

package/dist/virtualizer-D9qfT4wS.d.mts

@@ -0,0 +1,349 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/families/interaction/virtualizer/virtualizer-types.d.ts
+/** Scroll axis virtualized by one controller. */
+type VirtualizerOrientation = "horizontal" | "vertical";
+/** Target placement for {@link VirtualizerController.scrollToIndex}. */
+type VirtualizerAlignment = "auto" | "center" | "end" | "start";
+/** One materialized item inside the rendered window. */
+interface VirtualItem {
+  /** Zero-based item index inside the collection. */
+  readonly index: number;
+  /** Stable render key resolved through `getItemKey`. */
+  readonly key: string | number;
+  /** Lane this item occupies, `0` for single-lane lists. */
+  readonly lane: number;
+  /** Main-axis start offset in CSS pixels, including leading padding. */
+  readonly start: number;
+  /** Main-axis extent in CSS pixels. */
+  readonly size: number;
+  /** Main-axis end offset in CSS pixels. */
+  readonly end: number;
+  /** Whether this index is declared sticky through `stickyIndexes`. */
+  readonly isSticky: boolean;
+  /** Whether `size` comes from a dynamic measurement instead of an estimate. */
+  readonly isMeasured: boolean;
+}
+/** Inclusive visible index range, before overscan is applied. */
+interface VirtualRange {
+  /** First index intersecting the viewport. */
+  readonly startIndex: number;
+  /** Last index intersecting the viewport. */
+  readonly endIndex: number;
+}
+/** Viewport extent used before the platform reports a measured size. */
+interface VirtualizerRect {
+  /** Inline-axis extent in CSS pixels. */
+  readonly width: number;
+  /** Block-axis extent in CSS pixels. */
+  readonly height: number;
+}
+/** Serializable scroll position captured for later restoration. */
+interface VirtualizerScrollSnapshot {
+  /** Raw main-axis scroll offset when the snapshot was taken. */
+  readonly offset: number;
+  /** First visible index, or `null` when nothing was visible. */
+  readonly anchorIndex: number | null;
+  /** Distance from the anchor item start to the viewport start. */
+  readonly anchorGap: number;
+}
+/** Options shared by {@link createVirtualizer} and {@link useVirtualizer}. */
+interface VirtualizerOptions {
+  /** Number of items in the collection. Reactive values relayout on change. */
+  readonly count: MaybeRefOrGetter<number>;
+  /**
+   * Scroll axis to virtualize.
+   *
+   * @default "vertical"
+   */
+  readonly orientation?: MaybeRefOrGetter<VirtualizerOrientation | undefined>;
+  /**
+   * Exact main-axis item size: a fixed pixel size or a per-index resolver.
+   * When provided, dynamic measurements are ignored.
+   *
+   * @default undefined
+   */
+  readonly itemSize?: number | ((index: number) => number);
+  /**
+   * Estimated main-axis item size used until an item is measured.
+   * Required when `itemSize` is not provided.
+   *
+   * @default undefined
+   */
+  readonly estimateItemSize?: number | ((index: number) => number);
+  /**
+   * Main-axis gap between adjacent items in one lane.
+   *
+   * @default 0
+   */
+  readonly gap?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Parallel lanes laid out across the cross axis, as in a masonry grid.
+   * Item `i` occupies lane `i % lanes`.
+   *
+   * @default 1
+   */
+  readonly lanes?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Extra items rendered before and after the visible range in every lane.
+   *
+   * @default 2
+   */
+  readonly overscan?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Leading main-axis padding in CSS pixels.
+   *
+   * @default 0
+   */
+  readonly paddingStart?: number;
+  /**
+   * Trailing main-axis padding in CSS pixels.
+   *
+   * @default 0
+   */
+  readonly paddingEnd?: number;
+  /**
+   * Stable key resolver for rendered items.
+   *
+   * @default the item index
+   */
+  readonly getItemKey?: (index: number) => string | number;
+  /**
+   * Indexes that stay rendered while scrolled past, newest wins.
+   *
+   * @default []
+   */
+  readonly stickyIndexes?: MaybeRefOrGetter<readonly number[] | undefined>;
+  /**
+   * Keep the viewport visually stable when items before it change size.
+   *
+   * @default true
+   */
+  readonly anchorScroll?: boolean;
+  /**
+   * Viewport rect assumed until a real viewport is attached and measured.
+   * This is what server rendering and hydration lay out against.
+   *
+   * @default { width: 0, height: 0 }
+   */
+  readonly initialRect?: VirtualizerRect;
+  /**
+   * Main-axis scroll offset assumed before the viewport reports one.
+   *
+   * @default 0
+   */
+  readonly initialScrollOffset?: number;
+  /** Called after the visible range changes, including to `null`. */
+  readonly onRangeChange?: (range: VirtualRange | null) => void;
+}
+/** Windowing controller for one scroll axis. */
+interface VirtualizerController {
+  /** Items to render, visible range plus overscan plus the active sticky item. */
+  readonly virtualItems: Readonly<ShallowRef<readonly VirtualItem[]>>;
+  /** Visible index range before overscan, or `null` for an empty collection. */
+  readonly range: Readonly<ShallowRef<VirtualRange | null>>;
+  /** Total scrollable main-axis size, including padding. */
+  readonly totalSize: Readonly<ShallowRef<number>>;
+  /** Current main-axis scroll offset. */
+  readonly scrollOffset: Readonly<ShallowRef<number>>;
+  /** Current main-axis viewport extent. */
+  readonly viewportSize: Readonly<ShallowRef<number>>;
+  /** Sticky index currently pinned at the viewport start, or `null`. */
+  readonly activeStickyIndex: Readonly<ShallowRef<number | null>>;
+  /** Attach the scrollable viewport element, or detach with `null`. */
+  readonly setViewport: (element: Element | null) => void;
+  /** Track one rendered item element for dynamic measurement, or stop with `null`. */
+  readonly measureElement: (element: Element | null, index: number) => void;
+  /** Record an explicit dynamic measurement for one index. */
+  readonly resizeItem: (index: number, size: number) => void;
+  /** Drop dynamic measurements from `fromIndex` onward and relayout. */
+  readonly invalidateMeasurements: (fromIndex?: number) => void;
+  /** Shift state after `prepended` items were inserted at index `0`. */
+  readonly notifyPrepended: (prepended: number) => void;
+  /** Scroll to a clamped main-axis offset. */
+  readonly scrollToOffset: (offset: number) => void;
+  /** Scroll until the item at `index` satisfies the alignment. */
+  readonly scrollToIndex: (index: number, alignment?: VirtualizerAlignment) => void;
+  /** Capture the current position for later {@link restoreScroll}. */
+  readonly createScrollSnapshot: () => VirtualizerScrollSnapshot;
+  /** Restore a captured position, preferring the anchored item. */
+  readonly restoreScroll: (snapshot: VirtualizerScrollSnapshot) => void;
+  /** Release observers, listeners, and watchers, then freeze the controller. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-runtime.d.ts
+/** Create an SSR-safe windowing controller for one scroll axis. */
+declare function createVirtualizer(options: VirtualizerOptions): VirtualizerController;
+/** Create a virtualizer disposed with the current Vue effect scope. */
+declare function useVirtualizer(options: VirtualizerOptions): VirtualizerController;
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-grid.d.ts
+/** Options shared by {@link createGridVirtualizer} and {@link useGridVirtualizer}. */
+interface GridVirtualizerOptions {
+  /** Number of grid rows. Reactive values relayout on change. */
+  readonly rowCount: MaybeRefOrGetter<number>;
+  /** Number of grid columns. Reactive values relayout on change. */
+  readonly columnCount: MaybeRefOrGetter<number>;
+  /**
+   * Exact row height: fixed pixels or a per-index resolver.
+   *
+   * @default undefined
+   */
+  readonly rowSize?: number | ((index: number) => number) | undefined;
+  /**
+   * Estimated row height used until a row is measured.
+   * Required when `rowSize` is not provided.
+   *
+   * @default undefined
+   */
+  readonly estimateRowSize?: number | ((index: number) => number) | undefined;
+  /**
+   * Exact column width: fixed pixels or a per-index resolver.
+   *
+   * @default undefined
+   */
+  readonly columnSize?: number | ((index: number) => number) | undefined;
+  /**
+   * Estimated column width used until a column is measured.
+   * Required when `columnSize` is not provided.
+   *
+   * @default undefined
+   */
+  readonly estimateColumnSize?: number | ((index: number) => number) | undefined;
+  /**
+   * Gap between adjacent rows in CSS pixels.
+   *
+   * @default 0
+   */
+  readonly rowGap?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Gap between adjacent columns in CSS pixels.
+   *
+   * @default 0
+   */
+  readonly columnGap?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Extra rows and columns rendered around the visible window.
+   *
+   * @default 2
+   */
+  readonly overscan?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Viewport rect assumed until a real viewport is attached and measured.
+   *
+   * @default { width: 0, height: 0 }
+   */
+  readonly initialRect?: VirtualizerRect;
+  /**
+   * Stable key resolver for rendered rows.
+   *
+   * @default the row index
+   */
+  readonly getRowKey?: (index: number) => string | number;
+  /**
+   * Stable key resolver for rendered columns.
+   *
+   * @default the column index
+   */
+  readonly getColumnKey?: (index: number) => string | number;
+}
+/** One rendered grid cell in viewport coordinates. */
+interface VirtualGridCell {
+  /** Zero-based row index. */
+  readonly rowIndex: number;
+  /** Zero-based column index. */
+  readonly columnIndex: number;
+  /** Stable render key combining the row and column keys. */
+  readonly key: string;
+  /** Block-axis start offset in CSS pixels. */
+  readonly top: number;
+  /** Inline-axis start offset in CSS pixels. */
+  readonly left: number;
+  /** Cell width in CSS pixels. */
+  readonly width: number;
+  /** Cell height in CSS pixels. */
+  readonly height: number;
+}
+/** Grid windowing controller over one shared scrollable viewport. */
+interface GridVirtualizerController {
+  /** Row-axis virtualizer, including measurement and scrolling APIs. */
+  readonly rows: VirtualizerController;
+  /** Column-axis virtualizer, including measurement and scrolling APIs. */
+  readonly columns: VirtualizerController;
+  /** Rendered cells for the current window, in row-major order. */
+  readonly virtualCells: Readonly<ShallowRef<readonly VirtualGridCell[]>>;
+  /** Attach the scrollable viewport element to both axes, or detach with `null`. */
+  readonly setViewport: (element: Element | null) => void;
+  /** Scroll until the addressed cell satisfies the alignment on both axes. */
+  readonly scrollToCell: (rowIndex: number, columnIndex: number, alignment?: VirtualizerAlignment) => void;
+  /** Release both axes and freeze the controller. */
+  readonly dispose: () => void;
+}
+/** Create an SSR-safe two-axis grid virtualizer over one viewport. */
+declare function createGridVirtualizer(options: GridVirtualizerOptions): GridVirtualizerController;
+/** Create a grid virtualizer disposed with the current Vue effect scope. */
+declare function useGridVirtualizer(options: GridVirtualizerOptions): GridVirtualizerController;
+//#endregion
+//#region src/families/interaction/virtualizer/virtualizer-infinite.d.ts
+/** Loading direction relative to item indexes. */
+type InfiniteLoadDirection = "backward" | "forward";
+/** Lifecycle state for one loading direction. */
+type InfiniteLoadStatus = "idle" | "loading";
+/** Context handed to one load callback invocation. */
+interface InfiniteLoadContext {
+  /** Direction being loaded: `backward` toward index `0`, `forward` past the end. */
+  readonly direction: InfiniteLoadDirection;
+  /** Aborted when this invocation becomes stale; its result must be discarded. */
+  readonly signal: AbortSignal;
+}
+/** Options shared by {@link createInfiniteLoader} and {@link useInfiniteLoader}. */
+interface InfiniteLoaderOptions {
+  /** Visible range of the driving virtualizer, usually `controller.range`. */
+  readonly range: MaybeRefOrGetter<VirtualRange | null | undefined>;
+  /** Current collection size. Reactive values re-evaluate loading proximity. */
+  readonly count: MaybeRefOrGetter<number>;
+  /**
+   * Items from either collection edge at which loading starts.
+   *
+   * @default 4
+   */
+  readonly threshold?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Whether earlier items remain to load before index `0`.
+   *
+   * @default false
+   */
+  readonly canLoadBackward?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Whether later items remain to load past the current end.
+   *
+   * @default false
+   */
+  readonly canLoadForward?: MaybeRefOrGetter<boolean | undefined>;
+  /** Load earlier items. Resolve after the collection is updated. */
+  readonly onLoadBackward?: (context: InfiniteLoadContext) => Promise<void> | void;
+  /** Load later items. Resolve after the collection is updated. */
+  readonly onLoadForward?: (context: InfiniteLoadContext) => Promise<void> | void;
+  /** Called when a non-stale load rejects. Without it, the rejection is rethrown. */
+  readonly onLoadError?: (direction: InfiniteLoadDirection, error: unknown) => void;
+}
+/** Bidirectional infinite loading controller. */
+interface InfiniteLoaderController {
+  /** Loading state toward index `0`. */
+  readonly backwardStatus: Readonly<ShallowRef<InfiniteLoadStatus>>;
+  /** Loading state past the current end. */
+  readonly forwardStatus: Readonly<ShallowRef<InfiniteLoadStatus>>;
+  /** Re-evaluate both directions immediately. */
+  readonly check: () => void;
+  /** Abort in-flight loads so their eventual results are discarded as stale. */
+  readonly cancel: (direction?: InfiniteLoadDirection) => void;
+  /** Cancel everything and freeze the controller. */
+  readonly dispose: () => void;
+}
+/** Create an SSR-safe bidirectional infinite loading controller. */
+declare function createInfiniteLoader(options: InfiniteLoaderOptions): InfiniteLoaderController;
+/** Create an infinite loader disposed with the current Vue effect scope. */
+declare function useInfiniteLoader(options: InfiniteLoaderOptions): InfiniteLoaderController;
+//#endregion
+export { VirtualizerScrollSnapshot as S, VirtualizerAlignment as _, InfiniteLoaderOptions as a, VirtualizerOrientation as b, GridVirtualizerController as c, createGridVirtualizer as d, useGridVirtualizer as f, VirtualRange as g, VirtualItem as h, InfiniteLoaderController as i, GridVirtualizerOptions as l, useVirtualizer as m, InfiniteLoadDirection as n, createInfiniteLoader as o, createVirtualizer as p, InfiniteLoadStatus as r, useInfiniteLoader as s, InfiniteLoadContext as t, VirtualGridCell as u, VirtualizerController as v, VirtualizerRect as x, VirtualizerOptions as y };

package/dist/virtualizer.d.mts

@@ -0,0 +1,2 @@
+import { S as VirtualizerScrollSnapshot, _ as VirtualizerAlignment, a as InfiniteLoaderOptions, b as VirtualizerOrientation, c as GridVirtualizerController, d as createGridVirtualizer, f as useGridVirtualizer, g as VirtualRange, h as VirtualItem, i as InfiniteLoaderController, l as GridVirtualizerOptions, m as useVirtualizer, n as InfiniteLoadDirection, o as createInfiniteLoader, p as createVirtualizer, r as InfiniteLoadStatus, s as useInfiniteLoader, t as InfiniteLoadContext, u as VirtualGridCell, v as VirtualizerController, x as VirtualizerRect, y as VirtualizerOptions } from "./virtualizer-D9qfT4wS.mjs";
+export { type GridVirtualizerController, type GridVirtualizerOptions, type InfiniteLoadContext, type InfiniteLoadDirection, type InfiniteLoadStatus, type InfiniteLoaderController, type InfiniteLoaderOptions, type VirtualGridCell, type VirtualItem, type VirtualRange, type VirtualizerAlignment, type VirtualizerController, type VirtualizerOptions, type VirtualizerOrientation, type VirtualizerRect, type VirtualizerScrollSnapshot, createGridVirtualizer, createInfiniteLoader, createVirtualizer, useGridVirtualizer, useInfiniteLoader, useVirtualizer };

package/dist/virtualizer.mjs

@@ -0,0 +1,2 @@
+import { a as createVirtualizer, i as useGridVirtualizer, n as useInfiniteLoader, o as useVirtualizer, r as createGridVirtualizer, t as createInfiniteLoader } from "./virtualizer-BlxKjT3W.mjs";
+export { createGridVirtualizer, createInfiniteLoader, createVirtualizer, useGridVirtualizer, useInfiniteLoader, useVirtualizer };

package/dist/{visually-hidden-BOqfqBFt.d.mts → visually-hidden-CUr9BX0K.d.mts}

@@ -1,4 +1,4 @@
-//#region src/VisuallyHidden.vue.d.ts
+//#region src/families/accessibility/visually-hidden/visually-hidden.vue.d.ts
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
   default?: (props: typeof __VLS_1) => any;

package/dist/{visually-hidden-BwDOx5yf.mjs → visually-hidden-SDjRJYRK.mjs}

@@ -2,9 +2,9 @@ import './style.css';
 import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
 import { createElementBlock, defineComponent, openBlock, renderSlot, useTemplateRef } from "vue";
 //#endregion
-//#region src/VisuallyHidden.vue
-var VisuallyHidden_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
-	__name: "VisuallyHidden",
+//#region src/families/accessibility/visually-hidden/visually-hidden.vue
+var visually_hidden_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "visually-hidden",
 	setup(__props, { expose: __expose }) {
 		const element = useTemplateRef("element");
 		__expose({ element });
@@ -16,6 +16,6 @@ var VisuallyHidden_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/*
 			}, [renderSlot(_ctx.$slots, "default", {}, void 0, true)], 512);
 		};
 	}
-}), [["__scopeId", "data-v-812b49c6"]]);
+}), [["__scopeId", "data-v-5b6748e6"]]);
 //#endregion
-export { VisuallyHidden_default as t };
+export { visually_hidden_default as t };

package/dist/visually-hidden.d.mts

@@ -1,2 +1,2 @@
-import { t as _default } from "./visually-hidden-BOqfqBFt.mjs";
+import { t as _default } from "./visually-hidden-CUr9BX0K.mjs";
 export { _default as VisuallyHidden };

package/dist/visually-hidden.mjs

@@ -1,2 +1,2 @@
-import { t as VisuallyHidden_default } from "./visually-hidden-BwDOx5yf.mjs";
-export { VisuallyHidden_default as VisuallyHidden };
+import { t as visually_hidden_default } from "./visually-hidden-SDjRJYRK.mjs";
+export { visually_hidden_default as VisuallyHidden };