kokotable 0.95.0

package/dist/mui/src/grouping/groupRow.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Typography } from "@mui/material";
+import { flexRender } from "@tanstack/react-table";
+import { aggregations as defaultAggregations, columnMetaOf, isBuiltinAggregation } from "../../../core/src/index";
+import { AggregateChip } from "./AggregateChip";
+/** depth 1단계당 들여쓰기 (MUI spacing 단위). 그룹값 셀과 집계 셀에 같이 적용한다 */
+export const GROUP_DEPTH_INDENT = 2;
+/** depth 별 그룹 행 배경 — 깊어질수록 한 단계씩 어둡다 */
+export const GROUP_ROW_BG_SHADES = ["grey.50", "grey.100", "grey.200", "grey.300"];
+export function groupRowBgColor(depth) {
+    return GROUP_ROW_BG_SHADES[Math.min(Math.max(depth, 0), GROUP_ROW_BG_SHADES.length - 1)];
+}
+/** 그룹 행 hover 색 — 한 단계 더 어두운 색 */
+export function groupRowHoverColor(depth) {
+    return groupRowBgColor(depth + 1);
+}
+/** 카테고리형(enum/select/text) — 고유 개수 외의 집계는 뜻이 없다 */
+export function isCategoricalColumn(column) {
+    const dataType = columnMetaOf(column.columnDef)?.dataType;
+    return dataType === "enum" || dataType === "select" || dataType === "text";
+}
+function isBooleanColumn(column) {
+    return columnMetaOf(column.columnDef)?.dataType === "boolean";
+}
+/** 그룹 컬럼의 표시 이름 — 헤더가 문자열이면 그것, 아니면 id */
+export function columnLabelOf(column) {
+    const header = column.columnDef.header;
+    return typeof header === "string" ? header : column.id;
+}
+/**
+ * 그룹값 라벨 — `node.label`(코어가 `selectOptions` 로 해석) → 컬럼 `cell` 렌더러 → 문자열.
+ *
+ * `cell` 렌더러는 TanStack 셀 컨텍스트를 기대하므로 최소한의 모조 컨텍스트로 부른다 —
+ * `row.original` 에는 현재 값과 조상 그룹 값을 넣어 상위 필드를 참조하는 렌더러도 동작한다.
+ * 렌더러가 던지면 문자열로 물러선다.
+ */
+export function resolveGroupValue(node, column) {
+    const value = node.groupValue;
+    if (node.label !== undefined && node.label !== null && node.label !== "")
+        return node.label;
+    if (value === null || value === undefined || value === "")
+        return "(비어 있음)";
+    const cellDef = column?.columnDef.cell;
+    if (column && typeof cellDef === "function") {
+        try {
+            const original = Object.fromEntries(node.path.map((step) => [step.key, step.value]));
+            original[node.groupKey] = value;
+            const ctx = {
+                getValue: () => value,
+                renderValue: () => value,
+                row: { original, index: 0, id: `group:${node.groupKey}` },
+                column,
+                cell: undefined,
+                table: undefined,
+            };
+            const rendered = flexRender(cellDef, ctx);
+            if (rendered !== null && rendered !== undefined && rendered !== "")
+                return rendered;
+        }
+        catch {
+            // 렌더러가 행 인스턴스를 요구하는 경우 — 문자열로 물러선다
+        }
+    }
+    return String(value);
+}
+/**
+ * 집계 셀 내용. 그릴 것이 없으면 `null`.
+ *
+ * 우선순위: `meta.aggRender` → 카테고리형은 `count_distinct` + 사용자 집계(`applies` 참)만, boolean 은 `applies("boolean")` 인 것만
+ * (내장: `count_true`·`count_distinct`·`ratio`) → `AggregateChip`
+ * (선택된 함수 = `selection[columnId]`, 없으면 첫 값. 함수가 둘 이상이면 칩을 눌러 바꾼다).
+ * 대상은 `meta.enableAgg` / `meta.aggRender` 가 있거나 `node.aggregates[columnId]` 가 있는 컬럼뿐이다.
+ */
+export function renderAggregateCellContent({ column, node, selection, onSelect, chip, registry: givenRegistry, }) {
+    const Chip = chip ?? AggregateChip;
+    const registry = givenRegistry ?? defaultAggregations;
+    const meta = columnMetaOf(column.columnDef);
+    const allAggregates = node.aggregates ?? {};
+    let perColumn = allAggregates[column.id];
+    if (!meta?.enableAgg && !meta?.aggRender && !perColumn)
+        return null;
+    const presentFns = (source) => source ? Object.keys(source).filter((fn) => source[fn] !== null && source[fn] !== undefined) : [];
+    if (meta?.aggRender) {
+        const fns = presentFns(perColumn);
+        const value = fns.length > 0 ? perColumn[fns[0]] : undefined;
+        const render = meta.aggRender;
+        const rendered = render({ value, columnId: column.id, allAggregates }, column);
+        return rendered === null || rendered === undefined ? null : rendered;
+    }
+    if (!perColumn)
+        return null;
+    const dataType = meta?.dataType;
+    const keep = (fn) => {
+        if (isCategoricalColumn(column)) {
+            // 내장은 고유 개수만 (최빈값 등은 그룹 행에 길게 찍히므로 뺀다); 사용자 집계는 `applies` 를 따른다
+            if (fn === "count_distinct")
+                return true;
+            if (isBuiltinAggregation(fn))
+                return false;
+            return !!registry.get(fn)?.applies(dataType);
+        }
+        if (isBooleanColumn(column))
+            return !!registry.get(fn)?.applies(dataType);
+        return true;
+    };
+    if (isCategoricalColumn(column) || isBooleanColumn(column)) {
+        const kept = {};
+        for (const fn of Object.keys(perColumn))
+            if (keep(fn) && perColumn[fn] !== undefined)
+                kept[fn] = perColumn[fn];
+        perColumn = kept;
+    }
+    const available = presentFns(perColumn);
+    if (available.length === 0)
+        return null;
+    const chosen = selection[column.id];
+    const selected = chosen && available.includes(chosen) ? chosen : available[0];
+    const toggleable = available.length > 1 && !!onSelect;
+    const value = perColumn[selected];
+    return (_jsx(Chip, { aggFn: selected, value: typeof value === "number" || typeof value === "string" ? value : String(value), options: available, columnLabel: columnLabelOf(column), registry: givenRegistry, onChangeAggFn: toggleable ? (fn) => onSelect(column.id, fn) : undefined }));
+}
+/** 그룹값 텍스트 — 굵게 */
+export function GroupValueText({ children }) {
+    return (_jsx(Typography, { component: "span", variant: "body2", sx: { fontWeight: 600, whiteSpace: "nowrap" }, children: children }));
+}
+/** 집계 셀 내용을 가운데 놓는다 (ERP `aggCellContentSx`) */
+export function AggregateCellBox({ children }) {
+    return (_jsx(Box, { sx: { display: "flex", justifyContent: "center", alignItems: "center", width: "100%", minWidth: 0 }, children: children }));
+}

package/dist/mui/src/headers/defaultHeader.d.ts

@@ -0,0 +1,28 @@
+import type { ReactNode } from "react";
+import type { RowData } from "@tanstack/react-table";
+import type { HeaderDef, HeaderRenderContext, HeaderSlots } from "./types";
+/** 정렬 화살표 — MUI `TableSortLabel` 과 같은 모양(asc = 위). 정렬 전에는 흐리게, 다중 정렬은 순번 */
+export declare function SortArrow({ ctx }: {
+    ctx: HeaderRenderContext<any>;
+}): import("react").JSX.Element;
+/**
+ * 기본 슬롯 — 지금까지 `HeaderCell` 이 직접 그리던 것을 다섯 자리로 나눈 것.
+ * 소비자 정의는 `slots: { sortIndicator: … }` 처럼 일부만 바꾼다.
+ */
+export declare const defaultHeaderSlots: HeaderSlots<any>;
+/**
+ * 기본 배치 — `[pin] [content sortIndicator] [menuTrigger]` + 오른쪽 가장자리 `resizeHandle`.
+ * 정렬 가능하면 내용+화살표가 버튼이 된다 (클릭: 정렬 · Shift+클릭: 정렬 추가 · Enter/Space).
+ */
+export declare function renderDefaultHeader<T extends RowData>(ctx: HeaderRenderContext<T>, slots: HeaderSlots<T>): ReactNode;
+/** 기본 헤더 — 다른 정의와 같은 API 로 만든다 (dogfooding) */
+export declare const defaultHeader: HeaderDef<any>;
+/** 촘촘한 헤더 — 메뉴 버튼·리사이즈 핸들 없이 내용과 정렬 화살표만. 우클릭 메뉴는 그대로 열린다 */
+export declare const compactHeader: HeaderDef<any>;
+/** 내장 헤더 정의 — `meta.header: "compact"` 처럼 id 로 고른다 */
+export declare const headerRegistry: import("..").Registry<HeaderDef<any>>;
+/** 정의 하나를 실제 그릴 수 있게 기본과 합친다 — `render` 없으면 기본 배치가 슬롯을 조합한다 */
+export declare function materializeHeader<T extends RowData>(def: HeaderDef<T>): {
+    render: NonNullable<HeaderDef<T>["render"]>;
+    slots: HeaderSlots<T>;
+};

package/dist/mui/src/headers/defaultHeader.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, IconButton, Stack, Tooltip } from "@mui/material";
+import ArrowDownwardIcon from "@mui/icons-material/ArrowDownward";
+import MoreVertIcon from "@mui/icons-material/MoreVert";
+import PushPinIcon from "@mui/icons-material/PushPin";
+import { createRegistry } from "../registry";
+import { defineHeader } from "./defineHeader";
+import { headerRuleMetaOf } from "./meta";
+const JUSTIFY = {
+    left: "flex-start", center: "center", right: "flex-end",
+};
+/** 정렬 화살표 — MUI `TableSortLabel` 과 같은 모양(asc = 위). 정렬 전에는 흐리게, 다중 정렬은 순번 */
+export function SortArrow({ ctx }) {
+    const { sortState, multiSortIndex } = ctx;
+    return (_jsxs(Box, { component: "span", className: "koko-sort-indicator", "aria-hidden": true, sx: {
+            display: "inline-flex", alignItems: "center", ml: 0.5,
+            opacity: sortState ? 1 : 0.3, transition: "opacity 120ms",
+            ".koko-header-sort:hover &": { opacity: sortState ? 1 : 0.7 },
+        }, children: [_jsx(ArrowDownwardIcon, { sx: {
+                    fontSize: 16,
+                    transition: "transform 200ms",
+                    transform: sortState?.desc ? "rotate(0deg)" : "rotate(180deg)",
+                } }), multiSortIndex !== null && (_jsx(Box, { component: "span", sx: { fontSize: 10, color: "text.disabled" }, children: multiSortIndex }))] }));
+}
+/**
+ * 기본 슬롯 — 지금까지 `HeaderCell` 이 직접 그리던 것을 다섯 자리로 나눈 것.
+ * 소비자 정의는 `slots: { sortIndicator: … }` 처럼 일부만 바꾼다.
+ */
+export const defaultHeaderSlots = {
+    content: (ctx) => {
+        const tooltip = headerRuleMetaOf(ctx.column.columnDef).headerTooltip;
+        const label = ctx.defaultContent;
+        if (!tooltip || ctx.header.isPlaceholder)
+            return label;
+        return (_jsx(Tooltip, { title: tooltip, enterDelay: 300, children: _jsx(Box, { component: "span", sx: { textDecoration: "underline dotted", textUnderlineOffset: 3 }, children: label }) }));
+    },
+    sortIndicator: (ctx) => (ctx.can.canSort && ctx.sort ? _jsx(SortArrow, { ctx: ctx }) : null),
+    pinIndicator: (ctx) => (ctx.column.getIsPinned() ? (_jsx(PushPinIcon, { className: "koko-pin-indicator", "aria-label": ctx.labels.ui.unpin, sx: { fontSize: 12, color: "text.disabled", mr: 0.5, transform: ctx.column.getIsPinned() === "right" ? "scaleX(-1)" : undefined } })) : null),
+    menuTrigger: (ctx) => (ctx.menuEnabled ? (_jsx(IconButton, { size: "small", "aria-label": `${ctx.column.id} ${ctx.labels.ui.columnMenu}`, "aria-haspopup": "menu", className: "koko-column-menu-button", onClick: (event) => { event.stopPropagation(); ctx.openMenu(event.currentTarget); }, sx: { p: 0.25, ml: 0.25, opacity: 0.35, "&:hover": { opacity: 1 } }, children: _jsx(MoreVertIcon, { sx: { fontSize: 16 } }) })) : null),
+    resizeHandle: (ctx) => {
+        const { column, header } = ctx;
+        if (!ctx.can.canResize)
+            return null;
+        return (_jsx(Box, { role: "separator", "aria-orientation": "vertical", "aria-label": ctx.labels.ui.resizeHandle(column.id), onMouseDown: header.getResizeHandler(), onTouchStart: header.getResizeHandler(), onClick: (event) => event.stopPropagation(), onDoubleClick: () => column.resetSize(), sx: {
+                position: "absolute", top: 0, right: 0, bottom: 0, width: 6,
+                cursor: "col-resize", userSelect: "none", touchAction: "none",
+                "&:hover, &:active": { backgroundColor: "primary.main", opacity: 0.5 },
+                ...(column.getIsResizing() ? { backgroundColor: "primary.main", opacity: 0.8 } : {}),
+            } }));
+    },
+};
+/**
+ * 기본 배치 — `[pin] [content sortIndicator] [menuTrigger]` + 오른쪽 가장자리 `resizeHandle`.
+ * 정렬 가능하면 내용+화살표가 버튼이 된다 (클릭: 정렬 · Shift+클릭: 정렬 추가 · Enter/Space).
+ */
+export function renderDefaultHeader(ctx, slots) {
+    const { sort, column, align } = ctx;
+    const sortable = ctx.can.canSort && !!sort;
+    const body = _jsxs(_Fragment, { children: [slots.content(ctx), slots.sortIndicator(ctx)] });
+    const onKeyDown = (event) => {
+        if (event.key === "Enter" || event.key === " ") {
+            event.preventDefault();
+            sort?.toggleSort(column.id, { multi: event.shiftKey });
+        }
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(Stack, { direction: "row", alignItems: "center", justifyContent: align ? JUSTIFY[align] : "flex-start", sx: { minWidth: 0 }, children: [slots.pinIndicator(ctx), sortable ? (_jsx(Tooltip, { title: ctx.labels.ui.sortHint, enterDelay: 600, children: _jsx(Box, { component: "span", role: "button", tabIndex: 0, className: "koko-header-sort", onClick: (event) => sort.toggleSort(column.id, { multi: event.shiftKey }), onKeyDown: onKeyDown, sx: {
+                                display: "inline-flex", alignItems: "center", minWidth: 0, cursor: "pointer", userSelect: "none",
+                                overflow: "hidden", textOverflow: "ellipsis",
+                                "&:hover": { color: "text.secondary" },
+                                "&:focus-visible": { outline: "2px solid", outlineColor: "primary.main", outlineOffset: 2, borderRadius: 0.5 },
+                            }, children: body }) })) : (_jsx(Box, { component: "span", sx: { display: "inline-flex", alignItems: "center", minWidth: 0, overflow: "hidden", textOverflow: "ellipsis" }, children: body })), slots.menuTrigger(ctx)] }), slots.resizeHandle(ctx)] }));
+}
+/** 기본 헤더 — 다른 정의와 같은 API 로 만든다 (dogfooding) */
+export const defaultHeader = defineHeader({
+    id: "default",
+    slots: defaultHeaderSlots,
+    render: renderDefaultHeader,
+});
+/** 촘촘한 헤더 — 메뉴 버튼·리사이즈 핸들 없이 내용과 정렬 화살표만. 우클릭 메뉴는 그대로 열린다 */
+export const compactHeader = defineHeader({
+    id: "compact",
+    slots: { menuTrigger: () => null, resizeHandle: () => null, pinIndicator: () => null },
+});
+/** 내장 헤더 정의 — `meta.header: "compact"` 처럼 id 로 고른다 */
+export const headerRegistry = createRegistry([defaultHeader, compactHeader]);
+/** 정의 하나를 실제 그릴 수 있게 기본과 합친다 — `render` 없으면 기본 배치가 슬롯을 조합한다 */
+export function materializeHeader(def) {
+    const slots = { ...defaultHeaderSlots, ...def.slots };
+    return { render: def.render ?? renderDefaultHeader, slots };
+}

package/dist/mui/src/headers/defineHeader.d.ts

@@ -0,0 +1,21 @@
+import type { RowData } from "@tanstack/react-table";
+import type { Registry } from "../registry";
+import type { HeaderCapabilities, HeaderContext, HeaderDef, HeaderMeta } from "./types";
+/** 헤더 정의 — 타입을 좁혀 주는 항등 함수 (설계 2절). Provider `headers[]` 나 `meta.header` 에 넣는다 */
+export declare function defineHeader<T extends RowData = any>(def: HeaderDef<T>): HeaderDef<T>;
+export declare function headerMetaOf<T extends RowData = any>(columnDef: {
+    meta?: unknown;
+} | undefined): HeaderMeta<T>;
+/**
+ * 적용 순서: `column.meta.header`(id 또는 정의) > Provider `headers[]` 중 `when` 이 참인 첫 정의 > 내장 기본.
+ * 문자열 id 는 Provider 정의 → 내장 레지스트리 순으로 찾고, 없으면 기본이다.
+ */
+export declare function resolveHeaderDef<T extends RowData>(ctx: HeaderContext<T>, providerHeaders: ReadonlyArray<HeaderDef<T>>, builtin: Registry<HeaderDef<any>>, fallback: HeaderDef<any>): HeaderDef<T>;
+/**
+ * 규칙을 해석하고 그 결과를 TanStack 컬럼 정의에 되쓴다.
+ *
+ * `column.columnDef` 는 테이블 인스턴스가 만든 사본이라 소비자의 정의 객체는 바뀌지 않는다.
+ * 되쓰는 이유: `ColumnVisibilityMenu` 처럼 `column.getCanHide()` 만 보는 곳도 같은 답을 내야 한다.
+ * 규칙이 없는 항목은 건드리지 않는다. 멱등이라 렌더 중에 불러도 안전하다.
+ */
+export declare function applyHeaderRules<T extends RowData>(ctx: HeaderContext<T>, def: HeaderDef<T> | undefined): HeaderCapabilities;

package/dist/mui/src/headers/defineHeader.js

@@ -0,0 +1,68 @@
+/** 헤더 정의 — 타입을 좁혀 주는 항등 함수 (설계 2절). Provider `headers[]` 나 `meta.header` 에 넣는다 */
+export function defineHeader(def) {
+    return def;
+}
+export function headerMetaOf(columnDef) {
+    return columnDef?.meta ?? {};
+}
+/**
+ * 적용 순서: `column.meta.header`(id 또는 정의) > Provider `headers[]` 중 `when` 이 참인 첫 정의 > 내장 기본.
+ * 문자열 id 는 Provider 정의 → 내장 레지스트리 순으로 찾고, 없으면 기본이다.
+ */
+export function resolveHeaderDef(ctx, providerHeaders, builtin, fallback) {
+    const meta = headerMetaOf(ctx.column.columnDef).header;
+    if (meta && typeof meta === "object")
+        return meta;
+    if (typeof meta === "string") {
+        return providerHeaders.find((def) => def.id === meta) ?? builtin.get(meta) ?? fallback;
+    }
+    return providerHeaders.find((def) => !def.when || def.when(ctx)) ?? fallback;
+}
+const RULE_TO_OPTION = {
+    canSort: "enableSorting",
+    canPin: "enablePinning",
+    canHide: "enableHiding",
+    canResize: "enableResizing",
+    canGroup: "enableGrouping",
+    canFilter: "enableColumnFilter",
+};
+function fallbackOf(column, table, key) {
+    const def = column.columnDef;
+    switch (key) {
+        case "canSort": return column.getCanSort();
+        case "canPin": return column.getCanPin();
+        case "canHide": return column.getCanHide();
+        // 테이블에서 리사이즈를 켜지 않았으면 핸들도 항목도 의미가 없다
+        case "canResize": return !!table.options.enableColumnResizing && column.getCanResize();
+        // 그룹핑은 TanStack 이 아니라 `useGrouping` 이 맡는다 — 컬럼 정의의 플래그만 본다
+        case "canGroup": return def.enableGrouping !== false;
+        case "canFilter": return def.enableColumnFilter !== false && !!def.filter && !def.filter.hidden;
+    }
+}
+/**
+ * 규칙을 해석하고 그 결과를 TanStack 컬럼 정의에 되쓴다.
+ *
+ * `column.columnDef` 는 테이블 인스턴스가 만든 사본이라 소비자의 정의 객체는 바뀌지 않는다.
+ * 되쓰는 이유: `ColumnVisibilityMenu` 처럼 `column.getCanHide()` 만 보는 곳도 같은 답을 내야 한다.
+ * 규칙이 없는 항목은 건드리지 않는다. 멱등이라 렌더 중에 불러도 안전하다.
+ */
+export function applyHeaderRules(ctx, def) {
+    const rules = def?.rules ?? {};
+    const out = {};
+    const target = ctx.column.columnDef;
+    for (const key of Object.keys(RULE_TO_OPTION)) {
+        const rule = rules[key];
+        if (rule) {
+            const allowed = !!rule(ctx);
+            const option = RULE_TO_OPTION[key];
+            if (target[option] !== allowed)
+                target[option] = allowed;
+            // TanStack 은 accessor 없는 컬럼은 규칙이 허용해도 정렬·필터할 수 없다
+            out[key] = key === "canGroup" || key === "canFilter" ? allowed : allowed && fallbackOf(ctx.column, ctx.table, key);
+        }
+        else {
+            out[key] = fallbackOf(ctx.column, ctx.table, key);
+        }
+    }
+    return out;
+}

package/dist/mui/src/headers/index.d.ts

@@ -0,0 +1,5 @@
+export { defineHeader, resolveHeaderDef, applyHeaderRules, headerMetaOf } from "./defineHeader";
+export { defaultHeader, compactHeader, headerRegistry, defaultHeaderSlots, renderDefaultHeader, materializeHeader, SortArrow, } from "./defaultHeader";
+export { headerRuleMetaOf, resolveCellAlign } from "./meta";
+export type { HeaderRuleMeta, CellAlign } from "./meta";
+export type { HeaderContext, HeaderRenderContext, HeaderCapabilities, HeaderSlots, HeaderSlot, HeaderRules, HeaderDef, HeaderMeta, HeaderAlign, } from "./types";

package/dist/mui/src/headers/index.js

@@ -0,0 +1,3 @@
+export { defineHeader, resolveHeaderDef, applyHeaderRules, headerMetaOf } from "./defineHeader";
+export { defaultHeader, compactHeader, headerRegistry, defaultHeaderSlots, renderDefaultHeader, materializeHeader, SortArrow, } from "./defaultHeader";
+export { headerRuleMetaOf, resolveCellAlign } from "./meta";

package/dist/mui/src/headers/meta.d.ts

@@ -0,0 +1,18 @@
+export type CellAlign = "left" | "center" | "right";
+/**
+ * 코어 `ColumnMeta` 의 헤더·셀 규칙 — 코어에 있는 필드지만 mui 가 캐스팅으로 읽는다
+ * (코어 `ColumnMeta` 가 제네릭이라 `columnDef.meta` 를 그대로 좁히기 번거롭다).
+ */
+export interface HeaderRuleMeta {
+    headerTooltip?: string;
+    headerAlign?: CellAlign;
+    /** 셀 정렬. 미지정 시 숫자(`dataType: "number"`)는 right */
+    align?: CellAlign;
+}
+export declare function headerRuleMetaOf(columnDef: {
+    meta?: unknown;
+} | undefined): HeaderRuleMeta;
+/** 셀 정렬 — `meta.align` → 숫자는 right → 미지정 */
+export declare function resolveCellAlign(columnDef: {
+    meta?: unknown;
+} | undefined): CellAlign | undefined;

package/dist/mui/src/headers/meta.js

@@ -0,0 +1,11 @@
+import { columnMetaOf } from "../../../core/src/index";
+export function headerRuleMetaOf(columnDef) {
+    return columnDef?.meta ?? {};
+}
+/** 셀 정렬 — `meta.align` → 숫자는 right → 미지정 */
+export function resolveCellAlign(columnDef) {
+    const rule = headerRuleMetaOf(columnDef);
+    if (rule.align)
+        return rule.align;
+    return columnMetaOf(columnDef)?.dataType === "number" ? "right" : undefined;
+}

package/dist/mui/src/headers/types.d.ts

@@ -0,0 +1,84 @@
+import type { ReactNode } from "react";
+import type { PopoverPosition } from "@mui/material";
+import type { Column, Header, RowData, Table } from "@tanstack/react-table";
+import type { ColumnSortState, SortSource } from "../../../core/src/index";
+import type { KokoTableLabels } from "../provider/labels";
+export type HeaderAlign = "left" | "center" | "right";
+/**
+ * 헤더 정의·규칙·메뉴 항목이 받는 컨텍스트 (설계 문서 2절).
+ * 설계의 다섯 필드(`header · column · table · sort · labels`)에 정렬 상태 둘을 더했다 —
+ * 슬롯·메뉴 항목이 `sort.getColumnSort()` 를 각자 다시 부르지 않게.
+ */
+export interface HeaderContext<T extends RowData = any> {
+    header: Header<T, unknown>;
+    column: Column<T, unknown>;
+    table: Table<T>;
+    sort: SortSource | undefined;
+    labels: KokoTableLabels;
+    /** 이 컬럼의 정렬 상태. 정렬 중이 아니거나 `sort` 가 없으면 null */
+    sortState: ColumnSortState | null;
+    /** 다중 정렬일 때 1부터 시작하는 순번. 단일 정렬이면 null */
+    multiSortIndex: number | null;
+}
+/** `rules` 와 TanStack 옵션을 합친 결과 — 슬롯·메뉴 항목 `when` 이 본다 */
+export interface HeaderCapabilities {
+    canSort: boolean;
+    canPin: boolean;
+    canHide: boolean;
+    canGroup: boolean;
+    canResize: boolean;
+    canFilter: boolean;
+}
+/** 슬롯·`render` 가 받는 컨텍스트 — 규칙 해석 결과와 기본 내용·메뉴 열기가 더해진다 */
+export interface HeaderRenderContext<T extends RowData = any> extends HeaderContext<T> {
+    can: HeaderCapabilities;
+    /** `columnDef.header` 렌더 결과 (`TableContent renderHeader` prop 적용 후). placeholder 헤더면 null */
+    defaultContent: ReactNode;
+    /** 헤더 정렬 (`meta.headerAlign` → 셀 정렬 → 표시 전용은 center) */
+    align: HeaderAlign | undefined;
+    /** 컬럼 메뉴를 쓸 수 있는가 (테이블 있음 · `enableColumnMenu` · 표시 전용/placeholder 아님) */
+    menuEnabled: boolean;
+    /** 컬럼 메뉴 열기 — 앵커 요소(버튼) 또는 커서 좌표. `menuEnabled` 가 아니면 아무 일도 없다 */
+    openMenu: (anchor: HTMLElement | PopoverPosition) => void;
+    size?: "small" | "medium";
+}
+export type HeaderSlot<T extends RowData = any> = (ctx: HeaderRenderContext<T>) => ReactNode;
+/** 헤더 셀을 이루는 다섯 자리 — 각각 `(ctx) => ReactNode` */
+export interface HeaderSlots<T extends RowData = any> {
+    content: HeaderSlot<T>;
+    sortIndicator: HeaderSlot<T>;
+    resizeHandle: HeaderSlot<T>;
+    menuTrigger: HeaderSlot<T>;
+    pinIndicator: HeaderSlot<T>;
+}
+/**
+ * 소비자가 정하는 규칙. 정의한 규칙이 TanStack 옵션(`enableSorting` 등)보다 우선하고,
+ * 그 결과가 컬럼 정의(`column.columnDef.enable*`)에도 써져 `column.getCanSort()` 류가 같은 답을 낸다.
+ * 정의하지 않은 규칙은 TanStack 옵션을 따른다.
+ */
+export interface HeaderRules<T extends RowData = any> {
+    canSort?: (ctx: HeaderContext<T>) => boolean;
+    canPin?: (ctx: HeaderContext<T>) => boolean;
+    canHide?: (ctx: HeaderContext<T>) => boolean;
+    canGroup?: (ctx: HeaderContext<T>) => boolean;
+    canResize?: (ctx: HeaderContext<T>) => boolean;
+    canFilter?: (ctx: HeaderContext<T>) => boolean;
+}
+export interface HeaderDef<T extends RowData = any> {
+    id: string;
+    /**
+     * 헤더 셀 내용 전체 교체. 미지정 시 기본 배치(`renderDefaultHeader`)가 `slots` 를 조합한다.
+     * 바깥 `<th>`(colSpan · 고정 sticky · 폭 · 우클릭 메뉴)는 유지된다 — `<th>` 까지 바꾸려면 `components.HeaderCell`.
+     */
+    render?: (ctx: HeaderRenderContext<T>, slots: HeaderSlots<T>) => ReactNode;
+    /** 일부 자리만 교체 — 나머지는 기본 슬롯 */
+    slots?: Partial<HeaderSlots<T>>;
+    rules?: HeaderRules<T>;
+    /** 이 정의를 어느 컬럼에 적용할지 (Provider `headers[]` 에서 첫 참 정의가 이긴다). 미지정 = 모든 컬럼 */
+    when?: (ctx: HeaderContext<T>) => boolean;
+}
+/** 코어 `ColumnMeta` 에 없는 헤더 정의 자리 — `columnMetaOf` 캐스팅으로 읽는다 (코어 추가 요청) */
+export interface HeaderMeta<T extends RowData = any> {
+    /** 헤더 정의 id(Provider `headers[]` 또는 내장 `default`·`compact`) 또는 정의 객체 */
+    header?: string | HeaderDef<T>;
+}

package/dist/mui/src/headers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mui/src/index.d.ts

@@ -0,0 +1,110 @@
+export { FilterArea, resolveFilterGridSize } from "./filter/FilterArea";
+export type { FilterAreaProps, GridColCount, GridColsConfig } from "./filter/FilterArea";
+export { FilterInput } from "./filter/FilterInput";
+export { OperatorMenu, operatorLabel, OPERATOR_LABELS } from "./filter/inputs/OperatorMenu";
+export { TextFilterInput } from "./filter/inputs/TextFilterInput";
+export { NumberFilterInput } from "./filter/inputs/NumberFilterInput";
+export { DateFilterInput, periodRange } from "./filter/inputs/DateFilterInput";
+export { SelectFilterInput, MultiSelectFilterInput, BooleanFilterInput, } from "./filter/inputs/SelectFilterInput";
+export { RelationFilterInput } from "./filter/inputs/RelationFilterInput";
+export { LinearFilterInput } from "./filter/inputs/LinearFilterInput";
+export { ScheduleFilterInput } from "./filter/inputs/ScheduleFilterInput";
+export { withEditor, builtinFilterEditors, defaultEditorForVariant, registerBuiltinEditors, resolveFilterEditor, resolveFilterChip, } from "./filter/kinds";
+export type { FilterKindDisplay, LooseFilterKindDisplay, ProvidedFilterKinds, ResolveFilterEditorConfig } from "./filter/kinds";
+export { TableContent } from "./content/TableContent";
+export type { TableContentProps, RowProps, DetailPanelProps, EditingOptions, EditMode, VirtualRows, VirtualColumns, } from "./content/TableContent";
+export { HeaderCell } from "./content/HeaderCell";
+export type { HeaderCellProps } from "./content/HeaderCell";
+export { ColumnMenu, moveColumn, canMoveColumn } from "./content/ColumnMenu";
+export type { ColumnMenuProps } from "./content/ColumnMenu";
+export { ColumnVisibilityMenu } from "./content/ColumnVisibilityMenu";
+export type { ColumnVisibilityMenuProps } from "./content/ColumnVisibilityMenu";
+export { SelectionActionBar } from "./content/SelectionActionBar";
+export type { SelectionActionBarProps } from "./content/SelectionActionBar";
+export { TableErrorFallback, errorStatus, isBadRequestError } from "./content/TableErrorFallback";
+export type { TableErrorFallbackProps } from "./content/TableErrorFallback";
+export { EditCell } from "./content/EditCell";
+export type { EditCellProps, EditSpecMeta } from "./content/EditCell";
+export { renderCellValue } from "./content/cellValue";
+export type { CellValueOptions } from "./content/cellValue";
+export { getCellError, cellErrorSx } from "./content/cellError";
+export type { CellErrorInfo } from "./content/cellError";
+export { pinnedSx } from "./content/pinning";
+export { resolveDensity } from "./content/density";
+export type { Density, DensitySpec } from "./content/density";
+export { selectionColumn, expandColumn, rowActionsColumn, rowNumberColumn, withDisplayColumns, canExpandRow, isDisplayColumnId, DISPLAY_COLUMN_PREFIX, LEGACY_DISPLAY_COLUMN_PREFIX, LEGACY_DISPLAY_COLUMN_IDS, ROW_SELECT_COLUMN_ID, ROW_EXPAND_COLUMN_ID, ROW_ACTIONS_COLUMN_ID, ROW_NUMBER_COLUMN_ID, } from "./columns/displayColumns";
+export type { SelectionColumnOptions, ExpandColumnOptions, RowActionsColumnOptions, RowNumberColumnOptions, WithDisplayColumnsOptions, } from "./columns/displayColumns";
+export { GlobalFilterField } from "./toolbar/GlobalFilterField";
+export type { GlobalFilterFieldProps } from "./toolbar/GlobalFilterField";
+export { SortControl } from "./content/SortControl";
+export type { SortControlProps } from "./content/SortControl";
+export { CardContent } from "./content/CardContent";
+export type { CardContentProps } from "./content/CardContent";
+export { GroupingBar } from "./grouping/GroupingBar";
+export type { GroupingBarProps } from "./grouping/GroupingBar";
+export { StepExpandButton } from "./grouping/StepExpandButton";
+export type { StepExpandButtonProps } from "./grouping/StepExpandButton";
+export { GROUP_DRAG_COLUMN_TYPE, GROUP_DRAG_INDEX_TYPE, GROUP_BATCH_SIZE_OPTIONS, GROUP_REJECTED_MESSAGE, } from "./grouping/GroupingBar";
+export { AggregationChips, aggregatableColumns, toggleAggregation } from "./grouping/AggregationChips";
+export type { AggregationChipsProps } from "./grouping/AggregationChips";
+export { AggregateChip, getAggIcon, formatAggValue, AGG_CHIP_COLORS } from "./grouping/AggregateChip";
+export type { AggregateChipProps, AggChipColor } from "./grouping/AggregateChip";
+export { GROUP_DEPTH_INDENT, GROUP_ROW_BG_SHADES, groupRowBgColor, resolveGroupValue, renderAggregateCellContent, isCategoricalColumn, } from "./grouping/groupRow";
+export type { AggRender, AggRenderProps, AggregateCellContentOptions } from "./grouping/groupRow";
+export type { GroupRowLayout } from "./content/TableContent";
+export { PaginationArea } from "./pagination/PaginationArea";
+export type { PaginationAreaProps } from "./pagination/PaginationArea";
+export { PivotTable } from "./pivot/PivotTable";
+export type { PivotTableProps } from "./pivot/PivotTable";
+export { TopFilterLayout, SideFilterLayout, SearchBar } from "./TableLayout";
+export type { TableLayoutProps, TopFilterLayoutProps, SideFilterLayoutProps, SearchBarProps, CollapsibleFilterProps, } from "./TableLayout";
+export { ResizeHandle, useResizeWidth, clampWidth } from "./layout/ResizeHandle";
+export type { ResizeHandleProps, ResizeHandleBinding, UseResizeWidthOptions } from "./layout/ResizeHandle";
+export { useVirtualColumns, virtualColumnSlots } from "./virtualColumns/useVirtualColumns";
+export type { VirtualColumn, VirtualColumnInput, VirtualColumnResult, UseVirtualColumnsOptions, UseVirtualColumnsReturn, } from "./virtualColumns/useVirtualColumns";
+export { virtualColumnDefs, virtualColumnFields } from "./virtualColumns/virtualColumnDefs";
+export type { VirtualColumnDefsOptions } from "./virtualColumns/virtualColumnDefs";
+export { validateExpression, evaluateExpression, evaluateTemplate, evaluateVirtualColumn, applyVirtualColumns, tokenizeExpression, normalizeExpression, referencedFields, describeExpression, TEMPLATE_FIELD_PATTERN, } from "./virtualColumns/expression";
+export type { VirtualColumnType, VirtualColumnField, ExpressionValidation, Token as ExpressionToken, } from "./virtualColumns/expression";
+export { VirtualColumnSection } from "./virtualColumns/VirtualColumnSection";
+export type { VirtualColumnSectionProps } from "./virtualColumns/VirtualColumnSection";
+export { VirtualColumnDialog } from "./virtualColumns/VirtualColumnDialog";
+export type { VirtualColumnDialogProps } from "./virtualColumns/VirtualColumnDialog";
+export { VirtualColumnCard, VIRTUAL_NUMBER_OPERATORS } from "./virtualColumns/VirtualColumnCard";
+export type { VirtualColumnCardProps } from "./virtualColumns/VirtualColumnCard";
+export { arrangeGroupedColumns } from "./content/TableContent";
+export type { GroupedColumnMode } from "./content/TableContent";
+export { summarizeSearch, formatConditionValue, countActiveConditions, isActiveCondition, EMPTY_VALUE_TEXT, VALUELESS_TEXT, } from "./addons/searchSummary";
+export type { SearchSummary, ConditionSummary, ConditionStatus, SortSummary, SummarizeSearchOptions, FormatConditionValueOptions, } from "./addons/searchSummary";
+export { FilterStatusContent, FilterStatusModal, FilterStatusButton, useFilterStatusSummary, } from "./addons/FilterStatusModal";
+export type { FilterStatusContentProps, FilterStatusModalProps, FilterStatusButtonProps, FilterStatusSearch, } from "./addons/FilterStatusModal";
+export { ShareDropdown } from "./addons/ShareDropdown";
+export type { ShareDropdownProps, ShareAction, ShareDropdownMessages } from "./addons/ShareDropdown";
+export { createSearchStore, useSearchStore, useSearchStoreBridge } from "./addons/searchStore";
+export type { SearchStore, SearchStoreSnapshot, SearchStoreActions, CreateSearchStoreOptions, } from "./addons/searchStore";
+export { FilterModal, FilterModalButton } from "./addons/FilterModal";
+export type { FilterModalProps, FilterModalButtonProps, FilterModalSearch } from "./addons/FilterModal";
+export { KokoTableProvider, useKokoTableConfig, resolveTableProps, mergeKokoTableConfig, DEFAULT_KOKO_TABLE_CONFIG, DEFAULT_TABLE_DEFAULTS, toRegistry, applyPatch, } from "./provider/KokoTableProvider";
+export type { KokoTableProviderProps, KokoTableConfig, KokoTableConfigInput, KokoTableComponents, KokoTableDefaults, KokoCellRenderers, KokoFilterInputs, CellRenderer, CellRendererKey, CellRendererProps, EmptyStateProps, LoadingSkeletonProps, GroupRowRenderContext, DetailPanelRowContext, KokoTableMenus, KokoTableMenusInput, KokoTableRegistries, KokoFilterKinds, FilterKindUi, OpenFilterHandler, } from "./provider/KokoTableProvider";
+export { DEFAULT_LABELS, DEFAULT_UI_LABELS, mergeLabels } from "./provider/labels";
+export type { KokoTableLabels, KokoTableLabelsInput, KokoUiLabels } from "./provider/labels";
+export { MenuItemList, ContextMenu, defaultColumnMenuItems, defaultRowMenuItems, defaultGroupRowMenuItems, visibleMenuItems, createHeaderContext, createColumnMenuCtx, createRowMenuCtx, } from "./content/menuItems";
+export type { MenuItemSpec, ColumnMenuItem, ColumnMenuContext, ColumnMenuItemsContext, ColumnMenuItemsFn, RowMenuItem, RowMenuContext, RowMenuItemsFn, MenuItemListProps, ContextMenuProps, } from "./content/menuItems";
+export type { RenderHeaderContext } from "./content/HeaderCell";
+export type { ColumnMenuAnchor } from "./content/ColumnMenu";
+export { createRegistry, isRegistry } from "./registry";
+export type { Registry, RegistryPatch, MenuItemDef, MenuPatch, CellRendererDef, AggregationDef, ExportFormatterDef, } from "./registry";
+export { defineHeader, resolveHeaderDef, applyHeaderRules, headerMetaOf, defaultHeader, compactHeader, headerRegistry, defaultHeaderSlots, renderDefaultHeader, materializeHeader, SortArrow, headerRuleMetaOf, resolveCellAlign, } from "./headers";
+export type { HeaderContext, HeaderRenderContext, HeaderCapabilities, HeaderSlots, HeaderSlot, HeaderRules, HeaderDef, HeaderMeta, HeaderAlign, HeaderRuleMeta, CellAlign, } from "./headers";
+export { columnMenuRegistry, defaultColumnMenuDefs, columnHeaderText, COLUMN_MENU_GROUP, rowMenuRegistry, defaultRowMenuDefs, rowCopyText, ROW_MENU_GROUP, resolveMenuDefs, menuSpecsFrom, copyToClipboard, } from "./menus";
+export type { ColumnMenuCtx, ColumnMenuItemDef, ColumnMenuPatch, RowMenuCtx, RowMenuItemDef, RowMenuPatch, GroupRowCtx, } from "./menus";
+export { PresetBar } from "./addons/PresetBar";
+export type { PresetBarProps, PresetBarMessages } from "./addons/PresetBar";
+export { TableScreen, TableScreenBase, displayColumnOptionsOf } from "./TableScreen";
+export type { TableScreenProps, TableScreenBaseProps, TableScreenSlots, SlotValue } from "./TableScreen";
+export { cellRenderers, defineCellRenderer, resolveCellRenderer, toCellRendererDefs, useCellRenderers, layerRegistry, registriesOf, isEmptyCellValue, BUILTIN_CELL_RENDERERS, } from "./content/cellRenderers";
+export type { CellContext, CellRendererId, KokoRegistries } from "./content/cellRenderers";
+export { useAggregations, aggChipColor } from "./grouping/AggregateChip";
+export { useExportFormatters } from "./exporters";
+export { AggregationSettingsButton } from "./grouping/AggregationSettingsButton";
+export type { AggregationSettingsButtonProps } from "./grouping/AggregationSettingsButton";