@ai-matrx/design-system 0.22.0 → 0.25.0

package/dist/data-table/validation.cjs

@@ -0,0 +1,229 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/data-table/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  describeValidationRules: () => describeValidationRules,
+  hasValidationRules: () => hasValidationRules,
+  parseValidationRules: () => parseValidationRules,
+  serializeValidationRules: () => serializeValidationRules,
+  validateCellValue: () => validateCellValue
+});
+module.exports = __toCommonJS(validation_exports);
+var OK = { ok: true };
+var STORED_KEYS = [
+  "min",
+  "max",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "patternHint",
+  "allowedValues",
+  "unique"
+];
+function finiteNumber(raw) {
+  if (typeof raw === "number") return Number.isFinite(raw) ? raw : void 0;
+  if (typeof raw === "string" && raw.trim() !== "") {
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function nonNegativeInteger(raw) {
+  const n = finiteNumber(raw);
+  if (n === void 0) return void 0;
+  const i = Math.trunc(n);
+  return i >= 0 ? i : void 0;
+}
+function parseValidationRules(raw) {
+  let source = raw;
+  if (typeof source === "string") {
+    const text = source.trim();
+    if (text === "") return {};
+    try {
+      source = JSON.parse(text);
+    } catch {
+      return {};
+    }
+  }
+  if (!source || typeof source !== "object" || Array.isArray(source)) return {};
+  const obj = source;
+  const out = {};
+  const min = finiteNumber(obj.min);
+  if (min !== void 0) out.min = min;
+  const max = finiteNumber(obj.max);
+  if (max !== void 0) out.max = max;
+  const minLength = nonNegativeInteger(obj.minLength);
+  if (minLength !== void 0) out.minLength = minLength;
+  const maxLength = nonNegativeInteger(obj.maxLength);
+  if (maxLength !== void 0) out.maxLength = maxLength;
+  if (typeof obj.pattern === "string" && obj.pattern.trim() !== "") {
+    out.pattern = obj.pattern;
+    if (typeof obj.patternHint === "string" && obj.patternHint.trim() !== "") {
+      out.patternHint = obj.patternHint.trim();
+    }
+  }
+  if (Array.isArray(obj.allowedValues)) {
+    const values = obj.allowedValues.filter(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean"
+    ).map((v) => String(v).trim()).filter((v) => v !== "");
+    const seen = /* @__PURE__ */ new Set();
+    const unique = values.filter((v) => {
+      const key = v.toLowerCase();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    if (unique.length > 0) out.allowedValues = unique;
+  }
+  if (obj.unique === true) out.unique = true;
+  return out;
+}
+function hasValidationRules(rules) {
+  if (!rules) return false;
+  return STORED_KEYS.some((key) => rules[key] !== void 0);
+}
+function serializeValidationRules(rules) {
+  const out = {};
+  if (!rules) return out;
+  for (const key of STORED_KEYS) {
+    const value = rules[key];
+    if (value === void 0) continue;
+    if (key === "allowedValues" && (!Array.isArray(value) || value.length === 0)) continue;
+    if (key === "unique" && value !== true) continue;
+    if ((key === "pattern" || key === "patternHint") && String(value).trim() === "") continue;
+    out[key] = value;
+  }
+  if (out.patternHint !== void 0 && out.pattern === void 0) delete out.patternHint;
+  return out;
+}
+function describeValidationRules(rules) {
+  const out = [];
+  if (rules.min !== void 0 && rules.max !== void 0) {
+    out.push(`Between ${rules.min} and ${rules.max}`);
+  } else if (rules.min !== void 0) {
+    out.push(`At least ${rules.min}`);
+  } else if (rules.max !== void 0) {
+    out.push(`At most ${rules.max}`);
+  }
+  if (rules.minLength !== void 0 && rules.maxLength !== void 0) {
+    out.push(`${rules.minLength}\u2013${rules.maxLength} characters`);
+  } else if (rules.minLength !== void 0) {
+    out.push(`At least ${rules.minLength} characters`);
+  } else if (rules.maxLength !== void 0) {
+    out.push(`At most ${rules.maxLength} characters`);
+  }
+  if (rules.pattern) {
+    out.push(rules.patternHint ? `Pattern ${rules.patternHint}` : `Matches ${rules.pattern}`);
+  }
+  if (rules.allowedValues?.length) {
+    out.push(`One of: ${rules.allowedValues.join(", ")}`);
+  }
+  if (rules.unique) out.push("Unique across rows");
+  return out;
+}
+var CHOICE_FORMATS = /* @__PURE__ */ new Set(["choice", "multi_choice"]);
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+function asText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map((v) => String(v)).join(", ");
+  if (value !== null && typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+function validateCellValue(args) {
+  const { rules, dataType, format, value, existingValues } = args;
+  if (!rules || !hasValidationRules(rules)) return OK;
+  if (isEmptyValue(value)) return OK;
+  const text = asText(value);
+  const numeric = finiteNumber(value);
+  if (numeric !== void 0) {
+    if (rules.min !== void 0 && numeric < rules.min) {
+      return { ok: false, reason: `Must be at least ${rules.min}` };
+    }
+    if (rules.max !== void 0 && numeric > rules.max) {
+      return { ok: false, reason: `Must be at most ${rules.max}` };
+    }
+  }
+  if (rules.minLength !== void 0 && text.length < rules.minLength) {
+    return {
+      ok: false,
+      reason: `Must be at least ${rules.minLength} character${rules.minLength === 1 ? "" : "s"} (this is ${text.length})`
+    };
+  }
+  if (rules.maxLength !== void 0 && text.length > rules.maxLength) {
+    return {
+      ok: false,
+      reason: `Must be at most ${rules.maxLength} character${rules.maxLength === 1 ? "" : "s"} (this is ${text.length})`
+    };
+  }
+  if (rules.pattern) {
+    let re = null;
+    try {
+      re = new RegExp(rules.pattern);
+    } catch {
+      re = null;
+    }
+    if (re && !re.test(text)) {
+      return {
+        ok: false,
+        reason: rules.patternHint ? `Must match the pattern ${rules.patternHint}` : `Must match the pattern ${rules.pattern}`
+      };
+    }
+  }
+  const isChoiceColumn = format ? CHOICE_FORMATS.has(format.id) : false;
+  if (rules.allowedValues?.length && !isChoiceColumn) {
+    const target = text.trim();
+    const hit = rules.allowedValues.some(
+      (v) => v === target || v.toLowerCase() === target.toLowerCase()
+    );
+    if (!hit) {
+      return {
+        ok: false,
+        reason: `Must be one of: ${rules.allowedValues.join(", ")}`
+      };
+    }
+  }
+  if (rules.unique && existingValues && existingValues.length > 0) {
+    const target = text.trim().toLowerCase();
+    const clash = existingValues.some(
+      (other) => !isEmptyValue(other) && asText(other).trim().toLowerCase() === target
+    );
+    if (clash) {
+      return {
+        ok: false,
+        reason: `Must be unique \u2014 another row already has "${text}"`
+      };
+    }
+  }
+  void dataType;
+  return OK;
+}
+//# sourceMappingURL=validation.cjs.map

package/dist/data-table/validation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/data-table/validation.ts"],"sourcesContent":["/**\n * Column validation rules for user data tables — THE one rule model.\n *\n * A rule lives on `workbench.udt_dataset_fields.validation_rules` (jsonb) and\n * answers one question: may this value be written into this column? The\n * champions are Excel's data validation (a rule per column; an invalid entry is\n * refused WITH the reason) and Airtable (type-level only). We take Excel's\n * posture: the reason is the product.\n *\n * THREE LAWS this module exists to keep:\n *\n * 1. **`required` is NOT stored here.** The column already declares it as\n *    `is_required`, and a second copy is a second truth. `ValidationRules.required`\n *    is a read-only MIRROR for callers that want one object to reason about —\n *    `parseValidationRules` never invents it and the editor never writes it.\n *\n * 2. **A rule judges a value the user MEANT to write; it never judges what is\n *    already stored.** Existing values that violate a rule are legal, are never\n *    rewritten, and render in the SAME amber the format system already uses for\n *    a mismatch (`<FormattedFieldValue validationRules>`). Declaring a rule is\n *    how a user FINDS the stray values in their data, exactly as declaring a\n *    choice column's options is.\n *\n * 3. **An empty value is never a rule violation.** Emptiness is `is_required`'s\n *    question, asked once, by the callers that own the whole row. A `min: 0`\n *    rule that refused an empty cell would make every optional number column\n *    mandatory by accident.\n *\n * `unique` is the one rule this module cannot answer alone: it is a statement\n * about the OTHER rows, so the caller passes `existingValues` (the loaded rows'\n * values for that column) when it holds them. Without them the rule is skipped\n * rather than guessed — and it is deliberately NOT enforced by the database\n * trigger, because a cross-row check inside a per-row BEFORE trigger is the\n * wrong shape (it cannot see concurrent inserts and it walks the table on every\n * write). See `migrations/udt_validation_rules_strict_enforcement.sql`.\n *\n * Moved here from the app (`@ai-matrx/design-system/data-table/validation`) so\n * every table in the product enforces and explains validation the same way.\n */\n\nimport type { FieldFormatConfig } from \"../field-formats/types\";\n\nexport type ValidationRules = {\n  /**\n   * MIRROR of the column's `is_required`. Never stored in `validation_rules`,\n   * never written by the editor — present so a caller can carry one object.\n   */\n  required?: boolean;\n  /** Smallest number accepted. Number-ish columns only. */\n  min?: number;\n  /** Largest number accepted. Number-ish columns only. */\n  max?: number;\n  /** Fewest characters accepted. Text-ish columns only. */\n  minLength?: number;\n  /** Most characters accepted. Text-ish columns only. */\n  maxLength?: number;\n  /**\n   * A regular expression the value must match. Written in the dialect BOTH\n   * JavaScript and Postgres understand, and **anchored by the author** — an\n   * unanchored `\\d{3}` matches \"abc123def\" in both engines, which is almost\n   * never what a person drawing a rule means.\n   */\n  pattern?: string;\n  /** Plain-English shape shown when `pattern` refuses, e.g. `###-####`. */\n  patternHint?: string;\n  /**\n   * The exact values accepted. Only for a column that is NOT a choice column —\n   * a choice column already carries its options in its format, and a second\n   * list would be a second vocabulary for the same column.\n   */\n  allowedValues?: string[];\n  /** No two rows may carry the same value. Checked by the caller, never by the trigger. */\n  unique?: boolean;\n};\n\nexport type ValidationOk = { ok: true };\nexport type ValidationFailure = { ok: false; reason: string };\nexport type ValidationResult = ValidationOk | ValidationFailure;\n\nconst OK: ValidationOk = { ok: true };\n\n/** Keys the editor may write. `required` is deliberately absent — law 1. */\nconst STORED_KEYS = [\n  \"min\",\n  \"max\",\n  \"minLength\",\n  \"maxLength\",\n  \"pattern\",\n  \"patternHint\",\n  \"allowedValues\",\n  \"unique\",\n] as const;\n\nfunction finiteNumber(raw: unknown): number | undefined {\n  if (typeof raw === \"number\") return Number.isFinite(raw) ? raw : undefined;\n  if (typeof raw === \"string\" && raw.trim() !== \"\") {\n    const n = Number(raw);\n    return Number.isFinite(n) ? n : undefined;\n  }\n  return undefined;\n}\n\nfunction nonNegativeInteger(raw: unknown): number | undefined {\n  const n = finiteNumber(raw);\n  if (n === undefined) return undefined;\n  const i = Math.trunc(n);\n  return i >= 0 ? i : undefined;\n}\n\n/**\n * Read whatever is stored on the column into the rule model. TOLERANT by\n * design: this reads a jsonb column that predates the feature, that an agent or\n * an import may have written, and that a future version may extend. Anything it\n * cannot understand is dropped, never thrown on — a column with a garbled rule\n * must still be editable.\n */\nexport function parseValidationRules(raw: unknown): ValidationRules {\n  let source: unknown = raw;\n  if (typeof source === \"string\") {\n    const text = source.trim();\n    if (text === \"\") return {};\n    try {\n      source = JSON.parse(text);\n    } catch {\n      return {};\n    }\n  }\n  if (!source || typeof source !== \"object\" || Array.isArray(source)) return {};\n  const obj = source as Record<string, unknown>;\n  const out: ValidationRules = {};\n\n  const min = finiteNumber(obj.min);\n  if (min !== undefined) out.min = min;\n  const max = finiteNumber(obj.max);\n  if (max !== undefined) out.max = max;\n\n  const minLength = nonNegativeInteger(obj.minLength);\n  if (minLength !== undefined) out.minLength = minLength;\n  const maxLength = nonNegativeInteger(obj.maxLength);\n  if (maxLength !== undefined) out.maxLength = maxLength;\n\n  if (typeof obj.pattern === \"string\" && obj.pattern.trim() !== \"\") {\n    out.pattern = obj.pattern;\n    if (typeof obj.patternHint === \"string\" && obj.patternHint.trim() !== \"\") {\n      out.patternHint = obj.patternHint.trim();\n    }\n  }\n\n  if (Array.isArray(obj.allowedValues)) {\n    const values = obj.allowedValues\n      .filter(\n        (v): v is string | number | boolean =>\n          typeof v === \"string\" || typeof v === \"number\" || typeof v === \"boolean\",\n      )\n      .map((v) => String(v).trim())\n      .filter((v) => v !== \"\");\n    // De-duplicate, keeping the author's order.\n    const seen = new Set<string>();\n    const unique = values.filter((v) => {\n      const key = v.toLowerCase();\n      if (seen.has(key)) return false;\n      seen.add(key);\n      return true;\n    });\n    if (unique.length > 0) out.allowedValues = unique;\n  }\n\n  if (obj.unique === true) out.unique = true;\n\n  return out;\n}\n\n/** True when the column actually constrains anything. */\nexport function hasValidationRules(rules: ValidationRules | null | undefined): boolean {\n  if (!rules) return false;\n  return STORED_KEYS.some((key) => rules[key] !== undefined);\n}\n\n/**\n * The object to STORE. Strips `required` (law 1) and every empty key, so a\n * column whose rules were all cleared stores `{}` rather than a husk of nulls\n * — which also matters because `update_user_table_config` COALESCEs the column,\n * so `{}` is the only way to clear it.\n */\nexport function serializeValidationRules(\n  rules: ValidationRules | null | undefined,\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (!rules) return out;\n  for (const key of STORED_KEYS) {\n    const value = rules[key];\n    if (value === undefined) continue;\n    if (key === \"allowedValues\" && (!Array.isArray(value) || value.length === 0)) continue;\n    if (key === \"unique\" && value !== true) continue;\n    if ((key === \"pattern\" || key === \"patternHint\") && String(value).trim() === \"\") continue;\n    out[key] = value;\n  }\n  // A hint with no pattern says nothing; drop it rather than store a dangling half-rule.\n  if (out.patternHint !== undefined && out.pattern === undefined) delete out.patternHint;\n  return out;\n}\n\n/** Plain-English list of what a column requires — for tooltips and for agents. */\nexport function describeValidationRules(rules: ValidationRules): string[] {\n  const out: string[] = [];\n  if (rules.min !== undefined && rules.max !== undefined) {\n    out.push(`Between ${rules.min} and ${rules.max}`);\n  } else if (rules.min !== undefined) {\n    out.push(`At least ${rules.min}`);\n  } else if (rules.max !== undefined) {\n    out.push(`At most ${rules.max}`);\n  }\n  if (rules.minLength !== undefined && rules.maxLength !== undefined) {\n    out.push(`${rules.minLength}–${rules.maxLength} characters`);\n  } else if (rules.minLength !== undefined) {\n    out.push(`At least ${rules.minLength} characters`);\n  } else if (rules.maxLength !== undefined) {\n    out.push(`At most ${rules.maxLength} characters`);\n  }\n  if (rules.pattern) {\n    out.push(rules.patternHint ? `Pattern ${rules.patternHint}` : `Matches ${rules.pattern}`);\n  }\n  if (rules.allowedValues?.length) {\n    out.push(`One of: ${rules.allowedValues.join(\", \")}`);\n  }\n  if (rules.unique) out.push(\"Unique across rows\");\n  return out;\n}\n\nconst CHOICE_FORMATS = new Set([\"choice\", \"multi_choice\"]);\n\nfunction isEmptyValue(value: unknown): boolean {\n  if (value === null || value === undefined) return true;\n  if (typeof value === \"string\" && value.trim() === \"\") return true;\n  if (Array.isArray(value) && value.length === 0) return true;\n  return false;\n}\n\n/** The value as the user reads it — the basis for every text rule. */\nfunction asText(value: unknown): string {\n  if (typeof value === \"string\") return value;\n  if (Array.isArray(value)) return value.map((v) => String(v)).join(\", \");\n  if (value !== null && typeof value === \"object\") {\n    try {\n      return JSON.stringify(value);\n    } catch {\n      return String(value);\n    }\n  }\n  return String(value);\n}\n\nexport type ValidateCellArgs = {\n  rules: ValidationRules | null | undefined;\n  /** The column's storage type (`string` | `number` | `integer` | …). */\n  dataType: string;\n  /** The column's declared display format, when it has one. */\n  format?: FieldFormatConfig | null;\n  /** The value the user is trying to write, already type-normalized. */\n  value: unknown;\n  /**\n   * Every OTHER row's value for this column, when the caller holds them. Only\n   * `unique` reads this; omit it and `unique` is skipped rather than guessed.\n   */\n  existingValues?: unknown[];\n};\n\n/**\n * Judge one value against one column's rules.\n *\n * Returns the FIRST reason it fails, in the order a person would check them\n * (range, length, shape, membership, uniqueness) — a wall of five complaints\n * about one cell is not more helpful than the first one.\n */\nexport function validateCellValue(args: ValidateCellArgs): ValidationResult {\n  const { rules, dataType, format, value, existingValues } = args;\n  if (!rules || !hasValidationRules(rules)) return OK;\n\n  // Law 3 — emptiness belongs to `is_required`, not to a rule.\n  if (isEmptyValue(value)) return OK;\n\n  const text = asText(value);\n  const numeric = finiteNumber(value);\n\n  // ── range ───────────────────────────────────────────────────────────────\n  // Applied only when a number can honestly be read out of the value. A\n  // non-numeric value in a number column is a TYPE problem, already reported by\n  // the format layer and by strict mode; saying \"Must be at least 0\" about the\n  // word \"pending\" would be a second, worse answer to a question already asked.\n  if (numeric !== undefined) {\n    if (rules.min !== undefined && numeric < rules.min) {\n      return { ok: false, reason: `Must be at least ${rules.min}` };\n    }\n    if (rules.max !== undefined && numeric > rules.max) {\n      return { ok: false, reason: `Must be at most ${rules.max}` };\n    }\n  }\n\n  // ── length ──────────────────────────────────────────────────────────────\n  if (rules.minLength !== undefined && text.length < rules.minLength) {\n    return {\n      ok: false,\n      reason: `Must be at least ${rules.minLength} character${rules.minLength === 1 ? \"\" : \"s\"} (this is ${text.length})`,\n    };\n  }\n  if (rules.maxLength !== undefined && text.length > rules.maxLength) {\n    return {\n      ok: false,\n      reason: `Must be at most ${rules.maxLength} character${rules.maxLength === 1 ? \"\" : \"s\"} (this is ${text.length})`,\n    };\n  }\n\n  // ── shape ───────────────────────────────────────────────────────────────\n  if (rules.pattern) {\n    let re: RegExp | null = null;\n    try {\n      re = new RegExp(rules.pattern);\n    } catch {\n      // An unparseable pattern is the AUTHOR's defect, not this value's. It is\n      // reported where it is written (the editor refuses to save one); here it\n      // must never turn into a refusal the typist cannot act on.\n      re = null;\n    }\n    if (re && !re.test(text)) {\n      return {\n        ok: false,\n        reason: rules.patternHint\n          ? `Must match the pattern ${rules.patternHint}`\n          : `Must match the pattern ${rules.pattern}`,\n      };\n    }\n  }\n\n  // ── membership ──────────────────────────────────────────────────────────\n  // Skipped on a choice column by construction: its options are its format's\n  // job, they are offered in the picker, and an off-list value there is legal\n  // and amber by design. A second list here would contradict that.\n  const isChoiceColumn = format ? CHOICE_FORMATS.has(format.id) : false;\n  if (rules.allowedValues?.length && !isChoiceColumn) {\n    const target = text.trim();\n    const hit = rules.allowedValues.some(\n      (v) => v === target || v.toLowerCase() === target.toLowerCase(),\n    );\n    if (!hit) {\n      return {\n        ok: false,\n        reason: `Must be one of: ${rules.allowedValues.join(\", \")}`,\n      };\n    }\n  }\n\n  // ── uniqueness ──────────────────────────────────────────────────────────\n  if (rules.unique && existingValues && existingValues.length > 0) {\n    const target = text.trim().toLowerCase();\n    const clash = existingValues.some(\n      (other) => !isEmptyValue(other) && asText(other).trim().toLowerCase() === target,\n    );\n    if (clash) {\n      return {\n        ok: false,\n        reason: `Must be unique — another row already has \"${text}\"`,\n      };\n    }\n  }\n\n  // `dataType` is not read by any rule today: every rule above is answered by\n  // the VALUE, and the storage type is already enforced by strict mode and by\n  // the format layer. It stays in the signature because it is the one fact a\n  // future rule (a date range, say) cannot be written without, and adding it\n  // later would change every callsite.\n  void dataType;\n\n  return OK;\n}\n"],"mappings":"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","names":[]}

package/dist/data-table/validation.d.cts

@@ -0,0 +1,125 @@
+import { F as FieldFormatConfig } from '../types-CJWU1Gae.cjs';
+
+/**
+ * Column validation rules for user data tables — THE one rule model.
+ *
+ * A rule lives on `workbench.udt_dataset_fields.validation_rules` (jsonb) and
+ * answers one question: may this value be written into this column? The
+ * champions are Excel's data validation (a rule per column; an invalid entry is
+ * refused WITH the reason) and Airtable (type-level only). We take Excel's
+ * posture: the reason is the product.
+ *
+ * THREE LAWS this module exists to keep:
+ *
+ * 1. **`required` is NOT stored here.** The column already declares it as
+ *    `is_required`, and a second copy is a second truth. `ValidationRules.required`
+ *    is a read-only MIRROR for callers that want one object to reason about —
+ *    `parseValidationRules` never invents it and the editor never writes it.
+ *
+ * 2. **A rule judges a value the user MEANT to write; it never judges what is
+ *    already stored.** Existing values that violate a rule are legal, are never
+ *    rewritten, and render in the SAME amber the format system already uses for
+ *    a mismatch (`<FormattedFieldValue validationRules>`). Declaring a rule is
+ *    how a user FINDS the stray values in their data, exactly as declaring a
+ *    choice column's options is.
+ *
+ * 3. **An empty value is never a rule violation.** Emptiness is `is_required`'s
+ *    question, asked once, by the callers that own the whole row. A `min: 0`
+ *    rule that refused an empty cell would make every optional number column
+ *    mandatory by accident.
+ *
+ * `unique` is the one rule this module cannot answer alone: it is a statement
+ * about the OTHER rows, so the caller passes `existingValues` (the loaded rows'
+ * values for that column) when it holds them. Without them the rule is skipped
+ * rather than guessed — and it is deliberately NOT enforced by the database
+ * trigger, because a cross-row check inside a per-row BEFORE trigger is the
+ * wrong shape (it cannot see concurrent inserts and it walks the table on every
+ * write). See `migrations/udt_validation_rules_strict_enforcement.sql`.
+ *
+ * Moved here from the app (`@ai-matrx/design-system/data-table/validation`) so
+ * every table in the product enforces and explains validation the same way.
+ */
+
+type ValidationRules = {
+    /**
+     * MIRROR of the column's `is_required`. Never stored in `validation_rules`,
+     * never written by the editor — present so a caller can carry one object.
+     */
+    required?: boolean;
+    /** Smallest number accepted. Number-ish columns only. */
+    min?: number;
+    /** Largest number accepted. Number-ish columns only. */
+    max?: number;
+    /** Fewest characters accepted. Text-ish columns only. */
+    minLength?: number;
+    /** Most characters accepted. Text-ish columns only. */
+    maxLength?: number;
+    /**
+     * A regular expression the value must match. Written in the dialect BOTH
+     * JavaScript and Postgres understand, and **anchored by the author** — an
+     * unanchored `\d{3}` matches "abc123def" in both engines, which is almost
+     * never what a person drawing a rule means.
+     */
+    pattern?: string;
+    /** Plain-English shape shown when `pattern` refuses, e.g. `###-####`. */
+    patternHint?: string;
+    /**
+     * The exact values accepted. Only for a column that is NOT a choice column —
+     * a choice column already carries its options in its format, and a second
+     * list would be a second vocabulary for the same column.
+     */
+    allowedValues?: string[];
+    /** No two rows may carry the same value. Checked by the caller, never by the trigger. */
+    unique?: boolean;
+};
+type ValidationOk = {
+    ok: true;
+};
+type ValidationFailure = {
+    ok: false;
+    reason: string;
+};
+type ValidationResult = ValidationOk | ValidationFailure;
+/**
+ * Read whatever is stored on the column into the rule model. TOLERANT by
+ * design: this reads a jsonb column that predates the feature, that an agent or
+ * an import may have written, and that a future version may extend. Anything it
+ * cannot understand is dropped, never thrown on — a column with a garbled rule
+ * must still be editable.
+ */
+declare function parseValidationRules(raw: unknown): ValidationRules;
+/** True when the column actually constrains anything. */
+declare function hasValidationRules(rules: ValidationRules | null | undefined): boolean;
+/**
+ * The object to STORE. Strips `required` (law 1) and every empty key, so a
+ * column whose rules were all cleared stores `{}` rather than a husk of nulls
+ * — which also matters because `update_user_table_config` COALESCEs the column,
+ * so `{}` is the only way to clear it.
+ */
+declare function serializeValidationRules(rules: ValidationRules | null | undefined): Record<string, unknown>;
+/** Plain-English list of what a column requires — for tooltips and for agents. */
+declare function describeValidationRules(rules: ValidationRules): string[];
+type ValidateCellArgs = {
+    rules: ValidationRules | null | undefined;
+    /** The column's storage type (`string` | `number` | `integer` | …). */
+    dataType: string;
+    /** The column's declared display format, when it has one. */
+    format?: FieldFormatConfig | null;
+    /** The value the user is trying to write, already type-normalized. */
+    value: unknown;
+    /**
+     * Every OTHER row's value for this column, when the caller holds them. Only
+     * `unique` reads this; omit it and `unique` is skipped rather than guessed.
+     */
+    existingValues?: unknown[];
+};
+/**
+ * Judge one value against one column's rules.
+ *
+ * Returns the FIRST reason it fails, in the order a person would check them
+ * (range, length, shape, membership, uniqueness) — a wall of five complaints
+ * about one cell is not more helpful than the first one.
+ */
+declare function validateCellValue(args: ValidateCellArgs): ValidationResult;
+
+export { type ValidateCellArgs, type ValidationFailure, type ValidationOk, type ValidationResult, type ValidationRules, describeValidationRules, hasValidationRules, parseValidationRules, serializeValidationRules, validateCellValue };

package/dist/data-table/validation.d.ts

@@ -0,0 +1,125 @@
+import { F as FieldFormatConfig } from '../types-CJWU1Gae.js';
+
+/**
+ * Column validation rules for user data tables — THE one rule model.
+ *
+ * A rule lives on `workbench.udt_dataset_fields.validation_rules` (jsonb) and
+ * answers one question: may this value be written into this column? The
+ * champions are Excel's data validation (a rule per column; an invalid entry is
+ * refused WITH the reason) and Airtable (type-level only). We take Excel's
+ * posture: the reason is the product.
+ *
+ * THREE LAWS this module exists to keep:
+ *
+ * 1. **`required` is NOT stored here.** The column already declares it as
+ *    `is_required`, and a second copy is a second truth. `ValidationRules.required`
+ *    is a read-only MIRROR for callers that want one object to reason about —
+ *    `parseValidationRules` never invents it and the editor never writes it.
+ *
+ * 2. **A rule judges a value the user MEANT to write; it never judges what is
+ *    already stored.** Existing values that violate a rule are legal, are never
+ *    rewritten, and render in the SAME amber the format system already uses for
+ *    a mismatch (`<FormattedFieldValue validationRules>`). Declaring a rule is
+ *    how a user FINDS the stray values in their data, exactly as declaring a
+ *    choice column's options is.
+ *
+ * 3. **An empty value is never a rule violation.** Emptiness is `is_required`'s
+ *    question, asked once, by the callers that own the whole row. A `min: 0`
+ *    rule that refused an empty cell would make every optional number column
+ *    mandatory by accident.
+ *
+ * `unique` is the one rule this module cannot answer alone: it is a statement
+ * about the OTHER rows, so the caller passes `existingValues` (the loaded rows'
+ * values for that column) when it holds them. Without them the rule is skipped
+ * rather than guessed — and it is deliberately NOT enforced by the database
+ * trigger, because a cross-row check inside a per-row BEFORE trigger is the
+ * wrong shape (it cannot see concurrent inserts and it walks the table on every
+ * write). See `migrations/udt_validation_rules_strict_enforcement.sql`.
+ *
+ * Moved here from the app (`@ai-matrx/design-system/data-table/validation`) so
+ * every table in the product enforces and explains validation the same way.
+ */
+
+type ValidationRules = {
+    /**
+     * MIRROR of the column's `is_required`. Never stored in `validation_rules`,
+     * never written by the editor — present so a caller can carry one object.
+     */
+    required?: boolean;
+    /** Smallest number accepted. Number-ish columns only. */
+    min?: number;
+    /** Largest number accepted. Number-ish columns only. */
+    max?: number;
+    /** Fewest characters accepted. Text-ish columns only. */
+    minLength?: number;
+    /** Most characters accepted. Text-ish columns only. */
+    maxLength?: number;
+    /**
+     * A regular expression the value must match. Written in the dialect BOTH
+     * JavaScript and Postgres understand, and **anchored by the author** — an
+     * unanchored `\d{3}` matches "abc123def" in both engines, which is almost
+     * never what a person drawing a rule means.
+     */
+    pattern?: string;
+    /** Plain-English shape shown when `pattern` refuses, e.g. `###-####`. */
+    patternHint?: string;
+    /**
+     * The exact values accepted. Only for a column that is NOT a choice column —
+     * a choice column already carries its options in its format, and a second
+     * list would be a second vocabulary for the same column.
+     */
+    allowedValues?: string[];
+    /** No two rows may carry the same value. Checked by the caller, never by the trigger. */
+    unique?: boolean;
+};
+type ValidationOk = {
+    ok: true;
+};
+type ValidationFailure = {
+    ok: false;
+    reason: string;
+};
+type ValidationResult = ValidationOk | ValidationFailure;
+/**
+ * Read whatever is stored on the column into the rule model. TOLERANT by
+ * design: this reads a jsonb column that predates the feature, that an agent or
+ * an import may have written, and that a future version may extend. Anything it
+ * cannot understand is dropped, never thrown on — a column with a garbled rule
+ * must still be editable.
+ */
+declare function parseValidationRules(raw: unknown): ValidationRules;
+/** True when the column actually constrains anything. */
+declare function hasValidationRules(rules: ValidationRules | null | undefined): boolean;
+/**
+ * The object to STORE. Strips `required` (law 1) and every empty key, so a
+ * column whose rules were all cleared stores `{}` rather than a husk of nulls
+ * — which also matters because `update_user_table_config` COALESCEs the column,
+ * so `{}` is the only way to clear it.
+ */
+declare function serializeValidationRules(rules: ValidationRules | null | undefined): Record<string, unknown>;
+/** Plain-English list of what a column requires — for tooltips and for agents. */
+declare function describeValidationRules(rules: ValidationRules): string[];
+type ValidateCellArgs = {
+    rules: ValidationRules | null | undefined;
+    /** The column's storage type (`string` | `number` | `integer` | …). */
+    dataType: string;
+    /** The column's declared display format, when it has one. */
+    format?: FieldFormatConfig | null;
+    /** The value the user is trying to write, already type-normalized. */
+    value: unknown;
+    /**
+     * Every OTHER row's value for this column, when the caller holds them. Only
+     * `unique` reads this; omit it and `unique` is skipped rather than guessed.
+     */
+    existingValues?: unknown[];
+};
+/**
+ * Judge one value against one column's rules.
+ *
+ * Returns the FIRST reason it fails, in the order a person would check them
+ * (range, length, shape, membership, uniqueness) — a wall of five complaints
+ * about one cell is not more helpful than the first one.
+ */
+declare function validateCellValue(args: ValidateCellArgs): ValidationResult;
+
+export { type ValidateCellArgs, type ValidationFailure, type ValidationOk, type ValidationResult, type ValidationRules, describeValidationRules, hasValidationRules, parseValidationRules, serializeValidationRules, validateCellValue };