@gabrielbryk/json-schema-to-zod 2.8.0 → 2.9.0

package/dist/esm/parsers/parseSchema.js

@@ -1,36 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.its = exports.parseSchema = void 0;
-const parseAnyOf_js_1 = require("./parseAnyOf.js");
-const parseBoolean_js_1 = require("./parseBoolean.js");
-const parseDefault_js_1 = require("./parseDefault.js");
-const parseMultipleType_js_1 = require("./parseMultipleType.js");
-const parseNot_js_1 = require("./parseNot.js");
-const parseNull_js_1 = require("./parseNull.js");
-const parseAllOf_js_1 = require("./parseAllOf.js");
-const parseArray_js_1 = require("./parseArray.js");
-const parseConst_js_1 = require("./parseConst.js");
-const parseEnum_js_1 = require("./parseEnum.js");
-const parseIfThenElse_js_1 = require("./parseIfThenElse.js");
-const parseNumber_js_1 = require("./parseNumber.js");
-const parseObject_js_1 = require("./parseObject.js");
-const parseString_js_1 = require("./parseString.js");
-const parseOneOf_js_1 = require("./parseOneOf.js");
-const parseSimpleDiscriminatedOneOf_js_1 = require("./parseSimpleDiscriminatedOneOf.js");
-const parseNullable_js_1 = require("./parseNullable.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
+import { parseAnyOf } from "./parseAnyOf.js";
+import { parseBoolean } from "./parseBoolean.js";
+import { parseDefault } from "./parseDefault.js";
+import { parseMultipleType } from "./parseMultipleType.js";
+import { parseNot } from "./parseNot.js";
+import { parseNull } from "./parseNull.js";
+import { parseAllOf } from "./parseAllOf.js";
+import { parseArray } from "./parseArray.js";
+import { parseConst } from "./parseConst.js";
+import { parseEnum } from "./parseEnum.js";
+import { parseIfThenElse } from "./parseIfThenElse.js";
+import { parseNumber } from "./parseNumber.js";
+import { parseObject } from "./parseObject.js";
+import { parseString } from "./parseString.js";
+import { parseOneOf } from "./parseOneOf.js";
+import { parseSimpleDiscriminatedOneOf } from "./parseSimpleDiscriminatedOneOf.js";
+import { parseNullable } from "./parseNullable.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+import { resolveUri } from "../utils/resolveUri.js";
+import { buildRefRegistry } from "../utils/buildRefRegistry.js";
+export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
     // Ensure ref bookkeeping exists so $ref declarations and getter-based recursion work
     refs.root = refs.root ?? schema;
+    refs.rootBaseUri = refs.rootBaseUri ?? "root:///";
     refs.declarations = refs.declarations ?? new Map();
     refs.dependencies = refs.dependencies ?? new Map();
     refs.inProgress = refs.inProgress ?? new Set();
     refs.refNameByPointer = refs.refNameByPointer ?? new Map();
     refs.usedNames = refs.usedNames ?? new Set();
     if (typeof schema !== "object")
-        return schema ? (0, anyOrUnknown_js_1.anyOrUnknown)(refs) : "z.never()";
+        return schema ? anyOrUnknown(refs) : "z.never()";
+    const parentBase = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
+    const baseUri = typeof schema.$id === "string"
+        ? resolveUri(parentBase, schema.$id)
+        : parentBase;
+    const dynamicAnchors = Array.isArray(refs.dynamicAnchors) ? [...refs.dynamicAnchors] : [];
+    if (typeof schema.$dynamicAnchor === "string") {
+        dynamicAnchors.push({
+            name: schema.$dynamicAnchor,
+            uri: baseUri,
+            path: refs.path,
+        });
+    }
     if (refs.parserOverride) {
-        const custom = refs.parserOverride(schema, refs);
+        const custom = refs.parserOverride(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
         if (typeof custom === "string") {
             return custom;
         }
@@ -41,7 +53,7 @@ const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) =>
             return seen.r;
         }
         if (refs.depth === undefined || seen.n >= refs.depth) {
-            return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+            return anyOrUnknown(refs);
         }
         seen.n += 1;
     }
@@ -49,15 +61,15 @@ const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) =>
         seen = { r: undefined, n: 0 };
         refs.seen.set(schema, seen);
     }
-    if (exports.its.a.ref(schema)) {
-        const parsedRef = parseRef(schema, refs);
+    if (its.a.ref(schema)) {
+        const parsedRef = parseRef(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
         seen.r = parsedRef;
         return parsedRef;
     }
-    let parsed = selectParser(schema, refs);
+    let parsed = selectParser(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
     if (!blockMeta) {
         if (!refs.withoutDescribes) {
-            parsed = addDescribes(schema, parsed, refs);
+            parsed = addDescribes(schema, parsed, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
         }
         if (!refs.withoutDefaults) {
             parsed = addDefaults(schema, parsed);
@@ -67,19 +79,21 @@ const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) =>
     seen.r = parsed;
     return parsed;
 };
-exports.parseSchema = parseSchema;
 const parseRef = (schema, refs) => {
-    const resolved = resolveRef(refs.root, schema.$ref);
+    const refValue = schema.$dynamicRef ?? schema.$ref;
+    const resolved = resolveRef(schema, refValue, refs);
     if (!resolved) {
-        return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+        refs.onUnresolvedRef?.(refValue, refs.path);
+        return anyOrUnknown(refs);
     }
-    const { schema: target, path } = resolved;
-    const refName = getOrCreateRefName(schema.$ref, path, refs);
+    const { schema: target, path, pointerKey } = resolved;
+    const refName = getOrCreateRefName(pointerKey, path, refs);
     if (!refs.declarations.has(refName) && !refs.inProgress.has(refName)) {
         refs.inProgress.add(refName);
-        const declaration = (0, exports.parseSchema)(target, {
+        const declaration = parseSchema(target, {
             ...refs,
             path,
+            currentBaseUri: resolved.baseUri,
             currentSchemaName: refName,
             root: refs.root,
         });
@@ -132,23 +146,93 @@ const addDescribes = (schema, parsed, refs) => {
     }
     return parsed;
 };
-const resolveRef = (root, ref) => {
-    if (!root || !ref.startsWith("#/"))
-        return undefined;
-    const rawSegments = ref
-        .slice(2)
-        .split("/")
-        .filter((segment) => segment.length > 0)
-        .map(decodePointerSegment);
-    let current = root;
-    for (const segment of rawSegments) {
-        if (typeof current !== "object" || current === null)
-            return undefined;
-        current = current[segment];
-    }
-    return { schema: current, path: rawSegments };
+const resolveRef = (schemaNode, ref, refs) => {
+    const base = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
+    // Handle dynamicRef lookup via dynamicAnchors stack
+    const isDynamic = typeof schemaNode.$dynamicRef === "string";
+    if (isDynamic && refs.dynamicAnchors && ref.startsWith("#")) {
+        const name = ref.slice(1);
+        for (let i = refs.dynamicAnchors.length - 1; i >= 0; i -= 1) {
+            const entry = refs.dynamicAnchors[i];
+            if (entry.name === name) {
+                const key = `${entry.uri}#${name}`;
+                const target = refs.refRegistry?.get(key);
+                if (target) {
+                    return { schema: target.schema, path: target.path, baseUri: target.baseUri, pointerKey: key };
+                }
+            }
+        }
+    }
+    // Resolve URI against base
+    const resolvedUri = resolveUri(base, ref);
+    const [uriBase, fragment] = resolvedUri.split("#");
+    const key = fragment ? `${uriBase}#${fragment}` : uriBase;
+    let regEntry = refs.refRegistry?.get(key);
+    if (regEntry) {
+        return { schema: regEntry.schema, path: regEntry.path, baseUri: regEntry.baseUri, pointerKey: key };
+    }
+    // Legacy recursive ref: treat as dynamic to __recursive__
+    if (schemaNode.$recursiveRef) {
+        const recursiveKey = `${base}#__recursive__`;
+        regEntry = refs.refRegistry?.get(recursiveKey);
+        if (regEntry) {
+            return {
+                schema: regEntry.schema,
+                path: regEntry.path,
+                baseUri: regEntry.baseUri,
+                pointerKey: recursiveKey,
+            };
+        }
+    }
+    // External resolver hook
+    const extBase = uriBaseFromRef(resolvedUri);
+    if (refs.resolveExternalRef && extBase && !isLocalBase(extBase, refs.rootBaseUri ?? "")) {
+        const loaded = refs.resolveExternalRef(extBase);
+        if (loaded) {
+            // If async resolver is used synchronously here, it will be ignored; keep simple sync for now
+            const schema = loaded.then ? undefined : loaded;
+            if (schema) {
+                const { registry } = buildRefRegistry(schema, extBase);
+                registry.forEach((entry, k) => refs.refRegistry?.set(k, entry));
+                regEntry = refs.refRegistry?.get(key);
+                if (regEntry) {
+                    return {
+                        schema: regEntry.schema,
+                        path: regEntry.path,
+                        baseUri: regEntry.baseUri,
+                        pointerKey: key,
+                    };
+                }
+            }
+        }
+    }
+    // Backward compatibility: JSON Pointer into root
+    if (refs.root && ref.startsWith("#/")) {
+        const rawSegments = ref
+            .slice(2)
+            .split("/")
+            .filter((segment) => segment.length > 0)
+            .map(decodePointerSegment);
+        let current = refs.root;
+        for (const segment of rawSegments) {
+            if (typeof current !== "object" || current === null)
+                return undefined;
+            current = current[segment];
+        }
+        return { schema: current, path: rawSegments, baseUri: base, pointerKey: ref };
+    }
+    return undefined;
 };
 const decodePointerSegment = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+const uriBaseFromRef = (resolvedUri) => {
+    const hashIdx = resolvedUri.indexOf("#");
+    return hashIdx === -1 ? resolvedUri : resolvedUri.slice(0, hashIdx);
+};
+const isLocalBase = (base, rootBase) => {
+    if (!rootBase)
+        return false;
+    return base === rootBase;
+};
 const getOrCreateRefName = (pointer, path, refs) => {
     if (refs.refNameByPointer?.has(pointer)) {
         return refs.refNameByPointer.get(pointer);
@@ -159,12 +243,24 @@ const getOrCreateRefName = (pointer, path, refs) => {
     return preferred;
 };
 const buildNameFromPath = (path, used) => {
-    const filtered = path.filter((segment) => segment !== "$defs" && segment !== "definitions" && segment !== "properties");
+    const filtered = path
+        .map((segment, idx) => {
+        if (idx === 0 && (segment === "$defs" || segment === "definitions")) {
+            return undefined; // root-level defs prefix is redundant for naming
+        }
+        if (segment === "properties")
+            return undefined; // skip noisy properties segment
+        if (segment === "$defs" || segment === "definitions")
+            return "Defs";
+        return segment;
+    })
+        .filter((segment) => segment !== undefined);
     const base = filtered.length
         ? filtered
             .map((segment) => typeof segment === "number"
             ? `Ref${segment}`
             : segment
+                .toString()
                 .replace(/[^a-zA-Z0-9_$]/g, " ")
                 .split(" ")
                 .filter(Boolean)
@@ -201,60 +297,60 @@ const addAnnotations = (schema, parsed) => {
     return parsed;
 };
 const selectParser = (schema, refs) => {
-    if (exports.its.a.nullable(schema)) {
-        return (0, parseNullable_js_1.parseNullable)(schema, refs);
+    if (its.a.nullable(schema)) {
+        return parseNullable(schema, refs);
     }
-    else if (exports.its.an.object(schema)) {
-        return (0, parseObject_js_1.parseObject)(schema, refs);
+    else if (its.an.object(schema)) {
+        return parseObject(schema, refs);
     }
-    else if (exports.its.an.array(schema)) {
-        return (0, parseArray_js_1.parseArray)(schema, refs);
+    else if (its.an.array(schema)) {
+        return parseArray(schema, refs);
     }
-    else if (exports.its.an.anyOf(schema)) {
-        return (0, parseAnyOf_js_1.parseAnyOf)(schema, refs);
+    else if (its.an.anyOf(schema)) {
+        return parseAnyOf(schema, refs);
     }
-    else if (exports.its.an.allOf(schema)) {
-        return (0, parseAllOf_js_1.parseAllOf)(schema, refs);
+    else if (its.an.allOf(schema)) {
+        return parseAllOf(schema, refs);
     }
-    else if (exports.its.a.simpleDiscriminatedOneOf(schema)) {
-        return (0, parseSimpleDiscriminatedOneOf_js_1.parseSimpleDiscriminatedOneOf)(schema, refs);
+    else if (its.a.simpleDiscriminatedOneOf(schema)) {
+        return parseSimpleDiscriminatedOneOf(schema, refs);
     }
-    else if (exports.its.a.oneOf(schema)) {
-        return (0, parseOneOf_js_1.parseOneOf)(schema, refs);
+    else if (its.a.oneOf(schema)) {
+        return parseOneOf(schema, refs);
     }
-    else if (exports.its.a.not(schema)) {
-        return (0, parseNot_js_1.parseNot)(schema, refs);
+    else if (its.a.not(schema)) {
+        return parseNot(schema, refs);
     }
-    else if (exports.its.an.enum(schema)) {
-        return (0, parseEnum_js_1.parseEnum)(schema); //<-- needs to come before primitives
+    else if (its.an.enum(schema)) {
+        return parseEnum(schema); //<-- needs to come before primitives
     }
-    else if (exports.its.a.const(schema)) {
-        return (0, parseConst_js_1.parseConst)(schema);
+    else if (its.a.const(schema)) {
+        return parseConst(schema);
     }
-    else if (exports.its.a.multipleType(schema)) {
-        return (0, parseMultipleType_js_1.parseMultipleType)(schema, refs);
+    else if (its.a.multipleType(schema)) {
+        return parseMultipleType(schema, refs);
     }
-    else if (exports.its.a.primitive(schema, "string")) {
-        return (0, parseString_js_1.parseString)(schema, refs);
+    else if (its.a.primitive(schema, "string")) {
+        return parseString(schema, refs);
     }
-    else if (exports.its.a.primitive(schema, "number") ||
-        exports.its.a.primitive(schema, "integer")) {
-        return (0, parseNumber_js_1.parseNumber)(schema);
+    else if (its.a.primitive(schema, "number") ||
+        its.a.primitive(schema, "integer")) {
+        return parseNumber(schema);
     }
-    else if (exports.its.a.primitive(schema, "boolean")) {
-        return (0, parseBoolean_js_1.parseBoolean)(schema);
+    else if (its.a.primitive(schema, "boolean")) {
+        return parseBoolean(schema);
     }
-    else if (exports.its.a.primitive(schema, "null")) {
-        return (0, parseNull_js_1.parseNull)(schema);
+    else if (its.a.primitive(schema, "null")) {
+        return parseNull(schema);
     }
-    else if (exports.its.a.conditional(schema)) {
-        return (0, parseIfThenElse_js_1.parseIfThenElse)(schema, refs);
+    else if (its.a.conditional(schema)) {
+        return parseIfThenElse(schema, refs);
     }
     else {
-        return (0, parseDefault_js_1.parseDefault)(schema, refs);
+        return parseDefault(schema, refs);
     }
 };
-exports.its = {
+export const its = {
     an: {
         object: (x) => x.type === "object",
         array: (x) => x.type === "array",
@@ -266,7 +362,7 @@ exports.its = {
         nullable: (x) => x.nullable === true,
         multipleType: (x) => Array.isArray(x.type),
         not: (x) => x.not !== undefined,
-        ref: (x) => typeof x.$ref === "string",
+        ref: (x) => typeof x.$ref === "string" || typeof x.$dynamicRef === "string",
         const: (x) => x.const !== undefined,
         primitive: (x, p) => x.type === p,
         conditional: (x) => Boolean("if" in x && x.if && "then" in x && "else" in x && x.then && x.else),

package/dist/esm/parsers/parseSimpleDiscriminatedOneOf.js

@@ -1,21 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSimpleDiscriminatedOneOf = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseSimpleDiscriminatedOneOf = (schema, refs) => {
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseSimpleDiscriminatedOneOf = (schema, refs) => {
     const discriminator = schema.discriminator.propertyName;
-    const options = schema.oneOf.map((option, i) => (0, parseSchema_js_1.parseSchema)(option, {
+    const options = schema.oneOf.map((option, i) => parseSchema(option, {
         ...refs,
         path: [...refs.path, "oneOf", i],
     }));
     return schema.oneOf.length
         ? schema.oneOf.length === 1
-            ? (0, parseSchema_js_1.parseSchema)(schema.oneOf[0], {
+            ? parseSchema(schema.oneOf[0], {
                 ...refs,
                 path: [...refs.path, "oneOf", 0],
             })
             : `z.discriminatedUnion("${discriminator}", [${options.join(", ")}])`
-        : (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+        : anyOrUnknown(refs);
 };
-exports.parseSimpleDiscriminatedOneOf = parseSimpleDiscriminatedOneOf;

package/dist/esm/parsers/parseString.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseString = void 0;
-const withMessage_js_1 = require("../utils/withMessage.js");
-const parseSchema_js_1 = require("./parseSchema.js");
-const parseString = (schema, refs) => {
+import { withMessage } from "../utils/withMessage.js";
+import { parseSchema } from "./parseSchema.js";
+export const parseString = (schema, refs) => {
     const formatError = schema.errorMessage?.format;
     const refContext = ensureRefs(refs);
     const topLevelFormatMap = {
@@ -29,7 +26,7 @@ const parseString = (schema, refs) => {
     const formatHandled = Boolean(formatFn);
     let formatWasHandled = formatHandled;
     if (!formatHandled) {
-        r += (0, withMessage_js_1.withMessage)(schema, "format", ({ value }) => {
+        r += withMessage(schema, "format", ({ value }) => {
             switch (value) {
                 case "email":
                     formatWasHandled = true;
@@ -248,25 +245,25 @@ const parseString = (schema, refs) => {
     if (schema.format && !formatWasHandled) {
         refContext.onUnknownFormat?.(schema.format, refContext.path);
     }
-    r += (0, withMessage_js_1.withMessage)(schema, "pattern", ({ json }) => ({
+    r += withMessage(schema, "pattern", ({ json }) => ({
         opener: `.regex(new RegExp(${json})`,
         closer: ")",
         messagePrefix: ", { error: ",
         messageCloser: " })",
     }));
-    r += (0, withMessage_js_1.withMessage)(schema, "minLength", ({ json }) => ({
+    r += withMessage(schema, "minLength", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
         messagePrefix: ", { error: ",
         messageCloser: " })",
     }));
-    r += (0, withMessage_js_1.withMessage)(schema, "maxLength", ({ json }) => ({
+    r += withMessage(schema, "maxLength", ({ json }) => ({
         opener: `.max(${json}`,
         closer: ")",
         messagePrefix: ", { error: ",
         messageCloser: " })",
     }));
-    r += (0, withMessage_js_1.withMessage)(schema, "contentEncoding", ({ value }) => {
+    r += withMessage(schema, "contentEncoding", ({ value }) => {
         if (value === "base64") {
             return {
                 opener: ".base64(",
@@ -276,7 +273,7 @@ const parseString = (schema, refs) => {
             };
         }
     });
-    const contentMediaType = (0, withMessage_js_1.withMessage)(schema, "contentMediaType", ({ value }) => {
+    const contentMediaType = withMessage(schema, "contentMediaType", ({ value }) => {
         if (value === "application/json") {
             return {
                 opener: '.transform((str, ctx) => { try { return JSON.parse(str); } catch (err) { ctx.addIssue({ code: "custom", message: "Invalid JSON" }); }}',
@@ -288,10 +285,10 @@ const parseString = (schema, refs) => {
     });
     if (contentMediaType != "") {
         r += contentMediaType;
-        r += (0, withMessage_js_1.withMessage)(schema, "contentSchema", ({ value }) => {
+        r += withMessage(schema, "contentSchema", ({ value }) => {
             if (value && value instanceof Object) {
                 return {
-                    opener: `.pipe(${(0, parseSchema_js_1.parseSchema)(value, refContext)}`,
+                    opener: `.pipe(${parseSchema(value, refContext)}`,
                     closer: ")",
                     messagePrefix: ", { error: ",
                     messageCloser: " })",
@@ -301,7 +298,6 @@ const parseString = (schema, refs) => {
     }
     return r;
 };
-exports.parseString = parseString;
 function ensureRefs(refs) {
     if (refs)
         return refs;

package/dist/esm/utils/anyOrUnknown.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.anyOrUnknown = void 0;
 /**
  * Returns "z.unknown()" if the useUnknown option is enabled, otherwise "z.any()".
  * This helper is used throughout the library for fallback cases.
@@ -8,7 +5,6 @@ exports.anyOrUnknown = void 0;
  * @param refs - The refs object containing options
  * @returns The appropriate Zod schema string
  */
-const anyOrUnknown = (refs) => {
+export const anyOrUnknown = (refs) => {
     return refs?.useUnknown ? "z.unknown()" : "z.any()";
 };
-exports.anyOrUnknown = anyOrUnknown;

package/dist/esm/utils/buildRefRegistry.js

@@ -0,0 +1,52 @@
+import { resolveUri } from "./resolveUri.js";
+export const buildRefRegistry = (schema, rootBaseUri = "root:///", opts = {}) => {
+    const registry = new Map();
+    const walk = (node, baseUri, path) => {
+        if (typeof node !== "object" || node === null)
+            return;
+        const obj = node;
+        const nextBase = obj.$id ? resolveUri(baseUri, obj.$id) : baseUri;
+        // Legacy recursive anchor
+        if (obj.$recursiveAnchor === true) {
+            const name = "__recursive__";
+            registry.set(`${nextBase}#${name}`, {
+                schema: node,
+                path,
+                baseUri: nextBase,
+                dynamic: true,
+                anchor: name,
+            });
+        }
+        // Register base entry
+        registry.set(nextBase, { schema: node, path, baseUri: nextBase });
+        if (typeof obj.$anchor === "string") {
+            registry.set(`${nextBase}#${obj.$anchor}`, {
+                schema: node,
+                path,
+                baseUri: nextBase,
+                anchor: obj.$anchor,
+            });
+        }
+        if (typeof obj.$dynamicAnchor === "string") {
+            const name = obj.$dynamicAnchor;
+            registry.set(`${nextBase}#${name}`, {
+                schema: node,
+                path,
+                baseUri: nextBase,
+                dynamic: true,
+                anchor: name,
+            });
+        }
+        for (const key in obj) {
+            const value = obj[key];
+            if (Array.isArray(value)) {
+                value.forEach((v, i) => walk(v, nextBase, [...path, key, i]));
+            }
+            else if (typeof value === "object" && value !== null) {
+                walk(value, nextBase, [...path, key]);
+            }
+        }
+    };
+    walk(schema, rootBaseUri, []);
+    return { registry, rootBaseUri };
+};

package/dist/esm/utils/cliTools.js

@@ -1,11 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArgs = parseArgs;
-exports.parseOrReadJSON = parseOrReadJSON;
-exports.readPipe = readPipe;
-exports.printParams = printParams;
-const fs_1 = require("fs");
-function parseArgs(params, args, help) {
+import { statSync, readFileSync } from "fs";
+export function parseArgs(params, args, help) {
     const result = {};
     if (help) {
         let index = args.indexOf("--help");
@@ -62,15 +56,15 @@ function parseArgs(params, args, help) {
     }
     return result;
 }
-function parseOrReadJSON(jsonOrPath) {
+export function parseOrReadJSON(jsonOrPath) {
     jsonOrPath = jsonOrPath.trim();
     if (jsonOrPath.length < 255 &&
-        (0, fs_1.statSync)(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
-        jsonOrPath = (0, fs_1.readFileSync)(jsonOrPath, "utf-8");
+        statSync(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
+        jsonOrPath = readFileSync(jsonOrPath, "utf-8");
     }
     return JSON.parse(jsonOrPath);
 }
-function readPipe() {
+export function readPipe() {
     return new Promise((resolve, reject) => {
         let buf = "";
         process.stdin
@@ -85,7 +79,7 @@ function readPipe() {
         });
     });
 }
-function printParams(params) {
+export function printParams(params) {
     const longest = Object.keys(params).reduce((l, c) => (c.length > l ? c.length : l), 5);
     const header = "Name " + " ".repeat(longest - 2) + "Short Description";
     console.log(header);

package/dist/esm/utils/cycles.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeScc = exports.detectCycles = exports.findRefDependencies = void 0;
-const findRefDependencies = (schema, validDefNames) => {
+export const findRefDependencies = (schema, validDefNames) => {
     const deps = new Set();
     function traverse(obj) {
         if (obj === null || typeof obj !== "object")
@@ -25,8 +22,7 @@ const findRefDependencies = (schema, validDefNames) => {
     traverse(schema);
     return deps;
 };
-exports.findRefDependencies = findRefDependencies;
-const detectCycles = (defNames, deps) => {
+export const detectCycles = (defNames, deps) => {
     const cycleNodes = new Set();
     const visited = new Set();
     const recursionStack = new Set();
@@ -57,8 +53,7 @@ const detectCycles = (defNames, deps) => {
     }
     return cycleNodes;
 };
-exports.detectCycles = detectCycles;
-const computeScc = (defNames, deps) => {
+export const computeScc = (defNames, deps) => {
     // Tarjan's algorithm, keeps mapping for quick "is this ref in my cycle?"
     const index = new Map();
     const lowlink = new Map();
@@ -110,4 +105,3 @@ const computeScc = (defNames, deps) => {
     }
     return { cycleMembers, componentByName };
 };
-exports.computeScc = computeScc;

package/dist/esm/utils/half.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.half = void 0;
-const half = (arr) => {
+export const half = (arr) => {
     return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
 };
-exports.half = half;

package/dist/esm/utils/jsdocs.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addJsdocs = exports.expandJsdocs = void 0;
-const expandJsdocs = (jsdocs) => {
+export const expandJsdocs = (jsdocs) => {
     const lines = jsdocs.split("\n");
     const result = lines.length === 1
         ? lines[0]
@@ -9,12 +6,10 @@ const expandJsdocs = (jsdocs) => {
             .join("\n")}\n`;
     return `/**${result}*/\n`;
 };
-exports.expandJsdocs = expandJsdocs;
-const addJsdocs = (schema, parsed) => {
+export const addJsdocs = (schema, parsed) => {
     const description = schema.description;
     if (!description) {
         return parsed;
     }
-    return `\n${(0, exports.expandJsdocs)(description)}${parsed}`;
+    return `\n${expandJsdocs(description)}${parsed}`;
 };
-exports.addJsdocs = addJsdocs;