@mkbabb/glass-ui 6.0.0 → 7.0.0

package/dist/composables/motion/useStaggerReveal.d.ts

@@ -1,52 +0,0 @@
-interface StaggerRevealConfig {
-    /** Delay between each target becoming `revealed`. Default 60ms. */
-    staggerMs?: number;
-    /** When true (default), a target stays revealed after first entering the viewport. */
-    once?: boolean;
-    /** IntersectionObserver rootMargin. Default `0px`. */
-    rootMargin?: string;
-    /** IntersectionObserver threshold. Default 0.15. */
-    threshold?: number;
-}
-/**
- * Sequence entrance animations for a list/grid. Each registered target
- * gets a staggered `revealed` flag once it crosses the viewport threshold.
- * Consumers bind the flag to a Tailwind class (e.g. `opacity-100 translate-y-0`)
- * and let CSS transitions handle the visual entry.
- *
- * AQ.W5: on an engine with native `view()` timelines, no `IntersectionObserver`
- * is constructed — prefer the `[data-scroll-reveal]` CSS recipe
- * (scroll-driven.css). This composable is the feature-detected fallback (the
- * sole writer when the native feature is absent); under native, `register()`
- * reveals immediately so the terminal state is correct and the CSS animates.
- */
-export declare function useStaggerReveal(options?: StaggerRevealConfig): {
-    targets: import("vue").Ref<HTMLElement[], HTMLElement[]>;
-    register: (el: HTMLElement | null, index?: number) => void;
-    revealed: Record<number, boolean>;
-};
-/**
- * The `[data-scroll-reveal-once]` latch — BC.W-MOTION-PRESETS.
- *
- * The `scroll-driven.css` `[data-scroll-reveal]` recipe rides a native `view()`
- * timeline that RE-FIRES its entrance every time a child re-enters the entry range
- * — wrong for a virtualized/teleporting list (a row scrolls out + back and re-plays
- * the fade-lift). A `view()` timeline cannot latch "play once" (the CSS limit), so
- * the `[data-scroll-reveal-once]` opt-in plays the entrance ONCE: this directive
- * adds `data-revealed=""` to each child on its FIRST cross and `unobserve`s it (the
- * SAME `once: true` discipline `useStaggerReveal` runs above — `if (once)
- * observer?.unobserve(el)`); the CSS plays the one-shot `gl-reveal-once` keyframe
- * keyed off `[data-revealed]`, NOT the live `view()` range. NO second observer
- * engine — the same `IntersectionObserver` the composable speaks for the `once`
- * case, packaged as a Vue directive a consumer binds on the scroller.
- *
- * On an engine without `IntersectionObserver` (SSR/old) it reveals immediately so
- * the terminal state is correct (the CSS animation simply never plays). Under PRM
- * the scroll-driven.css `@media` outer gate drops the entrance and the row paints
- * in-place (a flourish — the reveal carve, not a legibility cue).
- */
-export declare const vScrollRevealOnce: {
-    mounted(scroller: HTMLElement): void;
-    unmounted(scroller: HTMLElement): void;
-};
-export {};

package/dist/composables/motion/useViewTransition.d.ts

@@ -1,81 +0,0 @@
-/** Options for `startViewTransition`. `types` (Chrome 140+, absent on Firefox
- *  144) tag the active transition so `:active-view-transition-type(<t>)` CSS can
- *  author DIRECTION-specific curves. Feature-detected — when the engine lacks the
- *  object-with-`types` overload the call degrades to the plain-callback form
- *  (one symmetric curve), which is functionally identical (the swap still runs). */
-export interface ViewTransitionOptions {
-    types?: string[];
-    /**
-     * BA.W-ATLAS-RECONCILE A-4b — take the JS-level INSTANT path under
-     * `prefers-reduced-motion: reduce` (run `mutate` directly, NO snapshot
-     * captured). The HEAD default pushes PRM to CSS only (`view-transition.css`
-     * sets `animation: none` on the VT pseudos) — but that STILL captures a
-     * snapshot. For the navigation case a reduced-motion user wants the swap to
-     * happen with no transition machinery at all; `navigate()` sets this true.
-     * Defaults to `false` so the existing sync-VT consumers (muster J.W5 row
-     * re-rank) keep their exact CSS-handled PRM behaviour. @default false
-     */
-    instantUnderReducedMotion?: boolean;
-}
-export interface ViewTransitionResult {
-    /**
-     * Resolves when the transition's `finished` promise settles (or
-     * immediately in the fallback path). Use to route focus per the a11y
-     * MANDATORY: `await startViewTransition(mutate).finished; el.focus()`.
-     * Never rejects — a skipped/aborted transition settles cleanly.
-     */
-    finished: Promise<void>;
-    /** True when the native API ran; false when the instant fallback ran. */
-    transitioned: boolean;
-}
-/**
- * True when `document.startViewTransition` is available — the feature-detected
- * predicate consumers gate optional VT-only styling on.
- */
-export declare function supportsViewTransitions(): boolean;
-/**
- * Wrap a synchronous DOM mutation in `document.startViewTransition` with an
- * instant fallback. `mutate` performs the DOM/state change and is called
- * synchronously in BOTH paths (native and fallback), so the post-mutation DOM
- * is identical regardless of support.
- *
- * @param mutate the synchronous DOM/state change to animate between.
- * @param options optional `{ types }` — directional transition types tagged on
- *   the active transition for `:active-view-transition-type(<t>)` CSS curves
- *   (Chrome 140+; feature-detected, degrades to one symmetric curve elsewhere).
- * @returns `{ finished, transitioned }` — await `finished` to route focus.
- *
- * @example
- *   const { finished } = startViewTransition(() => { rows.value = reranked });
- *   await finished;            // animation done
- *   firstRow.value?.focus();   // consumer routes focus (the a11y MANDATORY)
- *
- * @example
- *   // directional intent — snappier exit on collapse, softer entry on expand
- *   startViewTransition(() => mutate(), { types: ["dock-expand"] });
- */
-export declare function startViewTransition(mutate: () => void | Promise<void>, options?: ViewTransitionOptions): ViewTransitionResult;
-/** Options for `navigate` — the directional transition `types` (Chrome 140+,
- *  feature-detected; tag `["forward"]`/`["back"]` off the navigation direction). */
-export type NavigateOptions = ViewTransitionOptions;
-/**
- * Run a (possibly ASYNC) navigation callback wrapped in a View Transition, with
- * the reduced-motion + unsupported instant-paths. The navigation ALWAYS runs
- * (awaited); the morph is conditional on support + motion preference. Returns the
- * same `{ finished, transitioned }` contract — `await navigate(go).finished` then
- * route focus (the a11y MANDATORY).
- *
- * @example  the card → masthead route morph
- *   // both the card title + masthead title carry
- *   //   view-transition-class: gl-shared-element; view-transition-name: dash-title
- *   await navigate(() => router.push(`/${slug}`), { types: ["forward"] }).finished;
- *   mastheadTitle.value?.focus();
- */
-export declare function navigate(nav: () => void | Promise<void>, options?: NavigateOptions): ViewTransitionResult;
-/**
- * True when the route-transition morph can run (native VT available). A consumer
- * gates VT-only navigation styling on this (alias of `supportsViewTransitions`
- * named for the navigation call site). Under reduced motion the `navigate` helper
- * still takes the instant path even when this is `true`.
- */
-export declare function supportsRouteTransitions(): boolean;

package/dist/composables/virtual/index.d.ts

@@ -1,4 +0,0 @@
-export { useVirtualSectionWindow, clearSessionHeightCache, } from "./useVirtualSectionWindow";
-export { useWindowedStore } from "./useWindowedStore";
-export { buildSectionLayout, findSectionOffset, resolveActiveSection, resolveSectionWindow, } from "./virtualSectionLayout";
-export type { FlatSection, SectionLayout, SectionWindowRange, ForcedSectionWindowRange, } from "./virtualSectionLayout";

package/dist/composables/virtual/useVirtualSectionWindow.d.ts

@@ -1,72 +0,0 @@
-import { type MaybeRefOrGetter, type Ref } from "vue";
-import type { FlatSection } from "./virtualSectionLayout";
-/**
- * Lineage: a glass-ui primitive at v0.9.4, retired at v1.0 (MIGRATION.md §3.2),
- * carried on as a verbatim transposed copy in the words app, and HOME again at
- * BC (the live words consumer + the dock-search results list overturn the
- * no-consumer retirement verdict). Byte-faithful to the proven words copy save
- * the recorded refinements: the container/content ResizeObservers route through
- * the house `useResizeObserver` leaf (cleanup discipline) instead of raw
- * `new ResizeObserver`, and `findSectionOffset` is the binary-search variant.
- */
-interface VirtualWindowConfig<T extends FlatSection = FlatSection> {
-    /** The flat list of section items to virtualize. */
-    items: MaybeRefOrGetter<readonly T[]>;
-    /**
-     * The element whose scroll position drives the window.
-     * `null` = use `window` / document scroll.
-     */
-    scrollContainer: Ref<HTMLElement | null>;
-    /**
-     * The wrapper element around the virtualized content.
-     * When provided, scroll offset is computed relative to this element's
-     * position in the page, so content above it (headers, images, etc.)
-     * is correctly excluded from the layout calculation.
-     */
-    contentEl?: Ref<HTMLElement | null>;
-    /** Overscan before the viewport in pixels. Default: viewport height. */
-    overscanBeforePx?: number;
-    /** Overscan after the viewport in pixels. Default: 2x viewport height. */
-    overscanAfterPx?: number;
-    /** Number of items to warm before a target when using `ensureTargetWindow`. Default: 2. */
-    warmTargetBefore?: number;
-    /** Number of items to warm after a target when using `ensureTargetWindow`. Default: 3. */
-    warmTargetAfter?: number;
-}
-/**
- * Evict every cached measured section height. The documented escape for a
- * consumer that wants to drop the module-global `SESSION_HEIGHT_CACHE` (a
- * font-size change, a layout reflow that invalidates prior measurements).
- */
-export declare function clearSessionHeightCache(): void;
-/**
- * Scroll-based virtual windowing composable for section lists.
- *
- * Renders only the items visible in (or near) the scroll viewport,
- * using spacer divs to maintain correct scroll height. Supports:
- *
- * - Measured heights: call `measureSection(id, el)` from a template ref
- *   to replace estimated heights with real DOM measurements.
- * - Warm targeting: call `ensureTargetWindow(id)` to force an item into
- *   the render window before scrolling to it (auto-releases after 320ms).
- * - Active tracking: `activeId` / `activeRootId` report which section
- *   is currently at the 20% viewport mark. NOTE — this is the windowing-LOCAL
- *   render-active reader; a ToC/sidebar consumer reads `useScrollTracker`'s
- *   `activeId` (the deepest-visible reader) for the binding highlight. The two
- *   serve distinct concerns and are deliberately NOT one function
- *   (BC.W-VIRTUAL-WINDOW active-section reconcile).
- * - Content offset: provide `contentEl` to correctly handle non-virtualized
- *   content (headers, banners) above the virtual list.
- */
-export declare function useVirtualSectionWindow<T extends FlatSection>(options: VirtualWindowConfig<T>): {
-    visibleItems: import("vue").ComputedRef<T[]>;
-    topSpacerPx: import("vue").ComputedRef<number>;
-    bottomSpacerPx: import("vue").ComputedRef<number>;
-    measureSection: (id: string, el: HTMLElement | null) => void;
-    ensureTargetWindow: (id: string) => void;
-    getOffsetFor: (id: string) => number | null;
-    activeId: import("vue").ComputedRef<any>;
-    activeRootId: import("vue").ComputedRef<any>;
-    recalculate: () => void;
-};
-export {};

package/dist/composables/virtual/useWindowedStore.d.ts

@@ -1,43 +0,0 @@
-import { type Ref, type ShallowRef } from "vue";
-/**
- * Lineage: a glass-ui primitive at v0.9.4, retired at v1.0 (MIGRATION.md §3.3),
- * carried on as a verbatim transposed copy in the words app, and HOME again at
- * BC (the words wordlist store is the live consumer the no-consumer retirement
- * verdict missed). Byte-faithful to the proven words copy — the
- * generation-counter stale-append rejection is the load-bearing concurrency
- * primitive, preserved verbatim.
- */
-interface ResidentWindowConfig {
-    /** Maximum items to keep in memory. Default: 200. */
-    maxResident?: number;
-}
-interface ResidentWindowState<T> {
-    /** Currently loaded items (a sliding window of the full list). */
-    items: ShallowRef<T[]>;
-    /** Logical offset of `items[0]` in the full list. */
-    windowStart: Ref<number>;
-    /** Generation counter -- increments on each reset. Used to reject stale appends. */
-    generation: Ref<number>;
-    /** Append or replace items. `replace=true` resets window; `replace=false` appends with eviction from front. */
-    set(newItems: T[], replace?: boolean): void;
-    /** Prepend items before the current window. Evicts from the end if over `maxResident`. */
-    prepend(newItems: T[], newWindowStart: number): void;
-    /** Clear all items and reset window. */
-    clear(): void;
-    /**
-     * Append items only if the generation matches (i.e., no reset happened since the fetch started).
-     * Returns `true` if the append was accepted, `false` if rejected (stale).
-     */
-    appendIfCurrent(newItems: T[], expectedGeneration: number): boolean;
-}
-/**
- * Sliding-window store primitive for paginated / infinite-scroll data.
- *
- * Supports both forward (append) and backward (prepend) loading.
- * When items exceed `maxResident`, trims from the opposite end.
- *
- * Uses a generation counter to reject stale appends after a backward reset,
- * preventing race conditions between concurrent page fetches.
- */
-export declare function useWindowedStore<T>(options?: ResidentWindowConfig): ResidentWindowState<T>;
-export {};

package/dist/composables/virtual/virtualSectionLayout.d.ts

@@ -1,103 +0,0 @@
-/**
- * Pure layout computation functions for virtual section scrolling.
- *
- * These are stateless — they take data in, return layout info out.
- * No Vue reactivity, no DOM access.
- *
- * Lineage: this engine was a glass-ui primitive at v0.9.4, retired at v1.0
- * (MIGRATION.md §3.4 — "0 production consumers, demo-only"), and lived on as
- * a verbatim transposed copy in the words app. The retirement is REVERSED at
- * BC: the live words consumer + the dock-search results list overturn the
- * no-consumer verdict, so the windowing engine comes HOME. Byte-faithful to
- * the proven words copy except the one functional refinement recorded below
- * (`findSectionOffset` binary search) and the shared-hierarchy type-reconcile.
- */
-import type { SectionHierarchy } from "../sidebar/types";
-/**
- * A flattened section item with hierarchy metadata for virtual scrolling.
- *
- * The four hierarchy fields (`depth`/`rootId`/`parentId`/`rootIndex`) come
- * from the shared `SectionHierarchy` base (`composables/sidebar/types`) — the
- * same fields the sidebar's `TreeIndexEntry` carries, declared ONCE. The
- * producer (`flattenPaperSections` in latex-paper, the dock-search result
- * flattener) builds these in the consumer; glass-ui owns only the contract.
- */
-export interface FlatSection extends SectionHierarchy {
-    id: string;
-    index: number;
-    estimatedHeight: number;
-}
-/** A single entry in a computed section layout with resolved position. */
-interface VirtualLayoutEntry<T extends FlatSection = FlatSection> {
-    item: T;
-    height: number;
-    top: number;
-    bottom: number;
-}
-/** Complete layout for a list of sections — entries plus total height. */
-export interface SectionLayout<T extends FlatSection = FlatSection> {
-    entries: VirtualLayoutEntry<T>[];
-    totalHeight: number;
-    /**
-     * Entry slots sorted ascending by `item.id`, so `findSectionOffset` can
-     * binary-search an arbitrary string id in O(log n) (the words copy
-     * linear-scanned `entries` — `virtualSectionLayout.ts:244-252`). Built
-     * once in `buildSectionLayout`; the `top` is read straight off the matched
-     * entry, so the offset answer is byte-identical to the linear scan.
-     */
-    byId: VirtualLayoutEntry<T>[];
-}
-/** The visible window range with spacer sizes for virtual scrolling. */
-export interface SectionWindowRange {
-    startIndex: number;
-    endIndex: number;
-    topSpacerPx: number;
-    bottomSpacerPx: number;
-}
-/** A forced index range that must be included in the visible window. */
-export interface ForcedSectionWindowRange {
-    startIndex: number;
-    endIndex: number;
-}
-/**
- * Build a layout from a flat list of sections using a height resolver.
- *
- * Each entry gets an absolute `top` and `bottom` offset in pixels,
- * computed sequentially from index 0. Heights are rounded and clamped >= 1.
- */
-export declare function buildSectionLayout<T extends FlatSection>(items: readonly T[], getHeight: (item: T) => number): SectionLayout<T>;
-/**
- * Resolve which section indices are visible given scroll state.
- *
- * Uses binary search for O(log n) lookup. Overscan extends the window
- * before and after the viewport. An optional `forcedRange` guarantees
- * certain indices are always included (used for warm-up targeting).
- */
-export declare function resolveSectionWindow<T extends FlatSection>(layout: SectionLayout<T>, scrollTopPx: number, viewportHeightPx: number, overscanBeforePx: number, overscanAfterPx: number, forcedRange?: ForcedSectionWindowRange | null): SectionWindowRange;
-/**
- * Find the section that is "active" at a given scroll offset.
- *
- * Returns the last section whose top edge is at or before `activeOffsetPx`.
- *
- * NOTE — this is the windowing-LOCAL render-active reader (the section at the
- * 20%-viewport mark, used to label the current render window). It is NOT the
- * ToC's binding active-section reader: a sidebar/ToC consumer reads
- * `useScrollTracker.activeId` (the deepest-visible reader) for the highlight.
- * The two serve distinct concerns and are deliberately NOT one function
- * (BC.W-VIRTUAL-WINDOW active-section reconcile).
- */
-export declare function resolveActiveSection<T extends FlatSection>(layout: SectionLayout<T>, activeOffsetPx: number): T | null;
-/**
- * Find the pixel offset of a section by its `id`.
- * Returns `null` if the section is not in the layout.
- *
- * REFINEMENT (BC.W-VIRTUAL-WINDOW): the words copy linear-scans `entries`
- * matching on `id` (O(n), `virtualSectionLayout.ts:244-252`). Here we binary
- * search `layout.byId` — the entries sorted ascending by `item.id` in
- * `buildSectionLayout` — which is a total order over the string ids, so the
- * search is correct + O(log n). The `top` is read straight off the matched
- * entry, so the answer is byte-identical to the linear scan (the fixture pins
- * this over a 1000-item layout).
- */
-export declare function findSectionOffset<T extends FlatSection>(layout: SectionLayout<T>, id: string): number | null;
-export {};

package/dist/controls.d.ts

@@ -1 +0,0 @@
-export * from "./components/controls";

package/dist/controls.js

@@ -1,83 +0,0 @@
-import { t as e } from "./class-names-5jotTFzp.js";
-import { t } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { i as n } from "./dark-DIH-blY1.js";
-import { computed as r, createElementBlock as i, createStaticVNode as a, defineComponent as o, mergeProps as s, onBeforeUnmount as c, openBlock as l, ref as u, useAttrs as d, watch as f, watchEffect as p } from "vue";
-import { useMediaQuery as m } from "@vueuse/core";
-//#region src/components/controls/DarkModeToggle.vue?vue&type=script&setup=true&lang.ts
-var h = ["data-size", "data-eclipsing"], g = /* @__PURE__ */ t(/* @__PURE__ */ o({
-	inheritAttrs: !1,
-	__name: "DarkModeToggle",
-	props: {
-		size: { default: "md" },
-		disableTransitions: {
-			type: Boolean,
-			default: !1
-		},
-		eclipse: {
-			type: Boolean,
-			default: !1
-		}
-	},
-	setup(t) {
-		let o = t, g = d(), _ = u(!1), v = m("(prefers-reduced-motion: reduce)"), y = null, b = null, x = !1;
-		function S() {
-			y !== null && (clearTimeout(y), y = null);
-		}
-		function C() {
-			b !== null && (clearTimeout(b), b = null), _.value = !1;
-		}
-		function w() {
-			o.eclipse && (x = !1, S(), y = setTimeout(() => {
-				x = !0, y = null, v.value || (_.value = !0, b = window.setTimeout(C, 1700)), j();
-			}, 460));
-		}
-		function T() {
-			S();
-		}
-		function E(e) {
-			e.key === " " && !e.repeat && w();
-		}
-		function D(e) {
-			e.key === " " && T();
-		}
-		function O(e) {
-			if (o.eclipse && x) {
-				e.preventDefault(), e.stopPropagation(), x = !1;
-				return;
-			}
-			j();
-		}
-		f(v, (e) => {
-			e && C();
-		}), c(() => {
-			S(), C();
-		});
-		let k = r(() => e("dark-mode-toggle-button", "relative isolate inline-flex shrink-0 items-center justify-center", "cursor-pointer border-0 bg-transparent", "rounded-pill", "opacity-80", "focus-ring", g.class)), { isDark: A, toggleDark: j, setDisableTransitions: M } = n(), N = r(() => {
-			let { class: e, type: t, ...n } = g;
-			return {
-				"aria-label": A.value ? "Switch to light mode" : "Switch to dark mode",
-				"aria-pressed": A.value,
-				...n
-			};
-		});
-		return p(() => {
-			M(o.disableTransitions);
-		}), (e, n) => (l(), i("button", s({
-			type: "button",
-			class: k.value,
-			"data-size": o.size,
-			"data-eclipsing": t.eclipse && _.value ? "true" : void 0
-		}, N.value, {
-			onClick: O,
-			onPointerdown: w,
-			onPointerup: T,
-			onPointerleave: T,
-			onPointercancel: T,
-			onKeydown: E,
-			onKeyup: D,
-			onBlur: T
-		}), [...n[0] ||= [a("<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 472.39 472.39\" class=\"block h-full w-full fill-foreground\" data-v-82cc93de><g class=\"toggle-sun\" data-allow-motion data-v-82cc93de><path d=\"M403.21,167V69.18H305.38L236.2,0,167,69.18H69.18V167L0,236.2l69.18,69.18v97.83H167l69.18,69.18,69.18-69.18h97.83V305.38l69.18-69.18Zm-167,198.17a129,129,0,1,1,129-129A129,129,0,0,1,236.2,365.19Z\" data-v-82cc93de></path></g><g class=\"toggle-circle\" data-allow-motion data-v-82cc93de><circle cx=\"236.2\" cy=\"236.2\" r=\"90\" data-v-82cc93de></circle></g></svg>", 1)]], 16, h));
-	}
-}), [["__scopeId", "data-v-82cc93de"]]);
-//#endregion
-export { g as DarkModeToggle };