@moluoxixi/zod3-to-rule 0.1.1

package/README.md

@@ -0,0 +1,27 @@
+# Zod 3 to Rule
+
+`@moluoxixi/zod3-to-rule` 提供可序列化校验规则与 Zod 3 之间的桥接，不依赖 Vue 或任何表单 UI。
+
+规则 JSON 是稳定协议。外部输入先通过 `parseRuleSet()` 严格解析，再使用 `compileRules()` 编译为 Zod schema、required 元数据和跨字段/custom validator。`rulesToZod()` 只编译单字段 Zod 能力。
+
+```ts
+import { compileRules, parseRuleSet } from '@moluoxixi/zod3-to-rule'
+
+const parsed = parseRuleSet({
+  version: 1,
+  base: { type: 'string' },
+  rules: [
+    { kind: 'required', message: '请输入邮箱' },
+    { kind: 'email', message: '邮箱格式不正确' },
+  ],
+})
+
+if (parsed.success) {
+  const compiled = compileRules(parsed.data)
+  compiled.schema.safeParse('user@example.com')
+}
+```
+
+支持的基础类型包括 string、number、boolean、date、enum 和 JSON primitive literal。内置规则覆盖字符串长度、regex、email、URL、UUID、数值范围、integer、finite、multipleOf、日期范围、required、基础跨字段比较和命名 custom validator。
+
+`zodToRules()` 是受限的最佳努力导出器。它支持上述基础类型和 Zod 3 内置 checks，并返回结构化 diagnostics。`refine`、`superRefine`、transform、preprocess、coerce、default 和其他无法由规则 JSON 等价表达的行为不会被静默丢弃；存在不可恢复的 effects 或 coercion 时不会返回 `ruleSet`。

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './src/constants';
+export * from './src/diagnostics';
+export * from './src/from-zod';
+export * from './src/parse';
+export * from './src/rules';
+export * from './src/to-zod';
+export type * from './src/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,mBAAmB,aAAa,CAAA"}

package/dist/index.js

@@ -0,0 +1,421 @@
+import { z as t } from "zod";
+const _ = 1;
+function o(n, e, r = [], s = "error", i) {
+  return { code: n, severity: s, path: r, message: e, ...i === void 0 ? {} : { ruleIndex: i } };
+}
+function M(n) {
+  return n.map((e) => o(
+    "RULE_DOCUMENT_INVALID",
+    e.message,
+    e.path
+  ));
+}
+class l extends Error {
+  constructor(e) {
+    super(e.map((r) => r.message).join("; ")), this.diagnostics = e, this.name = "RuleCompileError";
+  }
+}
+function R(n) {
+  return typeof n.message == "string" ? n.message : void 0;
+}
+function d(n, e) {
+  const r = R(e);
+  return r ? { ...n, message: r } : n;
+}
+function p(n, e = []) {
+  return o("ZOD_UNSUPPORTED", n, e, "warning");
+}
+function Z(n) {
+  let e = n, r = !1, s = !1;
+  const i = [];
+  for (; ; ) {
+    if (e instanceof t.ZodOptional) {
+      r = !0, e = e.unwrap();
+      continue;
+    }
+    if (e instanceof t.ZodNullable) {
+      s = !0, e = e.unwrap();
+      continue;
+    }
+    if (e instanceof t.ZodDefault) {
+      i.push(p("Zod default values are not part of the rule format")), e = e.removeDefault();
+      continue;
+    }
+    if (e instanceof t.ZodEffects)
+      return i.push(p("Zod effects/refine/transform cannot be represented as rules")), { schema: e, optional: r, nullable: s, unsupported: !0, diagnostics: i };
+    break;
+  }
+  return { schema: e, optional: r, nullable: s, unsupported: !1, diagnostics: i };
+}
+function S(n) {
+  const e = [], r = [], s = n._def.checks;
+  for (const i of s) {
+    const a = i.kind;
+    switch (a) {
+      case "min":
+        e.push(d({ kind: "minLength", value: i.value }, i));
+        break;
+      case "max":
+        e.push(d({ kind: "maxLength", value: i.value }, i));
+        break;
+      case "length":
+        e.push(d({ kind: "length", value: i.value }, i));
+        break;
+      case "email":
+        e.push(d({ kind: "email" }, i));
+        break;
+      case "url":
+        e.push(d({ kind: "url" }, i));
+        break;
+      case "uuid":
+        e.push(d({ kind: "uuid" }, i));
+        break;
+      case "regex": {
+        const f = i.regex;
+        f instanceof RegExp ? e.push(d({ kind: "regex", source: f.source, flags: f.flags }, i)) : r.push(p("Zod regex check does not contain a RegExp"));
+        break;
+      }
+      default:
+        r.push(p(`Zod string check is not supported: ${String(a)}`));
+    }
+  }
+  return { rules: e, diagnostics: r };
+}
+function L(n) {
+  const e = [], r = [], s = n._def.checks;
+  for (const i of s) {
+    const a = i.kind;
+    switch (a) {
+      case "min":
+        e.push(d({ kind: "min", value: i.value, inclusive: i.inclusive }, i));
+        break;
+      case "max":
+        e.push(d({ kind: "max", value: i.value, inclusive: i.inclusive }, i));
+        break;
+      case "int":
+        e.push(d({ kind: "integer" }, i));
+        break;
+      case "finite":
+        e.push(d({ kind: "finite" }, i));
+        break;
+      case "multipleOf":
+        e.push(d({ kind: "multipleOf", value: i.value }, i));
+        break;
+      default:
+        r.push(p(`Zod number check is not supported: ${String(a)}`));
+    }
+  }
+  return { rules: e, diagnostics: r };
+}
+function N(n) {
+  const e = [], r = [], s = n._def.checks;
+  for (const i of s) {
+    const a = new Date(i.value);
+    if (Number.isNaN(a.getTime())) {
+      r.push(p("Zod date check does not contain a valid date value"));
+      continue;
+    }
+    i.kind === "min" ? e.push(d({ kind: "dateMin", value: a.toISOString() }, i)) : e.push(d({ kind: "dateMax", value: a.toISOString() }, i));
+  }
+  return { rules: e, diagnostics: r };
+}
+function x(n) {
+  const e = Z(n), r = [...e.diagnostics];
+  if (e.unsupported)
+    return { diagnostics: r };
+  if ((e.schema instanceof t.ZodString || e.schema instanceof t.ZodNumber || e.schema instanceof t.ZodBoolean || e.schema instanceof t.ZodDate) && e.schema._def.coerce)
+    return r.push(p("Zod coercion cannot be represented as rules")), { diagnostics: r };
+  let s, i = [];
+  if (e.schema instanceof t.ZodString) {
+    s = { type: "string" };
+    const a = S(e.schema);
+    i = a.rules, r.push(...a.diagnostics);
+  } else if (e.schema instanceof t.ZodNumber) {
+    s = { type: "number" };
+    const a = L(e.schema);
+    i = a.rules, r.push(...a.diagnostics);
+  } else if (e.schema instanceof t.ZodBoolean)
+    s = { type: "boolean" };
+  else if (e.schema instanceof t.ZodDate) {
+    s = { type: "date" };
+    const a = N(e.schema);
+    i = a.rules, r.push(...a.diagnostics);
+  } else if (e.schema instanceof t.ZodEnum)
+    s = { type: "enum", values: e.schema.options };
+  else if (e.schema instanceof t.ZodLiteral) {
+    const a = e.schema.value;
+    if (typeof a != "string" && typeof a != "number" && typeof a != "boolean" && a !== null)
+      return r.push(p("Zod literal value is not JSON-safe")), { diagnostics: r };
+    s = { type: "literal", value: a };
+  } else {
+    const a = e.schema._def;
+    return r.push(p(`Zod schema type is not supported: ${String(a.typeName ?? "unknown")}`)), { diagnostics: r };
+  }
+  return {
+    ruleSet: {
+      version: _,
+      base: s,
+      rules: i,
+      ...e.optional ? { optional: !0 } : {},
+      ...e.nullable ? { nullable: !0 } : {}
+    },
+    diagnostics: r
+  };
+}
+const T = t.union([t.string(), t.number().finite(), t.boolean(), t.null()]), E = t.lazy(() => t.union([
+  T,
+  t.array(E),
+  t.record(t.string(), E)
+])), u = t.object({ message: t.string().min(1).optional() }).strict(), j = t.discriminatedUnion("type", [
+  t.object({ type: t.literal("string") }).strict(),
+  t.object({ type: t.literal("number") }).strict(),
+  t.object({ type: t.literal("boolean") }).strict(),
+  t.object({ type: t.literal("date") }).strict(),
+  t.object({ type: t.literal("enum"), values: t.array(t.string()).min(1) }).strict(),
+  t.object({ type: t.literal("literal"), value: T }).strict()
+]), q = t.discriminatedUnion("kind", [
+  t.object({ kind: t.literal("required") }).merge(u),
+  t.object({ kind: t.literal("minLength"), value: t.number().int().nonnegative() }).merge(u),
+  t.object({ kind: t.literal("maxLength"), value: t.number().int().nonnegative() }).merge(u),
+  t.object({ kind: t.literal("length"), value: t.number().int().nonnegative() }).merge(u),
+  t.object({ kind: t.literal("regex"), source: t.string().min(1), flags: t.string().optional() }).merge(u),
+  t.object({ kind: t.literal("email") }).merge(u),
+  t.object({ kind: t.literal("url") }).merge(u),
+  t.object({ kind: t.literal("uuid") }).merge(u),
+  t.object({ kind: t.literal("min"), value: t.number().finite(), inclusive: t.boolean().optional() }).merge(u),
+  t.object({ kind: t.literal("max"), value: t.number().finite(), inclusive: t.boolean().optional() }).merge(u),
+  t.object({ kind: t.literal("integer") }).merge(u),
+  t.object({ kind: t.literal("finite") }).merge(u),
+  t.object({ kind: t.literal("multipleOf"), value: t.number().finite().positive() }).merge(u),
+  t.object({ kind: t.literal("dateMin"), value: t.string().datetime() }).merge(u),
+  t.object({ kind: t.literal("dateMax"), value: t.string().datetime() }).merge(u),
+  t.object({
+    kind: t.literal("compare"),
+    field: t.string().min(1),
+    operator: t.enum(["eq", "neq", "gt", "gte", "lt", "lte"])
+  }).merge(u),
+  t.object({ kind: t.literal("custom"), key: t.string().min(1), params: E.optional() }).merge(u)
+]).superRefine((n, e) => {
+  if (n.kind === "regex")
+    try {
+      const r = new RegExp(n.source, n.flags);
+    } catch (r) {
+      e.addIssue({
+        code: t.ZodIssueCode.custom,
+        message: r instanceof Error ? r.message : "Invalid regular expression",
+        path: ["source"]
+      });
+    }
+}), U = t.object({
+  version: t.literal(_),
+  base: j,
+  rules: t.array(q),
+  optional: t.boolean().optional(),
+  nullable: t.boolean().optional()
+}).strict();
+function V(n) {
+  const e = U.safeParse(n);
+  return e.success ? {
+    success: !0,
+    data: e.data,
+    diagnostics: []
+  } : { success: !1, diagnostics: M(e.error.issues) };
+}
+function c(n) {
+  return n.message ? { message: n.message } : {};
+}
+function A(n) {
+  switch (n.base.type) {
+    case "string":
+      return t.string();
+    case "number":
+      return t.number();
+    case "boolean":
+      return t.boolean();
+    case "date":
+      return t.date();
+    case "enum":
+      return t.enum(n.base.values);
+    case "literal":
+      return t.literal(n.base.value);
+  }
+}
+function C(n, e) {
+  try {
+    return new RegExp(n.source, n.flags);
+  } catch (r) {
+    throw new l([o(
+      "RULE_REGEX_INVALID",
+      r instanceof Error ? r.message : "Invalid regular expression",
+      ["rules", e],
+      "error",
+      e
+    )]);
+  }
+}
+function w(n, e, r) {
+  const s = new Date(n);
+  if (!Number.isNaN(s.getTime()))
+    return s;
+  throw new l([o(
+    "RULE_DATE_INVALID",
+    `${r} requires a valid ISO date`,
+    ["rules", e],
+    "error",
+    e
+  )]);
+}
+function D(n, e, r) {
+  switch (e.kind) {
+    case "required":
+      return n;
+    case "minLength":
+      if (!(n instanceof t.ZodString))
+        throw new l([o("RULE_TYPE_MISMATCH", "minLength requires a string base", ["rules", r], "error", r)]);
+      return n.min(e.value, c(e));
+    case "maxLength":
+      if (!(n instanceof t.ZodString))
+        throw new l([o("RULE_TYPE_MISMATCH", "maxLength requires a string base", ["rules", r], "error", r)]);
+      return n.max(e.value, c(e));
+    case "length":
+      if (!(n instanceof t.ZodString))
+        throw new l([o("RULE_TYPE_MISMATCH", "length requires a string base", ["rules", r], "error", r)]);
+      return n.length(e.value, c(e));
+    case "regex":
+      if (!(n instanceof t.ZodString))
+        throw new l([o("RULE_TYPE_MISMATCH", "regex requires a string base", ["rules", r], "error", r)]);
+      return n.regex(C(e, r), c(e));
+    case "email":
+      if (!(n instanceof t.ZodString))
+        throw new l([o("RULE_TYPE_MISMATCH", "email requires a string base", ["rules", r], "error", r)]);
+      return n.email(c(e));
+    case "url":
+      if (!(n instanceof t.ZodString))
+        throw new l([o("RULE_TYPE_MISMATCH", "url requires a string base", ["rules", r], "error", r)]);
+      return n.url(c(e));
+    case "uuid":
+      if (!(n instanceof t.ZodString))
+        throw new l([o("RULE_TYPE_MISMATCH", "uuid requires a string base", ["rules", r], "error", r)]);
+      return n.uuid(c(e));
+    case "min":
+      if (n instanceof t.ZodNumber)
+        return e.inclusive === !1 ? n.gt(e.value, c(e)) : n.gte(e.value, c(e));
+      throw new l([o("RULE_TYPE_MISMATCH", "min requires a number base", ["rules", r], "error", r)]);
+    case "max":
+      if (n instanceof t.ZodNumber)
+        return e.inclusive === !1 ? n.lt(e.value, c(e)) : n.lte(e.value, c(e));
+      throw new l([o("RULE_TYPE_MISMATCH", "max requires a number base", ["rules", r], "error", r)]);
+    case "integer":
+      if (n instanceof t.ZodNumber)
+        return n.int(c(e));
+      throw new l([o("RULE_TYPE_MISMATCH", "integer requires a number base", ["rules", r], "error", r)]);
+    case "finite":
+      if (n instanceof t.ZodNumber)
+        return n.finite(c(e));
+      throw new l([o("RULE_TYPE_MISMATCH", "finite requires a number base", ["rules", r], "error", r)]);
+    case "multipleOf":
+      if (n instanceof t.ZodNumber)
+        return n.multipleOf(e.value, c(e));
+      throw new l([o("RULE_TYPE_MISMATCH", "multipleOf requires a number base", ["rules", r], "error", r)]);
+    case "dateMin":
+      if (!(n instanceof t.ZodDate))
+        throw new l([o("RULE_TYPE_MISMATCH", "dateMin requires a date base", ["rules", r], "error", r)]);
+      return n.min(w(e.value, r, e.kind), c(e));
+    case "dateMax":
+      if (!(n instanceof t.ZodDate))
+        throw new l([o("RULE_TYPE_MISMATCH", "dateMax requires a date base", ["rules", r], "error", r)]);
+      return n.max(w(e.value, r, e.kind), c(e));
+    case "compare":
+    case "custom":
+      return n;
+  }
+}
+function O(n) {
+  let e = A(n), r;
+  for (const [s, i] of n.rules.entries())
+    e = D(e, i, s), i.kind === "required" && (r = i);
+  return n.base.type === "date" && (e = t.preprocess((s) => typeof s == "string" ? new Date(s) : s, e)), n.nullable && (e = e.nullable()), n.optional && (e = e.optional()), r && (e = e.refine((s) => s != null && (typeof s != "string" || s.trim().length > 0), c(r))), e;
+}
+function P(n) {
+  return n ? Array.isArray(n) ? n.filter(Boolean) : [n] : [];
+}
+function H(n, e, r, s) {
+  const i = (g) => {
+    if (g instanceof Date)
+      return Number.isNaN(g.getTime()) ? void 0 : { kind: "date", value: g.getTime() };
+    if (s === "date" && typeof g == "string") {
+      const h = new Date(g);
+      return Number.isNaN(h.getTime()) ? void 0 : { kind: "date", value: h.getTime() };
+    }
+    if (typeof g == "number" || typeof g == "string")
+      return { kind: typeof g == "number" ? "number" : "string", value: g };
+  }, a = i(n), f = i(e);
+  if (!a || !f || a.kind !== f.kind)
+    return !1;
+  switch (r) {
+    case "eq":
+      return Object.is(a.value, f.value);
+    case "neq":
+      return !Object.is(a.value, f.value);
+    case "gt":
+      return a.value > f.value;
+    case "gte":
+      return a.value >= f.value;
+    case "lt":
+      return a.value < f.value;
+    case "lte":
+      return a.value <= f.value;
+  }
+}
+function $(n, e = {}) {
+  var h;
+  const r = [], s = [];
+  let i, a;
+  for (const [k, m] of n.rules.entries()) {
+    if (m.kind === "required") {
+      i = !0, a = m.message;
+      continue;
+    }
+    if (m.kind === "compare") {
+      s.push((b, v) => H(b, v[m.field], m.operator, n.base.type) ? void 0 : m.message ?? `字段 ${m.field} 比较失败`);
+      continue;
+    }
+    if (m.kind === "custom") {
+      const b = (h = e.custom) == null ? void 0 : h[m.key];
+      if (!b) {
+        r.push(o(
+          "RULE_CUSTOM_VALIDATOR_MISSING",
+          `Custom validator not registered: ${m.key}`,
+          ["rules", k],
+          "error",
+          k
+        ));
+        continue;
+      }
+      s.push((v, y) => b(v, y, m.params));
+    }
+  }
+  n.optional && i && r.push(o(
+    "RULE_OPTIONAL_REQUIRED_CONFLICT",
+    "A rule set cannot be both optional and required",
+    ["optional"]
+  ));
+  const f = O(n), g = s.length === 0 ? void 0 : async (k, m) => {
+    const b = [];
+    for (const v of s)
+      b.push(...P(await v(k, m)));
+    return b;
+  };
+  return { schema: f, required: i, requiredMessage: a, validator: g, diagnostics: r };
+}
+export {
+  _ as RULE_SET_VERSION,
+  l as RuleCompileError,
+  $ as compileRules,
+  M as formatRuleZodIssues,
+  V as parseRuleSet,
+  o as ruleDiagnostic,
+  U as ruleSetSchema,
+  O as rulesToZod,
+  x as zodToRules
+};

package/dist/src/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const RULE_SET_VERSION: 1;
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAG,CAAU,CAAA"}

package/dist/src/diagnostics.d.ts

@@ -0,0 +1,9 @@
+import { ZodIssue } from 'zod';
+import { RuleDiagnostic, RuleDiagnosticSeverity } from './types';
+export declare function ruleDiagnostic(code: string, message: string, path?: (string | number)[], severity?: RuleDiagnosticSeverity, ruleIndex?: number): RuleDiagnostic;
+export declare function formatRuleZodIssues(issues: ZodIssue[]): RuleDiagnostic[];
+export declare class RuleCompileError extends Error {
+    readonly diagnostics: RuleDiagnostic[];
+    constructor(diagnostics: RuleDiagnostic[]);
+}
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/src/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAErE,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAO,EAC9B,QAAQ,GAAE,sBAAgC,EAC1C,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CAEhB;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,cAAc,EAAE,CAMxE;AAED,qBAAa,gBAAiB,SAAQ,KAAK;aACb,WAAW,EAAE,cAAc,EAAE;gBAA7B,WAAW,EAAE,cAAc,EAAE;CAI1D"}

package/dist/src/from-zod.d.ts

@@ -0,0 +1,4 @@
+import { ZodToRulesResult } from './types';
+import { z } from 'zod';
+export declare function zodToRules(schema: z.ZodTypeAny): ZodToRulesResult;
+//# sourceMappingURL=from-zod.d.ts.map

package/dist/src/from-zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-zod.d.ts","sourceRoot":"","sources":["../../src/from-zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,gBAAgB,EAAE,MAAM,SAAS,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA8IvB,wBAAgB,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,gBAAgB,CAqEjE"}

package/dist/src/parse.d.ts

@@ -0,0 +1,6 @@
+import { RuleParseResult, RuleSet } from './types';
+import { z } from 'zod';
+declare const ruleSetSchema: z.ZodType<RuleSet>;
+export declare function parseRuleSet(input: unknown): RuleParseResult;
+export { ruleSetSchema };
+//# sourceMappingURL=parse.d.ts.map

package/dist/src/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,eAAe,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA4DvB,QAAA,MAAM,aAAa,EAMO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;AAE5C,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAU5D;AAED,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/src/rules.d.ts

@@ -0,0 +1,3 @@
+import { CompiledRuleSet, RuleCompileContext, RuleSet } from './types';
+export declare function compileRules(ruleSet: RuleSet, context?: RuleCompileContext): CompiledRuleSet;
+//# sourceMappingURL=rules.d.ts.map

package/dist/src/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../src/rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEf,kBAAkB,EAElB,OAAO,EAER,MAAM,SAAS,CAAA;AA4ChB,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,kBAAuB,GAC/B,eAAe,CAuDjB"}

package/dist/src/to-zod.d.ts

@@ -0,0 +1,4 @@
+import { RuleSet } from './types';
+import { z } from 'zod';
+export declare function rulesToZod(ruleSet: RuleSet): z.ZodTypeAny;
+//# sourceMappingURL=to-zod.d.ts.map

package/dist/src/to-zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-zod.d.ts","sourceRoot":"","sources":["../../src/to-zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,OAAO,EAAE,MAAM,SAAS,CAAA;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA6HvB,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,CAAC,CAAC,UAAU,CA+BzD"}

package/dist/src/types.d.ts

@@ -0,0 +1,132 @@
+import { RULE_SET_VERSION } from './constants';
+export type RulePrimitive = string | number | boolean | null;
+export type RuleJsonValue = RulePrimitive | RuleJsonValue[] | {
+    [key: string]: RuleJsonValue;
+};
+export type RuleBase = {
+    type: 'string';
+} | {
+    type: 'number';
+} | {
+    type: 'boolean';
+} | {
+    type: 'date';
+} | {
+    type: 'enum';
+    values: [string, ...string[]];
+} | {
+    type: 'literal';
+    value: RulePrimitive;
+};
+export type RuleDescriptor = {
+    kind: 'required';
+    message?: string;
+} | {
+    kind: 'minLength';
+    value: number;
+    message?: string;
+} | {
+    kind: 'maxLength';
+    value: number;
+    message?: string;
+} | {
+    kind: 'length';
+    value: number;
+    message?: string;
+} | {
+    kind: 'regex';
+    source: string;
+    flags?: string;
+    message?: string;
+} | {
+    kind: 'email';
+    message?: string;
+} | {
+    kind: 'url';
+    message?: string;
+} | {
+    kind: 'uuid';
+    message?: string;
+} | {
+    kind: 'min';
+    value: number;
+    inclusive?: boolean;
+    message?: string;
+} | {
+    kind: 'max';
+    value: number;
+    inclusive?: boolean;
+    message?: string;
+} | {
+    kind: 'integer';
+    message?: string;
+} | {
+    kind: 'finite';
+    message?: string;
+} | {
+    kind: 'multipleOf';
+    value: number;
+    message?: string;
+} | {
+    kind: 'dateMin';
+    value: string;
+    message?: string;
+} | {
+    kind: 'dateMax';
+    value: string;
+    message?: string;
+} | {
+    kind: 'compare';
+    field: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
+    message?: string;
+} | {
+    kind: 'custom';
+    key: string;
+    params?: RuleJsonValue;
+    message?: string;
+};
+export interface RuleSet {
+    version: typeof RULE_SET_VERSION;
+    base: RuleBase;
+    rules: RuleDescriptor[];
+    optional?: boolean;
+    nullable?: boolean;
+}
+export type RuleDiagnosticSeverity = 'error' | 'warning';
+export interface RuleDiagnostic {
+    code: string;
+    severity: RuleDiagnosticSeverity;
+    path: (string | number)[];
+    message: string;
+    ruleIndex?: number;
+}
+export type RuleValidationResult = string | string[] | void | null | undefined;
+export type RuleValidator = (value: unknown, values: Record<string, unknown>) => RuleValidationResult | Promise<RuleValidationResult>;
+export type RuleCustomValidator = (value: unknown, values: Record<string, unknown>, params: RuleJsonValue | undefined) => RuleValidationResult | Promise<RuleValidationResult>;
+export interface RuleCompileContext {
+    custom?: Record<string, RuleCustomValidator>;
+}
+export interface CompiledRuleSet {
+    schema: import('zod').ZodTypeAny;
+    required?: boolean;
+    requiredMessage?: string;
+    validator?: RuleValidator;
+    diagnostics: RuleDiagnostic[];
+}
+export interface RuleParseSuccess {
+    success: true;
+    data: RuleSet;
+    diagnostics: [];
+}
+export interface RuleParseFailure {
+    success: false;
+    data?: undefined;
+    diagnostics: RuleDiagnostic[];
+}
+export type RuleParseResult = RuleParseSuccess | RuleParseFailure;
+export interface ZodToRulesResult {
+    ruleSet?: RuleSet;
+    diagnostics: RuleDiagnostic[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/index.ts

@@ -0,0 +1,7 @@
+export * from './src/constants'
+export * from './src/diagnostics'
+export * from './src/from-zod'
+export * from './src/parse'
+export * from './src/rules'
+export * from './src/to-zod'
+export type * from './src/types'