@exegia/corpora-ui 1.0.0 → 2.0.0

package/dist-lib/components/blocks/scaffold/type.d.ts

@@ -0,0 +1,216 @@
+import { default as React, ComponentProps, ReactElement, ReactNode } from 'react';
+/** Key of one scaffold's slice of the store. */
+export type TScaffoldInstanceId = string;
+/** The identity every scaffold part shares through ScaffoldContext. State
+ * itself lives in the store — parts subscribe to the atoms they render from,
+ * so this value never changes identity while the scaffold is mounted. */
+export interface IScaffoldContextValue {
+    scaffoldId: TScaffoldInstanceId;
+    /** Drawer width in px — Actions reads it to slide out of the drawer's way. */
+    inspectorWidth: number;
+}
+export interface IScaffoldPanelLayout {
+    width?: number;
+    secondarySize?: number;
+    secondaryExpanded?: boolean;
+    swapped?: boolean;
+}
+/** One scaffold's whole state, as `useScaffoldState` returns it. A component
+ * that watches one field should subscribe to that field's atom instead. */
+export interface IScaffoldState {
+    inspectorWidth: number | null;
+    panelLayouts: Record<string, IScaffoldPanelLayout>;
+    /** Whether the inspector drawer is currently shown. */
+    inspectorOpen: boolean;
+    /** How many panels currently fit side by side, from the measured canvas
+     * width at `SCAFFOLD_PANEL_MIN_WIDTH` per panel (1..`SCAFFOLD_PANEL_CAPACITY`). */
+    panelCapacity: number;
+    /** Ids of id'd panels the scaffold is currently hiding — auto-hidden by
+     * capacity pressure or toggled away from a tab. */
+    hiddenPanelIds: readonly string[];
+    /** Id of the panel whose tab the pointer is resting on — the canvas
+     * spotlights it by fading every other id'd panel to 0.35 opacity. */
+    hoveredPanelId: string | null;
+}
+/** Drive a scaffold by id from anywhere, as `useScaffoldActions` returns it. */
+export interface IScaffoldStateActions {
+    resizePanel: (panelId: string, width: number) => void;
+    resizeInspector: (width: number) => void;
+    resizeSecondaryPanel: (panelId: string, height: number) => void;
+    setSecondaryExpanded: (panelId: string, expanded: boolean) => void;
+    setPanelSwapped: (panelId: string, swapped: boolean) => void;
+    setInspectorOpen: (open: boolean) => void;
+    toggleInspector: () => void;
+    /** Show/hide an id'd panel. Showing past capacity auto-hides the
+     * least-recently-activated visible panel; the last visible one never hides. */
+    togglePanel: (panelId: string) => void;
+    reset: () => void;
+}
+/** @internal Which props currently control the scaffold — write gates for
+ * the action atoms, so the store never overwrites a prop. */
+export interface IScaffoldConfig {
+    controlsInspector: boolean;
+}
+/** @internal The mounted root's callbacks, published into the store so
+ * action atoms can report changes wherever they were fired from. */
+export interface IScaffoldHandlers {
+    onInspectorOpenChange?: (open: boolean) => void;
+}
+/** @internal Bookkeeping for responsive panel hiding.
+ * - `visibleOrder`: visible panel ids, least-recently-activated first — the
+ *   front is what capacity pressure evicts next.
+ * - `autoHidden`: panels the scaffold hid because the canvas shrank, most
+ *   recent last. They return on their own when room comes back.
+ * - `userHidden`: panels hidden by a tab press. They stay hidden until the
+ *   tab is pressed again, however wide the canvas grows. */
+export interface IScaffoldPanelVisibility {
+    visibleOrder: string[];
+    autoHidden: string[];
+    userHidden: string[];
+}
+export interface IScaffoldRootProps extends ComponentProps<"div"> {
+    /** Names this scaffold's slice of the store, so `useScaffoldState` /
+     * `useScaffoldActions` can drive it by id and its state outlives the
+     * component. Omitted, the root keys off `useId` and drops its state on
+     * unmount. `useScaffold().providerProps` carries one. */
+    scaffoldId?: TScaffoldInstanceId;
+    /** Controlled inspector state — pair with `onInspectorOpenChange`. The
+     * prop stays the source of truth: store writes are gated off, and actions
+     * report through the callback instead. */
+    inspectorOpen?: boolean;
+    /** Initial inspector state when uncontrolled. Closed by default. */
+    defaultInspectorOpen?: boolean;
+    onInspectorOpenChange?: (open: boolean) => void;
+    /** Drawer width in px. Also drives how far Actions slides aside. */
+    inspectorWidth?: number;
+}
+export type TScaffoldSidebarProps = ComponentProps<"nav">;
+export type TScaffoldMainProps = ComponentProps<"div">;
+export type TScaffoldCanvasProps = ComponentProps<"div">;
+/** React's drag/animation DOM handlers collide with motion's gesture props
+ * on `motion.*` elements — strip them from pass-through HTML props. */
+type TMotionSafe<T> = Omit<T, "onDrag" | "onDragStart" | "onDragEnd" | "onAnimationStart" | "onAnimationEnd" | "onAnimationIteration">;
+export interface IScaffoldActionsProps extends TMotionSafe<Omit<ComponentProps<"div">, "children">> {
+    /** Called when the Add segment is pressed. The segment renders only
+     * while this is present — omit it to hide Add, e.g. once the canvas
+     * holds `SCAFFOLD_PANEL_CAPACITY` panels. */
+    onAdd?: () => void;
+    /** Label of the Add segment. */
+    addLabel?: ReactNode;
+    /** Replaces the default add icon. */
+    addIcon?: ReactNode;
+    /** The panel tabs (`Scaffold.Tab`, one per open panel) and any extra
+     * segments, rendered before Add. Key each tab — closes animate out. */
+    children?: ReactNode;
+    /** Emit interaction-sound attributes (inert until an app binds cuelume). */
+    sound?: boolean;
+}
+export type TScaffoldPanelChild<T extends IScaffoldSubPanelProps = IScaffoldSubPanelProps> = ReactElement<T, React.JSXElementConstructor<T>>;
+export interface IScaffoldPanelProps {
+    /** Stable id opting the panel into responsive hiding: the canvas hides
+     * id'd panels when it can't grant each `SCAFFOLD_PANEL_MIN_WIDTH`, and a
+     * `Scaffold.Tab` with the matching `panelId` reflects and toggles it.
+     * Omitted, the panel always renders. */
+    id?: string;
+    /** The panel's content, rendered in a card with a drop shadow. */
+    children: ReactNode;
+    /** The panel's content, rendered in a card with a drop shadow. */
+    SecondaryPanel?: TScaffoldPanelChild;
+    /** Reveals the Swap action in the seam menu (needs `SecondaryPanel`).
+     * Swapping trades the two cards with a layout morph — flip the slot
+     * content here so each card carries its subject to its new home. */
+    onSwap?: () => void;
+    /** Reveals the Close action in the seam menu — remove `SecondaryPanel`
+     * here; the strip and the menu leave together. */
+    onCloseSecondary?: () => void;
+    /** Accessible name of the panel region. */
+    name?: string;
+    /** Emit interaction-sound attributes on the floating buttons. */
+    sound?: boolean;
+    /** Accessible name of the seam-menu toggle. */
+    swapLabel?: string;
+    /** Extra class names for the panel's root element. */
+    className?: string;
+}
+export interface IScaffoldTabProps extends TMotionSafe<Omit<ComponentProps<"div">, "children">> {
+    /** The tab's label. */
+    children?: ReactNode;
+    /** Id of the panel this tab fronts (`Scaffold.Panel`'s `id`). The tab
+     * then shows whether the panel is hidden and pressing its label toggles
+     * visibility — showing past capacity hides another panel in its place. */
+    panelId?: string;
+    /** Renders the tab's close button. The button renders only while this
+     * is present — omit it to pin the tab, e.g. on the last remaining
+     * panel (the canvas keeps at least one open). */
+    onClose?: () => void;
+    /** Accessible name of the close button. */
+    closeLabel?: string;
+    /** Emit interaction-sound attributes on the close button. */
+    sound?: boolean;
+}
+export type TSubPanelPosition = "bottom" | "top";
+export type TSubPanelVariant = "card" | "subtle" | "inset";
+export interface IScaffoldSubPanelProps extends TMotionSafe<Omit<ComponentProps<"div">, "children">> {
+    children?: ReactNode;
+    /** Accessible name of the sub-panel region. */
+    name?: string;
+    /** Whether this is the primary or secondary sub-panel. */
+    primary?: boolean;
+    /** Whether this sub-panel holds the flexible slot. Defaults to `primary` —
+     * the panel flips it when the Expand action trades the slots. */
+    expanded?: boolean;
+    /** Visual style of the sub-panel. */
+    variant?: TSubPanelVariant;
+    /** Fixed width in px; omitted, the sub-panel flexes to share the canvas. */
+    width?: number;
+    /** Emit interaction-sound attributes on the floating buttons. */
+    sound?: boolean;
+    /** Extra class names for the sub-panel's root element. */
+    className?: string;
+}
+export interface IScaffoldInspectorProps extends TMotionSafe<Omit<ComponentProps<"aside">, "children">> {
+    children?: ReactNode;
+    /** Accessible name of the drawer region. */
+    name?: string;
+}
+export interface IPanelFloatingButtonProps {
+    onClick?: () => void;
+    /** Accessible name — the button is icon-only. */
+    label: string;
+    sound?: boolean;
+    className?: string;
+}
+export interface IPanelMenuButtonProps extends IPanelFloatingButtonProps {
+    /** Called when the Expand action is pressed — the panel trades which
+     * sub-panel holds the flexible slot. */
+    onExpand?: () => void;
+    /** Renders the Close action; called when it is pressed — the consumer
+     * removes the secondary strip. */
+    onCloseSecondary?: () => void;
+    /** Whether the secondary strip currently holds the flexible slot —
+     * flips the Expand chevron between down and up. */
+    secondaryExpanded?: boolean;
+    /** Whether the panel is swapped (column-reverse). Mirrors the Expand
+     * chevron so it keeps pointing at the sub-panel that grows next. */
+    swapped?: boolean;
+}
+export interface IUseScaffoldOptions {
+    /** Names the scaffold's slice of the store. Omitted, the hook generates
+     * one and drops its state on unmount. */
+    scaffoldId?: TScaffoldInstanceId;
+    /** Initial inspector state. Closed by default. */
+    defaultInspectorOpen?: boolean;
+    /** Fires on every inspector open/close. */
+    onInspectorChange?: (open: boolean) => void;
+}
+export interface IScaffoldControls {
+    /** The id the hook and the root share — hand it to `useScaffoldState` /
+     * `useScaffoldActions` to drive the scaffold from elsewhere. */
+    scaffoldId: TScaffoldInstanceId;
+    inspectorOpen: boolean;
+    setInspectorOpen: (open: boolean) => void;
+    toggleInspector: () => void;
+    /** Spread onto Scaffold.Root. */
+    providerProps: Pick<IScaffoldRootProps, "scaffoldId" | "defaultInspectorOpen" | "onInspectorOpenChange">;
+}
+export {};

package/dist-lib/components/blocks/scaffold/use-scaffold-state.d.ts

@@ -0,0 +1,26 @@
+import { TScaffoldInstanceId, IScaffoldState, IScaffoldStateActions } from './type';
+/**
+ * Read the scaffold registered under `scaffoldId` from anywhere below
+ * `ExegiaProvider` — no controller, no props, no provider of its own.
+ *
+ * ```tsx
+ * const { inspectorOpen, hiddenPanelIds } = useScaffoldState("workspace")
+ * ```
+ *
+ * This returns the whole state object, so the caller re-renders on every
+ * change, hovers included. A component that reads one field should subscribe
+ * to that field's atom instead:
+ * `useAtomValue(scaffoldInspectorOpenAtom("workspace"))`.
+ */
+export declare function useScaffoldState(scaffoldId: TScaffoldInstanceId): IScaffoldState;
+/**
+ * Drive the scaffold registered under `scaffoldId` from anywhere. Writes
+ * only — the caller never re-renders when the scaffold changes, so this is
+ * what a command palette or a keyboard shortcut should reach for.
+ *
+ * ```tsx
+ * const scaffold = useScaffoldActions("workspace")
+ * <Button onClick={scaffold.toggleInspector}>Inspect</Button>
+ * ```
+ */
+export declare function useScaffoldActions(scaffoldId: TScaffoldInstanceId): IScaffoldStateActions;

package/dist-lib/components/blocks/scaffold/use-scaffold.d.ts

@@ -0,0 +1,14 @@
+import { IScaffoldControls, IUseScaffoldOptions } from './type';
+/**
+ * Owns the scaffold's inspector state for UI living outside the scaffold
+ * (title-bar buttons, command palette, shortcuts). Spread the returned
+ * `providerProps` onto `Scaffold.Root`; without this hook the root manages
+ * the same state internally via `defaultInspectorOpen`.
+ *
+ * The hook and the root meet in the store: `providerProps` carries a
+ * `scaffoldId`, both sides read and write that instance's atoms, and
+ * `useScaffoldState` / `useScaffoldActions` reach the same slice from
+ * anywhere else by id. Unnamed scaffolds key off `useId` and are dropped on
+ * unmount; an explicit `scaffoldId` outlives its component.
+ */
+export declare function useScaffold({ scaffoldId: scaffoldIdProp, defaultInspectorOpen, onInspectorChange, }?: IUseScaffoldOptions): IScaffoldControls;

package/dist-lib/components/blocks/scaffold/utils.d.ts

@@ -0,0 +1,38 @@
+import { Variants } from 'motion/react';
+import { ClassNameValue } from 'tailwind-merge';
+import { IScaffoldPanelVisibility, TSubPanelVariant } from './type.ts';
+/**
+ * How many panels fit on a canvas of `width` px, granting each
+ * `SCAFFOLD_PANEL_MIN_WIDTH` plus the gaps between them. Clamped to
+ * [1, SCAFFOLD_PANEL_CAPACITY]; an unmeasured canvas (`null`) fits the cap.
+ */
+export declare function getPanelCapacity(width: number | null): number;
+/** @internal An untracked scaffold: nothing registered, nothing hidden. */
+export declare const EMPTY_SCAFFOLD_VISIBILITY: IScaffoldPanelVisibility;
+/**
+ * @internal Fold the registered ids and current capacity into a settled
+ * visibility: prune departed panels, admit new ones, evict the
+ * least-recently-activated visible panels past capacity, and restore
+ * auto-hidden ones when room returns. Returns `prev` untouched when nothing
+ * changes, so callers can compare identities instead of contents.
+ */
+export declare function reconcileVisibility(prev: IScaffoldPanelVisibility, ids: readonly string[], capacity: number): IScaffoldPanelVisibility;
+/** Desktop backdrop the whole scaffold sits on — a soft warm-gray wash. */
+export declare const scaffoldBackgroundClass: ClassNameValue;
+export declare const SCAFFOLD_BEZEL_CLASSES = "bezel-lit-t-2 bezel-lit-blur-2 bezel-lit/57 bezel-dim-b-2 bezel-dim-blur-3 bezel-dim/11 dark:bezel-lit-blur-3 dark:bezel-lit/14 dark:bezel-dim/78";
+/** Card surface shared by a panel's primary area and secondary strip. */
+export declare const panelSurfaceClass: ClassNameValue;
+/** Floating icon button hovering over a panel (close, swap). */
+export declare const floatingButtonClass: ClassNameValue;
+/** Hidden until the pointer rests on the panel (always shown for touch and
+ * while focused) — the affordances stay quiet until the panel is engaged. */
+export declare const revealOnPanelHoverClass: ClassNameValue;
+/** Pill segment inside the actions cluster (Add, browse). */
+export declare const actionSegmentClass: ClassNameValue;
+/** Pill segments (seam-menu actions, tabs, Add) blur/fade in place while
+ * the track morphs around them. The exit is a fast tween, not the layout
+ * spring — the track stays overflow-visible, so popped-out segments must be
+ * gone before the shrinking pill leaves them behind as a ghost. */
+export declare const segmentVariants: Variants;
+/** Map of sub-panel variants to their corresponding side. */
+export declare const subPanelVariant: Record<TSubPanelVariant, ClassNameValue>;

package/dist-lib/components/blocks/shell/animated-panel-inset.d.ts

@@ -0,0 +1,2 @@
+import { TAnimatedSidebarInsetProps } from './type';
+export declare const AnimatedPanelInset: import('react').ForwardRefExoticComponent<Omit<TAnimatedSidebarInsetProps, "ref"> & import('react').RefAttributes<HTMLElement>>;

package/dist-lib/components/blocks/shell/animated-panel-provider.d.ts

@@ -0,0 +1,2 @@
+import { IAnimatedSidebarProviderProps } from './type';
+export declare function AnimatedPanelProvider({ children, shellId, defaultPanelWidth, open, defaultOpen, onOpenChange, openMobile, defaultOpenMobile, onOpenMobileChange, onNarrowChange, panelComponents: _panelComponents, className, style, ...props }: IAnimatedSidebarProviderProps): import("react").JSX.Element;

package/dist-lib/components/blocks/shell/animated-panel-trigger.d.ts

@@ -0,0 +1,2 @@
+import { IAnimatedSidebarTriggerProps } from './type';
+export declare const AnimatedPanelTrigger: import('react').ForwardRefExoticComponent<IAnimatedSidebarTriggerProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist-lib/components/blocks/shell/animated-panel.d.ts

@@ -0,0 +1,2 @@
+import { IAnimatedSidebarProps } from './type';
+export declare function AnimatedPanel({ side, variant, collapsible, ariaLabel, children, className, panelClassName, style, ref, ...props }: IAnimatedSidebarProps): import("react").JSX.Element | null;

package/dist-lib/components/blocks/shell/shell-fit-atom.d.ts

@@ -0,0 +1,68 @@
+import { IShellMetrics } from './shell-metrics';
+import { TShellFitInstanceId, IShellFitPanelBounds, IShellFitSeed, IShellFitState } from './type';
+/**
+ * A string-keyed atom family.
+ *
+ * `jotai/utils`' `atomFamily` is deprecated for Jotai v3, and we need only
+ * the string-keyed case with a `remove` — so this stays in-house rather than
+ * adding `jotai-family` as a second Jotai package to keep version-aligned.
+ * Dropping a key lets the store's WeakMap release that instance's state.
+ */
+type TFamily<AtomType> = ((id: TShellFitInstanceId) => AtomType) & {
+    remove: (id: TShellFitInstanceId) => void;
+};
+/** The shell's own measurement of its columns. `useShellFit` is the only
+ * writer; read `shellFitMeasuredAtom` to get it with the "no layout yet" case
+ * already resolved. */
+export declare const shellFitMetricsAtom: TFamily<import('jotai').PrimitiveAtom<IShellMetrics> & {
+    init: IShellMetrics;
+}>;
+/** The width the user dragged to, before clamping — null while the panel sits
+ * at `--panel-width`. Read `shellFitPanelWidthAtom` for the width the panel
+ * actually renders at: clamping on read is what lets a narrowing viewport
+ * pull the panel down without forgetting the width they asked for. */
+export declare const shellFitRequestedWidthAtom: TFamily<import('jotai').PrimitiveAtom<number | null> & {
+    init: number | null;
+}>;
+/** The metrics, or null when the shell has no layout to report — a server
+ * render, a `display: none` host, a test with no layout engine. A zero is not
+ * a width, and treating it as one would pin the panel to nothing. */
+export declare const shellFitMeasuredAtom: TFamily<import('jotai').Atom<IShellMetrics | null>>;
+/** Whether the shell can hold a secondary panel at all. */
+export declare const shellFitFitsAtom: TFamily<import('jotai').Atom<boolean>>;
+/** The range a resize may land in. */
+export declare const shellFitPanelBoundsAtom: TFamily<import('jotai').Atom<IShellFitPanelBounds>>;
+/** The width the secondary panel renders at, or null before the first
+ * measurement, where the caller falls back to `--panel-width`. */
+export declare const shellFitPanelWidthAtom: TFamily<import('jotai').Atom<number | null>>;
+/** The whole fit of one shell. This changes on every measurement, so a
+ * component that reads one field should subscribe to that field's atom
+ * instead: `useAtomValue(shellFitFitsAtom("app-shell"))`. */
+export declare const shellFitStateAtom: TFamily<import('jotai').Atom<IShellFitState>>;
+/** @internal The measurement's way in. Silent, and inert when the numbers did
+ * not move — a resize event that changes nothing must not re-render a shell. */
+export declare const measureShellFitAtom: TFamily<import('jotai').WritableAtom<null, [metrics: IShellMetrics], void> & {
+    init: null;
+}>;
+/** Resize the secondary panel. Clamped on the way in, so a drag past the
+ * gutter parks at the bound instead of banking travel it has to give back —
+ * and a caller with no idea how wide the shell is can still ask for 900. */
+export declare const resizeShellPanelAtom: TFamily<import('jotai').WritableAtom<null, [width: number], void> & {
+    init: null;
+}>;
+/** Back to the width the shell mounted with — `defaultPanelWidth`, or
+ * `--panel-width` when there was none. */
+export declare const resetShellPanelWidthAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** @internal Seed the instance once. A seed describes the mount, not every
+ * render, so a `defaultPanelWidth` that arrives later never overwrites a
+ * width the user dragged to. */
+export declare const mountShellFitAtom: TFamily<import('jotai').WritableAtom<null, [seed: IShellFitSeed], void> & {
+    init: null;
+}>;
+/** Drop every atom for `id`. `useShellFit` calls this on unmount for shells it
+ * keyed itself; an explicit `shellId` is the app's key and outlives its
+ * component, so a resized panel survives a route change. */
+export declare function removeShellFitInstance(id: TShellFitInstanceId): void;
+export {};

package/dist-lib/components/blocks/shell/shell-layout.d.ts

@@ -0,0 +1,3 @@
+import { IShellLayoutProps } from './type';
+import * as React from "react";
+export declare function ShellLayout({ children, variant, panels, className, header, trailing, defaultOpen, panelComponents, ...panelControlProps }: IShellLayoutProps): React.ReactElement;

package/dist-lib/components/blocks/shell/shell-metrics.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The shell's layout arithmetic, as plain functions over px.
+ *
+ * Nothing here touches React or the DOM. This module IS the contract of who
+ * gets which column, which keeps the rule unit-testable on its own and lets
+ * the shell-fit atoms (`shellFitFitsAtom`, `shellFitPanelWidthAtom`) call it
+ * without restating it: `useShellFit` only supplies the measurements.
+ */
+/** The px the shell lays itself out with. Every field is measured from a CSS
+ * variable (see `SHELL_WIDTHS`), never hard-coded, so a consumer's override
+ * flows straight through the rule. */
+export interface IShellSidebarFit {
+    width: number;
+    minWidth: number;
+    maxWidth: number;
+    canExpand: boolean;
+    mode: "expanded" | "icon" | "hidden";
+}
+/** Reserve the body first, then shrink, fold, or hide the navigation rail.
+ * The requested width/open state is retained so widening restores it. */
+export declare function fitSidebar({ width, padding, gap, insetMin, expanded, icon, minimum, open, collapsible, present, }: {
+    width: number;
+    padding: number;
+    gap: number;
+    insetMin: number;
+    expanded: number;
+    icon: number;
+    minimum: number;
+    open: boolean;
+    collapsible: string;
+    present: boolean;
+}): IShellSidebarFit;
+export interface IShellMetrics {
+    sidebar?: IShellSidebarFit;
+    /** What the left rail occupies right now — its expanded width, its icon
+     * width, or 0 when there is no rail at all (or it is off canvas). */
+    rail: number;
+    /** The floor the body refuses to go below. */
+    insetMin: number;
+    /** The secondary panel's floor, which is also the width it opens at. */
+    panelMin: number;
+    /** Available shell container width (legacy field name). */
+    viewport: number;
+    /** px the shell's own frame eats before any column gets a share: its
+     * padding, plus the gap between columns.
+     */
+    chrome: number;
+}
+/** px the shell needs before a secondary panel can exist: the rail as it
+ * stands, plus the body and the panel at their own floors. */
+export declare function requiredWidth({ rail, insetMin, panelMin }: IShellMetrics): number;
+/**
+ * Whether the shell can hold a secondary panel, including padding and gaps.
+ *
+ * An unmeasurable shell fails open. A server render, a `display: none` host
+ * or a test environment with no layout engine all report 0, and a panel must
+ * never disappear over a reading the layout could not produce.
+ */
+export declare function fitsPanel(metrics: IShellMetrics): boolean;
+/** How wide the secondary panel may be: never under its own floor, never past
+ * the slack the body holds above its floor. `max` never drops below `min`, so
+ * a shell that does not fit reports a degenerate range instead of an inverted
+ * one — `fitsPanel` is what hides the panel, not a negative bound. */
+export declare function panelBounds(metrics: IShellMetrics): {
+    min: number;
+    max: number;
+};
+export declare function clampPanelWidth(width: number, metrics: IShellMetrics): number;
+/** Resizes fire per pointer move and per resize event, most of them landing
+ * on the same numbers — comparing fields keeps those from re-rendering the
+ * whole shell. */
+export declare function metricsEqual(a: IShellMetrics, b: IShellMetrics): boolean;

package/dist-lib/components/blocks/shell/shell-panel-atom.d.ts

@@ -0,0 +1,40 @@
+import { TSidebarSide } from './type';
+type OpenState = Record<TSidebarSide, boolean>;
+type Handlers = {
+    setOpen: (open: boolean, side: TSidebarSide) => void;
+    setOpenMobile: (open: boolean, side: TSidebarSide) => void;
+};
+export declare function shellPanelAtoms(id: string): {
+    railWidth: import('jotai').PrimitiveAtom<number | null> & {
+        init: number | null;
+    };
+    resizeSidebar: import('jotai').WritableAtom<null, [width: number], void> & {
+        init: null;
+    };
+    open: import('jotai').PrimitiveAtom<OpenState> & {
+        init: OpenState;
+    };
+    mobile: import('jotai').PrimitiveAtom<OpenState> & {
+        init: OpenState;
+    };
+    components: import('jotai').PrimitiveAtom<Partial<Record<TSidebarSide, import('react').ReactNode>>> & {
+        init: Partial<Record<TSidebarSide, import('react').ReactNode>>;
+    };
+    handlers: import('jotai').PrimitiveAtom<Handlers | null> & {
+        init: Handlers | null;
+    };
+    setOpen: import('jotai').WritableAtom<null, [value: boolean, side: TSidebarSide], void> & {
+        init: null;
+    };
+    setOpenMobile: import('jotai').WritableAtom<null, [value: boolean, side: TSidebarSide], void> & {
+        init: null;
+    };
+    toggle: import('jotai').WritableAtom<null, [side: TSidebarSide], void> & {
+        init: null;
+    };
+    seed: import('jotai').WritableAtom<null, [initial?: Partial<OpenState> | undefined, initialMobile?: Partial<OpenState> | undefined], void> & {
+        init: null;
+    };
+};
+export declare function removeShellPanelInstance(id: string): void;
+export {};