@godxjp/ui 2.1.0 → 5.0.0

package/dist/Table.types-BbsxoIYE.d.ts

@@ -0,0 +1,352 @@
+import { RowData, Row as Row$1, ColumnDef, VisibilityState, ColumnPinningState, Table } from '@tanstack/react-table';
+import { ComponentProps, ReactNode, MouseEvent, CSSProperties, Ref, HTMLAttributes } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { C as ColorProp, D as DensityProp } from './color-DO0qqUAb.js';
+
+type GutterValue = number | [number, number] | Partial<Record<Breakpoint, number>>;
+type Breakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+type Justify = "start" | "end" | "center" | "space-around" | "space-between" | "space-evenly";
+type Align = "top" | "middle" | "bottom" | "stretch";
+interface RowProps extends Omit<ComponentProps<"div">, "children"> {
+    /** Horizontal gap (px), or [horizontal, vertical], or per-breakpoint object. */
+    gutter?: GutterValue;
+    /** Flex justify on the cross axis. */
+    justify?: Justify;
+    /** Flex align on the main axis. */
+    align?: Align;
+    /** Wrap children when sum > 24 cols (default true). */
+    wrap?: boolean;
+    children?: ReactNode;
+}
+declare function useRowGutter(): [number, number];
+declare function Row({ gutter, justify, align, wrap, className, style, children, ...rest }: RowProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Tag — Ant-Design label chip.
+ *
+ *   <Tag>basic</Tag>
+ *   <Tag color="success">done</Tag>
+ *   <Tag color="oklch(56% 0.15 240)">custom hue</Tag>
+ *   <Tag closable onClose={() => …}>removable</Tag>
+ *   <Tag bordered={false}>borderless</Tag>
+ *
+ * Distinct from <Badge>: Badge is for status pills (a numeric or
+ * single short word), Tag is for labels (potentially many in a row,
+ * potentially closable).
+ */
+/**
+ * Tag accepts the framework's full semantic palette except `"secondary"`
+ * (that one is reserved for Typography text-dimming). Aliased from the
+ * shared `ColorProp` so the vocabulary stays in lockstep with Alert,
+ * Result, Timeline, etc.
+ */
+type TagPresetColor = Exclude<ColorProp, "secondary">;
+interface TagProps extends Omit<ComponentProps<"span">, "color"> {
+    /** Preset hue or a custom CSS color. */
+    color?: TagPresetColor | string;
+    /** Show outline (default `true`). Borderless = solid-tinted background only. */
+    bordered?: boolean;
+    /** Show an × button. Calls `onClose`. */
+    closable?: boolean;
+    onClose?: (e: MouseEvent<HTMLButtonElement>) => void;
+    /** Leading icon. */
+    icon?: ReactNode;
+}
+declare function Tag({ color, bordered, closable, onClose, icon, className, style, children, ...rest }: TagProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * @godxjp/ui Table — type surface.
+ *
+ * Split out of `Table.tsx` in Stage 4 of the refactor (Plan §3) so
+ * the primitive file focuses on rendering + state, while consumers
+ * and the `<DataTable>` composite consume a focused type module.
+ *
+ * Also hosts the TanStack `ColumnMeta` augmentation — every consumer
+ * that touches a `meta` field benefits from the typed interface.
+ */
+
+type TableStickySide = "left" | "right";
+type TableStickyConfig = TableStickySide | false | {
+    side: TableStickySide;
+    from?: Breakpoint;
+};
+declare module "@tanstack/react-table" {
+    /**
+     * Primitive-level `ColumnMeta` — fields consumed by the `<Table>`
+     * primitive itself: cell rendering, sort UI in headers, sticky
+     * positioning.
+     *
+     * Composite-only fields (`filterable`, `filterLabel`,
+     * `filterOptions`, `hideable`) live in
+     * `composites/data-table/DataTable.types.ts` and are merged into
+     * `ColumnMeta` whenever a consumer imports from
+     * `@godxjp/ui/components/composites`.
+     */
+    interface ColumnMeta<TData extends RowData, TValue> {
+        className?: string;
+        headerClassName?: string;
+        cellClassName?: string | ((row: Row$1<TData>) => string | undefined);
+        style?: CSSProperties;
+        headerStyle?: CSSProperties;
+        cellStyle?: CSSProperties | ((row: Row$1<TData>) => CSSProperties | undefined);
+        sortable?: boolean;
+        sticky?: TableStickyConfig;
+    }
+}
+
+type TableDensity = DensityProp;
+type TableColumn<TData, TValue = unknown> = ColumnDef<TData, TValue>;
+type TableColumnVisibility = VisibilityState;
+type TableRowKey<TData> = Extract<keyof TData, string> | ((row: TData, index: number) => string | number);
+type TableFilterOperator = "eq" | "neq" | "contains" | "startsWith" | "endsWith" | "gt" | "gte" | "lt" | "lte" | "between" | "in";
+interface TableFilter {
+    key: string;
+    operator?: TableFilterOperator;
+    value?: string | number | boolean | null;
+    valueLabel?: ReactNode;
+}
+interface TableSort {
+    key: string;
+    direction: "asc" | "desc";
+}
+/** Multi-sort: ordered list whose head is the primary key. */
+type TableSortState = TableSort | TableSort[] | null;
+/** Numbered pagination (default behaviour for general lists). */
+interface TablePaginationNumberedConfig {
+    type?: "numbered";
+    current: number;
+    pageSize: number;
+    total: number;
+    pageSizeOptions?: number[];
+    showSizeChanger?: boolean;
+    hideOnSinglePage?: boolean;
+    disabled?: boolean;
+    showTotal?: (total: number, range: [number, number]) => ReactNode;
+    onChange?: (page: number, pageSize: number) => void;
+}
+/** Load-more pagination (feed-like activity / notification lists). */
+interface TablePaginationLoadMoreConfig {
+    type: "load-more";
+    hasMore: boolean;
+    onLoadMore: () => void;
+    currentCount: number;
+    total: number;
+    batchSize?: number;
+    loadingMore?: boolean;
+    loadMoreLabel?: ReactNode;
+    progressLabel?: (currentCount: number, total: number) => ReactNode;
+}
+/** Cursor pagination (time-series jump-to-period for kintai / payroll). */
+interface TablePaginationCursorConfig {
+    type: "cursor";
+    value: string;
+    onChange: (value: string) => void;
+    label: ReactNode;
+    prevLabel?: ReactNode;
+    nextLabel?: ReactNode;
+    jumpToLatestLabel?: ReactNode;
+    /** HTML input type — `"month"` (default), `"date"`, or `"week"`. */
+    inputType?: "month" | "date" | "week";
+    onPrev?: () => void;
+    onNext?: () => void;
+    onJumpToLatest?: () => void;
+    disabled?: boolean;
+}
+type TablePaginationVariantConfig = TablePaginationNumberedConfig | TablePaginationLoadMoreConfig | TablePaginationCursorConfig;
+interface TableViewSnapshot {
+    filters?: TableFilter[];
+    sort?: TableSort | null;
+    columnVisibility?: TableColumnVisibility;
+}
+interface TableViewItem extends TableViewSnapshot {
+    key: string;
+    label: ReactNode;
+    count?: ReactNode;
+    dotColor?: string;
+    disabled?: boolean;
+    deletable?: boolean;
+}
+interface TableViewsConfig {
+    items: TableViewItem[];
+    activeKey?: string;
+    onActiveKeyChange?: (key: string) => void;
+    onViewApply?: (view: TableViewItem) => void;
+    onDeleteView?: (view: TableViewItem) => void;
+    onItemsChange?: (items: TableViewItem[]) => void;
+    saveable?: boolean;
+    saveLabel?: ReactNode;
+    deleteLabel?: string;
+    onSaveCurrent?: () => void;
+}
+interface TableToolbarSearchConfig {
+    value: string;
+    onValueChange: (value: string) => void;
+    onSearch?: (value: string) => void;
+    onClear?: () => void;
+    placeholder?: string;
+    ariaLabel?: string;
+    inputRef?: Ref<HTMLInputElement>;
+    suffix?: ReactNode;
+    disabled?: boolean;
+}
+interface TableToolbarButtonConfig {
+    label?: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+}
+interface TableToolbarFilterConfig extends TableToolbarButtonConfig {
+    count?: number;
+}
+type TableToolbarColumnConfig = TableToolbarButtonConfig;
+interface TableToolbarConfig {
+    search?: false | TableToolbarSearchConfig;
+    filter?: false | TableToolbarFilterConfig;
+    columns?: false | TableToolbarColumnConfig;
+    primaryAction?: false | ReactNode | TableToolbarButtonConfig;
+    actions?: ReactNode;
+}
+interface TableBatchActionsContext<TData> {
+    selectedRowKeys: string[];
+    selectedRows: Row$1<TData>[];
+    totalSelectableCount: number;
+    selectAllVisible: () => void;
+    clearSelection: () => void;
+}
+interface TableBatchActionsConfig<TData> {
+    selectedRowKeys: string[];
+    onSelectedRowKeysChange: (keys: string[]) => void;
+    actions: ReactNode | ((context: TableBatchActionsContext<TData>) => ReactNode);
+    getCheckboxDisabled?: (row: Row$1<TData>) => boolean;
+    selectedLabel?: (count: number) => ReactNode;
+    selectAllLabel?: (count: number) => ReactNode;
+    clearLabel?: ReactNode;
+}
+interface TableFilterOption {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+}
+interface TableFilterItem {
+    key: string;
+    label: ReactNode;
+    value?: string;
+    valueLabel?: ReactNode;
+    operator?: TableFilterOperator;
+    options?: TableFilterOption[];
+    onValueChange?: (value: string) => void;
+    color?: TagPresetColor | string;
+    closable?: boolean;
+    onClose?: () => void;
+}
+type TableFilterBar = ReactNode | TableFilterItem[];
+type TablePagination = ReactNode | false | TablePaginationVariantConfig;
+type TableToolbar = ReactNode | false | TableToolbarConfig;
+type TableViews = ReactNode | false | TableViewsConfig;
+/** Expand-row config (rule 32 — no `expanded`-singular / `expand` synonyms). */
+interface TableExpandableConfig<TData> {
+    /** Rows whose expand panel is open. */
+    expandedRowKeys?: string[];
+    defaultExpandedRowKeys?: string[];
+    onExpandedRowsChange?: (keys: string[]) => void;
+    /** Renders the inline detail panel. */
+    renderExpandedRow: (row: Row$1<TData>) => ReactNode;
+    /** Allows more than one open expand panel at a time. Default `false`. */
+    allowMultiple?: boolean;
+    /** Hide the expand toggle for rows that have no detail panel. */
+    rowExpandable?: (row: Row$1<TData>) => boolean;
+}
+/** Inline-edit config — single editing row, multi-row dirty tracking. */
+interface TableEditingConfig<TData> {
+    /** The row currently in editing mode. `null` exits editing. */
+    rowId: string | null;
+    onStart?: (rowId: string) => void;
+    onCommit?: (rowId: string, patch: Record<string, unknown>) => void;
+    onCancel?: (rowId: string) => void;
+    /** Renders an inline editor for a cell. Return `null` to fall back to the column's normal cell. */
+    renderEditCell?: (column: TableColumn<TData, unknown>, row: Row$1<TData>) => ReactNode;
+    /** Rows that should be read-only (confirmed records / locked rows). */
+    isRowReadOnly?: (row: Row$1<TData>) => boolean;
+    /** Row + cell ids that carry unsaved changes — for the warning dot + footer banner. */
+    dirtyRowIds?: string[];
+    dirtyCellIds?: string[];
+    /** Footer banner — show "N rows unsaved" + Save-all / Cancel-all controls. */
+    onSaveAll?: () => void;
+    onCancelAll?: () => void;
+    saveAllLabel?: ReactNode;
+    cancelAllLabel?: ReactNode;
+    unsavedLabel?: (count: number) => ReactNode;
+}
+/** Row-group config — either a key resolver or a richer descriptor. */
+interface TableGroupDescriptor {
+    key: string;
+    label: ReactNode;
+    count?: ReactNode;
+    total?: ReactNode;
+}
+type TableGroupBy<TData> = (row: TData) => string | TableGroupDescriptor | undefined;
+/** Tree-row config. Children are resolved per parent row. */
+interface TableTreeConfig<TData> {
+    children: (row: TData) => TData[] | undefined;
+    defaultExpandedNodes?: string[];
+    expandedNodes?: string[];
+    onExpandedNodesChange?: (keys: string[]) => void;
+    /** Hard cap on nesting depth (defaults to a reasonable 8). */
+    maxDepth?: number;
+}
+/** Column-pinning callback (TanStack-canonical name). */
+type TableColumnPinningChange = (pinning: ColumnPinningState) => void;
+/**
+ * Selection slice the slim primitive understands — strictly the
+ * checkbox column wiring. The batch action band that surfaces
+ * actions lives on the `<DataTable>` composite (Stage 4b, v5.0.0).
+ */
+interface TableSelectionConfig<TData> {
+    selectedRowKeys: string[];
+    onSelectedRowKeysChange: (keys: string[]) => void;
+    getCheckboxDisabled?: (row: Row$1<TData>) => boolean;
+}
+interface TableProps<TData> extends Omit<HTMLAttributes<HTMLTableElement>, "children"> {
+    columns: TableColumn<TData, unknown>[];
+    data: TData[];
+    density?: TableDensity;
+    containerClassName?: string;
+    stickyHeader?: boolean;
+    rowKey?: TableRowKey<TData>;
+    getRowId?: (row: TData, index: number) => string;
+    caption?: ReactNode;
+    defaultColumnVisibility?: TableColumnVisibility;
+    columnVisibility?: TableColumnVisibility;
+    onColumnVisibilityChange?: (columnVisibility: TableColumnVisibility) => void;
+    /**
+     * Active sort. Pass a single `TableSort` for single-key sort (legacy)
+     * or `TableSort[]` for multi-sort (shift-click adds keys; canon ⑤).
+     */
+    sort?: TableSortState;
+    onSortChange?: (sort: TableSortState) => void;
+    /** Enable per-column horizontal resize handles (canon ⑤). */
+    resizable?: boolean;
+    /** Inline expand-row config (canon ⑥). */
+    expandable?: TableExpandableConfig<TData>;
+    /** Inline editing config (canon ⑦). */
+    editing?: TableEditingConfig<TData>;
+    /** Row-group descriptor — same vocabulary as TanStack `getGroupedRowModel`. */
+    groupBy?: TableGroupBy<TData>;
+    /** Tree-row resolver (canon ⑧, hierarchical rows). */
+    tree?: TableTreeConfig<TData>;
+    /** Receives column-pinning changes from the column manager lock toggle (canon ⑨). */
+    onColumnPinningChange?: TableColumnPinningChange;
+    /** Checkbox-column wiring. Use the `<DataTable>` composite for the batch action band. */
+    selection?: TableSelectionConfig<TData>;
+    footer?: ReactNode;
+    empty?: ReactNode;
+    rowClassName?: string | ((row: Row$1<TData>) => string | undefined);
+    /**
+     * Pre-built TanStack `useReactTable` instance, supplied by the
+     * `<DataTable>` composite. When provided, the primitive skips
+     * its internal `useReactTable` and consumes the externally-managed
+     * instance.
+     */
+    instance?: Table<TData>;
+}
+
+export { type Align as A, type Breakpoint as B, useRowGutter as C, type GutterValue as G, type Justify as J, Row as R, type TableBatchActionsConfig as T, type RowProps as a, type TableColumn as b, type TableColumnPinningChange as c, type TableColumnVisibility as d, type TableDensity as e, type TableEditingConfig as f, type TableExpandableConfig as g, type TableFilter as h, type TableFilterBar as i, type TableFilterOption as j, type TableGroupBy as k, type TablePagination as l, type TableProps as m, type TableRowKey as n, type TableSelectionConfig as o, type TableSort as p, type TableSortState as q, type TableToolbar as r, type TableToolbarConfig as s, type TableTreeConfig as t, type TableViewItem as u, type TableViewSnapshot as v, type TableViews as w, Tag as x, type TagPresetColor as y, type TagProps as z };

package/dist/color-DO0qqUAb.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared density prop-vocabulary per cardinal rule 23 §B.
+ *
+ * Different from `SizeProp` — density rescales the surrounding padding /
+ * row-height tokens (`--density-element-*`) while size targets the
+ * primitive's own visual axis. Tables and lists use `density` to fit
+ * more rows on screen without shrinking the type.
+ */
+type DensityProp = "compact" | "default" | "comfortable";
+
+/**
+ * Shared semantic-color prop-vocabulary per cardinal rule 23 §B.
+ *
+ * Every primitive that exposes a `color` prop picks from this superset.
+ * Each value maps 1:1 to a CSS variable (`--info`, `--success`,
+ * `--warning`, `--destructive`, `--attention`, `--primary`, `--secondary`)
+ * — same semantic slot across the whole system, only the hue / intensity
+ * scale shifts per primitive (cardinal rule 21 — `data-accent` rebinds
+ * `--primary`'s hue without renaming the slot).
+ *
+ * Existing primitives (AlertColor, ResultColor, ProgressColor,
+ * TagPresetColor, TimelineColor, TypographyColor) each accept a subset
+ * — point their aliases at `Extract<ColorProp, …>` instead of
+ * redeclaring the literals inline.
+ *
+ * Vocabulary note: the canonical name for the danger slot in this
+ * palette is `"destructive"` — every primitive that exposes a `color`
+ * prop now uses that name. The shared `StatusProp` (form-field
+ * validation) uses `"error"` deliberately — form errors are NOT
+ * destructive actions; the two concerns deserve distinct verbs.
+ */
+type ColorProp = "default" | "info" | "success" | "warning" | "destructive" | "attention" | "primary" | "secondary";
+/** Subset accepted by feedback primitives — same 5-slot ladder used
+ * by Alert / Result / Progress (no brand `primary`, no text-only
+ * `secondary` / `attention`). */
+type FeedbackColorProp = Extract<ColorProp, "default" | "info" | "success" | "warning" | "destructive">;
+
+export type { ColorProp as C, DensityProp as D, FeedbackColorProp as F };