@logixjs/form 0.0.1

package/dist/Rule.cjs

@@ -0,0 +1,307 @@
+"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/Rule.ts
+var Rule_exports = {};
+__export(Rule_exports, {
+  ERROR_VALUE_MAX_BYTES: () => ERROR_VALUE_MAX_BYTES,
+  assertErrorValueBudget: () => assertErrorValueBudget,
+  field: () => field,
+  fields: () => fields,
+  list: () => list,
+  make: () => make,
+  max: () => max,
+  maxLength: () => maxLength,
+  merge: () => merge,
+  min: () => min,
+  minLength: () => minLength,
+  pattern: () => pattern,
+  required: () => required,
+  root: () => root
+});
+module.exports = __toCommonJS(Rule_exports);
+
+// src/internal/validators/index.ts
+var import_effect = require("effect");
+var ERROR_VALUE_MAX_BYTES = 256;
+var textEncoder = new TextEncoder();
+var jsonByteSize = (value) => {
+  const json = JSON.stringify(value);
+  return textEncoder.encode(json).length;
+};
+var assertErrorValueBudget = (value, label) => {
+  const bytes = jsonByteSize(value);
+  if (bytes <= ERROR_VALUE_MAX_BYTES) return value;
+  throw new Error(`[Form.validators] ErrorValue for "${label}" must be JSON \u2264${ERROR_VALUE_MAX_BYTES}B (got ${bytes}B)`);
+};
+var errorValue = (label, value) => assertErrorValueBudget(value, label);
+var required = (decl) => {
+  const trim = typeof decl === "object" && decl !== null ? Boolean(decl.trim) : true;
+  const message = typeof decl === "string" ? decl : typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "required";
+  const err = errorValue("required", message);
+  return (value) => {
+    if (value === null || value === void 0) return err;
+    if (typeof value === "string") {
+      const v = trim ? value.trim() : value;
+      return v.length > 0 ? void 0 : err;
+    }
+    if (Array.isArray(value)) return value.length > 0 ? void 0 : err;
+    if (typeof value === "boolean") return value ? void 0 : err;
+    return void 0;
+  };
+};
+var minLength = (decl) => {
+  const min2 = typeof decl === "number" ? decl : decl.min;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "minLength";
+  const err = errorValue("minLength", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "string") return value.length >= min2 ? void 0 : err;
+    if (Array.isArray(value)) return value.length >= min2 ? void 0 : err;
+    return void 0;
+  };
+};
+var maxLength = (decl) => {
+  const max2 = typeof decl === "number" ? decl : decl.max;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "maxLength";
+  const err = errorValue("maxLength", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "string") return value.length <= max2 ? void 0 : err;
+    if (Array.isArray(value)) return value.length <= max2 ? void 0 : err;
+    return void 0;
+  };
+};
+var min = (decl) => {
+  const minValue = typeof decl === "number" ? decl : decl.min;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "min";
+  const err = errorValue("min", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "number" && Number.isFinite(value)) return value >= minValue ? void 0 : err;
+    return void 0;
+  };
+};
+var max = (decl) => {
+  const maxValue = typeof decl === "number" ? decl : decl.max;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "max";
+  const err = errorValue("max", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value === "number" && Number.isFinite(value)) return value <= maxValue ? void 0 : err;
+    return void 0;
+  };
+};
+var pattern = (decl) => {
+  const re = decl instanceof RegExp ? decl : decl.re;
+  const message = typeof decl === "object" && decl !== null && typeof decl.message === "string" ? decl.message : "pattern";
+  const err = errorValue("pattern", message);
+  return (value) => {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "string") return void 0;
+    return re.test(value) ? void 0 : err;
+  };
+};
+
+// src/Rule.ts
+var uniq = (items) => Array.from(new Set(items));
+var normalizeValidateOn = (input) => {
+  if (!Array.isArray(input)) return void 0;
+  const out = [];
+  for (const x of input) {
+    if (x === "onChange" || x === "onBlur") out.push(x);
+  }
+  return uniq(out);
+};
+var normalizeDeps = (input) => {
+  if (!Array.isArray(input)) return void 0;
+  const out = [];
+  for (const x of input) {
+    if (typeof x !== "string") continue;
+    const v = x.trim();
+    if (!v) continue;
+    out.push(v);
+  }
+  return uniq(out);
+};
+var isPlainObject = (value) => Boolean(value) && typeof value === "object" && value !== null && !Array.isArray(value);
+var make = (input) => {
+  if (typeof input === "function") {
+    return {
+      default: {
+        deps: [],
+        validate: input
+      }
+    };
+  }
+  if (!isPlainObject(input)) {
+    return {};
+  }
+  const baseDeps = normalizeDeps(input.deps) ?? [];
+  const baseValidateOn = normalizeValidateOn(input.validateOn);
+  const byName = /* @__PURE__ */ new Map();
+  const addRule = (name, raw) => {
+    const ruleName = typeof name === "string" ? name.trim() : "";
+    if (!ruleName) return;
+    if (byName.has(ruleName)) {
+      throw new Error(`[Form.Rule.make] Duplicate rule name "${ruleName}"`);
+    }
+    if (typeof raw === "function") {
+      byName.set(ruleName, {
+        deps: baseDeps,
+        validate: raw,
+        ...baseValidateOn !== void 0 ? { validateOn: baseValidateOn } : {}
+      });
+      return;
+    }
+    if (!raw || typeof raw !== "object") return;
+    const entry = raw;
+    const deps = normalizeDeps(entry.deps) ?? baseDeps;
+    const validateOn = normalizeValidateOn(entry.validateOn) ?? baseValidateOn;
+    const validate = entry.validate;
+    if (typeof validate !== "function") return;
+    byName.set(ruleName, {
+      ...entry,
+      deps,
+      validate,
+      ...validateOn !== void 0 ? { validateOn } : {}
+    });
+  };
+  const requiredDecl = input.required;
+  if (requiredDecl !== void 0 && requiredDecl !== false) {
+    const validate = required(requiredDecl);
+    addRule("required", (value) => validate(value));
+  }
+  const minLengthDecl = input.minLength;
+  if (minLengthDecl !== void 0) {
+    const validate = minLength(minLengthDecl);
+    addRule("minLength", (value) => validate(value));
+  }
+  const maxLengthDecl = input.maxLength;
+  if (maxLengthDecl !== void 0) {
+    const validate = maxLength(maxLengthDecl);
+    addRule("maxLength", (value) => validate(value));
+  }
+  const minDecl = input.min;
+  if (minDecl !== void 0) {
+    const validate = min(minDecl);
+    addRule("min", (value) => validate(value));
+  }
+  const maxDecl = input.max;
+  if (maxDecl !== void 0) {
+    const validate = max(maxDecl);
+    addRule("max", (value) => validate(value));
+  }
+  const patternDecl = input.pattern;
+  if (patternDecl !== void 0) {
+    const validate = pattern(patternDecl);
+    addRule("pattern", (value) => validate(value));
+  }
+  const validateBlock = input.validate;
+  if (typeof validateBlock === "function") {
+    addRule("validate", validateBlock);
+  } else if (isPlainObject(validateBlock)) {
+    const names2 = Object.keys(validateBlock).sort((a, b) => a.localeCompare(b));
+    for (const name of names2) {
+      addRule(name, validateBlock[name]);
+    }
+  }
+  const out = {};
+  const names = Array.from(byName.keys()).sort((a, b) => a.localeCompare(b));
+  for (const name of names) {
+    out[name] = byName.get(name);
+  }
+  return out;
+};
+var merge = (...rules) => {
+  const byName = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const ruleSet of rules) {
+    for (const name of Object.keys(ruleSet)) {
+      if (byName.has(name)) duplicates.add(name);
+      else byName.set(name, ruleSet[name]);
+    }
+  }
+  if (duplicates.size > 0) {
+    const list2 = Array.from(duplicates).sort((a, b) => a.localeCompare(b)).join(", ");
+    throw new Error(`[Form.Rule.merge] Duplicate rule name(s): ${list2}`);
+  }
+  const merged = {};
+  const names = Array.from(byName.keys()).sort((a, b) => a.localeCompare(b));
+  for (const name of names) {
+    merged[name] = byName.get(name);
+  }
+  return merged;
+};
+var field = (valuePath, rule, options) => ({
+  kind: "field",
+  valuePath,
+  rule,
+  ...options?.errorTarget !== void 0 ? { errorTarget: options.errorTarget } : {}
+});
+var root = (rule) => ({
+  kind: "root",
+  rule
+});
+var list = (listPath, spec) => ({
+  kind: "list",
+  listPath,
+  identity: spec.identity,
+  ...spec.item !== void 0 ? { item: spec.item } : {},
+  ...spec.list !== void 0 ? { list: spec.list } : {}
+});
+var fields = (...decls) => {
+  const out = {};
+  const list2 = [];
+  const isDeclArray = (value) => Array.isArray(value);
+  for (const item of decls) {
+    if (isDeclArray(item)) {
+      list2.push(...item);
+      continue;
+    }
+    list2.push(item);
+  }
+  for (const decl of list2) {
+    const path = typeof decl?.valuePath === "string" ? decl.valuePath.trim() : "";
+    if (!path) continue;
+    if (path in out) {
+      throw new Error(`[Form.Rule.fields] Duplicate valuePath "${path}"`);
+    }
+    out[path] = decl.rule;
+  }
+  return out;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERROR_VALUE_MAX_BYTES,
+  assertErrorValueBudget,
+  field,
+  fields,
+  list,
+  make,
+  max,
+  maxLength,
+  merge,
+  min,
+  minLength,
+  pattern,
+  required,
+  root
+});
+//# sourceMappingURL=Rule.cjs.map

package/dist/Rule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Rule.ts","../src/internal/validators/index.ts"],"sourcesContent":["import type * as Logix from '@logixjs/core'\nimport * as Validators from './internal/validators/index.js'\nimport type { CanonicalPath } from './internal/form/types.js'\n\nexport type AutoValidateOn = 'onChange' | 'onBlur'\n\nexport type RuleValidateOn = ReadonlyArray<AutoValidateOn>\n\nexport type RuleFn<Input, Ctx = unknown> = (input: Input, ctx: Ctx) => unknown | undefined\n\ntype RuleDeps<Input> = Input extends object\n  ? CanonicalPath<Input> extends never\n    ? string\n    : CanonicalPath<Input>\n  : string\n\nexport type Rule<Input, Ctx = unknown> = Logix.StateTrait.CheckRule<Input, Ctx> & {\n  /**\n   * validateOn：\n   * - Only affects the auto-validation phase (onChange/onBlur); submit/manual always runs.\n   * - If an empty array, auto-validation is disabled (only submit/manual runs).\n   */\n  readonly validateOn?: RuleValidateOn\n}\n\nexport type RuleSet<Input, Ctx = unknown> = Readonly<Record<string, Rule<Input, Ctx>>>\n\nexport type RuleEntry<Input, Ctx = unknown> =\n  | RuleFn<Input, Ctx>\n  | (Omit<Rule<Input, Ctx>, 'deps'> & {\n      readonly deps?: ReadonlyArray<RuleDeps<Input>>\n    })\n\nexport type RuleGroup<Input, Ctx = unknown> = Readonly<{\n  readonly deps?: ReadonlyArray<RuleDeps<Input>>\n  readonly validateOn?: RuleValidateOn\n  readonly validate: Readonly<Record<string, RuleEntry<Input, Ctx>>>\n}>\n\nexport type RuleConfig<Input, Ctx = unknown> = Readonly<{\n  readonly deps?: ReadonlyArray<RuleDeps<Input>>\n  readonly validateOn?: RuleValidateOn\n\n  // RHF-like builtins (expanded at build time into equivalent pure functions)\n  readonly required?: Validators.RequiredDecl\n  readonly minLength?: Validators.MinLengthDecl\n  readonly maxLength?: Validators.MaxLengthDecl\n  readonly min?: Validators.MinDecl\n  readonly max?: Validators.MaxDecl\n  readonly pattern?: Validators.PatternDecl\n\n  // RHF-like validate: a function or a named map of functions (RuleEntry form is also allowed to override deps/validateOn)\n  readonly validate?: RuleFn<Input, Ctx> | Readonly<Record<string, RuleEntry<Input, Ctx>>>\n}>\n\nexport type RuleInput<Input, Ctx = unknown> = RuleFn<Input, Ctx> | RuleGroup<Input, Ctx> | RuleConfig<Input, Ctx>\n\nconst uniq = <T>(items: ReadonlyArray<T>): ReadonlyArray<T> => Array.from(new Set(items))\n\nconst normalizeValidateOn = (input: unknown): RuleValidateOn | undefined => {\n  if (!Array.isArray(input)) return undefined\n  const out: Array<AutoValidateOn> = []\n  for (const x of input) {\n    if (x === 'onChange' || x === 'onBlur') out.push(x)\n  }\n  return uniq(out)\n}\n\nconst normalizeDeps = (input: unknown): ReadonlyArray<string> | undefined => {\n  if (!Array.isArray(input)) return undefined\n  const out: Array<string> = []\n  for (const x of input) {\n    if (typeof x !== 'string') continue\n    const v = x.trim()\n    if (!v) continue\n    out.push(v)\n  }\n  return uniq(out)\n}\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> =>\n  Boolean(value) && typeof value === 'object' && value !== null && !Array.isArray(value)\n\n/**\n * make：\n * - The result must be directly attachable to `StateTrait.node({ check })`.\n * - Does not introduce an extra wrapper (e.g. `{ rules: ... }`).\n */\nexport const make = <Input, Ctx = unknown>(input: RuleInput<Input, Ctx>): RuleSet<Input, Ctx> => {\n  if (typeof input === 'function') {\n    return {\n      default: {\n        deps: [],\n        validate: input,\n      },\n    }\n  }\n\n  if (!isPlainObject(input)) {\n    return {}\n  }\n\n  const baseDeps = normalizeDeps((input as any).deps) ?? []\n  const baseValidateOn = normalizeValidateOn((input as any).validateOn)\n\n  const byName = new Map<string, Rule<Input, Ctx>>()\n\n  const addRule = (name: string, raw: unknown): void => {\n    const ruleName = typeof name === 'string' ? name.trim() : ''\n    if (!ruleName) return\n    if (byName.has(ruleName)) {\n      throw new Error(`[Form.Rule.make] Duplicate rule name \"${ruleName}\"`)\n    }\n\n    if (typeof raw === 'function') {\n      byName.set(ruleName, {\n        deps: baseDeps,\n        validate: raw as any,\n        ...(baseValidateOn !== undefined ? { validateOn: baseValidateOn } : {}),\n      })\n      return\n    }\n\n    if (!raw || typeof raw !== 'object') return\n    const entry = raw as any\n    const deps = normalizeDeps(entry.deps) ?? baseDeps\n    const validateOn = normalizeValidateOn(entry.validateOn) ?? baseValidateOn\n    const validate = entry.validate\n    if (typeof validate !== 'function') return\n\n    byName.set(ruleName, {\n      ...entry,\n      deps,\n      validate,\n      ...(validateOn !== undefined ? { validateOn } : {}),\n    })\n  }\n\n  // RHF-like builtins (if declared, it will be expanded into an equivalent pure function)\n  const requiredDecl = (input as any).required as Validators.RequiredDecl | undefined\n  if (requiredDecl !== undefined && requiredDecl !== false) {\n    const validate = Validators.required(requiredDecl)\n    addRule('required', (value: Input) => validate(value))\n  }\n\n  const minLengthDecl = (input as any).minLength as Validators.MinLengthDecl | undefined\n  if (minLengthDecl !== undefined) {\n    const validate = Validators.minLength(minLengthDecl)\n    addRule('minLength', (value: Input) => validate(value))\n  }\n\n  const maxLengthDecl = (input as any).maxLength as Validators.MaxLengthDecl | undefined\n  if (maxLengthDecl !== undefined) {\n    const validate = Validators.maxLength(maxLengthDecl)\n    addRule('maxLength', (value: Input) => validate(value))\n  }\n\n  const minDecl = (input as any).min as Validators.MinDecl | undefined\n  if (minDecl !== undefined) {\n    const validate = Validators.min(minDecl)\n    addRule('min', (value: Input) => validate(value))\n  }\n\n  const maxDecl = (input as any).max as Validators.MaxDecl | undefined\n  if (maxDecl !== undefined) {\n    const validate = Validators.max(maxDecl)\n    addRule('max', (value: Input) => validate(value))\n  }\n\n  const patternDecl = (input as any).pattern as Validators.PatternDecl | undefined\n  if (patternDecl !== undefined) {\n    const validate = Validators.pattern(patternDecl)\n    addRule('pattern', (value: Input) => validate(value))\n  }\n\n  // validate: supports both legacy RuleGroup `{ validate: Record<string, RuleEntry> }`\n  // and RHF-style `validate: fn | Record<string, fn>`.\n  const validateBlock = (input as any).validate as unknown\n  if (typeof validateBlock === 'function') {\n    addRule('validate', validateBlock)\n  } else if (isPlainObject(validateBlock)) {\n    const names = Object.keys(validateBlock).sort((a, b) => a.localeCompare(b))\n    for (const name of names) {\n      addRule(name, (validateBlock as any)[name])\n    }\n  }\n\n  const out: Record<string, Rule<Input, Ctx>> = {}\n  const names = Array.from(byName.keys()).sort((a, b) => a.localeCompare(b))\n  for (const name of names) {\n    out[name] = byName.get(name)!\n  }\n  return out\n}\n\nexport const merge = <Input, Ctx = unknown>(...rules: ReadonlyArray<RuleSet<Input, Ctx>>): RuleSet<Input, Ctx> => {\n  const byName = new Map<string, Rule<Input, Ctx>>()\n  const duplicates = new Set<string>()\n\n  for (const ruleSet of rules) {\n    for (const name of Object.keys(ruleSet)) {\n      if (byName.has(name)) duplicates.add(name)\n      else byName.set(name, ruleSet[name]!)\n    }\n  }\n\n  if (duplicates.size > 0) {\n    const list = Array.from(duplicates)\n      .sort((a, b) => a.localeCompare(b))\n      .join(', ')\n    throw new Error(`[Form.Rule.merge] Duplicate rule name(s): ${list}`)\n  }\n\n  const merged: Record<string, Rule<Input, Ctx>> = {}\n  const names = Array.from(byName.keys()).sort((a, b) => a.localeCompare(b))\n  for (const name of names) {\n    merged[name] = byName.get(name)!\n  }\n\n  return merged\n}\n\nexport type ErrorTarget = '$value' | '$self'\n\nexport type ListIdentityPolicy =\n  | Readonly<{ readonly mode: 'trackBy'; readonly trackBy: string }>\n  | Readonly<{ readonly mode: 'store' }>\n  | Readonly<{ readonly mode: 'index' }>\n\nexport type FieldDecl<Input, Ctx = unknown> = Readonly<{\n  readonly kind: 'field'\n  readonly valuePath: string\n  readonly rule: RuleInput<Input, Ctx>\n  readonly errorTarget?: ErrorTarget\n}>\n\nexport type RootDecl<Input, Ctx = unknown> = Readonly<{\n  readonly kind: 'root'\n  readonly rule: RuleInput<Input, Ctx>\n}>\n\nexport type ListDecl<Item, Ctx = unknown> = Readonly<{\n  readonly kind: 'list'\n  readonly listPath: string\n  readonly identity: ListIdentityPolicy\n  readonly item?: RuleInput<Item, Ctx>\n  readonly list?: RuleInput<ReadonlyArray<Item>, Ctx>\n}>\n\nexport type RulesDecl<TValues extends object = any> = FieldDecl<any> | RootDecl<TValues> | ListDecl<any>\n\nexport const field = <Input, Ctx = unknown>(\n  valuePath: string,\n  rule: RuleInput<Input, Ctx>,\n  options?: { readonly errorTarget?: ErrorTarget },\n): FieldDecl<Input, Ctx> => ({\n  kind: 'field',\n  valuePath,\n  rule,\n  ...(options?.errorTarget !== undefined ? { errorTarget: options.errorTarget } : {}),\n})\n\nexport const root = <Input, Ctx = unknown>(rule: RuleInput<Input, Ctx>): RootDecl<Input, Ctx> => ({\n  kind: 'root',\n  rule,\n})\n\nexport const list = <Item, Ctx = unknown>(\n  listPath: string,\n  spec: {\n    readonly identity: ListIdentityPolicy\n    readonly item?: RuleInput<Item, Ctx>\n    readonly list?: RuleInput<ReadonlyArray<Item>, Ctx>\n  },\n): ListDecl<Item, Ctx> => ({\n  kind: 'list',\n  listPath,\n  identity: spec.identity,\n  ...(spec.item !== undefined ? { item: spec.item } : {}),\n  ...(spec.list !== undefined ? { list: spec.list } : {}),\n})\n\nexport const fields = <Input, Ctx = unknown>(\n  ...decls: ReadonlyArray<FieldDecl<Input, Ctx> | ReadonlyArray<FieldDecl<Input, Ctx>>>\n): Readonly<Record<string, RuleInput<Input, Ctx>>> => {\n  const out: Record<string, RuleInput<Input, Ctx>> = {}\n  const list: Array<FieldDecl<Input, Ctx>> = []\n\n  const isDeclArray = (value: unknown): value is ReadonlyArray<FieldDecl<Input, Ctx>> => Array.isArray(value)\n\n  for (const item of decls) {\n    if (isDeclArray(item)) {\n      list.push(...item)\n      continue\n    }\n    list.push(item)\n  }\n\n  for (const decl of list) {\n    const path = typeof decl?.valuePath === 'string' ? decl.valuePath.trim() : ''\n    if (!path) continue\n    if (path in out) {\n      throw new Error(`[Form.Rule.fields] Duplicate valuePath \"${path}\"`)\n    }\n    out[path] = decl.rule\n  }\n\n  return out\n}\n\nexport {\n  ERROR_VALUE_MAX_BYTES,\n  assertErrorValueBudget,\n  required,\n  minLength,\n  maxLength,\n  min,\n  max,\n  pattern,\n} from './internal/validators/index.js'\n","import { ParseResult } from 'effect'\n\nexport const ERROR_VALUE_MAX_BYTES = 256\n\nconst textEncoder = new TextEncoder()\n\nconst jsonByteSize = (value: unknown): number => {\n  const json = JSON.stringify(value)\n  return textEncoder.encode(json).length\n}\n\nconst truncateToJsonByteBudget = (value: string, maxBytes: number): string => {\n  if (jsonByteSize(value) <= maxBytes) return value\n\n  let lo = 0\n  let hi = value.length\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2)\n    const slice = value.slice(0, mid)\n    if (jsonByteSize(slice) <= maxBytes) lo = mid\n    else hi = mid - 1\n  }\n  return value.slice(0, lo)\n}\n\nexport const assertErrorValueBudget = (value: unknown, label: string): unknown => {\n  const bytes = jsonByteSize(value)\n  if (bytes <= ERROR_VALUE_MAX_BYTES) return value\n  throw new Error(`[Form.validators] ErrorValue for \"${label}\" must be JSON ≤${ERROR_VALUE_MAX_BYTES}B (got ${bytes}B)`)\n}\n\nconst errorValue = (label: string, value: unknown): unknown => assertErrorValueBudget(value, label)\n\nexport type RequiredDecl =\n  | boolean\n  | string\n  | Readonly<{\n      readonly message?: string\n      readonly trim?: boolean\n    }>\n\nexport const required = (decl: RequiredDecl): ((value: unknown) => unknown | undefined) => {\n  const trim = typeof decl === 'object' && decl !== null ? Boolean((decl as any).trim) : true\n  const message =\n    typeof decl === 'string'\n      ? decl\n      : typeof decl === 'object' && decl !== null && typeof (decl as any).message === 'string'\n        ? (decl as any).message\n        : 'required'\n\n  const err = errorValue('required', message)\n\n  return (value: unknown) => {\n    if (value === null || value === undefined) return err\n    if (typeof value === 'string') {\n      const v = trim ? value.trim() : value\n      return v.length > 0 ? undefined : err\n    }\n    if (Array.isArray(value)) return value.length > 0 ? undefined : err\n    if (typeof value === 'boolean') return value ? undefined : err\n    return undefined\n  }\n}\n\nexport type MinLengthDecl =\n  | number\n  | Readonly<{\n      readonly min: number\n      readonly message?: string\n    }>\n\nexport const minLength = (decl: MinLengthDecl): ((value: unknown) => unknown | undefined) => {\n  const min = typeof decl === 'number' ? decl : decl.min\n  const message =\n    typeof decl === 'object' && decl !== null && typeof decl.message === 'string' ? decl.message : 'minLength'\n  const err = errorValue('minLength', message)\n\n  return (value: unknown) => {\n    if (value === null || value === undefined) return undefined\n    if (typeof value === 'string') return value.length >= min ? undefined : err\n    if (Array.isArray(value)) return value.length >= min ? undefined : err\n    return undefined\n  }\n}\n\nexport type MaxLengthDecl =\n  | number\n  | Readonly<{\n      readonly max: number\n      readonly message?: string\n    }>\n\nexport const maxLength = (decl: MaxLengthDecl): ((value: unknown) => unknown | undefined) => {\n  const max = typeof decl === 'number' ? decl : decl.max\n  const message =\n    typeof decl === 'object' && decl !== null && typeof decl.message === 'string' ? decl.message : 'maxLength'\n  const err = errorValue('maxLength', message)\n\n  return (value: unknown) => {\n    if (value === null || value === undefined) return undefined\n    if (typeof value === 'string') return value.length <= max ? undefined : err\n    if (Array.isArray(value)) return value.length <= max ? undefined : err\n    return undefined\n  }\n}\n\nexport type MinDecl =\n  | number\n  | Readonly<{\n      readonly min: number\n      readonly message?: string\n    }>\n\nexport const min = (decl: MinDecl): ((value: unknown) => unknown | undefined) => {\n  const minValue = typeof decl === 'number' ? decl : decl.min\n  const message = typeof decl === 'object' && decl !== null && typeof decl.message === 'string' ? decl.message : 'min'\n  const err = errorValue('min', message)\n\n  return (value: unknown) => {\n    if (value === null || value === undefined) return undefined\n    if (typeof value === 'number' && Number.isFinite(value)) return value >= minValue ? undefined : err\n    return undefined\n  }\n}\n\nexport type MaxDecl =\n  | number\n  | Readonly<{\n      readonly max: number\n      readonly message?: string\n    }>\n\nexport const max = (decl: MaxDecl): ((value: unknown) => unknown | undefined) => {\n  const maxValue = typeof decl === 'number' ? decl : decl.max\n  const message = typeof decl === 'object' && decl !== null && typeof decl.message === 'string' ? decl.message : 'max'\n  const err = errorValue('max', message)\n\n  return (value: unknown) => {\n    if (value === null || value === undefined) return undefined\n    if (typeof value === 'number' && Number.isFinite(value)) return value <= maxValue ? undefined : err\n    return undefined\n  }\n}\n\nexport type PatternDecl =\n  | RegExp\n  | Readonly<{\n      readonly re: RegExp\n      readonly message?: string\n    }>\n\nexport const pattern = (decl: PatternDecl): ((value: unknown) => unknown | undefined) => {\n  const re = decl instanceof RegExp ? decl : decl.re\n  const message =\n    typeof decl === 'object' && decl !== null && typeof (decl as any).message === 'string'\n      ? (decl as any).message\n      : 'pattern'\n  const err = errorValue('pattern', message)\n\n  return (value: unknown) => {\n    if (value === null || value === undefined) return undefined\n    if (typeof value !== 'string') return undefined\n    return re.test(value) ? undefined : err\n  }\n}\n\nexport const schemaErrorMessage = (schemaError: unknown): string => {\n  let message: string\n  try {\n    message = ParseResult.TreeFormatter.formatErrorSync(schemaError as any)\n  } catch {\n    message = 'schema invalid'\n  }\n\n  const truncated = truncateToJsonByteBudget(message, ERROR_VALUE_MAX_BYTES)\n  return truncated.length > 0 ? truncated : 'schema invalid'\n}\n"],"mappings":"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","names":["min","max","names","list"]}

package/dist/Rule.d.cts

@@ -0,0 +1,2 @@
+import '@logixjs/core';
+export { A as AutoValidateOn, w as ERROR_VALUE_MAX_BYTES, E as ErrorTarget, i as FieldDecl, h as ListDecl, L as ListIdentityPolicy, g as RootDecl, m as Rule, p as RuleConfig, j as RuleEntry, l as RuleFn, o as RuleGroup, f as RuleInput, n as RuleSet, k as RuleValidateOn, e as RulesDecl, x as assertErrorValueBudget, s as field, v as fields, u as list, q as make, G as max, B as maxLength, r as merge, D as min, z as minLength, H as pattern, y as required, t as root } from './Rule-BOAiSVz9.cjs';

package/dist/Rule.d.ts

@@ -0,0 +1,2 @@
+import '@logixjs/core';
+export { A as AutoValidateOn, w as ERROR_VALUE_MAX_BYTES, E as ErrorTarget, i as FieldDecl, h as ListDecl, L as ListIdentityPolicy, g as RootDecl, m as Rule, p as RuleConfig, j as RuleEntry, l as RuleFn, o as RuleGroup, f as RuleInput, n as RuleSet, k as RuleValidateOn, e as RulesDecl, x as assertErrorValueBudget, s as field, v as fields, u as list, q as make, G as max, B as maxLength, r as merge, D as min, z as minLength, H as pattern, y as required, t as root } from './Rule-BOAiSVz9.js';

package/dist/Rule.js

@@ -0,0 +1,34 @@
+import {
+  ERROR_VALUE_MAX_BYTES,
+  assertErrorValueBudget,
+  field,
+  fields,
+  list,
+  make,
+  max,
+  maxLength,
+  merge,
+  min,
+  minLength,
+  pattern,
+  required,
+  root
+} from "./chunk-YVHXLY63.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ERROR_VALUE_MAX_BYTES,
+  assertErrorValueBudget,
+  field,
+  fields,
+  list,
+  make,
+  max,
+  maxLength,
+  merge,
+  min,
+  minLength,
+  pattern,
+  required,
+  root
+};
+//# sourceMappingURL=Rule.js.map

package/dist/Rule.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/SchemaErrorMapping-Cu5gl7-Z.d.ts

@@ -0,0 +1,50 @@
+import { S as SchemaError, a as SchemaPathMappingOptions, F as FieldPath } from './SchemaPathMapping-BUq2zm8W.js';
+
+interface SchemaErrorMappingOptions extends SchemaPathMappingOptions {
+    /**
+     * toLeaf: converts a schemaError into a leaf value that can be written into the error tree.
+     * - Default: write the raw schemaError as-is.
+     */
+    readonly toLeaf?: (schemaError: SchemaError) => unknown;
+}
+type SchemaErrorWrite = {
+    /**
+     * fieldPath: the field path without the `errors.` prefix (domain-facing).
+     */
+    readonly fieldPath: FieldPath;
+    /**
+     * errorPath: the actual path written into state (with the `errors.` prefix).
+     */
+    readonly errorPath: string;
+    readonly error: unknown;
+};
+declare const toSchemaErrorWrites: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => ReadonlyArray<SchemaErrorWrite>;
+/**
+ * toSchemaErrorTree：
+ * - Produces a subtree that can be written directly to `errors.$schema` (without the `errors.$schema` prefix).
+ */
+declare const toSchemaErrorTree: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+/**
+ * applySchemaErrorToState：
+ * - Maps a SchemaError and writes it back into state.errors.$schema.*.
+ * - Does not clear stale errors that are no longer matched (the caller should clear them within a more explicit scope).
+ */
+declare const applySchemaErrorToState: (state: unknown, schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+
+declare const SchemaErrorMapping: {
+    readonly applySchemaErrorToState: (state: unknown, schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+    readonly toSchemaErrorTree: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+    readonly toSchemaErrorWrites: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => ReadonlyArray<SchemaErrorWrite>;
+};
+
+declare const SchemaErrorMapping$1_SchemaErrorMapping: typeof SchemaErrorMapping;
+type SchemaErrorMapping$1_SchemaErrorMappingOptions = SchemaErrorMappingOptions;
+type SchemaErrorMapping$1_SchemaErrorWrite = SchemaErrorWrite;
+declare const SchemaErrorMapping$1_applySchemaErrorToState: typeof applySchemaErrorToState;
+declare const SchemaErrorMapping$1_toSchemaErrorTree: typeof toSchemaErrorTree;
+declare const SchemaErrorMapping$1_toSchemaErrorWrites: typeof toSchemaErrorWrites;
+declare namespace SchemaErrorMapping$1 {
+  export { SchemaErrorMapping$1_SchemaErrorMapping as SchemaErrorMapping, type SchemaErrorMapping$1_SchemaErrorMappingOptions as SchemaErrorMappingOptions, type SchemaErrorMapping$1_SchemaErrorWrite as SchemaErrorWrite, SchemaErrorMapping$1_applySchemaErrorToState as applySchemaErrorToState, SchemaErrorMapping$1_toSchemaErrorTree as toSchemaErrorTree, SchemaErrorMapping$1_toSchemaErrorWrites as toSchemaErrorWrites };
+}
+
+export { SchemaErrorMapping$1 as S, applySchemaErrorToState as a, toSchemaErrorWrites as b, SchemaErrorMapping as c, type SchemaErrorMappingOptions as d, type SchemaErrorWrite as e, toSchemaErrorTree as t };

package/dist/SchemaErrorMapping-DOrgLzii.d.cts

@@ -0,0 +1,50 @@
+import { S as SchemaError, a as SchemaPathMappingOptions, F as FieldPath } from './SchemaPathMapping-BUq2zm8W.cjs';
+
+interface SchemaErrorMappingOptions extends SchemaPathMappingOptions {
+    /**
+     * toLeaf: converts a schemaError into a leaf value that can be written into the error tree.
+     * - Default: write the raw schemaError as-is.
+     */
+    readonly toLeaf?: (schemaError: SchemaError) => unknown;
+}
+type SchemaErrorWrite = {
+    /**
+     * fieldPath: the field path without the `errors.` prefix (domain-facing).
+     */
+    readonly fieldPath: FieldPath;
+    /**
+     * errorPath: the actual path written into state (with the `errors.` prefix).
+     */
+    readonly errorPath: string;
+    readonly error: unknown;
+};
+declare const toSchemaErrorWrites: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => ReadonlyArray<SchemaErrorWrite>;
+/**
+ * toSchemaErrorTree：
+ * - Produces a subtree that can be written directly to `errors.$schema` (without the `errors.$schema` prefix).
+ */
+declare const toSchemaErrorTree: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+/**
+ * applySchemaErrorToState：
+ * - Maps a SchemaError and writes it back into state.errors.$schema.*.
+ * - Does not clear stale errors that are no longer matched (the caller should clear them within a more explicit scope).
+ */
+declare const applySchemaErrorToState: (state: unknown, schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+
+declare const SchemaErrorMapping: {
+    readonly applySchemaErrorToState: (state: unknown, schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+    readonly toSchemaErrorTree: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => unknown;
+    readonly toSchemaErrorWrites: (schemaError: SchemaError, options?: SchemaErrorMappingOptions) => ReadonlyArray<SchemaErrorWrite>;
+};
+
+declare const SchemaErrorMapping$1_SchemaErrorMapping: typeof SchemaErrorMapping;
+type SchemaErrorMapping$1_SchemaErrorMappingOptions = SchemaErrorMappingOptions;
+type SchemaErrorMapping$1_SchemaErrorWrite = SchemaErrorWrite;
+declare const SchemaErrorMapping$1_applySchemaErrorToState: typeof applySchemaErrorToState;
+declare const SchemaErrorMapping$1_toSchemaErrorTree: typeof toSchemaErrorTree;
+declare const SchemaErrorMapping$1_toSchemaErrorWrites: typeof toSchemaErrorWrites;
+declare namespace SchemaErrorMapping$1 {
+  export { SchemaErrorMapping$1_SchemaErrorMapping as SchemaErrorMapping, type SchemaErrorMapping$1_SchemaErrorMappingOptions as SchemaErrorMappingOptions, type SchemaErrorMapping$1_SchemaErrorWrite as SchemaErrorWrite, SchemaErrorMapping$1_applySchemaErrorToState as applySchemaErrorToState, SchemaErrorMapping$1_toSchemaErrorTree as toSchemaErrorTree, SchemaErrorMapping$1_toSchemaErrorWrites as toSchemaErrorWrites };
+}
+
+export { SchemaErrorMapping$1 as S, applySchemaErrorToState as a, toSchemaErrorWrites as b, SchemaErrorMapping as c, type SchemaErrorMappingOptions as d, type SchemaErrorWrite as e, toSchemaErrorTree as t };