@jc-times/business-ui 0.2.43

package/dist/types/Alert.d.ts

@@ -0,0 +1,11 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+export type AlertTone = "info" | "success" | "warning" | "danger";
+export type AlertProps = Omit<HTMLAttributes<HTMLDivElement>, "title"> & {
+    tone?: AlertTone;
+    title?: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    dismissLabel?: string;
+    onDismiss?: () => void;
+};
+export declare function Alert({ tone, title, description, action, dismissLabel, onDismiss, className, ...props }: AlertProps): import("react").JSX.Element;

package/dist/types/AmountFormat.d.ts

@@ -0,0 +1,15 @@
+/** Presentation only: symbols and units never change the stored numeric value. */
+export type MoneyFormat = {
+    symbol: string;
+    unit?: string;
+    display?: "symbol" | "unit" | "number";
+};
+export type AmountFormatOptions = {
+    moneyFormat?: MoneyFormat;
+    useGrouping?: boolean;
+    minimumFractionDigits?: number;
+};
+/** Formats exact decimal strings without a floating-point conversion or currency conversion. */
+export declare function formatDecimalAmount(value: string, options?: AmountFormatOptions): string;
+/** Integer storage adapter, suitable for server-side document generation. */
+export declare function formatScaledMoney(value: number, moneyFormat: MoneyFormat, scale?: number): string;

package/dist/types/AsyncDirectoryPicker.d.ts

@@ -0,0 +1,32 @@
+import { type InputHTMLAttributes, type ReactNode } from "react";
+export type AsyncDirectoryPickerProps<T> = {
+    selectedItem?: T | null;
+    loadItems(query: string, signal: AbortSignal): Promise<readonly T[]>;
+    getKey(item: T): string;
+    getText(item: T): string;
+    getSelectionText?: (item: T) => string;
+    renderItem(item: T): ReactNode;
+    onSelect(item: T): void | Promise<void>;
+    onQueryChange?: (query: string) => void;
+    ownerKey?: string;
+    label?: ReactNode;
+    placeholder?: string;
+    searchLabel?: ReactNode;
+    loadingTitle?: string;
+    emptyText?: ReactNode;
+    minimumCharacters?: number;
+    minimumCharactersText?: (minimum: number) => ReactNode;
+    debounceMs?: number;
+    /** Maximum cached queries per owner. Zero disables caching. Default: 50. */
+    cacheSize?: number;
+    /** Cache TTL in milliseconds; defaults to 5 minutes. Zero bypasses cache. */
+    cacheTtlMs?: number;
+    /** Change after directory mutations to invalidate cached results and pending requests. */
+    refreshKey?: string | number;
+    loadOnFocus?: boolean;
+    disabled?: boolean;
+    busy?: boolean;
+    className?: string;
+    inputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "disabled" | "role" | "aria-autocomplete" | "aria-expanded" | "aria-controls" | "aria-activedescendant">;
+};
+export declare function AsyncDirectoryPicker<T>({ selectedItem, loadItems, getKey, getText, getSelectionText, renderItem, onSelect, onQueryChange, ownerKey, label, placeholder, searchLabel, loadingTitle, emptyText, minimumCharacters, minimumCharactersText, debounceMs, cacheSize, cacheTtlMs, refreshKey, loadOnFocus, disabled, busy, className, inputProps }: AsyncDirectoryPickerProps<T>): import("react").JSX.Element;

package/dist/types/AsyncSearchPicker.d.ts

@@ -0,0 +1,26 @@
+import { type InputHTMLAttributes, type ReactNode, type Ref } from "react";
+export type AsyncSearchStatus = "idle" | "loading" | "error" | "success";
+export type AsyncSearchPickerProps<T> = {
+    query: string;
+    onQueryChange(query: string): void;
+    onSearch(query: string): void;
+    items: readonly T[];
+    getKey(item: T): string;
+    getText(item: T): string;
+    renderItem(item: T): ReactNode;
+    onSelect(item: T): void;
+    status?: AsyncSearchStatus;
+    error?: string;
+    label?: ReactNode;
+    searchLabel?: ReactNode;
+    loadingTitle?: string;
+    emptyText?: ReactNode;
+    minimumCharacters?: number;
+    minimumCharactersText?: (minimum: number) => ReactNode;
+    busy?: boolean;
+    disabled?: boolean;
+    className?: string;
+    inputRef?: Ref<HTMLInputElement>;
+    inputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "disabled" | "role" | "aria-autocomplete" | "aria-expanded" | "aria-controls" | "aria-activedescendant">;
+};
+export declare function AsyncSearchPicker<T>({ query, onQueryChange, onSearch, items, getKey, getText, renderItem, onSelect, status, error, label, searchLabel, loadingTitle, emptyText, minimumCharacters, minimumCharactersText, busy, disabled, className, inputRef, inputProps }: AsyncSearchPickerProps<T>): import("react").JSX.Element;

package/dist/types/AutoComplete.d.ts

@@ -0,0 +1,9 @@
+import { type ComboboxOption, type ComboboxProps } from "./Combobox";
+export type AutoCompleteProps = Omit<ComboboxProps, "allowsCustomValue" | "inputValue" | "defaultInputValue" | "onInputChange" | "selectedKey" | "defaultSelectedKey" | "onSelectionChange"> & {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSelect?: (item: ComboboxOption) => void;
+};
+export declare function AutoComplete({ value: controlledValue, defaultValue, onChange, onSelect, items, ...props }: AutoCompleteProps): import("react").JSX.Element;
+export declare const Autocomplete: typeof AutoComplete;

package/dist/types/Badge.d.ts

@@ -0,0 +1,13 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+export type BadgeTone = "neutral" | "info" | "success" | "warning" | "danger";
+export type BadgeSize = "small" | "medium";
+export type BadgeProps = HTMLAttributes<HTMLSpanElement> & {
+    tone?: BadgeTone;
+    size?: BadgeSize;
+    children: ReactNode;
+};
+export declare const Badge: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & {
+    tone?: BadgeTone;
+    size?: BadgeSize;
+    children: ReactNode;
+} & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/types/Button.d.ts

@@ -0,0 +1,36 @@
+import { type AnchorHTMLAttributes, type ButtonHTMLAttributes, type ReactNode } from "react";
+export type ButtonVariant = "primary" | "secondary" | "outline" | "ghost" | "danger";
+export type ButtonSize = "compact" | "default" | "touch";
+type ButtonSharedProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    busy?: boolean;
+    busyLabel?: ReactNode;
+};
+export type ButtonProps = ButtonSharedProps & ({
+    iconOnly: true;
+    "aria-label": string;
+} | {
+    iconOnly?: false;
+});
+type LinkButtonSharedProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    href: string;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    disabled?: boolean;
+};
+export type LinkButtonProps = LinkButtonSharedProps & ({
+    iconOnly: true;
+    "aria-label": string;
+} | {
+    iconOnly?: false;
+});
+export type ButtonStyleProps = Pick<ButtonSharedProps, "className"> & {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    iconOnly?: boolean;
+};
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const LinkButton: import("react").ForwardRefExoticComponent<LinkButtonProps & import("react").RefAttributes<HTMLAnchorElement>>;
+export declare function buttonClassName({ variant, size, iconOnly, className }?: ButtonStyleProps): string;
+export {};

package/dist/types/Cascader.d.ts

@@ -0,0 +1,57 @@
+import { type InputHTMLAttributes, type ReactNode, type Ref } from "react";
+export type CascaderOption = {
+    value: string;
+    label: string;
+    children?: CascaderOption[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+};
+type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "children" | "disabled" | "required"> & {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+};
+type CommonProps = {
+    options: CascaderOption[];
+    label?: ReactNode;
+    helpText?: ReactNode;
+    error?: ReactNode;
+    id?: string;
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+    placeholder?: string;
+    emptyText?: ReactNode;
+    clearLabel?: string;
+    allowClear?: boolean;
+    searchable?: boolean;
+    changeOnSelect?: boolean;
+    open?: boolean;
+    onOpenChange?(open: boolean): void;
+    loadData?(path: CascaderOption[]): void;
+    inputProps?: InputProps;
+    inputRef?: Ref<HTMLInputElement>;
+};
+export type CascaderProps = CommonProps & ({
+    multiple?: false;
+    value: string[];
+    onValueChange(value: string[], path: CascaderOption[]): void;
+} | {
+    multiple: true;
+    value: string[][];
+    onValueChange(value: string[][], paths: CascaderOption[][]): void;
+    /** Independent selection is the default; false enables parent/child conduction. */
+    checkStrictly?: boolean;
+    maxTagCount?: number;
+});
+/** Controlled hierarchical path picker. Data loading and business IDs belong to the caller. */
+export declare function Cascader(props: CascaderProps): import("react").JSX.Element;
+export type CascaderFlatItem = {
+    id: string;
+    label: string;
+    parentId?: string | null;
+    disabled?: boolean;
+};
+/** Reject ambiguous IDs and cycles instead of silently changing a business hierarchy. */
+export declare function buildCascaderOptions(items: readonly CascaderFlatItem[]): CascaderOption[];
+/** Build once per options change when adapting many selected department IDs. */
+export declare function indexCascaderPaths(options: readonly CascaderOption[]): Map<string, string[]>;
+export {};

package/dist/types/ChineseAddressRegions.d.ts

@@ -0,0 +1,4 @@
+import type { AddressRegion } from "./StructuredAddressInput";
+export declare const CHINESE_ADDRESS_DATA_VERSION = "2026.0.0";
+export declare const OVERSEAS_ADDRESS_REGION_ID = "overseas";
+export declare const chineseAddressRegions: readonly AddressRegion[];

package/dist/types/Combobox.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode, type Ref } from "react";
+import { type InputProps, type Placement } from "react-aria-components";
+export type ComboboxOption = {
+    id: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+};
+type DataAttributes = {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+};
+export type ComboboxProps = {
+    items: readonly ComboboxOption[];
+    label?: ReactNode;
+    placeholder?: string;
+    inputValue?: string;
+    defaultInputValue?: string;
+    selectedKey?: string | null;
+    defaultSelectedKey?: string;
+    onInputChange?: (value: string) => void;
+    onSelectionChange?: (key: string | null) => void;
+    loading?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    allowsCustomValue?: boolean;
+    emptyText?: ReactNode;
+    helpText?: ReactNode;
+    error?: ReactNode;
+    virtualized?: boolean;
+    className?: string;
+    inputRef?: Ref<HTMLInputElement>;
+    inputProps?: Omit<InputProps, "id" | "className" | "placeholder" | "value" | "defaultValue" | "onChange" | "disabled" | "required"> & DataAttributes;
+    placement?: Placement;
+    portalContainer?: Element;
+};
+export declare function Combobox({ items, label, placeholder, inputValue, defaultInputValue, selectedKey, defaultSelectedKey, onInputChange, onSelectionChange, loading, disabled, required, allowsCustomValue, emptyText, helpText, error, virtualized, className, inputRef, inputProps, placement, portalContainer }: ComboboxProps): import("react").JSX.Element;
+export {};

package/dist/types/ConfirmDialog.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+import { type ButtonVariant } from "./Button";
+import type { FocusTarget } from "./useModalFocusTrap";
+export type ConfirmDialogProps = {
+    open: boolean;
+    title: ReactNode;
+    description?: ReactNode;
+    confirmLabel?: ReactNode;
+    cancelLabel?: ReactNode;
+    confirmVariant?: Extract<ButtonVariant, "primary" | "danger">;
+    busy?: boolean;
+    busyLabel?: ReactNode;
+    closeOnEscape?: boolean;
+    initialFocus?: "cancel" | "confirm" | FocusTarget;
+    returnFocus?: FocusTarget | false;
+    onConfirm(): void;
+    onCancel(): void;
+    children?: ReactNode;
+};
+export declare function ConfirmDialog({ open, title, description, confirmLabel, cancelLabel, confirmVariant, busy, busyLabel, closeOnEscape, initialFocus, returnFocus, onConfirm, onCancel, children }: ConfirmDialogProps): import("react").JSX.Element | null;

package/dist/types/DataTable.d.ts

@@ -0,0 +1,68 @@
+import { type MRT_TableOptions, type MRT_RowData, type MRT_TableInstance, type MRT_ColumnDef } from "material-react-table";
+import { type CSSProperties, type HTMLAttributes, type ReactNode, type Ref, type TableHTMLAttributes } from "react";
+export { DataTableTheme } from './DataTableTheme';
+export { DataTableMergedRows, type DataTableMergedRowsProps } from './DataTableMergedRows';
+type DataAttributes = {
+    [key: `data-${string}`]: string | number | undefined;
+};
+export type DataTableSort = {
+    columnId: string;
+    direction: "ascending" | "descending";
+};
+export type DataTableColumn<Row> = {
+    id: string;
+    header: ReactNode;
+    cell: (row: Row) => ReactNode;
+    mobileLabel?: string;
+    sortValue?: (row: Row) => string | number | Date | null | undefined;
+    sortable?: boolean;
+    align?: "start" | "center" | "end";
+    width?: CSSProperties["width"];
+};
+export type DataTableProps<Row> = {
+    rows: readonly Row[];
+    columns: readonly DataTableColumn<Row>[];
+    getRowId: (row: Row) => string;
+    caption?: ReactNode;
+    sort?: DataTableSort | null;
+    defaultSort?: DataTableSort | null;
+    onSortChange?: (sort: DataTableSort | null) => void;
+    sortMode?: "client" | "server";
+    selectionSummary?: boolean;
+    selectPageLabel?: string;
+    renderSelectionActions?: (ids: ReadonlySet<string>) => ReactNode;
+    hiddenColumnIds?: ReadonlySet<string>;
+    selectedRowIds?: ReadonlySet<string>;
+    onSelectedRowIdsChange?: (ids: Set<string>) => void;
+    getRowDisabled?: (row: Row) => boolean;
+    loading?: boolean;
+    loadingRows?: number;
+    emptyTitle?: ReactNode;
+    emptyDescription?: ReactNode;
+    emptyAction?: ReactNode;
+    mobileLayout?: "scroll" | "cards";
+    stickyHorizontalScrollbar?: boolean;
+    horizontalScrollbarLabel?: string;
+    className?: string;
+    rootRef?: Ref<HTMLDivElement>;
+    rootProps?: Omit<HTMLAttributes<HTMLDivElement>, "children" | "className"> & DataAttributes;
+    tableRef?: Ref<HTMLTableElement>;
+    tableProps?: Omit<TableHTMLAttributes<HTMLTableElement>, "children" | "className"> & DataAttributes;
+};
+/** Advanced table configuration. Use inside a component, just like MRT's hook. */
+export declare function useDataTable<Row extends MRT_RowData>(options: MRT_TableOptions<Row>): MRT_TableInstance<Row>;
+/** Render the public advanced table instance; callers own domain columns/data. */
+export declare function DataTableView<Row extends MRT_RowData>({ table, stickyHorizontalScrollbar, horizontalScrollbarLabel }: {
+    table: MRT_TableInstance<Row>;
+    stickyHorizontalScrollbar?: boolean;
+    horizontalScrollbarLabel?: string;
+}): import("react").JSX.Element;
+export type { MRT_TableOptions as DataTableOptions, MRT_TableInstance as DataTableInstance, MRT_ColumnDef as DataTableColumnDef };
+export type ConfiguredDataTableProps<Row extends MRT_RowData> = {
+    options: MRT_TableOptions<Row>;
+    stickyHorizontalScrollbar?: boolean;
+    horizontalScrollbarLabel?: string;
+};
+export declare function DataTable<Row>(props: DataTableProps<Row>): ReactNode;
+export declare function DataTable<Row extends MRT_RowData>(props: ConfiguredDataTableProps<Row>): ReactNode;
+export declare function sortRows<Row>(rows: readonly Row[], columns: readonly DataTableColumn<Row>[], sort?: DataTableSort | null): Row[];

package/dist/types/DataTableHorizontalScrollbar.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+type Props = {
+    children: ReactNode;
+    enabled?: boolean;
+    label?: string;
+};
+export declare function DataTableHorizontalScrollbar({ children, enabled, label }: Props): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+export {};

package/dist/types/DataTableIcons.d.ts

@@ -0,0 +1,19 @@
+import { type SvgIconProps } from '@mui/material/SvgIcon';
+export declare const icons: {
+    SearchIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    CloseIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    CancelIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    ArrowDownwardIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    ExpandMoreIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    ArrowRightIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    SyncAltIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    MoreVertIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    ViewColumnIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    FilterListIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    FilterAltIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    FilterListOffIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    PushPinIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    DragHandleIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    RestartAltIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    VisibilityOffIcon: import("react").ForwardRefExoticComponent<Omit<SvgIconProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+};

package/dist/types/DataTableMergedRows.d.ts

@@ -0,0 +1,11 @@
+import { type MRT_TableInstance } from 'material-react-table';
+import type { ReactNode } from 'react';
+import type { MRT_RowData } from 'material-react-table';
+export type DataTableMergedRowsProps<Row extends MRT_RowData, Detail> = {
+    table: MRT_TableInstance<Row>;
+    getDetails: (row: Row) => readonly Detail[];
+    detailColumnIds: readonly string[];
+    getDetailValue: (detail: Detail | null, columnId: string) => ReactNode;
+    emptyContent?: ReactNode;
+};
+export declare function DataTableMergedRows<Row extends MRT_RowData, Detail>(props: DataTableMergedRowsProps<Row, Detail>): import("react").JSX.Element;

package/dist/types/DataTableTheme.d.ts

@@ -0,0 +1,4 @@
+import { type ReactNode } from 'react';
+export declare function DataTableTheme({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/DateInput.d.ts

@@ -0,0 +1,25 @@
+import { type InputHTMLAttributes, type Ref } from "react";
+export type DateInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "defaultValue" | "onChange"> & {
+    value: string;
+    onValueChange(value: string): void;
+    inputRef?: Ref<HTMLInputElement>;
+    inputClassName?: string;
+    minDate?: string;
+    maxDate?: string;
+    isDateUnavailable?(isoDate: string): boolean;
+    onValidationError?(message: string | null): void;
+};
+export declare const DateInput: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "defaultValue" | "onChange" | "value"> & {
+    value: string;
+    onValueChange(value: string): void;
+    inputRef?: Ref<HTMLInputElement>;
+    inputClassName?: string;
+    minDate?: string;
+    maxDate?: string;
+    isDateUnavailable?(isoDate: string): boolean;
+    onValidationError?(message: string | null): void;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export declare function parseDate(value: string): string | null;
+export declare function calendarDays(year: number, month: number): {
+    date: Date;
+}[];

package/dist/types/DocumentRenderBudget.d.ts

@@ -0,0 +1,9 @@
+export type PdfRenderBudget = {
+    maxDevicePixelRatio: number;
+    maxCanvasPixels: number;
+    overscanPixels: number;
+    neighboringPages: number;
+    preloadOffsets: number[];
+};
+export declare function getPdfRenderBudget(viewportWidth: number, coarsePointer: boolean): PdfRenderBudget;
+export declare function constrainedPixelRatio(cssWidth: number, cssHeight: number, devicePixelRatio: number, budget: PdfRenderBudget): number;

package/dist/types/DocumentViewer.d.ts

@@ -0,0 +1,11 @@
+import "./styles.css";
+import "./document-viewer/document-viewer.css";
+export { DocumentViewer, type DocumentViewerSource, type DocumentViewerProps } from "./document-viewer/DocumentViewer";
+export { DocumentViewerViewport, type DocumentViewerViewportProps } from "./document-viewer/DocumentViewerViewport";
+export { ContinuousPdfViewer } from "./document-viewer/ContinuousPdfViewer";
+export { PdfThumbnailRail, PageThumbnail } from "./document-viewer/PdfThumbnailRail";
+export { PdfWorkspace } from "./document-viewer/PdfWorkspace";
+export { PdfCanvasPage } from "./document-viewer/PdfCanvasPage";
+export { PdfToolbar } from "./document-viewer/PdfToolbar";
+export { usePdfCanvas } from "./document-viewer/usePdfCanvas";
+export { usePdfViewport } from "./document-viewer/usePdfViewport";

package/dist/types/DocumentViewerV2.d.ts

@@ -0,0 +1,10 @@
+import "./styles.css";
+import "./document-viewer-v2.css";
+import "./document-viewer/document-viewer.css";
+export type { DocumentViewerV2HeadlessProps, DocumentViewerV2OverlayContext } from './document-viewer-v2/HeadlessPdfViewer';
+export { DocumentViewerV2, DocumentViewerV2 as DocumentViewer, createDocumentViewerV2Config, DOCUMENT_VIEWER_V2_DISABLED_CATEGORIES, } from "./document-viewer-v2/DocumentViewerV2";
+export type { DocumentViewerV2BufferSource, DocumentViewerV2Config, DocumentViewerV2Props, DocumentViewerV2Source, DocumentViewerV2PdfSource, DocumentViewerV2ImageSource, DocumentViewerV2NativeProps, DocumentViewerV2UrlSource, } from "./document-viewer-v2/DocumentViewerV2";
+export type { DocumentViewerProps, DocumentViewerSource } from './document-viewer/DocumentViewer';
+export { DocumentViewerViewport, ContinuousPdfViewer, PdfThumbnailRail, PageThumbnail, PdfWorkspace, PdfCanvasPage, PdfToolbar, usePdfCanvas, usePdfViewport } from './DocumentViewer';
+export type { DocumentViewerViewportProps } from './DocumentViewer';
+export type { PDFViewerConfig, PDFViewerRef, PluginRegistry, } from "@embedpdf/react-pdf-viewer";

package/dist/types/DropdownMenu.d.ts

@@ -0,0 +1,73 @@
+import { type ButtonProps as AriaButtonProps, type MenuItemProps as AriaMenuItemProps, type MenuProps as AriaMenuProps, type Placement } from "react-aria-components";
+import { type AriaAttributes, type ReactNode, type Ref } from "react";
+import { type ButtonSize, type ButtonVariant } from "./Button";
+type DropdownMenuItemPresentation = {
+    label: ReactNode;
+    textValue: string;
+    disabled?: boolean;
+    startIcon?: ReactNode;
+    endSlot?: ReactNode;
+    selectedIcon?: ReactNode;
+    current?: AriaAttributes["aria-current"];
+    itemRef?: Ref<HTMLDivElement>;
+    itemProps?: DropdownMenuItemProps;
+};
+export type DropdownMenuAction = DropdownMenuItemPresentation & {
+    type?: "item";
+    id: string;
+    dangerous?: boolean;
+    onAction(): void;
+};
+export type DropdownMenuSeparator = {
+    type: "separator";
+    id: string;
+};
+export type DropdownMenuGroup = {
+    type: "group";
+    id: string;
+    label?: ReactNode;
+    items: readonly DropdownMenuEntry[];
+};
+export type DropdownMenuSubmenu = DropdownMenuItemPresentation & {
+    type: "submenu";
+    id: string;
+    items: readonly DropdownMenuEntry[];
+};
+export type DropdownMenuEntry = DropdownMenuAction | DropdownMenuSeparator | DropdownMenuGroup | DropdownMenuSubmenu;
+export type DropdownMenuSelection = "all" | Set<string>;
+type DropdownMenuSelectionProps = {
+    selectionMode?: "none";
+    selectedKeys?: never;
+    defaultSelectedKeys?: never;
+    onSelectionChange?: never;
+} | {
+    selectionMode: "single" | "multiple";
+    selectedKeys?: "all" | Iterable<string>;
+    defaultSelectedKeys?: "all" | Iterable<string>;
+    onSelectionChange?: (keys: DropdownMenuSelection) => void;
+};
+type DataAttributes = {
+    [key: `data-${string}`]: string | number | undefined;
+};
+export type DropdownMenuTriggerProps = Omit<AriaButtonProps, "children" | "className" | "isDisabled"> & DataAttributes;
+export type DropdownMenuListProps = Omit<AriaMenuProps<DropdownMenuEntry>, "children" | "className" | "items" | "selectionMode" | "selectedKeys" | "defaultSelectedKeys" | "onSelectionChange"> & DataAttributes;
+export type DropdownMenuItemProps = Omit<AriaMenuItemProps<DropdownMenuEntry>, "children" | "className" | "id" | "value" | "textValue" | "isDisabled" | "onAction" | "aria-current"> & DataAttributes;
+export type DropdownMenuProps = DropdownMenuSelectionProps & {
+    trigger: ReactNode;
+    triggerLabel?: string;
+    triggerVariant?: ButtonVariant;
+    triggerSize?: ButtonSize;
+    triggerRef?: Ref<HTMLButtonElement>;
+    triggerProps?: DropdownMenuTriggerProps;
+    items: readonly DropdownMenuEntry[];
+    menuLabel?: string;
+    menuRef?: Ref<HTMLDivElement>;
+    menuProps?: DropdownMenuListProps;
+    placement?: Placement;
+    portalContainer?: Element;
+    disabled?: boolean;
+    className?: string;
+};
+export declare function DropdownMenu({ trigger, triggerLabel, triggerVariant, triggerSize, items, menuLabel, triggerRef, triggerProps, menuRef, menuProps, placement, portalContainer, disabled, className, selectionMode, selectedKeys, defaultSelectedKeys, onSelectionChange }: DropdownMenuProps): import("react").JSX.Element;
+export declare const Menu: typeof DropdownMenu;
+export {};

package/dist/types/EmptyState.d.ts

@@ -0,0 +1,9 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+export type EmptyStateProps = Omit<HTMLAttributes<HTMLDivElement>, "title"> & {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    compact?: boolean;
+};
+export declare function EmptyState({ icon, title, description, action, compact, className, ...props }: EmptyStateProps): import("react").JSX.Element;

package/dist/types/ExplainableButton.d.ts

@@ -0,0 +1,7 @@
+import { type ButtonProps } from "./Button";
+export type ExplainableButtonProps = Omit<ButtonProps, "disabled"> & {
+    disabled?: boolean;
+    disabledReason?: string;
+    reasonPresentation?: "inline" | "popover";
+};
+export declare function ExplainableButton({ disabled, disabledReason, reasonPresentation, onClick, onFocus, onBlur, onKeyDown, children, ...props }: ExplainableButtonProps): import("react").JSX.Element;

package/dist/types/FileDropzone.d.ts

@@ -0,0 +1,20 @@
+import { type InputHTMLAttributes, type LabelHTMLAttributes, type ReactNode, type Ref } from "react";
+export type FileDropzoneProps = Omit<LabelHTMLAttributes<HTMLLabelElement>, "children" | "onChange"> & {
+    children: ReactNode;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    maxFileSize?: number;
+    maxFiles?: number;
+    inputRef?: Ref<HTMLInputElement>;
+    inputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "accept" | "children" | "className" | "disabled" | "multiple" | "onChange" | "type">;
+    onFilesSelected(files: readonly File[]): void;
+    onFilesRejected?(files: readonly File[]): void;
+    onRejections?(rejections: readonly FileRejection[]): void;
+};
+export type FileRejection = {
+    file: File;
+    reason: "type" | "size" | "count";
+};
+export declare function FileDropzone({ children, accept, multiple, disabled, inputRef, inputProps, maxFileSize, maxFiles, onRejections, onFilesSelected, onFilesRejected, className, onDragEnter, onDragLeave, onDragOver, onDrop, onKeyDown, ...props }: FileDropzoneProps): import("react").JSX.Element;
+export declare function acceptsFile(file: Pick<File, "name" | "type">, accept?: string): boolean;

package/dist/types/FilePreparationDialog.d.ts

@@ -0,0 +1,12 @@
+import type { FilePreparation } from "./useFilePreparation";
+export type FilePreparationLabels = {
+    preparingTitle: string;
+    failedTitle: string;
+    preparingDescription: string;
+    cancel: string;
+    close: string;
+};
+export declare function FilePreparationDialog({ preparation, labels }: {
+    preparation: FilePreparation;
+    labels: FilePreparationLabels;
+}): import("react").JSX.Element | null;

package/dist/types/FloatingControls.d.ts

@@ -0,0 +1,39 @@
+import { type ReactElement, type ReactNode } from "react";
+import { type ButtonVariant } from "./Button";
+type FloatingSide = "top" | "right" | "bottom" | "left";
+type FloatingAlign = "start" | "center" | "end";
+export type TooltipProps = {
+    children: ReactElement;
+    content: ReactNode;
+    side?: FloatingSide;
+    delayDuration?: number;
+    disabled?: boolean;
+    contentClassName?: string;
+};
+export declare function Tooltip({ children, content, side, delayDuration, disabled, contentClassName }: TooltipProps): import("react").JSX.Element;
+export type PopoverProps = {
+    trigger: ReactElement;
+    children: ReactNode;
+    title?: ReactNode;
+    closeLabel?: string;
+    side?: FloatingSide;
+    align?: FloatingAlign;
+    open?: boolean;
+    defaultOpen?: boolean;
+    modal?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    contentClassName?: string;
+};
+export declare function Popover({ trigger, children, title, closeLabel, side, align, open, defaultOpen, modal, onOpenChange, contentClassName }: PopoverProps): import("react").JSX.Element;
+export type PopconfirmProps = Omit<PopoverProps, "children" | "title" | "onOpenChange"> & {
+    title: ReactNode;
+    description?: ReactNode;
+    confirmLabel?: ReactNode;
+    cancelLabel?: ReactNode;
+    confirmVariant?: ButtonVariant;
+    onConfirm: () => void | Promise<void>;
+    onConfirmError?: (error: unknown) => void;
+    onOpenChange?: (open: boolean) => void;
+};
+export declare function Popconfirm({ title, description, confirmLabel, cancelLabel, confirmVariant, onConfirm, onConfirmError, open: controlledOpen, defaultOpen, onOpenChange, ...popoverProps }: PopconfirmProps): import("react").JSX.Element;
+export {};