@o3co/ts.hocon 1.14.1 → 1.14.3

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
@@ -34,6 +36,18 @@ declare function validate<T>(config: Config, schema: ZodType<T>): T;
  * @throws `ZodError` when the value does not match the schema.
  */
 declare function getValidated<T>(config: Config, path: string, schema: ZodType<T>): T;
+/**
+ * Options for the {@link hocon} unit markers.
+ */
+interface UnitMarkerOptions {
+    /**
+     * Refuse a value that does not name its unit: a number (`ttl = 30`) or a
+     * string of the number alone (`"30"`, what an environment variable gives),
+     * which would otherwise read in the default unit (milliseconds, bytes, days).
+     * `30s`, `"30 s"`, `64KiB`, `2w` read as before. Default `false` (#233).
+     */
+    readonly requireUnit?: boolean;
+}
 /**
  * Zod schema markers for HOCON unit values. Each reads the forms the matching
  * Config getter reads and gives what the getter gives (a number in the
@@ -54,23 +68,26 @@ declare const hocon: {
      * significant digits than a double holds can read differently: the getter
      * reads its text, the marker its JS value (`1.0000000000000001` in `us`:
      * 1000.0000000000001 through the getter, 1000 here).
+     * `options.requireUnit` refuses a value that does not name its unit (#233).
      */
-    duration(unit?: DurationUnit): ZodTransform<number, unknown>;
+    duration(unit?: DurationUnit, options?: UnitMarkerOptions): ZodTransform<number, unknown>;
     /**
      * A byte size, read as {@link Config.getBytes} reads it (default unit `B`),
      * exponent forms included, except that a number literal with more
      * significant digits than a double holds can read differently: the getter
      * reads its text, the marker its JS value (`1.99999999999999999`: 1 through
      * the getter, 2 here).
+     * `options.requireUnit` refuses a value that does not name its unit (#233).
      */
-    bytes(unit?: ByteUnit): ZodTransform<number, unknown>;
+    bytes(unit?: ByteUnit, options?: UnitMarkerOptions): ZodTransform<number, unknown>;
     /**
      * A calendar period, read as {@link Config.getPeriod} reads it (a bare
      * integer is days), except that a number literal with a decimal point or in
      * exponent form (`7.0`, `1e2`) can read differently: the getter refuses it,
      * the marker reads the JS number.
+     * `options.requireUnit` refuses a value that does not name its unit (#233).
      */
-    period(): ZodTransform<Period, unknown>;
+    period(options?: UnitMarkerOptions): ZodTransform<Period, unknown>;
 };
 /**
  * Parse a HOCON string and {@link validate} it.
@@ -89,4 +106,4 @@ declare function parseWithSchema<T>(input: string, schema: ZodType<T>, opts?: Pa
  */
 declare function parseFileWithSchema<T>(filePath: string, schema: ZodType<T>, opts?: ParseOptions): T;
 
-export { getValidated, hocon, parseFileWithSchema, parseWithSchema, validate };
+export { type UnitMarkerOptions, getValidated, hocon, parseFileWithSchema, parseWithSchema, validate };

package/dist/zod.js

@@ -1,14 +1,16 @@
 import {
   parse,
   parseFile
-} from "./chunk-JVABBNF5.js";
+} from "./chunk-ITRXT66R.js";
 import {
   coerceBoolean,
   coerceNumber,
+  namesMagnitudeUnit,
+  namesPeriodUnit,
   readBytes,
   readDuration,
   readPeriod
-} from "./chunk-GOXMKYWS.js";
+} from "./chunk-5PV3HO2V.js";
 
 // src/zod.ts
 import { z } from "zod";
@@ -27,8 +29,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)]);
@@ -60,7 +65,7 @@ function dropPrototypeKeys(value, path, issues) {
   }
   return kept;
 }
-function unitMarker(what, read) {
+function unitMarker(what, read, namesUnit) {
   return z.transform((input, ctx) => {
     if (typeof input !== "string" && typeof input !== "number") {
       ctx.issues.push({ code: "custom", message: `expected ${what}, got ${describeInput(input)}`, input });
@@ -68,16 +73,18 @@ function unitMarker(what, read) {
     }
     const text = typeof input === "string" ? input : String(input);
     const reading = read(text);
+    if (reading.ok && namesUnit !== void 0 && (typeof input === "number" || !namesUnit(text))) {
+      pushProblem(ctx, what, "missing-unit", input);
+      return z.NEVER;
+    }
     if (reading.ok) return reading.value;
-    ctx.issues.push({
-      code: "custom",
-      message: unitProblemMessage(what, reading.problem),
-      input,
-      params: { problem: reading.problem }
-    });
+    pushProblem(ctx, what, reading.problem, input);
     return z.NEVER;
   });
 }
+function pushProblem(ctx, what, problem, input) {
+  ctx.issues.push({ code: "custom", message: unitProblemMessage(what, problem), input, params: { problem } });
+}
 function unitProblemMessage(what, problem) {
   switch (problem) {
     case "invalid":
@@ -86,6 +93,8 @@ function unitProblemMessage(what, problem) {
       return `${what} must be non-negative`;
     case "overflow":
       return `${what} overflows the representable range`;
+    case "missing-unit":
+      return `${what} must name its unit`;
   }
 }
 function describeInput(input) {
@@ -100,9 +109,10 @@ var hocon = {
    * significant digits than a double holds can read differently: the getter
    * reads its text, the marker its JS value (`1.0000000000000001` in `us`:
    * 1000.0000000000001 through the getter, 1000 here).
+   * `options.requireUnit` refuses a value that does not name its unit (#233).
    */
-  duration(unit) {
-    return unitMarker("duration", (text) => readDuration(text, unit));
+  duration(unit, options) {
+    return unitMarker("duration", (text) => readDuration(text, unit), requireUnit(options, namesMagnitudeUnit));
   },
   /**
    * A byte size, read as {@link Config.getBytes} reads it (default unit `B`),
@@ -110,20 +120,25 @@ var hocon = {
    * significant digits than a double holds can read differently: the getter
    * reads its text, the marker its JS value (`1.99999999999999999`: 1 through
    * the getter, 2 here).
+   * `options.requireUnit` refuses a value that does not name its unit (#233).
    */
-  bytes(unit) {
-    return unitMarker("byte size", (text) => readBytes(text, unit));
+  bytes(unit, options) {
+    return unitMarker("byte size", (text) => readBytes(text, unit), requireUnit(options, namesMagnitudeUnit));
   },
   /**
    * A calendar period, read as {@link Config.getPeriod} reads it (a bare
    * integer is days), except that a number literal with a decimal point or in
    * exponent form (`7.0`, `1e2`) can read differently: the getter refuses it,
    * the marker reads the JS number.
+   * `options.requireUnit` refuses a value that does not name its unit (#233).
    */
-  period() {
-    return unitMarker("period", readPeriod);
+  period(options) {
+    return unitMarker("period", readPeriod, requireUnit(options, namesPeriodUnit));
   }
 };
+function requireUnit(options, namesUnit) {
+  return options?.requireUnit === true ? namesUnit : void 0;
+}
 function getDefType(schema) {
   const zod = schema._zod;
   return zod?.def?.type;
@@ -170,6 +185,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 +204,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 +260,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.3",
   "description": "Full Lightbend HOCON spec-compliant parser and config library for TypeScript",
   "keywords": [
     "hocon",