@ansh-ui/vue 0.2.0

package/dist/primitives.d.ts

@@ -0,0 +1,300 @@
+import { R as ReadonlyRef } from './utils-IKPG3zcC.js';
+export { S as SlotContent, c as cx, r as resolveSlotContent, u as useId } from './utils-IKPG3zcC.js';
+import { b as PositionResult, a as PositionOptions } from './position-Cn7qP1pn.js';
+export { A as Align, P as Placement, R as Rect, S as Side, c as computePosition } from './position-Cn7qP1pn.js';
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+import * as _ansh_ui_core from '@ansh-ui/core';
+import { BudgetReport, PointerState, ScrollTrackOptions, ScrollProgress, FrameState, MotionValue, AnimationOptions, SpringOptions } from '@ansh-ui/core';
+
+/**
+ * State that works both controlled and uncontrolled — the Vue counterpart of
+ * `@ansh-ui/react`'s hook of the same name, and just as load-bearing here.
+ *
+ * A `<Select>` must work as `<Select />` (owns its value), `<Select :default-value="a" />` (owns
+ * its value, seeded), `v-model="v"` (the parent owns it via `modelValue`/`update:modelValue`), and
+ * `<Select :open="open" @update:open="…" />` for a named prop like a dialog's `open`. All four are
+ * the same shape: **the prop is controlled when the reactive getter returns something other than
+ * `undefined`**, evaluated on every read rather than latched once — so a component that starts
+ * uncontrolled and later receives a value (an async-loaded form) switches over instead of silently
+ * ignoring the prop from then on.
+ *
+ * ```ts
+ * const [value, setValue] = useControllableState(
+ *   () => props.modelValue,
+ *   defaultValue,
+ *   (next) => emit('update:modelValue', next),
+ * )
+ * ```
+ *
+ * `getProp` is a plain function rather than a `Ref` so it can read straight off `props` — Vue's
+ * `computed` tracks whatever reactive properties it touches, `props.foo` included, with no need to
+ * wrap the caller's access pattern.
+ */
+declare function useControllableState<T>(getProp: () => T | undefined, defaultValue: T, onChange?: (value: T) => void): [ComputedRef<T>, (next: T | ((previous: T) => T)) => void];
+
+/** Ids of the currently open dismissable layers, outermost first. Exposed for tests. */
+declare function getLayerStack(): readonly string[];
+interface DismissOptions {
+    /** Close on pointer press outside the surface. Default `true`. */
+    outsidePress?: boolean;
+    /** Close on Escape. Only the topmost layer responds. Default `true`. */
+    escapeKey?: boolean;
+    /**
+     * Extra elements that count as "inside" — normally the trigger.
+     *
+     * Without this the trigger's own click closes the surface via the outside handler and then
+     * immediately reopens it via its own click handler, so the surface appears not to close at all.
+     */
+    ignore?: Array<Ref<HTMLElement | null | undefined>>;
+}
+declare function useDismiss(target: Ref<HTMLElement | null | undefined>, open: ReadonlyRef<boolean>, onDismiss: () => void, options?: DismissOptions): void;
+declare function useScrollLock(active: ReadonlyRef<boolean>): void;
+
+/** Every tabbable descendant, in tab order. */
+declare function getTabbable(container: HTMLElement | null | undefined): HTMLElement[];
+/**
+ * Trap Tab within a container while `active`.
+ *
+ * Implemented on `keydown` at the container rather than with sentinel elements at either end. The
+ * sentinel approach adds two focusable nodes to the accessibility tree that screen readers can land
+ * on and announce as blank; intercepting the key does not.
+ */
+declare function useFocusTrap(target: Ref<HTMLElement | null | undefined>, active: ReadonlyRef<boolean>): void;
+/**
+ * Restore focus to whatever was focused before `active` became true.
+ *
+ * The element is captured on activation, not on mount, because a component can be mounted long
+ * before it opens.
+ */
+declare function useFocusRestore(active: ReadonlyRef<boolean>): void;
+/**
+ * Move focus into a surface when it opens.
+ *
+ * Prefers an explicitly marked element, then the first tabbable one, then the container itself. The
+ * container fallback matters for a dialog whose only content is text: focus must land inside it so a
+ * screen reader announces the dialog rather than continuing from the page behind.
+ */
+declare function useAutoFocus(target: Ref<HTMLElement | null | undefined>, active: ReadonlyRef<boolean>, initialFocus?: Ref<HTMLElement | null | undefined>): void;
+/**
+ * Roving tabindex for a composite widget (toolbar, tab list, menu).
+ *
+ * The ARIA authoring practice: a composite has exactly **one** tab stop, and arrow keys move within
+ * it. Returns a keydown handler to bind on the composite's container.
+ */
+declare function useRovingFocus(options: {
+    /** Items in DOM order. */
+    items: Ref<Array<HTMLElement | null>>;
+    /** Index that currently owns the tab stop. */
+    active: () => number;
+    onActiveChange: (index: number) => void;
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    loop?: boolean;
+}): (event: KeyboardEvent) => void;
+
+interface AnchoredPositionOptions extends PositionOptions {
+    /** Set the floating element's width to the anchor's — what a combobox listbox wants. */
+    matchWidth?: boolean;
+}
+interface AnchoredPosition {
+    style: Record<string, string>;
+    arrowStyle: Record<string, string> | undefined;
+    placement: PositionResult['placement'];
+    side: PositionResult['side'];
+}
+/**
+ * Keep a floating element positioned against an anchor — the Vue counterpart of `@ansh-ui/react`'s
+ * `useAnchoredPosition`.
+ *
+ * Recomputes on scroll (capture phase, so nested scroll containers are caught), on viewport resize,
+ * and whenever either element changes size. It deliberately does **not** poll on every frame: that
+ * costs a forced layout per frame for a value that changes only on discrete events.
+ *
+ * Bound to `open` rather than a separate `enabled` flag — every consumer in this package positions
+ * only while its surface is open, so a second flag would be unused surface area.
+ */
+declare function useAnchoredPosition(anchorRef: Ref<HTMLElement | null | undefined>, floatingRef: Ref<HTMLElement | null | undefined>, open: ReadonlyRef<boolean>, options?: AnchoredPositionOptions): {
+    position: ComputedRef<AnchoredPosition>;
+    update: () => void;
+};
+
+/**
+ * Keep an element mounted while it animates out — the Vue counterpart of `@ansh-ui/react`'s
+ * `usePresence`.
+ *
+ * The problem: `v-if="open"` cannot animate on close, because Vue removes the node the instant
+ * `open` flips (Vue's own `<Transition>` solves this for simple cases, but our overlay components
+ * need the resolved `mounted`/`state` pair to drive `data-state` for CSS *and* to gate focus
+ * trapping and scroll locking off the same signal). The fix is the same as React's: keep rendering
+ * it and unmount when the exit animation actually finishes.
+ *
+ * Finishing is detected from `animationend`/`transitionend` rather than a duration prop, which would
+ * have to be kept in sync with the CSS by hand and drifts the moment someone retimes the animation
+ * in the stylesheet. The timeout is only a safety net for the case where no animation is declared at
+ * all and no event ever fires.
+ */
+declare function usePresence(open: ReadonlyRef<boolean>, target: Ref<HTMLElement | null | undefined>): {
+    mounted: Ref<boolean>;
+    state: Ref<'open' | 'closed'>;
+};
+
+/**
+ * Observer and lifecycle composables.
+ *
+ * A consistent pattern throughout: composables that take an element accept a **ref you bind in the
+ * template**, and watch it rather than reading it once. This matters because a template ref is
+ * `null` during `setup()` and only populated after mount — and stays null across a `v-if` toggle,
+ * then repopulates. Watching handles all of that; reading once in `onMounted` silently fails for
+ * conditionally-rendered elements, which is the most common bug in hand-written Vue composables.
+ */
+/** Subscribe to the shared ticker for the current scope's lifetime. */
+declare function useTicker(callback: (state: FrameState) => void, options?: {
+    phase?: 'read' | 'compute' | 'write' | 'post';
+    priority?: number;
+    enabled?: Ref<boolean> | boolean;
+}): () => void;
+interface UseInViewOptions {
+    threshold?: number;
+    rootMargin?: string;
+    once?: boolean;
+}
+/**
+ * Is the element in view?
+ *
+ * @param target A template ref. Watched, so it works with `v-if` and with elements that mount late.
+ */
+declare function useInView(target: Ref<HTMLElement | null | undefined>, options?: UseInViewOptions): Ref<boolean>;
+/** Track an element's size as a reactive value. */
+declare function useElementSize(target: Ref<HTMLElement | null | undefined>): Ref<{
+    width: number;
+    height: number;
+}>;
+/**
+ * Track an element's scroll progress.
+ *
+ * Returns a **shallowRef holding a mutable state object**, not a reactive number. Scroll progress
+ * changes every frame; making it reactive would flush an effect per frame and undo the phase
+ * separation the kernel provides. Read `progress.value.progress` inside a `useTicker` callback, or
+ * pass `onChange` and write to the DOM directly.
+ */
+declare function useScrollProgress(target: Ref<HTMLElement | null | undefined>, options?: ScrollTrackOptions & {
+    onChange?: (progress: ScrollProgress) => void;
+}): ShallowRef<ScrollProgress>;
+/** Track the window's (or a container's) overall scroll. */
+declare function useWindowScroll(onChange?: (info: {
+    progress: number;
+    scroll: number;
+    velocity: number;
+    max: number;
+}) => void, options?: {
+    axis?: 'y' | 'x';
+    container?: HTMLElement | null;
+}): ShallowRef<{
+    progress: number;
+    scroll: number;
+    velocity: number;
+    max: number;
+}>;
+/**
+ * Track pointer position over an element.
+ *
+ * The returned object is mutated in place by the tracker each frame and is deliberately **not**
+ * reactive — reading it in a template would flush on every pointer move.
+ */
+declare function usePointer(target: Ref<HTMLElement | null | undefined>, options?: {
+    smoothing?: number;
+    trackOutside?: boolean;
+}): ShallowRef<Readonly<PointerState> | null>;
+/**
+ * Does the user prefer reduced motion?
+ *
+ * Returns `false` during SSR, which is the hydration-safe default: the server cannot know, and
+ * differing between server and first client render would be a mismatch.
+ */
+declare function useReducedMotion(): Ref<boolean>;
+/**
+ * Live frame-budget telemetry for a development overlay.
+ *
+ * Sampled at 4 Hz rather than per frame: a number changing 60 times a second is unreadable, and
+ * rendering it that often distorts the measurement it is reporting.
+ */
+declare function useFrameBudget(): Ref<BudgetReport | null>;
+
+/**
+ * Vue motion composables.
+ *
+ * The design principle mirrors the React package: animated values live **outside** Vue's
+ * reactivity. A `ref` that updates 60 times a second triggers 60 reactive effect flushes and, if
+ * anything in a template reads it, 60 patch cycles — which is precisely the cost that makes
+ * "animation in a framework" slow.
+ *
+ * So {@link useMotionValue} returns the engine's `MotionValue` directly and writes to the DOM. Where
+ * a value genuinely belongs in a template, {@link useMotionRef} bridges it into a `shallowRef` and
+ * says plainly what that costs.
+ *
+ * Cleanup uses `onScopeDispose` rather than `onBeforeUnmount`, so these compose correctly inside
+ * `effectScope()` — including in Pinia stores and outside a component instance entirely.
+ */
+/**
+ * Create a {@link MotionValue} bound to the current effect scope.
+ *
+ * Does not trigger re-renders. Pass it to `useMotionStyle` or read it in a `useTicker` callback.
+ */
+declare function useMotionValue<T>(initial: T): MotionValue<T>;
+/**
+ * Bridge a MotionValue into a Vue ref.
+ *
+ * **This makes the value reactive, which means a component update on every change.** For a value
+ * being animated continuously that is 60 updates per second. Use it for values that change at
+ * interaction rate — a settled spring, a toggle — not for anything mid-animation.
+ *
+ * A `shallowRef` rather than `ref` because the value is replaced wholesale, never mutated, so deep
+ * reactivity would be pure overhead.
+ */
+declare function useMotionRef<T>(value: MotionValue<T>): Readonly<ShallowRef<T>>;
+/**
+ * Write a MotionValue straight to an element's style property, bypassing Vue's renderer.
+ *
+ * This is the mechanism for smooth animation in Vue. Bind the returned ref to an element:
+ *
+ * ```vue
+ * <script setup>
+ * const x = useMotionValue(0)
+ * const el = useMotionStyle(x, (v) => `translateX(${v}px)`)
+ * </script>
+ * <template><div :ref="el" /></template>
+ * ```
+ */
+declare function useMotionStyle<T, El extends HTMLElement = HTMLElement>(value: MotionValue<T>, format: (value: T) => string, property?: string): ShallowRef<El | null>;
+/**
+ * A spring that continuously chases a target.
+ *
+ * The target is a plain setter rather than a reactive ref, deliberately: reading a ref inside the
+ * spring's per-frame callback would register a reactive dependency and flush an effect every
+ * frame, which defeats the purpose of keeping the animation outside the reactivity system.
+ */
+declare function useSpringValue(initial: number, options?: SpringOptions): {
+    value: MotionValue<number>;
+    set: (target: number) => void;
+};
+/**
+ * Scope-bound imperative animation.
+ *
+ * Any in-flight animation is stopped when the scope disposes, and when `start` is called again —
+ * which is the behaviour you want, since two animations driving one value fight each other.
+ */
+declare function useAnimate(): <T>(from: T | MotionValue<T>, to: T | readonly T[], options?: AnimationOptions<T>) => _ansh_ui_core.AnimationControls;
+/**
+ * Drive a MotionValue from a reactive source.
+ *
+ * The bridge in the other direction: when a `ref` in your component changes, animate toward the new
+ * value. This is the idiomatic way to connect Vue state to Ansh motion.
+ *
+ * ```ts
+ * const open = ref(false)
+ * const height = useMotionValue(0)
+ * useAnimatedFrom(open, height, (isOpen) => (isOpen ? 320 : 0), { spring: 'snappy' })
+ * ```
+ */
+declare function useAnimatedFrom<Source, T>(source: Ref<Source>, target: MotionValue<T>, map: (value: Source) => T, options?: AnimationOptions<T>): void;
+
+export { type AnchoredPosition, type AnchoredPositionOptions, type DismissOptions, PositionOptions, PositionResult, ReadonlyRef, type UseInViewOptions, getLayerStack, getTabbable, useAnchoredPosition, useAnimate, useAnimatedFrom, useAutoFocus, useControllableState, useDismiss, useElementSize, useFocusRestore, useFocusTrap, useFrameBudget, useInView, useMotionRef, useMotionStyle, useMotionValue, usePointer, usePresence, useReducedMotion, useRovingFocus, useScrollLock, useScrollProgress, useSpringValue, useTicker, useWindowScroll };

package/dist/primitives.js

@@ -0,0 +1,8 @@
+export { usePresence } from './chunk-6XJOB6LE.js';
+export { computePosition, getLayerStack, useAnchoredPosition, useDismiss, useScrollLock } from './chunk-XZ5ZFLZM.js';
+export { getTabbable, useAutoFocus, useFocusRestore, useFocusTrap, useRovingFocus } from './chunk-TMG3M6TK.js';
+export { useControllableState } from './chunk-OAQ7MDYX.js';
+export { useAnimate, useAnimatedFrom, useElementSize, useFrameBudget, useInView, useMotionRef, useMotionStyle, useMotionValue, usePointer, useReducedMotion, useScrollProgress, useSpringValue, useTicker, useWindowScroll } from './chunk-EVO23GUS.js';
+export { cx, resolveSlotContent, useId } from './chunk-NJDDNO4C.js';
+//# sourceMappingURL=primitives.js.map
+//# sourceMappingURL=primitives.js.map

package/dist/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"primitives.js"}

package/dist/sidebar-CQqEmpid.d.cts

@@ -0,0 +1,124 @@
+import * as vue from 'vue';
+import { VNode, PropType } from 'vue';
+import { S as SlotContent } from './utils-IKPG3zcC.cjs';
+
+interface NavItem {
+    id: string;
+    label: string;
+    href?: string;
+    icon?: SlotContent;
+    /** Count or status shown on the right. */
+    badge?: SlotContent;
+    disabled?: boolean;
+    onClick?: () => void;
+    /** Nested items, rendered in a collapsible group. */
+    items?: readonly NavItem[];
+}
+interface NavSection {
+    id: string;
+    /** Heading above the group. Omit for an unlabelled block. */
+    label?: string;
+    items: readonly NavItem[];
+}
+/**
+ * The application sidebar — the Vue counterpart of `@ansh-ui/react`'s `Sidebar`.
+ *
+ * A `<nav>` containing lists of links — the structure a screen reader user navigates by landmark,
+ * and the reason this isn't a stack of divs. Nested groups are `<button aria-expanded>` controlling
+ * a `<ul>`, so their state is announced.
+ *
+ * Collapsing to an icon rail keeps the labels in the DOM (visually hidden), rather than removing
+ * them. Removing them would leave a rail of unlabelled icons for anyone using assistive technology,
+ * which is exactly the population for whom the space saving is irrelevant.
+ *
+ * `header`/`footer` are React props of arbitrary content in the source; here they are the `#header`
+ * and `#footer` slots — passing a whole render tree through a prop is idiomatic React and awkward
+ * Vue, the same reasoning `HoverCard`'s `#content` slot documents.
+ */
+declare const Sidebar: vue.DefineComponent<vue.ExtractPropTypes<{
+    sections: {
+        type: PropType<readonly NavSection[]>;
+        required: true;
+    };
+    /** Id of the active item. */
+    activeId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Collapse to an icon rail. */
+    collapsed: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Show the collapse toggle. Default `true`. */
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("navigate" | "update:collapsed")[], "navigate" | "update:collapsed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    sections: {
+        type: PropType<readonly NavSection[]>;
+        required: true;
+    };
+    /** Id of the active item. */
+    activeId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Collapse to an icon rail. */
+    collapsed: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Show the collapse toggle. Default `true`. */
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onNavigate?: ((...args: any[]) => any) | undefined;
+    "onUpdate:collapsed"?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: string;
+    activeId: string;
+    collapsed: boolean;
+    defaultCollapsed: boolean;
+    collapsible: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * The header + sidebar + content frame — the Vue counterpart of `@ansh-ui/react`'s `AppShell`.
+ *
+ * A grid rather than nested flex containers, so the sidebar and header can be `position: sticky`
+ * without the content needing compensating margins — the arrangement that breaks the moment the
+ * header's height changes.
+ *
+ * The skip link is the first focusable element on the page. It is the cheapest accessibility win
+ * available and it is missing from almost every application shell: without it, a keyboard user
+ * traverses the entire navigation on every single page load.
+ *
+ * `sidebar`/`header` are the `#sidebar`/`#header` slots (see `Sidebar`'s doc comment for why); the
+ * main content is the default slot.
+ */
+declare const AppShell: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { AppShell as A, type NavItem as N, Sidebar as S, type NavSection as a };

package/dist/sidebar-CTZ-Ckko.d.ts

@@ -0,0 +1,124 @@
+import * as vue from 'vue';
+import { VNode, PropType } from 'vue';
+import { S as SlotContent } from './utils-IKPG3zcC.js';
+
+interface NavItem {
+    id: string;
+    label: string;
+    href?: string;
+    icon?: SlotContent;
+    /** Count or status shown on the right. */
+    badge?: SlotContent;
+    disabled?: boolean;
+    onClick?: () => void;
+    /** Nested items, rendered in a collapsible group. */
+    items?: readonly NavItem[];
+}
+interface NavSection {
+    id: string;
+    /** Heading above the group. Omit for an unlabelled block. */
+    label?: string;
+    items: readonly NavItem[];
+}
+/**
+ * The application sidebar — the Vue counterpart of `@ansh-ui/react`'s `Sidebar`.
+ *
+ * A `<nav>` containing lists of links — the structure a screen reader user navigates by landmark,
+ * and the reason this isn't a stack of divs. Nested groups are `<button aria-expanded>` controlling
+ * a `<ul>`, so their state is announced.
+ *
+ * Collapsing to an icon rail keeps the labels in the DOM (visually hidden), rather than removing
+ * them. Removing them would leave a rail of unlabelled icons for anyone using assistive technology,
+ * which is exactly the population for whom the space saving is irrelevant.
+ *
+ * `header`/`footer` are React props of arbitrary content in the source; here they are the `#header`
+ * and `#footer` slots — passing a whole render tree through a prop is idiomatic React and awkward
+ * Vue, the same reasoning `HoverCard`'s `#content` slot documents.
+ */
+declare const Sidebar: vue.DefineComponent<vue.ExtractPropTypes<{
+    sections: {
+        type: PropType<readonly NavSection[]>;
+        required: true;
+    };
+    /** Id of the active item. */
+    activeId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Collapse to an icon rail. */
+    collapsed: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Show the collapse toggle. Default `true`. */
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("navigate" | "update:collapsed")[], "navigate" | "update:collapsed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    sections: {
+        type: PropType<readonly NavSection[]>;
+        required: true;
+    };
+    /** Id of the active item. */
+    activeId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** Collapse to an icon rail. */
+    collapsed: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Show the collapse toggle. Default `true`. */
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onNavigate?: ((...args: any[]) => any) | undefined;
+    "onUpdate:collapsed"?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: string;
+    activeId: string;
+    collapsed: boolean;
+    defaultCollapsed: boolean;
+    collapsible: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * The header + sidebar + content frame — the Vue counterpart of `@ansh-ui/react`'s `AppShell`.
+ *
+ * A grid rather than nested flex containers, so the sidebar and header can be `position: sticky`
+ * without the content needing compensating margins — the arrangement that breaks the moment the
+ * header's height changes.
+ *
+ * The skip link is the first focusable element on the page. It is the cheapest accessibility win
+ * available and it is missing from almost every application shell: without it, a keyboard user
+ * traverses the entire navigation on every single page load.
+ *
+ * `sidebar`/`header` are the `#sidebar`/`#header` slots (see `Sidebar`'s doc comment for why); the
+ * main content is the default slot.
+ */
+declare const AppShell: vue.DefineComponent<{}, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { AppShell as A, type NavItem as N, Sidebar as S, type NavSection as a };