@deadragdoll/reactnu 0.1.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 code4bones
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# ReactNU
+
+`@deadragdoll/reactnu` is a nostalgic React and TypeScript component library
+inspired by Norton Utilities 6.0 — a tribute to a beautiful era of precise,
+purposeful DOS utility software. It brings that crisp, high-contrast language
+to modern, dense, keyboard-friendly desktop-style interfaces: panels, windows,
+menus, dialogs, data controls, and application chrome.
+
+## Install
+
+```bash
+npm install @deadragdoll/reactnu react react-dom
+```
+
+ReactNU requires React 19 and React DOM 19. Import the stylesheet once in your
+application entry point:
+
+```tsx
+import "@deadragdoll/reactnu/styles.css";
+```
+
+## Quick Start
+
+```tsx
+import { Button, NuThemeProvider } from "@deadragdoll/reactnu";
+import "@deadragdoll/reactnu/styles.css";
+
+export function App() {
+  return (
+    <NuThemeProvider>
+      <Button variant="primary">Run diagnostics</Button>
+    </NuThemeProvider>
+  );
+}
+```
+
+For a full desktop shell with managed windows, start with `NuThemeProvider` and
+`NuDesktop`; `NuDesktop` provides the application-host and window-manager
+layers internally. The [Getting Started guide](./docs/GETTING_STARTED.md) shows
+the recommended composition.
+
+## Architecture: Desktop First
+
+ReactNU is organized around a desktop shell, rather than a collection of
+unrelated controls. `NuDesktop` is the top-level application surface: it owns
+the screen geometry and composes the application-menu and managed-window
+layers internally.
+
+```text
+NuThemeProvider
+└─ NuDesktop
+   ├─ Main menu (host-provided through the app host)
+   └─ NuWindowProvider
+      ├─ Workspace content: panels, views, forms, lists, trees
+      ├─ App bar: host-provided status and window controls
+      └─ Managed windows and dialogs
+```
+
+Place your normal application UI in `NuDesktop`'s children. Use
+`useNuWindowManager()` anywhere below it to open managed `Window` and dialog
+surfaces. For an embedded or bounded area that needs windows but not a full
+desktop, use `NuWindowProvider` directly.
+
+## Documentation
+
+This package includes the complete Markdown documentation set:
+
+- [Getting Started](./docs/GETTING_STARTED.md)
+- [API Reference](./docs/API_REFERENCE.md)
+- [Component Index](./docs/COMPONENT_INDEX.md)
+- [Architecture](./docs/ARCHITECTURE.md)
+- [Theme Provider](./docs/NuThemeProvider.md)
+- [Window Provider](./docs/NuWindowProvider.md)
+- [Storybook guidance](./docs/STORYBOOK.md)
+
+Each public component has a dedicated page in [`docs/`](./docs/).
+
+## Components
+
+### Providers and desktop shell
+
+- `NuThemeProvider` — supplies themes, typography, desktop pattern, and theme context.
+- `NuDesktop` — fullscreen desktop shell with workspace and app-bar regions.
+- `NuAppHostProvider` — owns application-level main-menu state.
+- `NuWindowProvider` — manages windows, dialogs, modal state, and window-manager hooks.
+- `Dashboard` — static grid or lane-based workspace layout.
+
+### Actions and input
+
+- `Button` — primary DOS-style action button.
+- `CommandButton` — compact command button with optional icon and popup menu.
+- `CheckBox` — controlled or uncontrolled checkbox with mnemonic labels.
+- `RadioGroup` and `RadioButton` — grouped single-choice controls.
+- `TextField` — basic labelled text input with optional debounced change handling.
+- `MaskedField` — text input constrained by a display/edit mask.
+- `Memo` — multi-line text editor.
+- `SpinBox` — numeric input with increment and decrement controls.
+- `TickBar` — keyboard and pointer-accessible slider with tick marks.
+- `Dropdown` — non-editable selection field with a popup list.
+- `ComboBox` — editable, locally filtered selection field.
+- `SearchBox` — async search and result-selection control.
+- `ProgressBar` — determinate or indeterminate progress indicator.
+- `Info` and `InfoAccent` — informational text and inline emphasis.
+
+### Data, navigation, and layout
+
+- `ListBox` — grouped or flat selectable list with optional checkboxes.
+- `ListView` — report-style, column-based data list.
+- `TreeView` — hierarchical tree with keyboard navigation and connector lines.
+- `TreeListView` — tree hierarchy combined with report columns.
+- `PropertyGrid` — hierarchical settings and inspector surface.
+- `PageControl` and `Tabs` — keyboard-navigable tabbed pages.
+- `ToolBar`, `ToolButton`, `ToolDropButton`, and `ToolSeparator` — compact command strip primitives.
+- `Stack` — small flexbox layout helper.
+- `Splitter` — resizable pane layout.
+- `NuView` — scroll-owning content pane.
+- `Panel` — raised primary application surface.
+- `Frame` — bordered container with optional title chrome.
+- `ReportCell` — aligned and toned report-column content helper.
+
+### Menus, windows, and desktop chrome
+
+- `MainMenu` — classic nested application menu bar.
+- `PopupMenu` and `usePopupMenu` — anchored/context popup menu and its state helper.
+- `Window` — draggable, resizable window or dialog chrome.
+- `WindowTitleButton` and `useWindowTitleButtons` — custom title-bar actions.
+- `StatusBarItem` — placement helper for window status bars.
+- `AppBarHost` and `AppBarItem` — bottom desktop-bar container and item primitive.
+- `WindowBar` — app-bar representation of managed windows.
+- `useNuWindowManager` — opens, updates, activates, and closes managed windows and helper dialogs.
+- `useAppHostMenu` and `useWindowMenu` — access desktop and window menu state.
+
+### Visual utilities
+
+- `NuGlyph` — consistent glyph/icon primitive for interface symbols.
+- `NuCrtGlitch` — opt-in, ambient CRT-fault effect.
+- `nuThemes`, `resolveNuTheme`, `isNuThemeName`, and `useNuTheme` — theme definitions and helpers.
+
+## Design Principles
+
+- sharp, high-contrast DOS-style geometry
+- visible focus and keyboard-first interactions
+- provider-owned themes and typography
+- body portals with viewport positioning for popups
+- host-owned desktop, menu, and window workflow composition
+
+## Package Contents
+
+- `dist/` — ESM, CommonJS, type declarations, and stylesheet
+- `docs/` — component, architecture, and integration documentation
+- `README.md` and `LICENSE`

package/dist/appHost/NuAppHostProvider.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from "react";
+type NuAppHostProviderProps = PropsWithChildren<{
+    renderMenu?: boolean;
+}>;
+export declare function NuAppHostProvider({ children, renderMenu }: NuAppHostProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/appHost/appHostContext.d.ts

@@ -0,0 +1,26 @@
+import { MainMenuStateValue } from "../components/MainMenu";
+import { NuMdiMenuBridge } from "../windowing/windowContext";
+type AppHostMenuContextValue = MainMenuStateValue & {
+    setWindowBridge: (bridge: NuMdiMenuBridge | null) => void;
+    windowBridge: NuMdiMenuBridge | null;
+};
+export declare const AppHostMenuContext: import("react").Context<AppHostMenuContextValue | null>;
+export declare function useAppHostMenu(): {
+    mainMenu: import("..").MainMenuNode[];
+    setMainMenu: import("react").Dispatch<import("react").SetStateAction<import("..").MainMenuNode[]>>;
+    setMenuItem: (id: string, patch: import("..").MainMenuItemPatch) => void;
+    setMenuFlags: (id: string, flags: import("..").MainMenuFlags) => void;
+    setMenuDisabled: (id: string, disabled: boolean) => void;
+    enableMenuItem: (id: string) => void;
+    disableMenuItem: (id: string) => void;
+    setMenuHidden: (id: string, hidden: boolean) => void;
+    showMenuItem: (id: string) => void;
+    hideMenuItem: (id: string) => void;
+    setMenuChecked: (id: string, checked: boolean) => void;
+    checkMenuItem: (id: string) => void;
+    uncheckMenuItem: (id: string) => void;
+    toggleMenuChecked: (id: string) => void;
+    setMenuCheckable: (id: string, checkable: boolean) => void;
+    setSubmenuTree: (id: string, items: import("..").MainMenuNode[]) => void;
+};
+export {};

package/dist/components/Button/Button.d.ts

@@ -0,0 +1,13 @@
+import { ButtonHTMLAttributes, PropsWithChildren } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+type ButtonVariant = "primary" | "secondary" | "danger" | "success";
+export type ButtonSlot = "root" | "face" | "label" | "focusIndicatorLeft" | "focusIndicatorRight" | "shadowRight" | "shadowBottom";
+export type ButtonProps = PropsWithChildren<ButtonHTMLAttributes<HTMLButtonElement> & {
+    defaultFocused?: boolean;
+    focused?: boolean;
+    slotClassNames?: SlotCustomizationProps<ButtonSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<ButtonSlot>["slotStyles"];
+    variant?: ButtonVariant;
+}>;
+export declare function Button({ children, className, defaultFocused, disabled, focused, onBlur, onClick, onFocus, slotClassNames, slotStyles, type, variant, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Button/index.d.ts

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

package/dist/components/CheckBox/CheckBox.d.ts

@@ -0,0 +1,14 @@
+import { ChangeEvent, InputHTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type CheckBoxSlot = "root" | "main" | "input" | "control" | "box" | "mark" | "label" | "hint";
+export type CheckBoxProps = Omit<InputHTMLAttributes<HTMLInputElement>, "checked" | "defaultChecked" | "onChange" | "type"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    hint?: string;
+    label: string;
+    onCheckedChange?: (checked: boolean, event: ChangeEvent<HTMLInputElement>) => void;
+    slotClassNames?: SlotCustomizationProps<CheckBoxSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<CheckBoxSlot>["slotStyles"];
+    uncheckedShape?: "box" | "none";
+};
+export declare function CheckBox({ checked, className, defaultChecked, disabled, hint, id, label, onCheckedChange, slotClassNames, slotStyles, uncheckedShape, ...props }: CheckBoxProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/CheckBox/index.d.ts

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

package/dist/components/ComboBox/ComboBox.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+import { ListBoxGroup, ListBoxItem } from "../ListBox/internals/types";
+export type ComboBoxSlot = "root" | "label" | "slot" | "field" | "bracket" | "inputShell" | "input" | "toggle" | "popup" | "listbox" | "hint";
+type ComboBoxChangeHandler = (value: string, item: ListBoxItem, group: ListBoxGroup) => void;
+type ComboBoxInputChangeHandler = (value: string) => void;
+export type ComboBoxProps = Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> & {
+    data: ListBoxGroup[];
+    defaultInputValue?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    hint?: string;
+    inputValue?: string;
+    label: string;
+    onInputValueChange?: ComboBoxInputChangeHandler;
+    onValueChange?: ComboBoxChangeHandler;
+    placeholder?: string;
+    slotClassNames?: SlotCustomizationProps<ComboBoxSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<ComboBoxSlot>["slotStyles"];
+    value?: string;
+};
+export declare function ComboBox({ className, data, defaultInputValue, defaultValue, disabled, hint, inputValue: inputValueProp, label, onInputValueChange, onValueChange, placeholder, slotClassNames, slotStyles, style, value, ...props }: ComboBoxProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ComboBox/index.d.ts

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

package/dist/components/CommandButton/CommandButton.d.ts

@@ -0,0 +1,17 @@
+import { ButtonHTMLAttributes, PropsWithChildren, ReactNode } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+import { type NuGlyphName } from "../Glyph";
+import { MainMenuItem, MainMenuNode } from "../MainMenu/MainMenu.types";
+export type CommandButtonSlot = "root" | "icon" | "label" | "caret";
+export type CommandButtonProps = PropsWithChildren<ButtonHTMLAttributes<HTMLButtonElement> & {
+    dropdown?: boolean;
+    icon?: NuGlyphName | ReactNode;
+    menuItems?: MainMenuNode[];
+    onMenuItemSelect?: (item: MainMenuItem) => void;
+    pressed?: boolean;
+    slotClassNames?: SlotCustomizationProps<CommandButtonSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<CommandButtonSlot>["slotStyles"];
+    toggled?: boolean;
+    uncheckedShape?: "box" | "none";
+}>;
+export declare function CommandButton({ children, className, dropdown, icon, menuItems, onClick, onMenuItemSelect, pressed, slotClassNames, slotStyles, toggled, type, uncheckedShape, ...props }: CommandButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/CommandButton/index.d.ts

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

package/dist/components/CrtGlitch/CrtGlitch.d.ts

@@ -0,0 +1,23 @@
+export type NuCrtGlitchProps = {
+    /** Average gap between glitch pulses, in ms. */
+    intervalMs?: number;
+    /** How long a single glitch pulse lasts, in ms. */
+    durationMs?: number;
+    /** When false, no pulses fire (filter defs stay mounted, inert). */
+    enabled?: boolean;
+    /**
+     * CSS selector for the pool of candidate elements, scoped under an open
+     * (non-minimized) window. Defaults to small leaf controls (buttons,
+     * checkboxes, icons, rows) rather than whole windows — a single control
+     * twitching in peripheral vision reads as a real fault; a whole window
+     * warping reads as a demo effect.
+     */
+    targetSelector?: string;
+    /**
+     * Fraction of pulses (0-1) that target a whole open window instead of a
+     * small leaf control from `targetSelector`. Falls back to the other pool
+     * when the chosen one has no candidates (e.g. no windows open).
+     */
+    topLevelRatio?: number;
+};
+export declare function NuCrtGlitch({ intervalMs, durationMs, enabled, targetSelector, topLevelRatio }: NuCrtGlitchProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/CrtGlitch/index.d.ts

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

package/dist/components/Dashboard/Dashboard.d.ts

@@ -0,0 +1,25 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from "react";
+export type DashboardItem = {
+    alignSelf?: CSSProperties["alignSelf"];
+    column?: string;
+    columnSpan?: number;
+    content: ReactNode;
+    id: string | number;
+    justifySelf?: CSSProperties["justifySelf"];
+    lane?: number;
+    maxWidth?: string;
+    minHeight?: string;
+    minWidth?: string;
+    row?: string;
+    rowSpan?: number;
+    width?: string;
+};
+export type DashboardProps = HTMLAttributes<HTMLDivElement> & {
+    columnCount?: number;
+    fill?: boolean;
+    gap?: number | string;
+    items: DashboardItem[];
+    layout?: "grid" | "lanes";
+    laneCount?: number;
+};
+export declare function Dashboard({ className, columnCount, fill, gap, items, layout, laneCount, style, ...props }: DashboardProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Dashboard/index.d.ts

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

package/dist/components/Desktop/Desktop.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes, PropsWithChildren, ReactNode } from "react";
+export type NuDesktopProps = PropsWithChildren<HTMLAttributes<HTMLDivElement> & {
+    appBar?: ReactNode;
+    appBarContent?: ReactNode;
+}>;
+export declare function NuDesktop({ appBar, appBarContent, children, className, ...props }: NuDesktopProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Desktop/index.d.ts

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

package/dist/components/Dropdown/Dropdown.d.ts

@@ -0,0 +1,19 @@
+import { HTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+import { ListBoxGroup, ListBoxItem } from "../ListBox/internals/types";
+export type DropdownSlot = "root" | "label" | "trigger" | "slot" | "field" | "bracket" | "valueShell" | "value" | "arrowShell" | "arrow" | "hint" | "popup" | "popupShell" | "listbox";
+type DropdownChangeHandler = (value: string, item: ListBoxItem, group: ListBoxGroup) => void;
+export type DropdownProps = Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> & {
+    data: ListBoxGroup[];
+    defaultValue?: string;
+    disabled?: boolean;
+    hint?: string;
+    label: string;
+    onValueChange?: DropdownChangeHandler;
+    placeholder?: string;
+    slotClassNames?: SlotCustomizationProps<DropdownSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<DropdownSlot>["slotStyles"];
+    value?: string;
+};
+export declare function Dropdown({ className, data, defaultValue, disabled, hint, label, onValueChange, placeholder, slotClassNames, slotStyles, value, style, ...props }: DropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Dropdown/index.d.ts

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

package/dist/components/Frame/Frame.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties, HTMLAttributes, PropsWithChildren, ReactNode } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type FrameTitleProps = {
+    background?: CSSProperties["background"];
+    borderColor?: CSSProperties["borderColor"];
+    color?: CSSProperties["color"];
+};
+export type FrameSlot = "root" | "title" | "titleStart" | "titleContent" | "titleEnd" | "body";
+export type FrameProps = PropsWithChildren<HTMLAttributes<HTMLDivElement> & {
+    contentStyle?: CSSProperties;
+    fill?: boolean;
+    slotClassNames?: SlotCustomizationProps<FrameSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<FrameSlot>["slotStyles"];
+    title?: string;
+    titleContent?: ReactNode;
+    titleEnd?: ReactNode;
+    titleProps?: FrameTitleProps;
+    titleStart?: ReactNode;
+    titleStyle?: CSSProperties;
+    variant?: "outline" | "title-bar";
+    titleAlign?: "start" | "center" | "end";
+    titleBold?: boolean;
+}>;
+export declare function Frame({ children, className, contentStyle, fill, slotClassNames, slotStyles, title, titleContent, titleEnd, titleAlign, titleBold, titleProps, titleStart, titleStyle, variant, ...props }: FrameProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Frame/index.d.ts

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

package/dist/components/Glyph/NuGlyph.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from "react";
+export type NuGlyphName = "check-fill" | "check-mark" | "dropdown-arrow" | "folder" | "gear" | "radio-fill" | "radio-ring" | "star" | "tree-caret-down" | "tree-caret-right" | "window-close" | "window-maximize" | "window-minimize" | "window-resize" | "window-restore";
+export type NuGlyphProps = Omit<HTMLAttributes<HTMLSpanElement>, "children"> & {
+    name: NuGlyphName;
+};
+export declare function NuGlyph({ className, name, ...props }: NuGlyphProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Glyph/index.d.ts

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

package/dist/components/Info/Info.d.ts

@@ -0,0 +1,13 @@
+import { CSSProperties, HTMLAttributes } from "react";
+export type InfoProps = HTMLAttributes<HTMLDivElement> & {
+    accentColor?: CSSProperties["color"];
+    fill?: boolean;
+};
+export type InfoAccentProps = HTMLAttributes<HTMLSpanElement> & {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    upper?: boolean;
+};
+export declare function Info({ accentColor, children, className, fill, style, ...props }: InfoProps): import("react/jsx-runtime").JSX.Element;
+export declare function InfoAccent({ bold, children, className, italic, style, underline, upper, ...props }: InfoAccentProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Info/index.d.ts

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

package/dist/components/ListBox/ListBox.d.ts

@@ -0,0 +1,23 @@
+import { ForwardedRef, HTMLAttributes, RefAttributes } from "react";
+import { ListBoxGroup, ListBoxItem } from "./internals/types";
+export type { ListBoxCategory, ListBoxGroup, ListBoxItem, ListBoxLabel } from "./internals/types";
+export type ListBoxHandle = {
+    activateItem: (itemId: string) => void;
+    focus: () => void;
+    getActiveItemId: () => string | null;
+    scrollToItem: (itemId: string) => void;
+    toggleItemCheck: (itemId: string) => void;
+};
+export type ListBoxProps = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    data: ListBoxGroup[];
+    checkedIds?: string[];
+    emptyText?: string;
+    onItemCheckChange?: (item: ListBoxItem, group: ListBoxGroup, checked: boolean) => void;
+    onItemDoubleClick?: (item: ListBoxItem, group: ListBoxGroup) => void;
+    rightCheckBox?: boolean;
+    selectedId?: string;
+    uncheckedShape?: "box" | "none";
+    onItemSelect?: (item: ListBoxItem, group: ListBoxGroup) => void;
+};
+declare function ListBoxInner({ className, data, checkedIds, emptyText, onItemCheckChange, onItemDoubleClick, onItemSelect, rightCheckBox, selectedId, uncheckedShape, ...props }: ListBoxProps, ref: ForwardedRef<ListBoxHandle>): import("react/jsx-runtime").JSX.Element;
+export declare const ListBox: (props: ListBoxProps & RefAttributes<ListBoxHandle>) => ReturnType<typeof ListBoxInner>;

package/dist/components/ListBox/index.d.ts

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

package/dist/components/ListBox/internals/ListBoxCategoryView.d.ts

@@ -0,0 +1,6 @@
+import { ListBoxCategory } from "./types";
+type ListBoxCategoryViewProps = {
+    category: ListBoxCategory;
+};
+export declare function ListBoxCategoryView({ category }: ListBoxCategoryViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ListBox/internals/ListBoxCheckControl.d.ts

@@ -0,0 +1,8 @@
+type ListBoxCheckControlProps = {
+    isChecked: boolean;
+    onActivate: () => void;
+    onToggleCheck: () => void;
+    uncheckedShape: "box" | "none";
+};
+export declare function ListBoxCheckControl({ isChecked, onActivate, onToggleCheck, uncheckedShape }: ListBoxCheckControlProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ListBox/internals/ListBoxGroupView.d.ts

@@ -0,0 +1,17 @@
+import { ListBoxGroup, ListBoxItem } from "./types";
+type ListBoxGroupViewProps = {
+    group: ListBoxGroup;
+    groupIndex: number;
+    isItemChecked: (item: ListBoxItem) => boolean;
+    listboxId: string;
+    onActivateItem: (item: ListBoxItem, group: ListBoxGroup, itemId: string) => void;
+    onDoubleClickItem?: (item: ListBoxItem, group: ListBoxGroup) => void;
+    onToggleItemCheck: (itemId: string) => void;
+    registerItemRef: (itemId: string, node: HTMLDivElement | null) => void;
+    resolvedActiveId: string | null;
+    rightCheckBox: boolean;
+    selectedId?: string;
+    uncheckedShape: "box" | "none";
+};
+export declare function ListBoxGroupView({ group, groupIndex, isItemChecked, listboxId, onActivateItem, onDoubleClickItem, onToggleItemCheck, registerItemRef, resolvedActiveId, rightCheckBox, selectedId, uncheckedShape }: ListBoxGroupViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ListBox/internals/ListBoxItemView.d.ts

@@ -0,0 +1,18 @@
+import { ListBoxGroup, ListBoxItem } from "./types";
+type ListBoxItemViewProps = {
+    group: ListBoxGroup;
+    isActive: boolean;
+    isChecked: boolean;
+    isSelected: boolean;
+    item: ListBoxItem;
+    itemId: string;
+    onActivate: (item: ListBoxItem, group: ListBoxGroup, itemId: string) => void;
+    onDoubleClick?: (item: ListBoxItem, group: ListBoxGroup) => void;
+    onToggleCheck: (itemId: string) => void;
+    registerItemRef: (itemId: string, node: HTMLDivElement | null) => void;
+    rightCheckBox: boolean;
+    uncheckedShape: "box" | "none";
+};
+declare function ListBoxItemViewInner({ group, isActive, isChecked, isSelected, item, itemId, onActivate, onDoubleClick, onToggleCheck, registerItemRef, rightCheckBox, uncheckedShape }: ListBoxItemViewProps): import("react/jsx-runtime").JSX.Element;
+export declare const ListBoxItemView: import("react").MemoExoticComponent<typeof ListBoxItemViewInner>;
+export {};

package/dist/components/ListBox/internals/helpers.d.ts

@@ -0,0 +1,5 @@
+import { FlattenedListBoxItem, ListBoxGroup, ListBoxItem } from "./types";
+export declare function buildListBoxItemId(listboxId: string, group: ListBoxGroup, groupIndex: number, item: ListBoxItem, itemIndex: number): string;
+export declare function flattenListBoxData(data: ListBoxGroup[], listboxId: string): FlattenedListBoxItem[];
+export declare function getInitialActiveId(selectableItems: FlattenedListBoxItem[], selectedId?: string): string;
+export declare function getListBoxItemChecked(item: ListBoxItem, checkedIds?: string[]): boolean;

package/dist/components/ListBox/internals/renderLabel.d.ts

@@ -0,0 +1,2 @@
+import { ListBoxLabel } from "./types";
+export declare function renderLabel(label: ListBoxLabel, className: string): import("react/jsx-runtime").JSX.Element;

package/dist/components/ListBox/internals/types.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from "react";
+export type ListBoxLabel = {
+    text: string;
+    icon?: ReactNode;
+};
+export type ListBoxCategory = ListBoxLabel & {
+    className?: string;
+};
+export type ListBoxItem = {
+    id?: string;
+    name: ListBoxLabel;
+    details?: ReactNode;
+    className?: string;
+    checkable?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    selected?: boolean;
+};
+export type ListBoxGroup = {
+    category: ListBoxCategory | null;
+    items: ListBoxItem[];
+};
+export type FlattenedListBoxItem = {
+    group: ListBoxGroup;
+    item: ListBoxItem;
+    itemId: string;
+};

package/dist/components/ListView/ListView.d.ts

@@ -0,0 +1,27 @@
+import { ForwardedRef, HTMLAttributes, RefAttributes } from "react";
+import { ListViewColumn, ListViewRowBase } from "./internals/types";
+export type { ListViewColumn, ListViewRowBase } from "./internals/types";
+export type ListViewHandle = {
+    activateRow: (rowId: string) => void;
+    focus: () => void;
+    getActiveRowId: () => string | null;
+    scrollToRow: (rowId: string) => void;
+    toggleRowCheck: (rowId: string) => void;
+};
+export type ListViewProps<T extends ListViewRowBase> = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    activeRowId?: string;
+    checkedIds?: string[];
+    columns: ListViewColumn<T>[];
+    data: T[];
+    defaultActiveRowId?: string;
+    emptyText?: string;
+    onActiveRowChange?: (row: T) => void;
+    onRowCheckChange?: (row: T, checked: boolean) => void;
+    onRowDoubleClick?: (row: T) => void;
+    onRowSelect?: (row: T) => void;
+    selectedId?: string;
+    showCheckBox?: boolean;
+    uncheckedShape?: "box" | "none";
+};
+declare function ListViewInner<T extends ListViewRowBase>({ activeRowId: activeRowIdProp, checkedIds, className, columns, data, defaultActiveRowId, emptyText, onActiveRowChange, onRowCheckChange, onRowDoubleClick, onRowSelect, selectedId, showCheckBox, uncheckedShape, ...props }: ListViewProps<T>, ref: ForwardedRef<ListViewHandle>): import("react/jsx-runtime").JSX.Element;
+export declare const ListView: <T extends ListViewRowBase>(props: ListViewProps<T> & RefAttributes<ListViewHandle>) => ReturnType<typeof ListViewInner>;

package/dist/components/ListView/index.d.ts

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

package/dist/components/ListView/internals/ListViewCheckControl.d.ts

@@ -0,0 +1,8 @@
+type ListViewCheckControlProps = {
+    isChecked: boolean;
+    onActivate: () => void;
+    onToggleCheck: () => void;
+    uncheckedShape: "box" | "none";
+};
+export declare function ListViewCheckControl({ isChecked, onActivate, onToggleCheck, uncheckedShape }: ListViewCheckControlProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ListView/internals/ListViewRow.d.ts

@@ -0,0 +1,18 @@
+import { ListViewColumn, ListViewRowBase } from "./types";
+type ListViewRowProps<T extends ListViewRowBase> = {
+    columns: ListViewColumn<T>[];
+    isActive: boolean;
+    isChecked: boolean;
+    isSelected: boolean;
+    onActivate: (rowId: string) => void;
+    onDoubleClick?: (row: T) => void;
+    onToggleCheck: (rowId: string) => void;
+    registerRowRef: (rowId: string, node: HTMLDivElement | null) => void;
+    row: T;
+    showCheckBox: boolean;
+    templateColumns: string;
+    uncheckedShape: "box" | "none";
+};
+declare function ListViewRowInner<T extends ListViewRowBase>({ columns, isActive, isChecked, isSelected, onActivate, onDoubleClick, onToggleCheck, registerRowRef, row, showCheckBox, templateColumns, uncheckedShape }: ListViewRowProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const ListViewRow: typeof ListViewRowInner;
+export {};

package/dist/components/ListView/internals/helpers.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from "react";
+import { ListViewColumn, ListViewRowBase } from "./types";
+export declare function getInitialActiveRowId<T extends ListViewRowBase>(rows: T[], selectedId?: string): string | null;
+export declare function getListViewRowChecked<T extends ListViewRowBase>(row: T, checkedIds?: string[]): boolean;
+export declare function renderListViewCellValue<T extends ListViewRowBase>(row: T, column: ListViewColumn<T>): ReactNode;