@o3co/ts.hocon 1.14.0 → 1.14.2

package/dist/zod.js

@@ -1,57 +1,67 @@
 import {
   parse,
   parseFile
-} from "./chunk-XWKO4JM3.js";
+} from "./chunk-JVABBNF5.js";
 import {
   coerceBoolean,
   coerceNumber,
   readBytes,
   readDuration,
   readPeriod
-} from "./chunk-WTXULUZS.js";
+} from "./chunk-GOXMKYWS.js";
 
 // src/zod.ts
 import { z } from "zod";
 function validate(config, schema) {
   requireResolved(config, "");
-  const plain = config.toObject();
-  refusePrototypeKeys(plain);
-  const coerced = coerceValue(plain, schema);
-  return schema.parse(coerced);
+  return parseValue(config.toObject(), schema);
 }
 function getValidated(config, path, schema) {
   requireResolved(config, path);
-  const val = config.get(path);
-  refusePrototypeKeys(val);
-  const coerced = coerceValue(val, schema);
-  return schema.parse(coerced);
+  return parseValue(config.get(path), schema);
+}
+function parseValue(value, schema) {
+  const refused = [];
+  const coerced = coerceValue(dropPrototypeKeys(value, [], refused), schema);
+  if (refused.length === 0) return schema.parse(coerced);
+  let result;
+  try {
+    result = schema.safeParse(coerced);
+  } catch (err) {
+    if (err instanceof z.core.$ZodAsyncError || err?.constructor?.name === "$ZodAsyncError") {
+      throw new z.ZodError(refused);
+    }
+    throw err;
+  }
+  if (result.success) throw new z.ZodError(refused);
+  throw new z.ZodError([...refused, ...withoutPrototypeKeyIssues(result.error.issues)]);
+}
+function withoutPrototypeKeyIssues(issues) {
+  return issues.filter((issue) => !issue.path.some((seg) => typeof seg === "string" && PROTOTYPE_KEYS.has(seg))).map(
+    (issue) => issue.code === "invalid_union" ? { ...issue, errors: issue.errors.map(withoutPrototypeKeyIssues) } : issue
+  );
 }
 function requireResolved(config, path) {
   config.getValue(path);
 }
 var PROTOTYPE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function refusePrototypeKeys(value) {
-  const issues = [];
-  collectPrototypeKeys(value, [], issues);
-  if (issues.length > 0) throw new z.ZodError(issues);
-}
-function collectPrototypeKeys(value, path, issues) {
-  if (Array.isArray(value)) {
-    value.forEach((item, i) => collectPrototypeKeys(item, [...path, i], issues));
-  } else if (typeof value === "object" && value !== null) {
-    for (const [key, item] of Object.entries(value)) {
-      if (PROTOTYPE_KEYS.has(key)) {
-        issues.push({
-          code: "custom",
-          path,
-          message: `key ${JSON.stringify(key)} names an object's prototype`,
-          params: { key }
-        });
-      } else {
-        collectPrototypeKeys(item, [...path, key], issues);
-      }
+function dropPrototypeKeys(value, path, issues) {
+  if (Array.isArray(value)) return value.map((item, i) => dropPrototypeKeys(item, [...path, i], issues));
+  if (typeof value !== "object" || value === null) return value;
+  const kept = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (PROTOTYPE_KEYS.has(key)) {
+      issues.push({
+        code: "custom",
+        path,
+        message: `key ${JSON.stringify(key)} names an object's prototype`,
+        params: { key }
+      });
+    } else {
+      kept[key] = dropPrototypeKeys(item, [...path, key], issues);
     }
   }
+  return kept;
 }
 function unitMarker(what, read) {
   return z.transform((input, ctx) => {
@@ -62,18 +72,23 @@ function unitMarker(what, read) {
     const text = typeof input === "string" ? input : String(input);
     const reading = read(text);
     if (reading.ok) return reading.value;
-    ctx.issues.push({ code: "custom", message: unitProblemMessage(what, reading.problem, text), input });
+    ctx.issues.push({
+      code: "custom",
+      message: unitProblemMessage(what, reading.problem),
+      input,
+      params: { problem: reading.problem }
+    });
     return z.NEVER;
   });
 }
-function unitProblemMessage(what, problem, text) {
+function unitProblemMessage(what, problem) {
   switch (problem) {
     case "invalid":
-      return `invalid ${what}: ${JSON.stringify(text)}`;
+      return `not a ${what}`;
     case "negative":
-      return `${what} must be non-negative: ${JSON.stringify(text)}`;
+      return `${what} must be non-negative`;
     case "overflow":
-      return `${what} overflows the representable range: ${JSON.stringify(text)}`;
+      return `${what} overflows the representable range`;
   }
 }
 function describeInput(input) {
@@ -116,6 +131,9 @@ function getDefType(schema) {
   const zod = schema._zod;
   return zod?.def?.type;
 }
+function getDef(schema) {
+  return schema._zod?.def;
+}
 function getInnerSchema(schema) {
   const def = schema._zod?.def;
   return def?.innerType ?? def?.schema;
@@ -124,6 +142,9 @@ function getObjectShape(schema) {
   const shape = schema._zod?.def?.shape;
   return typeof shape === "object" && shape !== null ? shape : void 0;
 }
+function getPropValues(schema) {
+  return schema._zod?.propValues;
+}
 function getArrayElement(schema) {
   return schema._zod?.def?.element;
 }
@@ -152,6 +173,14 @@ function coerceValue(value, schema) {
         return coerced !== void 0 ? coerced : value;
       }
       return value;
+    case "enum": {
+      const values = schema._zod.values;
+      return coerceToLiteral(value, values);
+    }
+    case "literal": {
+      const values = getDef(schema)?.values;
+      return values ? coerceToLiteral(value, new Set(values)) : value;
+    }
     case "object": {
       if (typeof value !== "object" || Array.isArray(value)) return value;
       const shape = getObjectShape(schema);
@@ -163,17 +192,63 @@ function coerceValue(value, schema) {
           result[key] = coerceValue(obj[key], shape[key]);
         }
       }
+      const catchall = getDef(schema)?.catchall;
+      if (catchall) {
+        for (const key of Object.keys(obj)) {
+          if (!Object.prototype.hasOwnProperty.call(shape, key)) result[key] = coerceValue(obj[key], catchall);
+        }
+      }
       return result;
     }
+    case "intersection": {
+      if (accepts(schema, value)) return value;
+      const def = getDef(schema);
+      const forLeft = coerceValue(value, def.left);
+      if (accepts(schema, forLeft)) return forLeft;
+      const forRight = coerceValue(value, def.right);
+      if (accepts(schema, forRight)) return forRight;
+      return coerceValue(forLeft, def.right);
+    }
     case "array": {
       if (!Array.isArray(value)) return value;
       const elementSchema = getArrayElement(schema);
       if (!elementSchema) return value;
       return value.map((item) => coerceValue(item, elementSchema));
     }
+    case "record": {
+      if (typeof value !== "object" || Array.isArray(value)) return value;
+      const valueSchema = getDef(schema)?.valueType;
+      if (!valueSchema) return value;
+      const result = {};
+      for (const [key, item] of Object.entries(value)) result[key] = coerceValue(item, valueSchema);
+      return result;
+    }
+    case "tuple": {
+      if (!Array.isArray(value)) return value;
+      const def = getDef(schema);
+      const items = def?.items ?? [];
+      const rest = def?.rest;
+      return value.map((item, i) => {
+        const itemSchema = i < items.length ? items[i] : rest;
+        return itemSchema ? coerceValue(item, itemSchema) : item;
+      });
+    }
+    case "union":
+      return coerceUnion(value, schema);
+    case "pipe": {
+      const input = getDef(schema)?.in;
+      return input ? coerceValue(value, input) : value;
+    }
+    case "lazy": {
+      const getter = getDef(schema)?.getter;
+      return getter ? coerceValue(value, getter()) : value;
+    }
     case "optional":
     case "nullable":
     case "default":
+    case "prefault":
+    case "nonoptional":
+    case "success":
     case "catch":
     case "readonly": {
       const inner = getInnerSchema(schema);
@@ -183,6 +258,42 @@ function coerceValue(value, schema) {
       return value;
   }
 }
+function coerceUnion(value, schema) {
+  const def = getDef(schema);
+  const options = def?.options ?? [];
+  const discriminator = def?.discriminator;
+  if (discriminator !== void 0) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+    const tag = Object.prototype.hasOwnProperty.call(value, discriminator) ? value[discriminator] : void 0;
+    const tagsOf = (o) => getPropValues(o)?.[discriminator];
+    const option = options.find((o) => tagsOf(o)?.has(tag)) ?? options.find((o) => {
+      const tags = tagsOf(o);
+      return tags !== void 0 && tags.has(coerceToLiteral(tag, tags));
+    });
+    return option ? coerceValue(value, option) : value;
+  }
+  if (options.some((option) => accepts(option, value))) return value;
+  for (const option of options) {
+    const coerced = coerceValue(value, option);
+    if (accepts(option, coerced)) return coerced;
+  }
+  return value;
+}
+function coerceToLiteral(value, literals) {
+  if (typeof value !== "string" || literals.has(value)) return value;
+  const n = coerceNumber(value);
+  if (n !== void 0 && literals.has(n)) return n;
+  const b = coerceBoolean(value);
+  if (b !== void 0 && literals.has(b)) return b;
+  return value;
+}
+function accepts(schema, value) {
+  try {
+    return schema.safeParse(value).success;
+  } catch {
+    return false;
+  }
+}
 export {
   getValidated,
   hocon,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3co/ts.hocon",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "Full Lightbend HOCON spec-compliant parser and config library for TypeScript",
   "keywords": [
     "hocon",
@@ -118,13 +118,13 @@
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.9.5",
-    "@vitest/coverage-v8": "4.1.10",
-    "js-yaml": "^4.3.1",
-    "smol-toml": "^1.7.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "js-yaml": "^4.3.2",
+    "smol-toml": "^1.9.0",
     "tsup": "^8.5.1",
     "typedoc": "^0.28.20",
     "typescript": "^5.9.3",
-    "vitest": "4.1.10",
+    "vitest": "4.1.11",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },