@o3co/ts.hocon 1.14.1 → 1.14.2

package/README.ja.md

@@ -249,7 +249,7 @@ const app = validate(cfg, Schema)
 const port = getValidated(cfg, 'server.port', z.number().int())
 ```
 
-スキーマが数値や真偽値を求める位置では文字列を変換するので、`PORT=8081` のとき `port = ${?PORT}` は `z.number()` を通ります。変換はスキーマに沿って、object・array・record（各値）・tuple・union・pipe（入力側のスキーマ）・lazy と、optional / nullable / default / prefault / nonoptional / catch / readonly の各ラッパーの中まで届きます。数値や真偽値の literal にも変換します（`z.literal(1)` に対する `"1"`）。object の `catchall` と intersection の中には届きません。`z.discriminatedUnion` は discriminator が選ぶ option に従って変換します。それ以外の union は、値をそのまま受け入れる option があれば変換せず（`z.union([z.number(), z.string()])` では `"5"` は文字列のまま）、なければ変換後の値を受け入れる最初の option に従って変換します（`z.union([z.number(), z.literal('auto')])` では `"8081"` は 8081）。その option を探すために option を順に試すので、深く再帰する通常の union は検証が遅くなります。そこでは `z.discriminatedUnion` を使ってください。
+スキーマが数値や真偽値を求める位置では文字列を変換するので、`PORT=8081` のとき `port = ${?PORT}` は `z.number()` を通ります。変換はスキーマに沿って、object・array・record（各値）・tuple・union・pipe（入力側のスキーマ）・lazy・intersection（両側が受け入れる最初の形。元の値、片側向けの変換、両側向けの変換の順）・object の `catchall` と、optional / nullable / default / prefault / nonoptional / success / catch / readonly の各ラッパーの中まで届きます。数値や真偽値の literal と、数値の enum の値にも変換します（`z.literal(1)` や `z.enum({ A: 1 })` に対する `"1"`）。`z.discriminatedUnion` は discriminator が選ぶ option に従って変換します。それ以外の union は、値をそのまま受け入れる option があれば変換せず（`z.union([z.number(), z.string()])` では `"5"` は文字列のまま）、なければ変換後の値を受け入れる最初の option に従って変換します（`z.union([z.number(), z.literal('auto')])` では `"8081"` は 8081）。その option を探すために option を順に試すので、深く再帰する通常の union は検証が遅くなります。そこでは `z.discriminatedUnion` を使ってください。
 
 HOCON の duration と byte size は文字列（`30m`、`64KiB`）なので、`z.number()` では通りません。`hocon.duration(unit?)` / `hocon.bytes(unit?)` マーカーは `getDuration()` / `getBytes()` と同じ規則で読み、指定した単位の数値を返します（既定は `ms` / `B`。単位のない数値は getter と同じ意味）。範囲や整数のチェックは、マーカーを数値スキーマに pipe して書きます:
 

package/README.md

@@ -250,7 +250,7 @@ const app = validate(cfg, Schema)
 const port = getValidated(cfg, 'server.port', z.number().int())
 ```
 
-A string is coerced where the schema expects a number or a boolean, so `port = ${?PORT}` with `PORT=8081` validates against `z.number()`. The coercion follows the schema through objects, arrays, records (each value), tuples, unions, pipes (by the input schema), lazy schemas and the optional / nullable / default / prefault / nonoptional / catch / readonly wrappers, and turns a string into a number or boolean literal (`"1"` for `z.literal(1)`). It does not walk an object's `catchall` or an intersection. A `z.discriminatedUnion` coerces by the option the discriminator picks. Any other union takes the value as it is when an option accepts it, so `z.union([z.number(), z.string()])` keeps `"5"` a string, and coerces it otherwise, by the first option that accepts the coerced value (`z.union([z.number(), z.literal('auto')])` reads `"8081"` as 8081). Finding that option tries the options in turn, so a deeply recursive plain union validates slowly; prefer `z.discriminatedUnion` there.
+A string is coerced where the schema expects a number or a boolean, so `port = ${?PORT}` with `PORT=8081` validates against `z.number()`. The coercion follows the schema through objects, arrays, records (each value), tuples, unions, pipes (by the input schema), lazy schemas, intersections (the first form both sides accept: as it is, coerced for one side, or for both), an object's `catchall` and the optional / nullable / default / prefault / nonoptional / success / catch / readonly wrappers, and turns a string into a number or boolean literal or a numeric enum value (`"1"` for `z.literal(1)` or `z.enum({ A: 1 })`). A `z.discriminatedUnion` coerces by the option the discriminator picks. Any other union takes the value as it is when an option accepts it, so `z.union([z.number(), z.string()])` keeps `"5"` a string, and coerces it otherwise, by the first option that accepts the coerced value (`z.union([z.number(), z.literal('auto')])` reads `"8081"` as 8081). Finding that option tries the options in turn, so a deeply recursive plain union validates slowly; prefer `z.discriminatedUnion` there.
 
 Durations and byte sizes are strings in HOCON (`30m`, `64KiB`), so `z.number()` refuses them. The `hocon.duration(unit?)` and `hocon.bytes(unit?)` markers read them with the same rules as `getDuration()` / `getBytes()` and give a number in the requested unit (default `ms` / `B`; a plain number keeps the getters' meaning). Pipe the marker into a number schema for range and integer checks:
 

package/dist/zod.cjs

@@ -27,8 +27,11 @@ function parseValue(value, schema) {
   let result;
   try {
     result = schema.safeParse(coerced);
-  } catch (e) {
-    throw new _zod2.z.ZodError(refused);
+  } catch (err) {
+    if (err instanceof _zod2.z.core.$ZodAsyncError || _optionalChain([err, 'optionalAccess', _ => _.constructor, 'optionalAccess', _2 => _2.name]) === "$ZodAsyncError") {
+      throw new _zod2.z.ZodError(refused);
+    }
+    throw err;
   }
   if (result.success) throw new _zod2.z.ZodError(refused);
   throw new _zod2.z.ZodError([...refused, ...withoutPrototypeKeyIssues(result.error.issues)]);
@@ -126,24 +129,24 @@ var hocon = {
 };
 function getDefType(schema) {
   const zod = schema._zod;
-  return _optionalChain([zod, 'optionalAccess', _ => _.def, 'optionalAccess', _2 => _2.type]);
+  return _optionalChain([zod, 'optionalAccess', _3 => _3.def, 'optionalAccess', _4 => _4.type]);
 }
 function getDef(schema) {
-  return _optionalChain([schema, 'access', _3 => _3._zod, 'optionalAccess', _4 => _4.def]);
+  return _optionalChain([schema, 'access', _5 => _5._zod, 'optionalAccess', _6 => _6.def]);
 }
 function getInnerSchema(schema) {
-  const def = _optionalChain([schema, 'access', _5 => _5._zod, 'optionalAccess', _6 => _6.def]);
-  return _nullishCoalesce(_optionalChain([def, 'optionalAccess', _7 => _7.innerType]), () => ( _optionalChain([def, 'optionalAccess', _8 => _8.schema])));
+  const def = _optionalChain([schema, 'access', _7 => _7._zod, 'optionalAccess', _8 => _8.def]);
+  return _nullishCoalesce(_optionalChain([def, 'optionalAccess', _9 => _9.innerType]), () => ( _optionalChain([def, 'optionalAccess', _10 => _10.schema])));
 }
 function getObjectShape(schema) {
-  const shape = _optionalChain([schema, 'access', _9 => _9._zod, 'optionalAccess', _10 => _10.def, 'optionalAccess', _11 => _11.shape]);
+  const shape = _optionalChain([schema, 'access', _11 => _11._zod, 'optionalAccess', _12 => _12.def, 'optionalAccess', _13 => _13.shape]);
   return typeof shape === "object" && shape !== null ? shape : void 0;
 }
 function getPropValues(schema) {
-  return _optionalChain([schema, 'access', _12 => _12._zod, 'optionalAccess', _13 => _13.propValues]);
+  return _optionalChain([schema, 'access', _14 => _14._zod, 'optionalAccess', _15 => _15.propValues]);
 }
 function getArrayElement(schema) {
-  return _optionalChain([schema, 'access', _14 => _14._zod, 'optionalAccess', _15 => _15.def, 'optionalAccess', _16 => _16.element]);
+  return _optionalChain([schema, 'access', _16 => _16._zod, 'optionalAccess', _17 => _17.def, 'optionalAccess', _18 => _18.element]);
 }
 function parseWithSchema(input, schema, opts) {
   const config = _chunkOUPKYWL3cjs.parse.call(void 0, input, opts);
@@ -170,8 +173,12 @@ 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 = _optionalChain([getDef, 'call', _17 => _17(schema), 'optionalAccess', _18 => _18.values]);
+      const values = _optionalChain([getDef, 'call', _19 => _19(schema), 'optionalAccess', _20 => _20.values]);
       return values ? coerceToLiteral(value, new Set(values)) : value;
     }
     case "object": {
@@ -185,8 +192,23 @@ function coerceValue(value, schema) {
           result[key] = coerceValue(obj[key], shape[key]);
         }
       }
+      const catchall = _optionalChain([getDef, 'call', _21 => _21(schema), 'optionalAccess', _22 => _22.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);
@@ -195,7 +217,7 @@ function coerceValue(value, schema) {
     }
     case "record": {
       if (typeof value !== "object" || Array.isArray(value)) return value;
-      const valueSchema = _optionalChain([getDef, 'call', _19 => _19(schema), 'optionalAccess', _20 => _20.valueType]);
+      const valueSchema = _optionalChain([getDef, 'call', _23 => _23(schema), 'optionalAccess', _24 => _24.valueType]);
       if (!valueSchema) return value;
       const result = {};
       for (const [key, item] of Object.entries(value)) result[key] = coerceValue(item, valueSchema);
@@ -204,8 +226,8 @@ function coerceValue(value, schema) {
     case "tuple": {
       if (!Array.isArray(value)) return value;
       const def = getDef(schema);
-      const items = _nullishCoalesce(_optionalChain([def, 'optionalAccess', _21 => _21.items]), () => ( []));
-      const rest = _optionalChain([def, 'optionalAccess', _22 => _22.rest]);
+      const items = _nullishCoalesce(_optionalChain([def, 'optionalAccess', _25 => _25.items]), () => ( []));
+      const rest = _optionalChain([def, 'optionalAccess', _26 => _26.rest]);
       return value.map((item, i) => {
         const itemSchema = i < items.length ? items[i] : rest;
         return itemSchema ? coerceValue(item, itemSchema) : item;
@@ -214,11 +236,11 @@ function coerceValue(value, schema) {
     case "union":
       return coerceUnion(value, schema);
     case "pipe": {
-      const input = _optionalChain([getDef, 'call', _23 => _23(schema), 'optionalAccess', _24 => _24.in]);
+      const input = _optionalChain([getDef, 'call', _27 => _27(schema), 'optionalAccess', _28 => _28.in]);
       return input ? coerceValue(value, input) : value;
     }
     case "lazy": {
-      const getter = _optionalChain([getDef, 'call', _25 => _25(schema), 'optionalAccess', _26 => _26.getter]);
+      const getter = _optionalChain([getDef, 'call', _29 => _29(schema), 'optionalAccess', _30 => _30.getter]);
       return getter ? coerceValue(value, getter()) : value;
     }
     case "optional":
@@ -226,6 +248,7 @@ function coerceValue(value, schema) {
     case "default":
     case "prefault":
     case "nonoptional":
+    case "success":
     case "catch":
     case "readonly": {
       const inner = getInnerSchema(schema);
@@ -237,13 +260,13 @@ function coerceValue(value, schema) {
 }
 function coerceUnion(value, schema) {
   const def = getDef(schema);
-  const options = _nullishCoalesce(_optionalChain([def, 'optionalAccess', _27 => _27.options]), () => ( []));
-  const discriminator = _optionalChain([def, 'optionalAccess', _28 => _28.discriminator]);
+  const options = _nullishCoalesce(_optionalChain([def, 'optionalAccess', _31 => _31.options]), () => ( []));
+  const discriminator = _optionalChain([def, 'optionalAccess', _32 => _32.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) => _optionalChain([getPropValues, 'call', _29 => _29(o), 'optionalAccess', _30 => _30[discriminator]]);
-    const option = _nullishCoalesce(options.find((o) => _optionalChain([tagsOf, 'call', _31 => _31(o), 'optionalAccess', _32 => _32.has, 'call', _33 => _33(tag)])), () => ( options.find((o) => {
+    const tagsOf = (o) => _optionalChain([getPropValues, 'call', _33 => _33(o), 'optionalAccess', _34 => _34[discriminator]]);
+    const option = _nullishCoalesce(options.find((o) => _optionalChain([tagsOf, 'call', _35 => _35(o), 'optionalAccess', _36 => _36.has, 'call', _37 => _37(tag)])), () => ( options.find((o) => {
       const tags = tagsOf(o);
       return tags !== void 0 && tags.has(coerceToLiteral(tag, tags));
     })));
@@ -267,7 +290,7 @@ function coerceToLiteral(value, literals) {
 function accepts(schema, value) {
   try {
     return schema.safeParse(value).success;
-  } catch (e2) {
+  } catch (e) {
     return false;
   }
 }

package/dist/zod.d.cts

@@ -4,10 +4,12 @@ import { C as Config, D as DurationUnit, B as ByteUnit, b as Period, a as ParseO
 /**
  * The whole config, validated against `schema`. HOCON strings are coerced
  * where the schema expects a number or a boolean (`"8080"` → 8080), through
- * objects, arrays, records, tuples, unions, pipes (by their input schema), lazy
- * schemas and optional / nullable / default / prefault / nonoptional / catch /
- * readonly wrappers; a union coerces by the option that takes the value (see
- * the README). Unit values go through the {@link hocon} markers.
+ * objects (and their catchall), arrays, records, tuples, unions,
+ * intersections, pipes (by their input schema), lazy schemas, numeric literals
+ * and enums, and optional / nullable / default / prefault / nonoptional /
+ * success / catch / readonly wrappers; a union coerces by the option that
+ * takes the value (see the README). Unit values go through the {@link hocon}
+ * markers.
  *
  * An object key named `__proto__`, `constructor` or `prototype` anywhere in
  * the value is refused with a `ZodError` issue at the object that holds it

package/dist/zod.d.ts

@@ -4,10 +4,12 @@ import { C as Config, D as DurationUnit, B as ByteUnit, b as Period, a as ParseO
 /**
  * The whole config, validated against `schema`. HOCON strings are coerced
  * where the schema expects a number or a boolean (`"8080"` → 8080), through
- * objects, arrays, records, tuples, unions, pipes (by their input schema), lazy
- * schemas and optional / nullable / default / prefault / nonoptional / catch /
- * readonly wrappers; a union coerces by the option that takes the value (see
- * the README). Unit values go through the {@link hocon} markers.
+ * objects (and their catchall), arrays, records, tuples, unions,
+ * intersections, pipes (by their input schema), lazy schemas, numeric literals
+ * and enums, and optional / nullable / default / prefault / nonoptional /
+ * success / catch / readonly wrappers; a union coerces by the option that
+ * takes the value (see the README). Unit values go through the {@link hocon}
+ * markers.
  *
  * An object key named `__proto__`, `constructor` or `prototype` anywhere in
  * the value is refused with a `ZodError` issue at the object that holds it

package/dist/zod.js

@@ -27,8 +27,11 @@ function parseValue(value, schema) {
   let result;
   try {
     result = schema.safeParse(coerced);
-  } catch {
-    throw new z.ZodError(refused);
+  } 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)]);
@@ -170,6 +173,10 @@ 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;
@@ -185,8 +192,23 @@ 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);
@@ -226,6 +248,7 @@ function coerceValue(value, schema) {
     case "default":
     case "prefault":
     case "nonoptional":
+    case "success":
     case "catch":
     case "readonly": {
       const inner = getInnerSchema(schema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3co/ts.hocon",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "description": "Full Lightbend HOCON spec-compliant parser and config library for TypeScript",
   "keywords": [
     "hocon",