@ahrowe/ui 0.35.0 → 0.36.0

package/dist/cjs-types/common/roomDrawer/roomDrawer.types.d.ts

@@ -0,0 +1,308 @@
+import { CSSProperties, ReactNode, Ref } from 'react';
+import { FloorPlan, OpeningKind, PlanParseResult, PlanPoint, PlanRoom, PlanSelection, PlanView } from '../floorPlan/index.js';
+import { IconContent } from '../types/icon.types.js';
+import { HtmlProps, SlotClassNames, SlotStyles } from '../types/slots.types.js';
+/**
+ * The drawing tools.
+ *
+ * Each opening kind is its own tool rather than one opening tool with a kind sub-mode:
+ * that is one less piece of state, one less prop to wire up, and one less way to be in
+ * a mode you did not realise you were in.
+ *
+ * There is deliberately no "room" tool. Rooms are the enclosed faces the walls form, so
+ * drawing a closed shape with `Rect` or `Wall` already produces one. A mode that
+ * declared which walls belonged to which room would reintroduce exactly the ownership
+ * relation that made a door unable to cut a shared wall in the first place.
+ */
+export type RoomDrawerTool = 'select' | 'wall' | 'rect' | 'door' | 'window' | 'archway' | 'measure';
+export type RoomDrawerChangeReason = 'draw-wall' | 'draw-rect' | 'move-node' | 'move-wall' | 'move-room' | 'nudge' | 'add-opening' | 'move-opening' | 'edit-opening' | 'edit-room' | 'edit-wall' | 'delete' | 'add-floor' | 'duplicate-floor' | 'remove-floor' | 'rename-floor' | 'move-floor' | 'edit-floor' | 'clear' | 'import' | 'undo' | 'redo' | 'external';
+export interface RoomDrawerChangeMeta {
+    reason: RoomDrawerChangeReason;
+    /**
+     * `false` for the intermediate values emitted while a pointer gesture is still in
+     * flight, `true` for the one that is also pushed onto the undo stack. `onChangeEnd`
+     * only ever fires with `true`.
+     */
+    committed: boolean;
+    /** Ids of whatever the change touched, for syncing an external selection. */
+    targetIds: string[];
+}
+/** Every string the drawer's own chrome renders, for localisation. */
+export interface RoomDrawerLabels {
+    /** The toolbar, read out by screen readers. */
+    tools?: string;
+    /** Tooltip on the storey height field. */
+    storeyHeightHint?: string;
+    /** Tooltip on an opening's sill height field. */
+    sillHeightHint?: string;
+    select?: string;
+    wall?: string;
+    rect?: string;
+    measure?: string;
+    door?: string;
+    window?: string;
+    archway?: string;
+    undo?: string;
+    redo?: string;
+    download?: string;
+    upload?: string;
+    underlay?: string;
+    addFloor?: string;
+    floorName?: string;
+    duplicateFloor?: string;
+    deleteFloor?: string;
+    floorHeight?: string;
+    moveFloorUp?: string;
+    moveFloorDown?: string;
+    /** The inspector's noun for a floor, shown when nothing is selected. */
+    selectedFloor?: string;
+    /** Shown in the hint line when an opened file could not be read at all. */
+    importFailed?: string;
+    snap?: string;
+    angleLock?: string;
+    grid?: string;
+    zoomIn?: string;
+    zoomOut?: string;
+    fit?: string;
+    roomName?: string;
+    addCorner?: string;
+    thickness?: string;
+    width?: string;
+    sill?: string;
+    head?: string;
+    deleteSelection?: string;
+    /** Shown when several things are selected. `{count}` is replaced with the number. */
+    selectedCount?: string;
+    /** What the inspector calls the current selection. */
+    selectedNothing?: string;
+    selectedRoom?: string;
+    selectedWall?: string;
+    selectedCorner?: string;
+    /** Overrides the opening's own kind, which is used by default. */
+    selectedOpening?: string;
+    hintSelect?: string;
+    hintWall?: string;
+    hintRect?: string;
+    hintMeasure?: string;
+    hintOpening?: string;
+}
+/** Every icon in the chrome is overridable. */
+export interface RoomDrawerIcons {
+    select?: IconContent;
+    wall?: IconContent;
+    rect?: IconContent;
+    measure?: IconContent;
+    door?: IconContent;
+    window?: IconContent;
+    archway?: IconContent;
+    undo?: IconContent;
+    redo?: IconContent;
+    download?: IconContent;
+    upload?: IconContent;
+    underlay?: IconContent;
+    addFloor?: IconContent;
+    duplicateFloor?: IconContent;
+    moveFloorUp?: IconContent;
+    moveFloorDown?: IconContent;
+    snap?: IconContent;
+    angleLock?: IconContent;
+    grid?: IconContent;
+    zoomIn?: IconContent;
+    zoomOut?: IconContent;
+    fit?: IconContent;
+    delete?: IconContent;
+}
+export type RoomDrawerSlots = 'root' | 'toolbar' | 'toolButton' | 'toolIcon' | 'viewControls' | 'viewButton' | 'zoomLabel' | 'canvasWrapper' | 'canvas' | 'grid' | 'rooms' | 'roomFill' | 'roomLabel' | 'walls' | 'wallBody' | 'openings' | 'opening' | 'overlay' | 'measureLine' | 'floorBar' | 'floorTab' | 'inspector' | 'inspectorLabel' | 'inspectorField' | 'hint';
+export interface RoomDrawerHandle {
+    /** The current plan, read synchronously. Useful in uncontrolled mode. */
+    getPlan: () => FloorPlan;
+    /** Replaces the plan. Pushes one history entry unless `resetHistory` is set. */
+    setPlan: (plan: FloorPlan, options?: {
+        resetHistory?: boolean;
+    }) => void;
+    /** Empties the plan, as one history entry. */
+    clear: () => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    /** Drops past and future without touching the plan. */
+    clearHistory: () => void;
+    /** The floor being edited, and switching to another. */
+    getFloorId: () => string;
+    setFloorId: (floorId: string) => void;
+    /** Adds an empty storey above the current one and switches to it. Returns its id. */
+    addFloor: (options?: {
+        label?: string;
+    }) => string;
+    /** Copies the current storey, geometry and all, and switches to the copy. */
+    duplicateFloor: () => string | null;
+    /** Removes a storey. Refuses to remove the last one. */
+    removeFloor: (floorId?: string) => void;
+    renameFloor: (floorId: string, label: string) => void;
+    /** Moves a storey up or down the stack, re-stacking the elevations behind it. */
+    moveFloor: (floorId: string, toIndex: number) => void;
+    /** Storey height in millimetres. Everything above moves to suit. */
+    setFloorHeight: (floorId: string, heightMm: number) => void;
+    /**
+     * Removes every ruler measurement. They are view state, not plan data, so they never
+     * reach `onChange`, a file, or the undo stack.
+     */
+    clearMeasurements: () => void;
+    /** Writes the current plan to a JSON file, as the download button does. */
+    download: (fileName?: string) => void;
+    /**
+     * Reads JSON text as a plan and loads it, as one undoable entry. Returns what it made
+     * of the text: a `null` plan means nothing was loaded. Use it to accept a file from
+     * your own UI, a drop target, or a server.
+     */
+    loadJson: (text: string) => PlanParseResult;
+    /** Everything currently selected, in selection order. Empty when nothing is. */
+    getSelection: () => PlanSelection[];
+    /** Replaces the selection. A single entry or `null` is accepted for convenience. */
+    select: (selection: readonly PlanSelection[] | PlanSelection | null) => void;
+    /** Adds to, removes from, or toggles entries without replacing the rest. */
+    addToSelection: (selection: readonly PlanSelection[] | PlanSelection) => void;
+    toggleSelection: (entry: PlanSelection) => void;
+    selectAll: () => void;
+    /** Deletes everything selected, with the same rules as the Delete key. */
+    deleteSelection: () => void;
+    getView: () => PlanView;
+    setView: (view: PlanView) => void;
+    zoomBy: (factor: number) => void;
+    /** Fits the whole plan into the viewport. */
+    fitToContent: (options?: {
+        padding?: number;
+    }) => void;
+    /** Screen (client) coordinates to world, and back. */
+    toWorld: (clientX: number, clientY: number) => PlanPoint;
+    toScreen: (point: PlanPoint) => {
+        x: number;
+        y: number;
+    };
+    getSvgElement: () => SVGSVGElement | null;
+}
+export interface RoomDrawerProps extends Omit<HtmlProps<HTMLDivElement>, 'onChange' | 'onSelect' | 'defaultValue'> {
+    /** Controlled plan. Omit for uncontrolled. */
+    value?: FloorPlan;
+    /** Initial plan when uncontrolled. Defaults to an empty single-floor plan. */
+    defaultValue?: FloorPlan;
+    /**
+     * Fires for every mutation, including the intermediate values emitted during a drag
+     * (`meta.committed === false`), so a controlled parent renders live feedback. Mirrors
+     * `Slider`'s `onChange` / `onChangeEnd` pair.
+     */
+    onChange?: (plan: FloorPlan, meta: RoomDrawerChangeMeta) => void;
+    /** Fires once per completed gesture or discrete edit, always with `committed: true`. */
+    onChangeEnd?: (plan: FloorPlan, meta: RoomDrawerChangeMeta) => void;
+    /** Id of the floor being edited. Controlled; pair it with `onFloorChange`. */
+    floorId?: string;
+    /** Id of the floor to start on. Uncontrolled. Defaults to the lowest. */
+    defaultFloorId?: string;
+    onFloorChange?: (floorId: string) => void;
+    /** The floor tabs and their add button. Default `true`. */
+    showFloorBar?: boolean;
+    /**
+     * Trace the storey below behind the one being edited, so walls can be lined up between
+     * floors. Default `true`; the toolbar toggle can still turn it off.
+     */
+    showUnderlay?: boolean;
+    tool?: RoomDrawerTool;
+    defaultTool?: RoomDrawerTool;
+    onToolChange?: (tool: RoomDrawerTool) => void;
+    /** Restricts and orders the toolbar. Defaults to all six tools. */
+    tools?: RoomDrawerTool[];
+    /**
+     * Controlled selection. An array, because the drawer supports selecting several things
+     * at once; a single selection is a one-element array.
+     */
+    selection?: readonly PlanSelection[];
+    defaultSelection?: readonly PlanSelection[];
+    onSelectionChange?: (selection: PlanSelection[]) => void;
+    /**
+     * Allow selecting more than one thing, by Ctrl/Cmd-clicking or by dragging a marquee
+     * across empty canvas with the select tool. Default `true`.
+     */
+    multiSelect?: boolean;
+    onHoverChange?: (target: PlanSelection | null) => void;
+    view?: PlanView;
+    defaultView?: PlanView;
+    onViewChange?: (view: PlanView) => void;
+    /** Screen pixels per millimetre. */
+    minZoom?: number;
+    maxZoom?: number;
+    /** Fit the plan into the viewport on mount, and when it first becomes non-empty. */
+    fitOnMount?: boolean;
+    /** Grid spacing in millimetres (default 100, i.e. 10cm). */
+    gridSize?: number;
+    showGrid?: boolean;
+    /** Snap to the grid and to existing geometry. Alt inverts it for one gesture. */
+    snap?: boolean;
+    /**
+     * Latch angle lock on, so drawing is constrained to multiples of `constrainAngle`
+     * without holding Shift. Shift then momentarily RELEASES the lock. Default `false`.
+     */
+    angleLock?: boolean;
+    /** The angle step in degrees that angle lock snaps to (default 45). */
+    constrainAngle?: number;
+    /** Draw the construction lines explaining what the pointer snapped to (default `true`). */
+    showSnapGuides?: boolean;
+    /** Millimetres. Applied to newly drawn walls. */
+    wallThickness?: number;
+    wallHeight?: number;
+    /** Defaults for newly placed openings, per kind. */
+    openingDefaults?: Partial<Record<OpeningKind, {
+        width?: number;
+        sill?: number;
+        head?: number;
+    }>>;
+    showMeasurements?: boolean;
+    formatLength?: (lengthMm: number) => string;
+    formatArea?: (areaMm2: number) => string;
+    showToolbar?: boolean;
+    showInspector?: boolean;
+    showHint?: boolean;
+    showHistoryControls?: boolean;
+    /** Download and open buttons in the toolbar. Default `true`. */
+    showFileControls?: boolean;
+    /**
+     * Name for the downloaded file, with `.json` appended if it is missing. Defaults to the
+     * plan's own `name`, or `floor-plan.json`.
+     */
+    fileName?: string;
+    /**
+     * Fires after every file the user opens, whether it worked or not. `issues` is empty
+     * only for a file that needed no repair; see `planFromJson`. Without this the drawer
+     * still reports a bad file in its hint line.
+     */
+    onImport?: (result: PlanParseResult) => void;
+    /**
+     * `'internal'` keeps an undo stack inside the component. `'none'` disables it and
+     * hides the buttons, for a consumer that owns its own history.
+     */
+    historyMode?: 'internal' | 'none';
+    historyLimit?: number;
+    onHistoryChange?: (state: {
+        canUndo: boolean;
+        canRedo: boolean;
+    }) => void;
+    /** View and select, but no edits. */
+    readOnly?: boolean;
+    disabled?: boolean;
+    /** Height of the canvas, any CSS length. */
+    canvasHeight?: string;
+    getRoomColor?: (room: PlanRoom, area: number) => string | undefined;
+    renderRoomLabel?: (room: PlanRoom | null, context: {
+        area: number;
+        faceId: string;
+    }) => ReactNode;
+    labels?: RoomDrawerLabels;
+    icons?: RoomDrawerIcons;
+    'aria-label'?: string;
+    /** Imperative handle for driving the editor. */
+    ref?: Ref<RoomDrawerHandle>;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<RoomDrawerSlots>;
+    styles?: SlotStyles<RoomDrawerSlots>;
+}

package/dist/cjs-types/common/roomDrawer/usePlanHistory.d.ts

@@ -0,0 +1,24 @@
+import { FloorPlan } from '../floorPlan/index.js';
+import { RoomDrawerChangeReason } from './roomDrawer.types.js';
+export interface PlanHistory {
+    present: FloorPlan;
+    canUndo: boolean;
+    canRedo: boolean;
+    /** Stashes the current plan as the snapshot a later `endGesture` would restore to. */
+    beginGesture: () => void;
+    /** Replaces the present mid-gesture. Pushes nothing. */
+    updateGesture: (plan: FloorPlan) => void;
+    /** Pushes the stashed snapshot, if the gesture actually changed anything. */
+    endGesture: () => boolean;
+    /** Discards the gesture and restores the stashed snapshot. */
+    cancelGesture: () => FloorPlan | null;
+    /** A discrete edit: pushes and replaces atomically. */
+    commit: (plan: FloorPlan, reason: RoomDrawerChangeReason, targetIds?: string[]) => void;
+    /** Replaces the present without touching history, for an externally driven value. */
+    replace: (plan: FloorPlan) => void;
+    undo: () => FloorPlan | null;
+    redo: () => FloorPlan | null;
+    clearHistory: () => void;
+    isGestureActive: () => boolean;
+}
+export declare function usePlanHistory(initial: FloorPlan, limit?: number): PlanHistory;

package/dist/cjs-types/common/roomViewer/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './roomViewer.js';
+export * from './roomViewer.types.js';

package/dist/cjs-types/common/roomViewer/roomViewer.d.ts

@@ -0,0 +1,10 @@
+import { RoomViewerProps } from './roomViewer.types.js';
+/**
+ * Read-only view of a floor plan.
+ *
+ * It renders the same `planCanvas` the drawer does, from the same `FloorPlan`, so the
+ * two cannot drift apart. Selection and hover are React state rather than classes pushed
+ * onto DOM nodes, which is what lets them be controlled from outside.
+ */
+declare function RoomViewer(props: RoomViewerProps): import("react").JSX.Element;
+export default RoomViewer;

package/dist/cjs-types/common/roomViewer/roomViewer.types.d.ts

@@ -0,0 +1,91 @@
+import { CSSProperties, ReactNode, Ref } from 'react';
+import { DerivedRoom, FloorPlan, PlanRoom, PlanView } from '../floorPlan/index.js';
+import { IconContent } from '../types/icon.types.js';
+import { HtmlProps, SlotClassNames, SlotStyles } from '../types/slots.types.js';
+export type RoomViewerSlots = 'root' | 'floorBar' | 'floorTab' | 'canvasWrapper' | 'canvas' | 'grid' | 'rooms' | 'roomFill' | 'roomLabel' | 'walls' | 'wallBody' | 'openings' | 'opening' | 'viewControls' | 'viewButton' | 'empty';
+export interface RoomViewerLabels {
+    /** Accessible name for the floor strip. */
+    floors?: string;
+    zoomIn?: string;
+    zoomOut?: string;
+    fit?: string;
+    empty?: string;
+    /** Announced when a room is selected. `{name}` and `{area}` are replaced. */
+    selectedRoom?: string;
+    /** Announced when the selection is cleared. */
+    noRoomSelected?: string;
+}
+export interface RoomViewerIcons {
+    zoomIn?: IconContent;
+    zoomOut?: IconContent;
+    fit?: IconContent;
+}
+export interface RoomViewerHandle {
+    /** Fits the active floor into the viewport. */
+    fitToContent: (options?: {
+        padding?: number;
+    }) => void;
+    getView: () => PlanView;
+    setView: (view: PlanView) => void;
+    zoomBy: (factor: number) => void;
+    /** Selects a room, or clears the selection with `null`. */
+    select: (roomId: string | null) => void;
+    getFloorId: () => string | null;
+    setFloorId: (floorId: string) => void;
+    /** The live `<svg>`, for measuring or screenshotting. */
+    getSvgElement: () => SVGSVGElement | null;
+}
+export interface RoomViewerProps extends Omit<HtmlProps<HTMLDivElement>, 'onSelect'> {
+    /**
+     * The plan to display, floors and all. This replaces the old `data` prop, which took
+     * pre-rendered SVG: that could not be selected, measured or re-themed, and nothing
+     * could be shared with the drawer.
+     */
+    plan?: FloorPlan;
+    /** Which storey is showing. Controlled; pair with `onFloorChange`. */
+    activeFloorId?: string;
+    defaultActiveFloorId?: string;
+    onFloorChange?: (floorId: string) => void;
+    /** Controlled selection. `null` is a real value here: nothing selected. */
+    selectedRoomId?: string | null;
+    defaultSelectedRoomId?: string | null;
+    onSelect?: (roomId: string | null, room: DerivedRoom | null, floorId: string) => void;
+    hoveredRoomId?: string | null;
+    onHoverChange?: (roomId: string | null) => void;
+    view?: PlanView;
+    defaultView?: PlanView;
+    onViewChange?: (view: PlanView) => void;
+    /** Rooms respond to pointer and keyboard. Default `true`. */
+    interactive?: boolean;
+    /** Drag to pan, wheel and pinch to zoom. Default `true`. */
+    pannable?: boolean;
+    /** Fit the plan into view once it is measured. Default `true`. */
+    fitOnMount?: boolean;
+    showFloorBar?: boolean;
+    showViewControls?: boolean;
+    showGrid?: boolean;
+    showRoomLabels?: boolean;
+    /** Door leaves, swing arcs and window symbols. Default `true`. */
+    showOpeningSymbols?: boolean;
+    getRoomColor?: (room: PlanRoom, area: number) => string | undefined;
+    renderRoomLabel?: (room: PlanRoom | null, context: {
+        area: number;
+        faceId: string;
+    }) => ReactNode;
+    getRoomLabel?: (room: PlanRoom | null, context: {
+        area: number;
+    }) => string;
+    formatArea?: (areaMm2: number) => string;
+    /** Canvas height. A number is pixels. Default 360. */
+    height?: number | string;
+    /** Shown when there is no plan, or the plan has nothing in it. */
+    emptyState?: ReactNode;
+    labels?: RoomViewerLabels;
+    icons?: RoomViewerIcons;
+    /** Imperative handle for driving the viewport. */
+    ref?: Ref<RoomViewerHandle>;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<RoomViewerSlots>;
+    styles?: SlotStyles<RoomViewerSlots>;
+}

package/dist/cjs-types/common/scrollFade/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './scrollFade.js';
+export * from './scrollFade.types.js';

package/dist/cjs-types/common/scrollFade/scrollFade.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { ScrollFadeProps } from './scrollFade.types.js';
+declare function ScrollFade({ children, axis, fadeLength, isAlwaysFaded, className, style, ref, ...rest }: ScrollFadeProps): ReactElement;
+export default ScrollFade;

package/dist/cjs-types/common/scrollFade/scrollFade.types.d.ts

@@ -0,0 +1,20 @@
+import { CSSProperties, ReactNode, Ref } from 'react';
+import { HtmlProps } from '../types/slots.types.js';
+export declare enum ScrollFadeAxis {
+    Vertical = "vertical",
+    Horizontal = "horizontal"
+}
+export interface ScrollFadeProps extends HtmlProps<HTMLDivElement> {
+    /** The scrolling content. */
+    children?: ReactNode;
+    /** Which way it scrolls. Default `ScrollFadeAxis.Vertical`. */
+    axis?: ScrollFadeAxis;
+    /** How far the fade runs from each edge, any CSS length. Default `24px`. */
+    fadeLength?: string;
+    /** Fade both ends whether or not content is hidden there. Default `false`. */
+    isAlwaysFaded?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    /** The scrolling element itself. */
+    ref?: Ref<HTMLDivElement>;
+}

package/dist/cjs-types/common/scrollbarProvider/index.d.ts

@@ -0,0 +1,2 @@
+import { default as ScrollbarProvider } from './scrollbarProvider.js';
+export default ScrollbarProvider;

package/dist/cjs-types/common/scrollbarProvider/scrollbarProvider.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+interface Properties {
+    className?: string | undefined;
+    children?: React.ReactNode | undefined;
+}
+declare function ScrollbarProvider({ className, children }: Properties): ReactElement;
+export default ScrollbarProvider;

package/dist/cjs-types/common/searchInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './searchInput.js';
+export * from './searchInput.types.js';

package/dist/cjs-types/common/searchInput/searchInput.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+import { SearchInputProps } from './searchInput.types.js';
+export default function SearchInput({ value, onChange, onDebounce, placeholder, label, debounceMs, totalAmount, showAmount, className, width, style, classNames, styles: slotStyles, labels, ref, ...rest }: SearchInputProps): ReactElement;

package/dist/cjs-types/common/searchInput/searchInput.types.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type SearchInputSlots = 'root' | 'input' | 'resultCount';
+/** Text SearchInput renders of its own, for translating it. */
+export interface SearchInputLabels {
+    /** The result count, given the number (default `12 results`). */
+    results?: (count: number) => string;
+}
+export interface SearchInputProps extends Omit<HtmlProps, 'onChange'> {
+    value: string;
+    onChange: (value: string) => void;
+    onDebounce?: (value: string) => void;
+    placeholder?: string;
+    label?: string;
+    debounceMs?: number;
+    totalAmount?: number;
+    showAmount?: boolean;
+    className?: string;
+    width?: number | string;
+    /** Classes for the inner elements. See `SearchInputSlots`. */
+    classNames?: SlotClassNames<SearchInputSlots>;
+    /** Inline styles for the inner elements. See `SearchInputSlots`. */
+    styles?: SlotStyles<SearchInputSlots>;
+    /** Overrides the text SearchInput renders of its own. Merged per key. */
+    labels?: SearchInputLabels;
+    /** Ref to the inner `<input>`, for focusing the field. */
+    ref?: React.Ref<HTMLInputElement>;
+}

package/dist/cjs-types/common/sectionHeader/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './sectionHeader.js';
+export * from './sectionHeader.types.js';

package/dist/cjs-types/common/sectionHeader/sectionHeader.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { SectionHeaderProps } from './sectionHeader.types.js';
+declare function SectionHeader(props: SectionHeaderProps): ReactElement;
+export default SectionHeader;

package/dist/cjs-types/common/sectionHeader/sectionHeader.types.d.ts

@@ -0,0 +1,27 @@
+import { CSSProperties, ReactNode } from 'react';
+import { IconContent } from '../types/icon.types.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+import { IconAction } from '../types/actions.types.js';
+export declare enum SectionHeaderSize {
+    Small = "small",
+    Medium = "medium",
+    Large = "large"
+}
+export type SectionHeaderAction = IconAction;
+export type SectionHeaderSlots = 'root' | 'identity' | 'leading' | 'titles' | 'title' | 'subtitle' | 'trailing' | 'left' | 'center' | 'actions';
+export interface SectionHeaderProps extends Omit<HtmlProps, 'title'> {
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    icon?: IconContent;
+    thumbnail?: string | ReactNode;
+    left?: ReactNode;
+    center?: ReactNode;
+    actions?: SectionHeaderAction[] | ReactNode;
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    size?: SectionHeaderSize;
+    divider?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<SectionHeaderSlots>;
+    styles?: SlotStyles<SectionHeaderSlots>;
+}

package/dist/cjs-types/common/sheetBackdrop/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './sheetBackdrop.js';
+export * from './sheetBackdrop.types.js';

package/dist/cjs-types/common/sheetBackdrop/sheetBackdrop.d.ts

@@ -0,0 +1,16 @@
+import { SheetBackdropProps } from './sheetBackdrop.types.js';
+/**
+ * The dimmed layer behind a bottom sheet, and the thing that closes it when tapped.
+ *
+ * It closes on its own `click` rather than letting the sheet's usual outside-click handling see
+ * the press, because that handling fires on mousedown/mouseup — and the sheet, backdrop included,
+ * unmounts the moment it closes. The browser then dispatches the `click` that completes the tap
+ * at whatever is under the cursor by then, which is the page behind the sheet: tapping to dismiss
+ * would also press a button underneath it.
+ *
+ * The press is stopped with native listeners rather than React's `stopPropagation`, which would
+ * not be enough: React listens at its own root container, so a native handler on `document` or
+ * `window` still runs afterwards.
+ */
+declare function SheetBackdrop({ onClose, className, style }: SheetBackdropProps): import("react").JSX.Element;
+export default SheetBackdrop;

package/dist/cjs-types/common/sheetBackdrop/sheetBackdrop.types.d.ts

@@ -0,0 +1,7 @@
+import { CSSProperties } from 'react';
+export interface SheetBackdropProps {
+    /** Called when the backdrop itself is clicked or tapped. */
+    onClose: () => void;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/cjs-types/common/skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './skeleton.js';
+export * from './skeleton.types.js';

package/dist/cjs-types/common/skeleton/skeleton.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { SkeletonProps } from './skeleton.types.js';
+declare function Skeleton(props: SkeletonProps): ReactElement;
+export default Skeleton;

package/dist/cjs-types/common/skeleton/skeleton.types.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export declare enum SkeletonVariant {
+    Text = "text",
+    Circle = "circle",
+    Rectangular = "rectangular"
+}
+export declare enum SkeletonAnimation {
+    Shimmer = "shimmer",
+    Pulse = "pulse",
+    None = "none"
+}
+export type SkeletonSlots = 'line';
+export interface SkeletonProps extends HtmlProps {
+    variant?: SkeletonVariant;
+    animation?: SkeletonAnimation;
+    lines?: number;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<SkeletonSlots>;
+    styles?: SlotStyles<SkeletonSlots>;
+}

package/dist/cjs-types/common/slider/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './slider.js';
+export * from './slider.types.js';

package/dist/cjs-types/common/slider/slider.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+import { SliderProps } from './slider.types.js';
+export default function Slider(props: SliderProps): ReactElement;