kokotable 0.95.0

package/dist/core/src/filters/describe.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 필터 값 → 사람이 읽는 문구 (순수 함수, JSX 없음).
+ *
+ * 기존 mui `searchSummary.formatConditionValue` 의 규칙을 core 로 옮긴 것이다 —
+ * 내장 kind 의 `operators[op].describe` 가 이 조각들을 조합하고, kind 가 없는 컬럼은
+ * `describeFilterValue` 의 일반 규칙(값 모양으로 추정)을 그대로 쓴다.
+ * 문구는 `FilterDescribeLabels` 로 바꿀 수 있다 (기본 한국어).
+ */
+import type { FilterOperator } from "../types/operators";
+import type { AnyFilterKind, FilterDescribeContext, FilterDescribeLabels } from "../types/filterKind";
+import type { RelationFilterValue } from "./relation";
+import type { LinearFilterValue } from "./linear";
+export declare const DEFAULT_DESCRIBE_LABELS: FilterDescribeLabels;
+export type DescribeOptions = Partial<FilterDescribeContext>;
+/** 스칼라 하나 — 선택지 라벨 · 예/아니오 · 날짜(`YYYY-MM-DD`) · 객체는 JSON */
+export declare function describeScalar(value: unknown, options?: DescribeOptions): string;
+/** 두 경계 — `a ~ b`, 빈 쪽은 `…`, 둘 다 비면 empty */
+export declare function describeRange(value: unknown, options?: DescribeOptions): string;
+/** 목록 — 쉼표, 길면 "외 N개" */
+export declare function describeList(value: unknown, options?: DescribeOptions): string;
+/** 관계 필터 — 그룹이 전부 "equals 하나" 면 컬럼별 값 묶음, 아니면 그룹 수 */
+export declare function describeRelation(value: RelationFilterValue, options?: DescribeOptions): string;
+/** 선형결합 필터 — "볼트 ≥2, 너트 (모두 충족)" */
+export declare function describeLinear(value: LinearFilterValue, options?: DescribeOptions): string;
+/** 일정 필터 — 날짜 하나 또는 기간 */
+export declare function describeSchedule(value: Record<string, unknown>, options?: DescribeOptions): string;
+export interface DescribeFilterValueOptions extends DescribeOptions {
+    operator?: FilterOperator | string;
+    /** 값 모양이 애매할 때 판단 근거 (relation/linear/schedule) */
+    variant?: string;
+}
+/**
+ * kind 가 없는 컬럼의 일반 규칙 — 값 모양으로 추정한다.
+ *
+ * - 값 없는 연산자(`empty`/`hasChild` …) → `labels.valueless`
+ * - 선택지가 있으면 값 대신 라벨
+ * - 두 원소 범위(숫자·날짜) → `a ~ b`, 그 외 배열은 쉼표
+ * - 관계(`groups`)/선형(`terms`)/일정(`date`|`start`) 은 요약 문구
+ */
+export declare function describeFilterValue(value: unknown, options?: DescribeFilterValueOptions): string;
+/**
+ * kind 경로의 문구 — 값 없는 연산자·빈 값을 먼저 처리하고 `operators[op].describe` 를 부른다.
+ * 연산자가 kind 에 없으면 `describeFilterValue` 의 일반 규칙으로 떨어진다.
+ */
+export declare function describeFilter(kind: AnyFilterKind | undefined, operator: string | undefined, value: unknown, options?: DescribeFilterValueOptions): string;

package/dist/core/src/filters/describe.js

@@ -0,0 +1,189 @@
+import { isValuelessOperator } from "../types/operators";
+import { isUnsetFilterValue } from "../utils/getValue";
+import { formatLocalDate } from "../utils/dateText";
+export const DEFAULT_DESCRIBE_LABELS = {
+    empty: "(없음)",
+    valueless: "-",
+    yes: "예",
+    no: "아니오",
+    more: (count) => `외 ${count}개`,
+    relationGroups: (groups, conditions) => `${groups}개 그룹 · 조건 ${conditions}개`,
+    matchAll: "모두 충족",
+    matchAny: "하나라도 충족",
+};
+const DATE_PREFIX = /^\d{4}-\d{2}-\d{2}/;
+const ISO_TIME_PREFIX = /^\d{4}-\d{2}-\d{2}T/;
+function ctxOf(options) {
+    return {
+        header: options.header ?? "",
+        labels: options.labels ?? DEFAULT_DESCRIBE_LABELS,
+        options: options.options,
+        relationColumns: options.relationColumns,
+        maxListItems: options.maxListItems,
+    };
+}
+const labelMap = (options) => options ? new Map(options.map((o) => [o.value, o.label])) : undefined;
+/** 스칼라 하나 — 선택지 라벨 · 예/아니오 · 날짜(`YYYY-MM-DD`) · 객체는 JSON */
+export function describeScalar(value, options = {}) {
+    const ctx = ctxOf(options);
+    const labels = labelMap(ctx.options);
+    if (value === null || value === undefined || value === "")
+        return ctx.labels.empty;
+    if (value === true)
+        return ctx.labels.yes;
+    if (value === false)
+        return ctx.labels.no;
+    if (value instanceof Date)
+        return formatLocalDate(value) ?? ctx.labels.empty;
+    if (typeof value === "string") {
+        const mapped = labels?.get(value);
+        if (mapped !== undefined)
+            return mapped;
+        // 기존 SearchConfig 의 Date 직렬화(ISO 시각) 는 날짜만 보인다
+        if (ISO_TIME_PREFIX.test(value))
+            return value.slice(0, 10);
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+        return labels?.get(String(value)) ?? String(value);
+    }
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+const isRangeElement = (v) => v === null || v === undefined || v === "" || typeof v === "number" || v instanceof Date
+    || (typeof v === "string" && DATE_PREFIX.test(v));
+const isRangeAnchor = (v) => typeof v === "number" || v instanceof Date || (typeof v === "string" && DATE_PREFIX.test(v));
+/** 두 경계 — `a ~ b`, 빈 쪽은 `…`, 둘 다 비면 empty */
+export function describeRange(value, options = {}) {
+    const ctx = ctxOf(options);
+    if (!Array.isArray(value))
+        return describeScalar(value, options);
+    const [lo, hi] = value;
+    const unsetLo = lo === null || lo === undefined || lo === "";
+    const unsetHi = hi === null || hi === undefined || hi === "";
+    if (unsetLo && unsetHi)
+        return ctx.labels.empty;
+    return `${unsetLo ? "…" : describeScalar(lo, options)} ~ ${unsetHi ? "…" : describeScalar(hi, options)}`;
+}
+/** 목록 — 쉼표, 길면 "외 N개" */
+export function describeList(value, options = {}) {
+    const ctx = ctxOf(options);
+    const list = Array.isArray(value) ? value : [value];
+    if (list.length === 0)
+        return ctx.labels.empty;
+    const items = list.map((v) => describeScalar(v, options));
+    const max = ctx.maxListItems ?? 5;
+    if (items.length > max)
+        return `${items.slice(0, max).join(", ")} ${ctx.labels.more(items.length - max)}`;
+    return items.join(", ");
+}
+/** 관계 필터 — 그룹이 전부 "equals 하나" 면 컬럼별 값 묶음, 아니면 그룹 수 */
+export function describeRelation(value, options = {}) {
+    const ctx = ctxOf(options);
+    const groups = value?.groups ?? [];
+    if (groups.length === 0)
+        return ctx.labels.empty;
+    const label = (key) => ctx.relationColumns?.find((c) => c.key === key)?.label ?? key;
+    const allSingleEquals = groups.every((g) => (g.conditions?.length ?? 0) === 1 && g.conditions[0]?.operator === "equals");
+    if (allSingleEquals) {
+        const byColumn = new Map();
+        for (const group of groups) {
+            const condition = group.conditions[0];
+            if (!condition?.column)
+                continue;
+            const list = byColumn.get(condition.column) ?? [];
+            list.push(describeScalar(condition.value, { labels: ctx.labels }));
+            byColumn.set(condition.column, list);
+        }
+        const parts = Array.from(byColumn, ([column, values]) => `${label(column)}: ${values.join(", ")}`);
+        if (parts.length > 0)
+            return parts.join(" / ");
+    }
+    const conditionCount = groups.reduce((sum, g) => sum + (g.conditions?.length ?? 0), 0);
+    return ctx.labels.relationGroups(groups.length, conditionCount);
+}
+const QUANTITY_OP_SYMBOL = { eq: "=", gte: "≥", lte: "≤", gt: ">", lt: "<" };
+/** 선형결합 필터 — "볼트 ≥2, 너트 (모두 충족)" */
+export function describeLinear(value, options = {}) {
+    const ctx = ctxOf(options);
+    const terms = value?.terms ?? [];
+    if (terms.length === 0)
+        return ctx.labels.empty;
+    const items = terms.map((term) => {
+        const name = term.target_name ?? term.target_code ?? `#${term.target_idx}`;
+        if (term.quantity === undefined || value.mode === "exists")
+            return name;
+        return `${name} ${QUANTITY_OP_SYMBOL[term.quantity_op ?? "gte"] ?? "≥"}${term.quantity}`;
+    });
+    return `${items.join(", ")} (${value.match_all ? ctx.labels.matchAll : ctx.labels.matchAny})`;
+}
+/** 일정 필터 — 날짜 하나 또는 기간 */
+export function describeSchedule(value, options = {}) {
+    const ctx = ctxOf(options);
+    if (typeof value.date === "string" && value.date)
+        return describeScalar(value.date, options);
+    const start = typeof value.start === "string" && value.start ? describeScalar(value.start, options) : "";
+    const end = typeof value.end === "string" && value.end ? describeScalar(value.end, options) : "";
+    if (!start && !end)
+        return ctx.labels.empty;
+    return `${start || "…"} ~ ${end || "…"}`;
+}
+const RANGE_OPERATORS = new Set(["between", "betweenInclusive", "outsideRange", "dateBetween"]);
+/**
+ * kind 가 없는 컬럼의 일반 규칙 — 값 모양으로 추정한다.
+ *
+ * - 값 없는 연산자(`empty`/`hasChild` …) → `labels.valueless`
+ * - 선택지가 있으면 값 대신 라벨
+ * - 두 원소 범위(숫자·날짜) → `a ~ b`, 그 외 배열은 쉼표
+ * - 관계(`groups`)/선형(`terms`)/일정(`date`|`start`) 은 요약 문구
+ */
+export function describeFilterValue(value, options = {}) {
+    const ctx = ctxOf(options);
+    const { operator, variant } = options;
+    if (operator && isValuelessOperator(operator))
+        return ctx.labels.valueless;
+    if (value === null || value === undefined || value === "")
+        return ctx.labels.empty;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return ctx.labels.empty;
+        const rangeOperator = operator === undefined || RANGE_OPERATORS.has(operator);
+        if (value.length === 2 && rangeOperator && !ctx.options && value.every(isRangeElement) && value.some(isRangeAnchor)) {
+            return describeRange(value, options);
+        }
+        return describeList(value, options);
+    }
+    if (typeof value === "object") {
+        const record = value;
+        if (variant === "relation" || Array.isArray(record.groups)) {
+            return describeRelation(value, options);
+        }
+        if (variant === "linear" || Array.isArray(record.terms)) {
+            return describeLinear(value, options);
+        }
+        if (variant === "schedule" || "date" in record || "start" in record || "end" in record) {
+            return describeSchedule(record, options);
+        }
+        if (value instanceof Date)
+            return describeScalar(value, options);
+        return JSON.stringify(value);
+    }
+    return describeScalar(value, options);
+}
+/**
+ * kind 경로의 문구 — 값 없는 연산자·빈 값을 먼저 처리하고 `operators[op].describe` 를 부른다.
+ * 연산자가 kind 에 없으면 `describeFilterValue` 의 일반 규칙으로 떨어진다.
+ */
+export function describeFilter(kind, operator, value, options = {}) {
+    const def = kind && operator ? kind.operators[operator] : undefined;
+    if (!def)
+        return describeFilterValue(value, options);
+    const ctx = ctxOf(options);
+    if (def.valueless)
+        return ctx.labels.valueless;
+    const empty = kind?.isEmpty ? kind.isEmpty(value) : isUnsetFilterValue(value);
+    if (empty)
+        return ctx.labels.empty;
+    return def.describe(value, ctx);
+}

package/dist/core/src/filters/kind.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 필터 kind 런타임 — `defineFilterKind` · 레지스트리 `filterKinds` · 컬럼에서 kind 해석.
+ * 타입은 `types/filterKind.ts`, 내장 kind 는 `filters/kinds/**`.
+ */
+import type { RowData } from "@tanstack/react-table";
+import type { TableColumnDef } from "../types/column";
+import type { AnyFilterKind, CheckedFilterSpec, FilterKind, FilterKindDef, FilterKindInput, FilterKindRef, FilterOperatorDef, FilterSpecOf, FilterVariant } from "../types";
+/**
+ * 정의 → 브랜드된 kind. `operators` 의 키 순서를 `operatorNames` 로 남긴다.
+ * 값·연산자 타입은 `operators` 에서 추론된다 (`FilterKindInput` 참조) — 나머지 필드는 그 타입으로 검사된다.
+ */
+export declare function defineFilterKind<Id extends string, TValue, TOp extends string, TRow = unknown>(def: FilterKindInput<Id, TValue, TOp, TRow>): FilterKind<Id, TValue, TOp, TRow>;
+export declare function isFilterKind(value: unknown): value is AnyFilterKind;
+/**
+ * `operators` 표를 이름 목록에서 만든다 — 내장 kind 가 백엔드 연산자 목록(`*_OPERATORS`)을
+ * 그대로 키로 써서 1:1 을 유지하는 통로다.
+ */
+export declare function operatorTable<TOp extends string, TValue, TRow = unknown>(names: readonly TOp[], build: (op: TOp) => FilterOperatorDef<TValue, TRow>): Record<TOp, FilterOperatorDef<TValue, TRow>>;
+/** `with()` 가 받는 덮어쓰기 — kind 전체 또는 표시 부분(editor/chip)만 */
+export type FilterKindPatch = AnyFilterKind | Partial<Pick<FilterKindDef<string, any, string, any>, "editor" | "chip">>;
+export interface FilterKindStore {
+    /** 같은 id 가 있으면 교체 */
+    register(kind: AnyFilterKind): void;
+    get(id: string): AnyFilterKind | undefined;
+    has(id: string): boolean;
+    list(): AnyFilterKind[];
+    /**
+     * 불변 파생 — `{ [id]: kind | { editor, chip } }` 또는 kind 배열을 얹은 새 저장소.
+     * 표시 부분만 주면 같은 id 의 기존 kind 위에 병합한다 (Provider 가 editor 를 끼우는 통로).
+     */
+    with(overrides: Record<string, FilterKindPatch> | AnyFilterKind[]): FilterKindStore;
+}
+export declare function createFilterKindStore(base?: AnyFilterKind[]): FilterKindStore;
+/** 전역 기본 레지스트리 — 내장 kind 는 `filters/kinds/index.ts` 가 여기 등록한다 */
+export declare const filterKinds: FilterKindStore;
+/** `filter.kind` (객체 또는 id) → kind 객체. id 가 미등록이면 undefined (variant 경로로 폴백) */
+export declare function resolveFilterKindRef(ref: FilterKindRef | undefined, store?: FilterKindStore): AnyFilterKind | undefined;
+export declare function resolveFilterKind<T extends RowData>(column: TableColumnDef<T> | undefined, store?: FilterKindStore): AnyFilterKind | undefined;
+/** kind 의 기본 입력 UI 힌트 — `variant` > `dataKind` 유추 > `"custom"` */
+export declare function filterKindVariant(kind: AnyFilterKind): FilterVariant;
+/** 미입력 판정 — kind 의 `isEmpty`, 없으면 공통 규칙 */
+export declare function isFilterValueEmpty(kind: AnyFilterKind | undefined, value: unknown): boolean;
+/** 요청에 실을 값 — `operators[op].serialize`, 없으면 그대로 */
+export declare function serializeFilterValue(kind: AnyFilterKind | undefined, operator: string | undefined, value: unknown): unknown;
+/** 서버 연산자 이름 — `wire`, 없으면 키 그대로 */
+export declare function wireOperator(kind: AnyFilterKind | undefined, operator: string): string;
+/**
+ * 컬럼에 kind 를 주는 타입 안전한 spec — `filter: filterSpec(moneyKind, { defaultOperator: "gte" })`.
+ * 레지스트리에 등록하지 않은 kind 객체에 연산자·기본값을 주는 통로다 — 제네릭 `K` 자리에서
+ * 연산자·값이 검사되고, 결과는 `CheckedFilterSpec`(브랜드만, 런타임 속성 없음) 으로 `filter` 에 들어간다.
+ */
+export declare function filterSpec<K extends AnyFilterKind>(kind: K, spec?: Omit<FilterSpecOf<K>, "kind">): CheckedFilterSpec;

package/dist/core/src/filters/kind.js

@@ -0,0 +1,110 @@
+import { isUnsetFilterValue } from "../utils/getValue";
+/**
+ * 정의 → 브랜드된 kind. `operators` 의 키 순서를 `operatorNames` 로 남긴다.
+ * 값·연산자 타입은 `operators` 에서 추론된다 (`FilterKindInput` 참조) — 나머지 필드는 그 타입으로 검사된다.
+ */
+export function defineFilterKind(def) {
+    const operatorNames = Object.keys(def.operators);
+    if (!(def.defaultOperator in def.operators)) {
+        throw new Error(`[koko-table] defineFilterKind("${def.id}"): defaultOperator "${def.defaultOperator}" 가 operators 에 없습니다.`);
+    }
+    for (const op of def.offered ?? []) {
+        if (!(op in def.operators)) {
+            throw new Error(`[koko-table] defineFilterKind("${def.id}"): offered "${op}" 가 operators 에 없습니다.`);
+        }
+    }
+    return { ...def, __filterKind: true, operatorNames };
+}
+export function isFilterKind(value) {
+    return !!value && typeof value === "object" && value.__filterKind === true
+        && typeof value.id === "string";
+}
+/**
+ * `operators` 표를 이름 목록에서 만든다 — 내장 kind 가 백엔드 연산자 목록(`*_OPERATORS`)을
+ * 그대로 키로 써서 1:1 을 유지하는 통로다.
+ */
+export function operatorTable(names, build) {
+    const table = {};
+    for (const op of names)
+        table[op] = build(op);
+    return table;
+}
+export function createFilterKindStore(base = []) {
+    const items = new Map(base.map((k) => [k.id, k]));
+    const store = {
+        register(kind) {
+            if (!isFilterKind(kind)) {
+                throw new Error("[koko-table] filterKinds.register: defineFilterKind 로 만든 객체만 등록할 수 있습니다.");
+            }
+            items.set(kind.id, kind);
+        },
+        get: (id) => items.get(id),
+        has: (id) => items.has(id),
+        list: () => Array.from(items.values()),
+        with(overrides) {
+            const next = createFilterKindStore(store.list());
+            const entries = Array.isArray(overrides)
+                ? overrides.map((k) => [k.id, k])
+                : Object.entries(overrides);
+            for (const [id, patch] of entries) {
+                if (isFilterKind(patch)) {
+                    next.register(patch.id === id ? patch : { ...patch, id });
+                    continue;
+                }
+                const current = items.get(id);
+                if (!current)
+                    continue; // 정의 없는 id 에 표시 부분만 오면 무시한다 — 판정 근거가 없다
+                next.register({ ...current, ...patch });
+            }
+            return next;
+        },
+    };
+    return store;
+}
+/** 전역 기본 레지스트리 — 내장 kind 는 `filters/kinds/index.ts` 가 여기 등록한다 */
+export const filterKinds = createFilterKindStore();
+/** `filter.kind` (객체 또는 id) → kind 객체. id 가 미등록이면 undefined (variant 경로로 폴백) */
+export function resolveFilterKindRef(ref, store = filterKinds) {
+    if (!ref)
+        return undefined;
+    if (typeof ref === "string")
+        return store.get(ref);
+    return isFilterKind(ref) ? ref : undefined;
+}
+export function resolveFilterKind(column, store = filterKinds) {
+    return resolveFilterKindRef(column?.filter?.kind, store);
+}
+/** kind 의 기본 입력 UI 힌트 — `variant` > `dataKind` 유추 > `"custom"` */
+export function filterKindVariant(kind) {
+    if (kind.variant)
+        return kind.variant;
+    switch (kind.dataKind) {
+        case "number": return "number";
+        case "date": return "date";
+        case "boolean": return "boolean";
+        case "relation": return "relation";
+        case "text": return "text";
+        default: return "custom";
+    }
+}
+/** 미입력 판정 — kind 의 `isEmpty`, 없으면 공통 규칙 */
+export function isFilterValueEmpty(kind, value) {
+    return kind?.isEmpty ? kind.isEmpty(value) : isUnsetFilterValue(value);
+}
+/** 요청에 실을 값 — `operators[op].serialize`, 없으면 그대로 */
+export function serializeFilterValue(kind, operator, value) {
+    const def = kind && operator ? kind.operators[operator] : undefined;
+    return def?.serialize ? def.serialize(value) : value;
+}
+/** 서버 연산자 이름 — `wire`, 없으면 키 그대로 */
+export function wireOperator(kind, operator) {
+    return kind?.operators[operator]?.wire ?? operator;
+}
+/**
+ * 컬럼에 kind 를 주는 타입 안전한 spec — `filter: filterSpec(moneyKind, { defaultOperator: "gte" })`.
+ * 레지스트리에 등록하지 않은 kind 객체에 연산자·기본값을 주는 통로다 — 제네릭 `K` 자리에서
+ * 연산자·값이 검사되고, 결과는 `CheckedFilterSpec`(브랜드만, 런타임 속성 없음) 으로 `filter` 에 들어간다.
+ */
+export function filterSpec(kind, spec = {}) {
+    return { ...spec, kind };
+}

package/dist/core/src/filters/kinds/_list.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 리스트 연산자 표 — enum · commonCode · cascade 가 공유한다.
+ *
+ * 판정은 `filters/registry.ts` 의 List 분기(`matchColumnFilter` 8단계)와 같은 함수를 부른다.
+ * `equals`/`notEquals` 는 텍스트 경로(백엔드는 enum 컬럼도 TextFilter 로 받는다).
+ */
+import type { ListOperator } from "../../types/operators";
+import type { FilterOperatorDef } from "../../types/filterKind";
+export type EnumFilterValue = string | number | Array<string | number>;
+export type EnumOperator = ListOperator | "equals" | "notEquals";
+export declare const ENUM_OPERATORS: readonly EnumOperator[];
+export declare function matchListOperator(cellValue: unknown, filterValue: unknown, operator: ListOperator): boolean;
+export declare function listOperatorDef(op: EnumOperator): FilterOperatorDef<EnumFilterValue>;

package/dist/core/src/filters/kinds/_list.js

@@ -0,0 +1,42 @@
+import { LIST_OPERATORS } from "../../types/operators";
+import { matchArrayCell, matchList, matchListBetween, toListFilterValue } from "../list";
+import { matchText } from "../text";
+import { describeList, describeRange } from "../describe";
+export const ENUM_OPERATORS = [...LIST_OPERATORS, "equals", "notEquals"];
+export function matchListOperator(cellValue, filterValue, operator) {
+    switch (operator) {
+        case "between":
+            return matchListBetween(cellValue, filterValue);
+        case "notIn":
+        case "notInArray":
+            return matchList(cellValue, filterValue, true);
+        case "arrIncludes":
+            return matchArrayCell(cellValue, filterValue, "one");
+        case "arrIncludesSome":
+            return matchArrayCell(cellValue, filterValue, "some");
+        case "arrIncludesAll":
+            return matchArrayCell(cellValue, filterValue, "all");
+        default:
+            return matchList(cellValue, filterValue, false);
+    }
+}
+export function listOperatorDef(op) {
+    if (op === "equals" || op === "notEquals") {
+        return {
+            client: (cell, value) => matchText(cell, value, op),
+            describe: (value, ctx) => describeList(value, ctx),
+        };
+    }
+    if (op === "between") {
+        return {
+            client: (cell, value) => matchListOperator(cell, value, op),
+            describe: (value, ctx) => describeRange(value, ctx),
+        };
+    }
+    return {
+        client: (cell, value) => matchListOperator(cell, value, op),
+        // 스칼라는 `[value]` 로 — 서버 `ListFilter.apply` 가 문자열을 글자 단위로 쪼개는 것을 막는다
+        serialize: (value) => toListFilterValue(value),
+        describe: (value, ctx) => describeList(value, ctx),
+    };
+}

package/dist/core/src/filters/kinds/boolean.d.ts

@@ -0,0 +1,3 @@
+export type BooleanFilterValue = boolean | "true" | "false";
+/** 백엔드는 `equals` 만 — 문자열 비교(`"true"` === `String(true)`) */
+export declare const booleanKind: import("../..").FilterKind<"boolean", BooleanFilterValue, "equals", unknown>;

package/dist/core/src/filters/kinds/boolean.js

@@ -0,0 +1,21 @@
+import { defineFilterKind } from "../kind";
+import { isUnsetFilterValue } from "../../utils/getValue";
+/** 백엔드는 `equals` 만 — 문자열 비교(`"true"` === `String(true)`) */
+export const booleanKind = defineFilterKind({
+    id: "boolean",
+    dataKind: "boolean",
+    variant: "boolean",
+    operators: {
+        equals: {
+            client: (cell, value) => String(cell) === String(value),
+            describe: (value, ctx) => {
+                const mapped = ctx.options?.find((o) => o.value === String(value))?.label;
+                if (mapped !== undefined)
+                    return mapped;
+                return value === true || value === "true" ? ctx.labels.yes : ctx.labels.no;
+            },
+        },
+    },
+    defaultOperator: "equals",
+    isEmpty: isUnsetFilterValue,
+});

package/dist/core/src/filters/kinds/cascade.d.ts

@@ -0,0 +1,6 @@
+import { type EnumFilterValue, type EnumOperator } from "./_list";
+/**
+ * 통합 cascade — enum 과 같은 판정에 `meta.cascadeFilterLevels`(레벨별 실제 필드)가 붙는다.
+ * 레벨 연산자는 `deriveOperators` 가 메타를 펼쳐 채운다.
+ */
+export declare const cascadeKind: import("../..").FilterKind<"cascade", EnumFilterValue, EnumOperator, unknown>;

package/dist/core/src/filters/kinds/cascade.js

@@ -0,0 +1,16 @@
+import { defineFilterKind, operatorTable } from "../kind";
+import { ENUM_OPERATORS, listOperatorDef } from "./_list";
+import { isUnsetFilterValue } from "../../utils/getValue";
+/**
+ * 통합 cascade — enum 과 같은 판정에 `meta.cascadeFilterLevels`(레벨별 실제 필드)가 붙는다.
+ * 레벨 연산자는 `deriveOperators` 가 메타를 펼쳐 채운다.
+ */
+export const cascadeKind = defineFilterKind({
+    id: "cascade",
+    dataKind: "text",
+    variant: "select",
+    operators: operatorTable(ENUM_OPERATORS, listOperatorDef),
+    defaultOperator: "inArray",
+    offered: ["inArray", "notInArray"],
+    isEmpty: isUnsetFilterValue,
+});

package/dist/core/src/filters/kinds/commonCode.d.ts

@@ -0,0 +1,3 @@
+import { type EnumFilterValue, type EnumOperator } from "./_list";
+/** 공통코드 — 값은 idx, 라벨은 `meta.selectOptions`. 다중 선택이 기본 */
+export declare const commonCodeKind: import("../..").FilterKind<"commonCode", EnumFilterValue, EnumOperator, unknown>;

package/dist/core/src/filters/kinds/commonCode.js

@@ -0,0 +1,13 @@
+import { defineFilterKind, operatorTable } from "../kind";
+import { ENUM_OPERATORS, listOperatorDef } from "./_list";
+import { isUnsetFilterValue } from "../../utils/getValue";
+/** 공통코드 — 값은 idx, 라벨은 `meta.selectOptions`. 다중 선택이 기본 */
+export const commonCodeKind = defineFilterKind({
+    id: "commonCode",
+    dataKind: "text",
+    variant: "multiSelect",
+    operators: operatorTable(ENUM_OPERATORS, listOperatorDef),
+    defaultOperator: "inArray",
+    offered: ["inArray", "notInArray"],
+    isEmpty: isUnsetFilterValue,
+});

package/dist/core/src/filters/kinds/date.d.ts

@@ -0,0 +1,9 @@
+import type { DateOperator } from "../../types/operators";
+export type DateBound = string | Date | null;
+/** `YYYY-MM-DD`(또는 Date) 하나 · 범위 `[lo, hi]` · `inPeriod` 토큰 */
+export type DateFilterValue = string | Date | [DateBound, DateBound];
+/**
+ * date · datetime 공용. `inPeriod` 도 백엔드 `DateFilter` 의 연산자라 여기 포함한다
+ * (`period` kind 는 기간 토큰만 쓰는 컬럼용 축약본).
+ */
+export declare const dateKind: import("../..").FilterKind<"date", DateFilterValue, DateOperator, unknown>;

package/dist/core/src/filters/kinds/date.js

@@ -0,0 +1,32 @@
+import { DATE_OPERATORS } from "../../types/operators";
+import { defineFilterKind, operatorTable } from "../kind";
+import { matchDate } from "../date";
+import { describeRange, describeScalar } from "../describe";
+import { isUnsetFilterValue } from "../../utils/getValue";
+import { toDateOnly } from "../../utils/dateText";
+const RANGE = new Set(["between", "betweenInclusive", "dateBetween"]);
+/**
+ * date · datetime 공용. `inPeriod` 도 백엔드 `DateFilter` 의 연산자라 여기 포함한다
+ * (`period` kind 는 기간 토큰만 쓰는 컬럼용 축약본).
+ */
+export const dateKind = defineFilterKind({
+    id: "date",
+    dataKind: "date",
+    variant: "date",
+    operators: operatorTable(DATE_OPERATORS, (op) => ({
+        client: (cell, value, ctx) => matchDate(cell, value, op, ctx.now),
+        describe: (value, ctx) => {
+            if (op === "inPeriod")
+                return ctx.labels.periods?.[String(value)] ?? describeScalar(value, ctx);
+            return RANGE.has(op) ? describeRange(value, ctx) : describeScalar(value, ctx);
+        },
+    })),
+    defaultOperator: "betweenInclusive",
+    offered: ["betweenInclusive", "inPeriod"],
+    isEmpty: isUnsetFilterValue,
+    // URL·프리셋에는 `YYYY-MM-DD` 만 — 구 SearchConfig 의 ISO 시각 문자열·Date 객체를 정규화한다
+    codec: {
+        encode: (value) => toDateOnly(value),
+        decode: (raw) => (raw === undefined || raw === null ? undefined : toDateOnly(raw)),
+    },
+});

package/dist/core/src/filters/kinds/enum.d.ts

@@ -0,0 +1,4 @@
+import { type EnumFilterValue, type EnumOperator } from "./_list";
+export type { EnumFilterValue, EnumOperator };
+/** select / multiSelect — 선택지는 `meta.selectOptions`, 구분은 `filter.variant` */
+export declare const enumKind: import("../..").FilterKind<"enum", EnumFilterValue, EnumOperator, unknown>;

package/dist/core/src/filters/kinds/enum.js

@@ -0,0 +1,13 @@
+import { defineFilterKind, operatorTable } from "../kind";
+import { ENUM_OPERATORS, listOperatorDef } from "./_list";
+import { isUnsetFilterValue } from "../../utils/getValue";
+/** select / multiSelect — 선택지는 `meta.selectOptions`, 구분은 `filter.variant` */
+export const enumKind = defineFilterKind({
+    id: "enum",
+    dataKind: "text",
+    variant: "select",
+    operators: operatorTable(ENUM_OPERATORS, listOperatorDef),
+    defaultOperator: "inArray",
+    offered: ["inArray", "notInArray"],
+    isEmpty: isUnsetFilterValue,
+});

package/dist/core/src/filters/kinds/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 내장 필터 kind — 전부 `defineFilterKind` 로 정의하고 전역 `filterKinds` 에 등록한다.
+ * helper 프리셋·`ColumnBuilder` 가 `filter.kind` 에 이것을 넣는다(dogfooding).
+ */
+import type { AnyFilterKind, FilterVariant } from "../../types";
+import { textKind } from "./text";
+import { numberKind } from "./number";
+import { dateKind } from "./date";
+import { periodKind } from "./period";
+import { booleanKind } from "./boolean";
+import { enumKind } from "./enum";
+import { commonCodeKind } from "./commonCode";
+import { cascadeKind } from "./cascade";
+import { relationKind } from "./relation";
+import { scheduleKind } from "./schedule";
+import { linearKind } from "./linear";
+export { textKind, numberKind, dateKind, periodKind, booleanKind, enumKind, commonCodeKind, cascadeKind, relationKind, scheduleKind, linearKind };
+export type { TextFilterValue } from "./text";
+export type { NumberFilterValue, NumberBound } from "./number";
+export type { DateFilterValue, DateBound } from "./date";
+export type { PeriodFilterValue } from "./period";
+export type { BooleanFilterValue } from "./boolean";
+export type { EnumFilterValue, EnumOperator } from "./_list";
+export type { RelationKindValue } from "./relation";
+export type { ScheduleFilterValue } from "./schedule";
+export { ENUM_OPERATORS, matchListOperator } from "./_list";
+export declare const BUILTIN_FILTER_KINDS: readonly [import("../..").FilterKind<"text", import("./text").TextFilterValue, import("../..").TextOperator, unknown>, import("../..").FilterKind<"number", import("./number").NumberFilterValue, import("../..").NumberOperator, unknown>, import("../..").FilterKind<"date", import("./date").DateFilterValue, import("../..").DateOperator, unknown>, import("../..").FilterKind<"period", string, "inPeriod", unknown>, import("../..").FilterKind<"boolean", import("./boolean").BooleanFilterValue, "equals", unknown>, import("../..").FilterKind<"enum", import("./_list").EnumFilterValue, import("./_list").EnumOperator, unknown>, import("../..").FilterKind<"commonCode", import("./_list").EnumFilterValue, import("./_list").EnumOperator, unknown>, import("../..").FilterKind<"cascade", import("./_list").EnumFilterValue, import("./_list").EnumOperator, unknown>, import("../..").FilterKind<"relation", import("./relation").RelationKindValue, import("../..").RelationOperator, unknown>, import("../..").FilterKind<"schedule", import("./schedule").ScheduleFilterValue, import("../..").ScheduleOperator, unknown>, import("../..").FilterKind<"linear", import("./linear").LinearFilterValue, import("../..").LinearOperator, unknown>];
+/** 문자열 id 좁힘용 — `FilterKindRegistry` 가 이 맵을 상속한다 */
+declare module "../../types/filterKind" {
+    interface BuiltinFilterKindMap {
+        text: typeof textKind;
+        number: typeof numberKind;
+        date: typeof dateKind;
+        period: typeof periodKind;
+        boolean: typeof booleanKind;
+        enum: typeof enumKind;
+        commonCode: typeof commonCodeKind;
+        cascade: typeof cascadeKind;
+        relation: typeof relationKind;
+        schedule: typeof scheduleKind;
+        linear: typeof linearKind;
+    }
+}
+/**
+ * variant → 내장 kind. `ColumnBuilder.setVariant` / `dataType` 유추가 kind 를 함께 붙이는 표.
+ * `custom` 은 kind 가 없다(호출부가 `render` 로 값 해석을 전담).
+ */
+export declare const BUILTIN_KIND_BY_VARIANT: Partial<Record<FilterVariant, AnyFilterKind>>;
+export declare function builtinKindForVariant(variant: FilterVariant): AnyFilterKind | undefined;