@deadragdoll/reactnu 0.1.9

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

@@ -0,0 +1,32 @@
+import { ReactNode } from "react";
+import { TreeDataItemBase, VisibleTreeDataItem } from "../../_shared/treeData";
+export type TreeListColumnAlign = "left" | "center" | "right" | "start" | "end";
+export type TreeListItemBase<TItem = unknown> = TreeDataItemBase<TItem> & {
+    checked?: boolean;
+    className?: string;
+    disabled?: boolean;
+    hint?: ReactNode;
+    icon?: ReactNode;
+    title: ReactNode;
+};
+export type TreeListColumn<T extends TreeListItemBase<T>> = {
+    align?: TreeListColumnAlign;
+    className?: string;
+    field?: keyof T;
+    headerAlign?: TreeListColumnAlign;
+    id: string;
+    minWidth?: number;
+    renderCell?: (item: T) => ReactNode;
+    resizable?: boolean;
+    title: string;
+    tree?: boolean;
+    width?: number | string;
+};
+export type TreeListCellContext<T extends TreeListItemBase<T>> = {
+    depth: number;
+    isLeaf: boolean;
+    item: T;
+    rowIndex: number;
+};
+export type TreeListGetCellContent<T extends TreeListItemBase<T>> = (itemId: string, columnId: string, context: TreeListCellContext<T>) => ReactNode;
+export type VisibleTreeListItem<T extends TreeListItemBase<T>> = VisibleTreeDataItem<T>;

package/dist/components/TreeView/TreeView.d.ts

@@ -0,0 +1,26 @@
+import { ForwardedRef, HTMLAttributes, RefAttributes } from "react";
+import { TreeItem } from "./internals/types";
+export type { TreeItem } from "./internals/types";
+export type TreeViewHandle = {
+    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 TreeViewProps = Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    data: TreeItem[];
+    defaultExpandedIds?: string[];
+    emptyText?: string;
+    expandedIds?: string[];
+    onExpandedIdsChange?: (expandedIds: string[]) => void;
+    onItemCheckChange?: (item: TreeItem, checked: boolean) => void;
+    onItemDoubleClick?: (item: TreeItem) => void;
+    onItemSelect?: (item: TreeItem) => void;
+    selectedId?: string;
+    uncheckedShape?: "box" | "none";
+};
+declare function TreeViewInner({ className, data, defaultExpandedIds, emptyText, expandedIds, onExpandedIdsChange, onItemCheckChange, onItemDoubleClick, onItemSelect, selectedId, uncheckedShape, ...props }: TreeViewProps, ref: ForwardedRef<TreeViewHandle>): import("react/jsx-runtime").JSX.Element;
+export declare const TreeView: (props: TreeViewProps & RefAttributes<TreeViewHandle>) => ReturnType<typeof TreeViewInner>;

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

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

package/dist/components/TreeView/internals/TreeViewItem.d.ts

@@ -0,0 +1,21 @@
+import { TreeItem } from "./types";
+type TreeViewItemProps = {
+    depth: number;
+    expandedIdSet: Set<string>;
+    guideMask: boolean[];
+    guideOffsets: number[];
+    hasNextSibling: boolean;
+    originOffset: number;
+    onActivateItem: (item: TreeItem, itemId: string) => void;
+    onDoubleClickItem?: (item: TreeItem) => void;
+    onToggleItemCheck?: (item: TreeItem, checked: boolean) => void;
+    onToggleItemExpanded: (item: TreeItem, expanded: boolean) => void;
+    registerItemRef: (itemId: string, node: HTMLDivElement | null) => void;
+    resolvedSelectedId: string | null;
+    treeId: string;
+    item: TreeItem;
+    uncheckedShape: "box" | "none";
+};
+declare function TreeViewItemInner({ depth, expandedIdSet, guideMask, guideOffsets, hasNextSibling, item, originOffset, onActivateItem, onDoubleClickItem, onToggleItemCheck, onToggleItemExpanded, registerItemRef, resolvedSelectedId, treeId, uncheckedShape }: TreeViewItemProps): import("react/jsx-runtime").JSX.Element;
+export declare const TreeViewItem: import("react").MemoExoticComponent<typeof TreeViewItemInner>;
+export {};

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

@@ -0,0 +1,5 @@
+import { TreeItem, VisibleTreeItem } from "./types";
+export declare function collectExpandedTreeIds(items: TreeItem[]): string[];
+export declare function findSelectedTreeItemId(items: TreeItem[]): string | null;
+export declare function findTreeItemById(items: TreeItem[], targetId: string): TreeItem | null;
+export declare function collectVisibleTreeItems(items: TreeItem[], expandedIds: Set<string>, depth?: number, guideMask?: boolean[], parentId?: string | null): VisibleTreeItem[];

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

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+import { TreeDataItemBase, VisibleTreeDataItem } from "../../_shared/treeData";
+export interface TreeItem extends TreeDataItemBase<TreeItem> {
+    checked?: boolean;
+    disabled?: boolean;
+    hint?: ReactNode;
+    icon?: ReactNode;
+    title: ReactNode;
+}
+export type VisibleTreeItem = VisibleTreeDataItem<TreeItem>;

package/dist/components/View/NuView.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes } from "react";
+type NuViewPadding = "none" | "cell" | "sm" | "md" | "lg";
+type NuViewScroll = "auto" | "x" | "y" | "both" | "hidden";
+export type NuViewProps = HTMLAttributes<HTMLDivElement> & {
+    fill?: boolean;
+    padding?: NuViewPadding;
+    scroll?: NuViewScroll;
+};
+export declare function NuView({ children, className, fill, padding, scroll, ...props }: NuViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

package/dist/components/Window/StatusBarItem.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes, ReactNode } from "react";
+export type StatusBarItemProps = HTMLAttributes<HTMLSpanElement> & {
+    align?: "start" | "center" | "end";
+    children: ReactNode;
+    grow?: boolean;
+};
+export declare function StatusBarItem({ align, children, className, grow, ...props }: StatusBarItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Window/Window.d.ts

@@ -0,0 +1,41 @@
+import { HTMLAttributes, PropsWithChildren, ReactNode } from "react";
+import { WindowTitleButtonDefinition } from "./WindowTitleButton";
+import { NuWindowBounds } from "../../windowing/windowing.types";
+export type WindowMode = "dialog" | "window";
+export type WindowBorder = "single" | "double";
+export type WindowPosition = {
+    left: number;
+    top: number;
+};
+export type WindowSize = {
+    height: number;
+    width: number;
+};
+export type WindowProps = PropsWithChildren<Omit<HTMLAttributes<HTMLElement>, "title"> & {
+    active?: boolean;
+    bodyClassName?: string;
+    border?: WindowBorder;
+    closeable?: boolean;
+    draggable?: boolean;
+    maximizable?: boolean;
+    maximized?: boolean;
+    minimizable?: boolean;
+    minimized?: boolean;
+    mode?: WindowMode;
+    onActivate?: () => void;
+    onBoundsChange?: (bounds: NuWindowBounds) => void;
+    onClose?: () => void;
+    onPositionChange?: (position: WindowPosition) => void;
+    onSizeChange?: (size: WindowSize) => void;
+    onToggleMaximized?: () => void;
+    onToggleMinimized?: () => void;
+    resizable?: boolean;
+    scrollable?: boolean;
+    statusBarClassName?: string;
+    statusBar?: ReactNode;
+    titleButtons?: WindowTitleButtonDefinition[];
+    title: string;
+}>;
+declare function WindowInner({ active, bodyClassName, border, children, className, closeable, draggable, maximizable, maximized, minimizable, minimized, mode, onActivate, onBoundsChange, onClose, onPointerDownCapture, onPositionChange, onSizeChange, onToggleMaximized, onToggleMinimized, resizable, scrollable, statusBarClassName, statusBar, style, titleButtons, title, ...props }: WindowProps): import("react/jsx-runtime").JSX.Element;
+export declare const Window: import("react").MemoExoticComponent<typeof WindowInner>;
+export {};

package/dist/components/Window/WindowTitleButton.d.ts

@@ -0,0 +1,17 @@
+import { ButtonHTMLAttributes, ReactNode } from "react";
+export type WindowTitleButtonIcon = "close" | "maximize" | "minimize" | "restore" | ReactNode;
+export type WindowTitleButtonVariant = "default" | "close";
+export type WindowTitleButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> & {
+    ariaLabel?: string;
+    icon: WindowTitleButtonIcon;
+    variant?: WindowTitleButtonVariant;
+};
+export type WindowTitleButtonDefinition = {
+    ariaLabel?: string;
+    className?: string;
+    icon: WindowTitleButtonIcon;
+    key?: string;
+    onClick?: () => void;
+    variant?: WindowTitleButtonVariant;
+};
+export declare function WindowTitleButton({ ariaLabel, className, icon, onClick, onPointerDown, type, variant, ...props }: WindowTitleButtonProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+export * from "./Window";
+export * from "./StatusBarItem";
+export * from "./WindowTitleButton";
+export * from "./useWindowTitleButtons";
+export * from "./windowMenuContext";

package/dist/components/Window/internals/WindowStatusBar.d.ts

@@ -0,0 +1,8 @@
+import { PointerEventHandler, PropsWithChildren } from "react";
+type WindowStatusBarProps = PropsWithChildren<{
+    onResizeStart?: PointerEventHandler<HTMLButtonElement>;
+    resizable?: boolean;
+    statusBarClassName?: string;
+}>;
+export declare function WindowStatusBar({ children, onResizeStart, resizable, statusBarClassName }: WindowStatusBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Window/internals/WindowTitleBar.d.ts

@@ -0,0 +1,10 @@
+import { PointerEventHandler } from "react";
+import { WindowTitleButtonDefinition } from "../WindowTitleButton";
+type WindowTitleBarProps = {
+    draggable: boolean;
+    onDragStart?: PointerEventHandler<HTMLElement>;
+    titleButtons: WindowTitleButtonDefinition[];
+    title: string;
+};
+export declare function WindowTitleBar({ draggable, onDragStart, titleButtons, title }: WindowTitleBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Window/useWindowTitleButtons.d.ts

@@ -0,0 +1,12 @@
+import { WindowTitleButtonDefinition } from "./WindowTitleButton";
+export type UseWindowTitleButtonsOptions = {
+    closeable?: boolean;
+    maximizable?: boolean;
+    maximized?: boolean;
+    minimizable?: boolean;
+    minimized?: boolean;
+    onClose?: () => void;
+    onToggleMaximized?: () => void;
+    onToggleMinimized?: () => void;
+};
+export declare function useWindowTitleButtons({ closeable, maximizable, maximized, minimizable, minimized, onClose, onToggleMaximized, onToggleMinimized }: UseWindowTitleButtonsOptions): WindowTitleButtonDefinition[];

package/dist/components/Window/windowMenuContext.d.ts

@@ -0,0 +1,3 @@
+import { MainMenuStateValue } from "../MainMenu";
+export declare const WindowMenuContext: import("react").Context<MainMenuStateValue | null>;
+export declare function useWindowMenu(): MainMenuStateValue;

package/dist/components/_shared/ControlOpener.d.ts

@@ -0,0 +1,18 @@
+import { ButtonHTMLAttributes, CSSProperties, HTMLAttributes, ReactNode } from "react";
+type ControlOpenerBaseProps = {
+    children?: ReactNode;
+    className?: string;
+    glyphClassName?: string;
+    glyphStyle?: CSSProperties;
+    style?: CSSProperties;
+};
+type ControlOpenerSpanProps = ControlOpenerBaseProps & Omit<HTMLAttributes<HTMLSpanElement>, "children" | "style"> & {
+    ariaHidden?: boolean;
+    as?: "span";
+};
+type ControlOpenerButtonProps = ControlOpenerBaseProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "style"> & {
+    as: "button";
+};
+export type ControlOpenerProps = ControlOpenerSpanProps | ControlOpenerButtonProps;
+export declare function ControlOpener(props: ControlOpenerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/_shared/portalPositioning.d.ts

@@ -0,0 +1,16 @@
+type PortalViewportRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare function isDocumentViewportRoot(portalRoot: HTMLElement | null): boolean;
+export declare function getPortalViewportRect(portalRoot: HTMLElement | null): PortalViewportRect;
+export declare function toPortalCoordinates(portalRoot: HTMLElement | null, position: {
+    left: number;
+    top: number;
+}): {
+    left: number;
+    top: number;
+};
+export {};