@deadragdoll/reactnu 0.1.9

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

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+export type ListViewRowBase = {
+    id: string;
+    checked?: boolean;
+    className?: string;
+    disabled?: boolean;
+    selected?: boolean;
+};
+export type ListViewColumn<T extends ListViewRowBase> = {
+    align?: "start" | "center" | "end";
+    className?: string;
+    field?: keyof T;
+    id: string;
+    renderCell?: (row: T) => ReactNode;
+    title: string;
+    width?: string;
+};

package/dist/components/MainMenu/MainMenu.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from "react";
+import { MainMenuItem, MainMenuNode } from "./MainMenu.types";
+export type MainMenuProps = HTMLAttributes<HTMLDivElement> & {
+    items: MainMenuNode[];
+    onItemSelect?: (item: MainMenuItem) => void;
+    uncheckedShape?: "box" | "none";
+};
+export declare function MainMenu({ className, items, onItemSelect, uncheckedShape, ...props }: MainMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/MainMenu/MainMenu.types.d.ts

@@ -0,0 +1,23 @@
+export type MainMenuFlags = {
+    checkable?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+};
+export type MainMenuDivider = {
+    hidden?: boolean;
+    id: string;
+    type: "divider";
+};
+export type MainMenuItem = MainMenuFlags & {
+    id: string;
+    items?: MainMenuNode[];
+    modifier?: string;
+    onSelect?: () => void;
+    shortcut?: string;
+    text: string;
+    type?: "item";
+};
+export type MainMenuNode = MainMenuItem | MainMenuDivider;
+export declare function isMainMenuDivider(item: MainMenuNode): item is MainMenuDivider;
+export declare function isMainMenuItem(item: MainMenuNode): item is MainMenuItem;

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

@@ -0,0 +1,3 @@
+export * from "./MainMenu";
+export * from "./MainMenu.types";
+export * from "./menuState";

package/dist/components/MainMenu/internals/MainMenuList.d.ts

@@ -0,0 +1,12 @@
+import { MainMenuItem, MainMenuNode } from "../MainMenu.types";
+type MainMenuListProps = {
+    activePath: string[];
+    items: MainMenuNode[];
+    level: number;
+    onActivateItem: (item: MainMenuItem, level: number) => void;
+    onHoverItem: (item: MainMenuItem, level: number) => void;
+    rootVariant?: "bar" | "popup";
+    uncheckedShape?: "box" | "none";
+};
+export declare function MainMenuList({ activePath, items, level, onActivateItem, onHoverItem, rootVariant, uncheckedShape }: MainMenuListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/MainMenu/menuState.d.ts

@@ -0,0 +1,40 @@
+import { Dispatch, SetStateAction } from "react";
+import { MainMenuItem, MainMenuFlags, MainMenuNode } from "./MainMenu.types";
+export type MainMenuItemPatch = Partial<Omit<MainMenuItem, "id" | "type">>;
+export type MainMenuStateValue = {
+    mainMenu: MainMenuNode[];
+    setMainMenu: Dispatch<SetStateAction<MainMenuNode[]>>;
+    setMenuItem: (id: string, patch: MainMenuItemPatch) => void;
+    setMenuFlags: (id: string, flags: 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: MainMenuNode[]) => void;
+};
+export declare function hasVisibleMainMenuItems(items: MainMenuNode[]): boolean;
+export declare function useMainMenuState(initialMainMenu?: MainMenuNode[]): {
+    mainMenu: MainMenuNode[];
+    setMainMenu: Dispatch<SetStateAction<MainMenuNode[]>>;
+    setMenuItem: (id: string, patch: MainMenuItemPatch) => void;
+    setMenuFlags: (id: string, flags: 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: MainMenuNode[]) => void;
+};

package/dist/components/MaskedField/MaskedField.d.ts

@@ -0,0 +1,13 @@
+import { InputHTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type MaskedFieldSlot = "root" | "label" | "slot" | "bracket" | "inputShell" | "input" | "hint";
+export type MaskedFieldProps = Omit<InputHTMLAttributes<HTMLInputElement>, "type"> & {
+    debounceMs?: number;
+    label: string;
+    hint?: string;
+    mask: string;
+    onDebouncedChange?: (value: string) => void;
+    slotClassNames?: SlotCustomizationProps<MaskedFieldSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<MaskedFieldSlot>["slotStyles"];
+};
+export declare function MaskedField({ "aria-invalid": ariaInvalid, className, debounceMs, defaultValue, hint, id, label, mask, onChange, onDebouncedChange, placeholder, slotClassNames, slotStyles, value, style, ...props }: MaskedFieldProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export * from "./MaskedField";
+export { getMaskedFieldState } from "./textMask";

package/dist/components/MaskedField/textMask.d.ts

@@ -0,0 +1,8 @@
+export declare function applyTextMask(mask: string, rawValue: string): string;
+export declare function getTextMaskInputMode(mask: string): "numeric" | undefined;
+export declare function isTextMaskComplete(mask: string, rawValue: string): boolean;
+export declare function getMaskedFieldState(mask: string, rawValue: string): {
+    formattedValue: string;
+    isComplete: boolean;
+    isInvalid: boolean;
+};

package/dist/components/Memo/Memo.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties, TextareaHTMLAttributes } from "react";
+type MemoScroll = "auto" | "x" | "y" | "both" | "hidden";
+export type MemoProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "children"> & {
+    background?: CSSProperties["background"];
+    content?: string;
+    fill?: boolean;
+    focusBackground?: CSSProperties["background"];
+    focusTextColor?: CSSProperties["color"];
+    onValueChange?: (value: string) => void;
+    scroll?: MemoScroll;
+    textColor?: CSSProperties["color"];
+};
+export declare function Memo({ background, className, content, defaultValue, fill, focusBackground, focusTextColor, onChange, onValueChange, scroll, style, textColor, value, ...props }: MemoProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/components/PageControl/PageControl.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, ReactNode } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type PageControlSlot = "root" | "tabs" | "tab" | "panel";
+export type PageControlPage = {
+    content: ReactNode;
+    disabled?: boolean;
+    id: string;
+    label: string;
+};
+export type PageControlProps = Omit<HTMLAttributes<HTMLDivElement>, "onChange"> & {
+    activePageId?: string;
+    defaultActivePageId?: string;
+    fill?: boolean;
+    onActivePageChange?: (page: PageControlPage) => void;
+    pages: PageControlPage[];
+    slotClassNames?: SlotCustomizationProps<PageControlSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<PageControlSlot>["slotStyles"];
+};
+export declare function PageControl({ activePageId: activePageIdProp, className, defaultActivePageId, fill, onActivePageChange, pages, slotClassNames, slotStyles, ...props }: PageControlProps): import("react/jsx-runtime").JSX.Element;
+export { PageControl as Tabs };

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

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

package/dist/components/Panel/Panel.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, PropsWithChildren } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type PanelSlot = "root" | "header" | "body" | "footer";
+export type PanelProps = PropsWithChildren<HTMLAttributes<HTMLElement> & {
+    footer?: string;
+    inset?: boolean;
+    slotClassNames?: SlotCustomizationProps<PanelSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<PanelSlot>["slotStyles"];
+    title?: string;
+}>;
+export declare function Panel({ children, className, footer, inset, slotClassNames, slotStyles, title, ...props }: PanelProps): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/PopupMenu/PopupMenu.d.ts

@@ -0,0 +1,22 @@
+import { HTMLAttributes } from "react";
+import { MainMenuItem, MainMenuNode } from "../MainMenu/MainMenu.types";
+export type PopupMenuPointAnchor = {
+    type: "point";
+    x: number;
+    y: number;
+};
+export type PopupMenuElementAnchor = {
+    element: HTMLElement;
+    type: "element";
+};
+export type PopupMenuAnchor = PopupMenuPointAnchor | PopupMenuElementAnchor;
+export type PopupMenuProps = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    anchor: PopupMenuAnchor | null;
+    defaultOpen?: boolean;
+    items: MainMenuNode[];
+    onItemSelect?: (item: MainMenuItem) => void;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    uncheckedShape?: "box" | "none";
+};
+export declare function PopupMenu({ anchor, className, defaultOpen, items, onItemSelect, onOpenChange, open, style: styleProp, uncheckedShape, ...props }: PopupMenuProps): import("react").ReactPortal | null;

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

@@ -0,0 +1,2 @@
+export * from "./PopupMenu";
+export * from "./usePopupMenu";

package/dist/components/PopupMenu/usePopupMenu.d.ts

@@ -0,0 +1,12 @@
+import { MouseEvent } from "react";
+import { PopupMenuAnchor } from "./PopupMenu";
+export declare function usePopupMenu(): {
+    anchor: PopupMenuAnchor | null;
+    close: () => void;
+    open: boolean;
+    openAtElement: (element: HTMLElement) => void;
+    openAtPoint: (x: number, y: number) => void;
+    openFromClick: (event: MouseEvent<HTMLElement>) => void;
+    openFromContextMenu: (event: MouseEvent<HTMLElement>) => void;
+    setOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

package/dist/components/ProgressBar/ProgressBar.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type ProgressBarSlot = "root" | "label" | "track" | "fill" | "value" | "hint";
+export type ProgressBarProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    hint?: string;
+    indeterminate?: boolean;
+    label?: string;
+    max?: number;
+    min?: number;
+    showValue?: boolean;
+    slotClassNames?: SlotCustomizationProps<ProgressBarSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<ProgressBarSlot>["slotStyles"];
+    trackBackground?: CSSProperties["background"];
+    value?: number;
+    valueRenderer?: (percent: number, value: number, min: number, max: number) => ReactNode;
+};
+export declare function ProgressBar({ className, hint, indeterminate, label, max, min, showValue, slotClassNames, slotStyles, style, trackBackground, value, valueRenderer, ...props }: ProgressBarProps): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/PropertyGrid/PropertyGrid.d.ts

@@ -0,0 +1,38 @@
+import { HTMLAttributes, ReactNode } from "react";
+type PropertyGridItemEntry = {
+    content: ReactNode;
+    disabled?: boolean;
+    hint?: string;
+    id: string;
+    label: string;
+    type?: "item";
+};
+type PropertyGridGroupEntry = {
+    children: PropertyGridEntry[];
+    disabled?: boolean;
+    expanded?: boolean;
+    id: string;
+    label: string;
+    summary?: ReactNode;
+    type: "group";
+};
+type PropertyGridSectionEntry = {
+    id: string;
+    title: string;
+    type: "section";
+};
+export type PropertyGridEntry = PropertyGridItemEntry | PropertyGridGroupEntry | PropertyGridSectionEntry;
+export type PropertyGridProps = HTMLAttributes<HTMLDivElement> & {
+    activeId?: string;
+    bordered?: boolean;
+    defaultActiveId?: string;
+    defaultExpandedIds?: string[];
+    entries: PropertyGridEntry[];
+    expandedIds?: string[];
+    fill?: boolean;
+    labelWidth?: string;
+    onActiveIdChange?: (activeId: string) => void;
+    onExpandedIdsChange?: (expandedIds: string[]) => void;
+};
+export declare function PropertyGrid({ activeId: activeIdProp, bordered, className, defaultActiveId, defaultExpandedIds, entries, expandedIds: expandedIdsProp, fill, labelWidth, onActiveIdChange, onExpandedIdsChange, style, ...props }: PropertyGridProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/components/RadioGroup/RadioButton.d.ts

@@ -0,0 +1,9 @@
+import { ChangeEvent, InputHTMLAttributes } from "react";
+export type RadioButtonProps = Omit<InputHTMLAttributes<HTMLInputElement>, "checked" | "defaultChecked" | "onChange" | "type"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    hint?: string;
+    label: string;
+    onCheckedChange?: (checked: boolean, event: ChangeEvent<HTMLInputElement>) => void;
+};
+export declare function RadioButton({ checked, className, defaultChecked, disabled, hint, id, label, onCheckedChange, ...props }: RadioButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/RadioGroup/RadioGroup.d.ts

@@ -0,0 +1,21 @@
+import { HTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type RadioGroupSlot = "root" | "label" | "options" | "hint";
+export type RadioOption = {
+    disabled?: boolean;
+    hint?: string;
+    label: string;
+    value: string;
+};
+export type RadioGroupProps = Omit<HTMLAttributes<HTMLFieldSetElement>, "onChange"> & {
+    defaultValue?: string;
+    hint?: string;
+    label?: string;
+    name?: string;
+    onValueChange?: (value: string) => void;
+    options: RadioOption[];
+    slotClassNames?: SlotCustomizationProps<RadioGroupSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<RadioGroupSlot>["slotStyles"];
+    value?: string;
+};
+export declare function RadioGroup({ className, defaultValue, hint, label, name, onValueChange, options, slotClassNames, slotStyles, style, value, ...props }: RadioGroupProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export * from "./RadioButton";
+export * from "./RadioGroup";

package/dist/components/ReportCell/ReportCell.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from "react";
+export type ReportCellProps = HTMLAttributes<HTMLSpanElement> & {
+    align?: "start" | "center" | "end";
+    tone?: "default" | "muted" | "accent" | "danger" | "success";
+};
+export declare function ReportCell({ align, className, tone, ...props }: ReportCellProps): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/SearchBox/SearchBox.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes, ReactNode } from "react";
+export type SearchBoxProps<T> = Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange"> & {
+    dataProvider: (query: string) => Promise<T[]>;
+    debounceMs?: number;
+    defaultQuery?: string;
+    disabled?: boolean;
+    emptyText?: string;
+    errorText?: string;
+    getItemDetails?: (item: T) => ReactNode;
+    getItemDisabled?: (item: T) => boolean;
+    getItemId: (item: T, index: number) => string;
+    getItemText: (item: T) => string;
+    hint?: string;
+    idleText?: string;
+    label: string;
+    loadingText?: string;
+    minQueryLength?: number;
+    onItemSelect?: (item: T) => void;
+    onQueryChange?: (query: string) => void;
+    placeholder?: string;
+    query?: string;
+};
+export declare function SearchBox<T>({ className, dataProvider, debounceMs, defaultQuery, disabled, emptyText, errorText, getItemDetails, getItemDisabled, getItemId, getItemText, hint, idleText, label, loadingText, minQueryLength, onItemSelect, onQueryChange, placeholder, query: queryProp, style, ...props }: SearchBoxProps<T>): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/SpinBox/SpinBox.d.ts

@@ -0,0 +1,16 @@
+import { InputHTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type SpinBoxSlot = "root" | "label" | "slot" | "bracket" | "inputShell" | "input" | "controls" | "button" | "hint";
+export type SpinBoxProps = Omit<InputHTMLAttributes<HTMLInputElement>, "defaultValue" | "type" | "value"> & {
+    defaultValue?: number;
+    hint?: string;
+    label: string;
+    max?: number;
+    min?: number;
+    onValueChange?: (value: number) => void;
+    slotClassNames?: SlotCustomizationProps<SpinBoxSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<SpinBoxSlot>["slotStyles"];
+    step?: number;
+    value?: number;
+};
+export declare function SpinBox({ className, defaultValue, disabled, hint, id, label, max, min, onBlur, onChange, onKeyDown, onValueChange, slotClassNames, slotStyles, step, style, value, ...props }: SpinBoxProps): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/Splitter/Splitter.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, ReactNode } from "react";
+type SplitterOrientation = "vertical" | "horizontal";
+export type SplitterProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    defaultValue?: number;
+    first: ReactNode;
+    max?: number;
+    min?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: SplitterOrientation;
+    saveId?: string;
+    second: ReactNode;
+    value?: number;
+};
+export declare function Splitter({ className, defaultValue, first, max, min, onValueChange, orientation, saveId, second, style, value, ...props }: SplitterProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/components/Stack/Stack.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes } from "react";
+type StackDirection = "row" | "column";
+type StackGap = "sm" | "md" | "lg";
+type StackAlign = "start" | "center" | "end" | "stretch";
+type StackJustify = "start" | "center" | "end" | "space-between" | "space-around";
+export type StackProps = HTMLAttributes<HTMLDivElement> & {
+    align?: StackAlign;
+    direction?: StackDirection;
+    gap?: StackGap;
+    justify?: StackJustify;
+};
+export declare function Stack({ align, children, className, direction, gap, justify, style, ...props }: StackProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/components/TextField/TextField.d.ts

@@ -0,0 +1,12 @@
+import { InputHTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type TextFieldSlot = "root" | "label" | "slot" | "bracket" | "inputShell" | "input" | "hint";
+export type TextFieldProps = InputHTMLAttributes<HTMLInputElement> & {
+    debounceMs?: number;
+    label: string;
+    hint?: string;
+    onDebouncedChange?: (value: string) => void;
+    slotClassNames?: SlotCustomizationProps<TextFieldSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<TextFieldSlot>["slotStyles"];
+};
+export declare function TextField({ className, debounceMs, defaultValue, hint, id, label, onChange, onDebouncedChange, placeholder, slotClassNames, slotStyles, type, value, ...props }: TextFieldProps): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/TickBar/TickBar.d.ts

@@ -0,0 +1,22 @@
+import { HTMLAttributes, ReactNode } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+export type TickBarSlot = "root" | "label" | "slot" | "track" | "rail" | "ticks" | "tick" | "thumb" | "value" | "hint";
+export type TickBarProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange"> & {
+    defaultValue?: number;
+    disabled?: boolean;
+    fill?: boolean;
+    hint?: string;
+    label?: string;
+    max?: number;
+    min?: number;
+    orientation?: "horizontal" | "vertical";
+    onValueChange?: (value: number) => void;
+    showValue?: boolean;
+    slotClassNames?: SlotCustomizationProps<TickBarSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<TickBarSlot>["slotStyles"];
+    step?: number;
+    tickCount?: number;
+    value?: number;
+    valueRenderer?: (value: number, min: number, max: number) => ReactNode;
+};
+export declare function TickBar({ className, defaultValue, disabled, fill, hint, id, label, max, min, orientation, onKeyDown, onValueChange, showValue, slotClassNames, slotStyles, step, style, tickCount, value, valueRenderer, ...props }: TickBarProps): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/ToolBar/ToolBar.d.ts

@@ -0,0 +1,25 @@
+import { HTMLAttributes } from "react";
+import { SlotCustomizationProps } from "../_shared/slotProps";
+import { CommandButtonProps } from "../CommandButton/CommandButton";
+import { MainMenuItem, MainMenuNode } from "../MainMenu/MainMenu.types";
+export type ToolBarProps = HTMLAttributes<HTMLDivElement> & {
+    fill?: boolean;
+    slotClassNames?: SlotCustomizationProps<"root">["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<"root">["slotStyles"];
+    wrap?: boolean;
+};
+export type ToolButtonSlot = "button" | "icon" | "label" | "caret";
+export type ToolButtonProps = Omit<CommandButtonProps, "menuItems" | "onMenuItemSelect" | "uncheckedShape" | "slotClassNames" | "slotStyles"> & {
+    slotClassNames?: SlotCustomizationProps<ToolButtonSlot>["slotClassNames"];
+    slotStyles?: SlotCustomizationProps<ToolButtonSlot>["slotStyles"];
+};
+export type ToolSeparatorProps = HTMLAttributes<HTMLDivElement> & SlotCustomizationProps<"separator">;
+export type ToolDropButtonProps = ToolButtonProps & {
+    menuItems?: MainMenuNode[];
+    onMenuItemSelect?: (item: MainMenuItem) => void;
+    uncheckedShape?: "box" | "none";
+};
+export declare function ToolBar({ children, className, fill, slotClassNames, slotStyles, wrap, ...props }: ToolBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToolButton({ className, slotClassNames, slotStyles, ...props }: ToolButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToolDropButton({ className, menuItems, onMenuItemSelect, slotClassNames, slotStyles, uncheckedShape, ...props }: ToolDropButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToolSeparator({ className, ...props }: ToolSeparatorProps): import("react/jsx-runtime").JSX.Element;

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

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

package/dist/components/TreeListView/TreeListView.d.ts

@@ -0,0 +1,33 @@
+import { ForwardedRef, HTMLAttributes, RefAttributes } from "react";
+import { TreeListColumn, TreeListGetCellContent, TreeListItemBase } from "./internals/types";
+export type { TreeListCellContext, TreeListColumn, TreeListGetCellContent, TreeListItemBase } from "./internals/types";
+export type TreeListViewHandle = {
+    activateItem: (itemId: string) => void;
+    collapseItem: (itemId: string) => void;
+    expandItem: (itemId: string) => void;
+    focus: () => void;
+    getActiveItemId: () => string | null;
+    scrollToItem: (itemId: string) => void;
+    toggleItemCheck: (itemId: string) => void;
+};
+export type TreeListViewProps<T extends TreeListItemBase<T>> = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    activeItemId?: string;
+    checkedIds?: string[];
+    columns: TreeListColumn<T>[];
+    data: T[];
+    dataVersion?: number;
+    defaultActiveItemId?: string;
+    defaultExpandedIds?: string[];
+    emptyText?: string;
+    expandedIds?: string[];
+    getCellContent?: TreeListGetCellContent<T>;
+    onActiveItemChange?: (item: T) => void;
+    onExpandedIdsChange?: (expandedIds: string[]) => void;
+    onItemCheckChange?: (item: T, checked: boolean) => void;
+    onItemDoubleClick?: (item: T) => void;
+    onItemSelect?: (item: T) => void;
+    selectedId?: string;
+    uncheckedShape?: "box" | "none";
+};
+declare function TreeListViewInner<T extends TreeListItemBase<T>>({ activeItemId: activeItemIdProp, checkedIds, className, columns, data, dataVersion, defaultActiveItemId, defaultExpandedIds, emptyText, expandedIds, getCellContent, onActiveItemChange, onExpandedIdsChange, onItemCheckChange, onItemDoubleClick, onItemSelect, selectedId, uncheckedShape, ...props }: TreeListViewProps<T>, ref: ForwardedRef<TreeListViewHandle>): import("react/jsx-runtime").JSX.Element;
+export declare const TreeListView: <T extends TreeListItemBase<T>>(props: TreeListViewProps<T> & RefAttributes<TreeListViewHandle>) => ReturnType<typeof TreeListViewInner>;

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

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

package/dist/components/TreeListView/internals/TreeListViewRow.d.ts

@@ -0,0 +1,28 @@
+import { TreeListColumn, TreeListGetCellContent, TreeListItemBase } from "./types";
+type TreeListViewRowProps<T extends TreeListItemBase<T>> = {
+    activeItemId: string | null;
+    checkedIds?: string[];
+    columns: TreeListColumn<T>[];
+    depth: number;
+    expandedIdSet: Set<string>;
+    getCellContent?: TreeListGetCellContent<T>;
+    guideMask: boolean[];
+    guideOffsets: number[];
+    hasNextSibling: boolean;
+    item: T;
+    onActivateItem: (item: T, itemId: string) => void;
+    onDoubleClickItem?: (item: T) => void;
+    onToggleItemCheck?: (item: T, checked: boolean) => void;
+    onToggleItemExpanded: (item: T, expanded: boolean) => void;
+    originOffset: number;
+    registerItemRef: (itemId: string, node: HTMLDivElement | null) => void;
+    rowIndexMap: Map<string, number>;
+    selectedItemId: string | null;
+    templateColumns: string;
+    treeColumnId: string | null;
+    treeId: string;
+    uncheckedShape: "box" | "none";
+};
+declare function TreeListViewRowInner<T extends TreeListItemBase<T>>({ activeItemId, checkedIds, columns, depth, expandedIdSet, getCellContent, guideMask, guideOffsets, hasNextSibling, item, onActivateItem, onDoubleClickItem, onToggleItemCheck, onToggleItemExpanded, originOffset, registerItemRef, rowIndexMap, selectedItemId, templateColumns, treeColumnId, treeId, uncheckedShape }: TreeListViewRowProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const TreeListViewRow: typeof TreeListViewRowInner;
+export {};

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

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { TreeListColumn, TreeListItemBase, VisibleTreeListItem } from "./types";
+export declare function collectExpandedTreeListIds<T extends TreeListItemBase<T>>(items: T[]): string[];
+export declare function findSelectedTreeListItemId<T extends TreeListItemBase<T>>(items: T[]): string | null;
+export declare function findTreeListItemById<T extends TreeListItemBase<T>>(items: T[], targetId: string): T | null;
+export declare function collectVisibleTreeListItems<T extends TreeListItemBase<T>>(items: T[], expandedIds: Set<string>, depth?: number, guideMask?: boolean[], parentId?: string | null): VisibleTreeListItem<T>[];
+export declare function getTreeListTemplateColumns<T extends TreeListItemBase<T>>(columns: TreeListColumn<T>[], { autoColumnWidths, userColumnWidths }?: {
+    autoColumnWidths?: Record<string, number>;
+    userColumnWidths?: Record<string, number>;
+}): string;
+export declare function getTreeListTreeColumnId<T extends TreeListItemBase<T>>(columns: TreeListColumn<T>[]): string;
+export declare function getTreeListCellAlign<T extends TreeListItemBase<T>>(column: TreeListColumn<T>, columnIndex: number): "center" | "left" | "right";
+export declare function getTreeListHeaderAlign<T extends TreeListItemBase<T>>(column: TreeListColumn<T>, columnIndex: number): "center" | "left" | "right";
+export declare function renderTreeListCellValue<T extends TreeListItemBase<T>>(item: T, column: TreeListColumn<T>): ReactNode;