@gabrielbryk/json-schema-to-zod 2.12.1 → 2.14.0

package/dist/parsers/parseString.js

@@ -3,246 +3,114 @@ import { parseSchema } from "./parseSchema.js";
 export const parseString = (schema, refs) => {
     const formatError = schema.errorMessage?.format;
     const refContext = ensureRefs(refs);
-    // Map formats to top-level Zod functions and their return types
+    // Map formats to Zod string methods
     const topLevelFormatMap = {
-        email: { fn: "z.email", zodType: "z.ZodEmail" },
-        ipv4: { fn: "z.ipv4", zodType: "z.ZodIPv4" },
-        ipv6: { fn: "z.ipv6", zodType: "z.ZodIPv6" },
-        uri: { fn: "z.url", zodType: "z.ZodURL" },
-        uuid: { fn: "z.uuid", zodType: "z.ZodUUID" },
-        cuid: { fn: "z.cuid", zodType: "z.ZodCUID" },
-        cuid2: { fn: "z.cuid2", zodType: "z.ZodCUID2" },
-        nanoid: { fn: "z.nanoid", zodType: "z.ZodNanoID" },
-        ulid: { fn: "z.ulid", zodType: "z.ZodULID" },
-        jwt: { fn: "z.jwt", zodType: "z.ZodJWT" },
-        e164: { fn: "z.e164", zodType: "z.ZodE164" },
-        base64url: { fn: "z.base64url", zodType: "z.ZodBase64URL" },
-        base64: { fn: "z.base64", zodType: "z.ZodBase64" },
-        emoji: { fn: "z.emoji", zodType: "z.ZodEmoji" },
-        "idn-email": { fn: "z.email", zodType: "z.ZodEmail" },
+        email: { fn: "z.email", zodType: "z.ZodString" },
+        ipv4: { fn: "z.ipv4", zodType: "z.ZodString" },
+        ipv6: { fn: "z.ipv6", zodType: "z.ZodString" },
+        uri: { fn: "z.url", zodType: "z.ZodString" },
+        uuid: { fn: "z.uuid", zodType: "z.ZodString" },
+        cuid: { fn: "z.cuid", zodType: "z.ZodString" },
+        cuid2: { fn: "z.cuid2", zodType: "z.ZodString" },
+        nanoid: { fn: "z.nanoid", zodType: "z.ZodString" },
+        ulid: { fn: "z.ulid", zodType: "z.ZodString" },
+        jwt: { fn: "z.jwt", zodType: "z.ZodString" },
+        e164: { fn: "z.e164", zodType: "z.ZodString" },
+        base64url: { fn: "z.base64url", zodType: "z.ZodString" },
+        base64: { fn: "z.base64", zodType: "z.ZodString" },
+        emoji: { fn: "z.emoji", zodType: "z.ZodString" },
+        "idn-email": { fn: "z.email", zodType: "z.ZodString" },
+        "date-time": { fn: "z.iso.datetime", zodType: "z.ZodString" },
+        date: { fn: "z.iso.date", zodType: "z.ZodString" },
+        time: { fn: "z.iso.time", zodType: "z.ZodString" },
+        duration: { fn: "z.iso.duration", zodType: "z.ZodString" },
     };
     const formatInfo = schema.format ? topLevelFormatMap[schema.format] : undefined;
     const formatFn = formatInfo?.fn;
-    const formatParam = formatError !== undefined ? `{ error: ${JSON.stringify(formatError)} }` : "";
-    let r = formatFn ? `${formatFn}(${formatParam})` : "z.string()";
-    const formatHandled = Boolean(formatFn);
-    let formatWasHandled = formatHandled;
-    if (!formatHandled) {
-        r += withMessage(schema, "format", ({ value }) => {
-            switch (value) {
-                case "email":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".email(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "ip":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".ip(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "ipv4":
-                    formatWasHandled = true;
-                    return {
-                        opener: '.ip({ version: "v4"',
-                        closer: " })",
-                        messagePrefix: ", error: ",
-                        messageCloser: " })",
-                    };
-                case "ipv6":
-                    formatWasHandled = true;
-                    return {
-                        opener: '.ip({ version: "v6"',
-                        closer: " })",
-                        messagePrefix: ", error: ",
-                        messageCloser: " })",
-                    };
-                case "uri":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".url(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "uuid":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".uuid(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "cuid":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".cuid(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "cuid2":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".cuid2(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "nanoid":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".nanoid(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "ulid":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".ulid(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "jwt":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".jwt(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "e164":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".e164(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "base64url":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".base64url(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "emoji":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".emoji(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "date-time":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".datetime({ offset: true",
-                        closer: " })",
-                        messagePrefix: ", error: ",
-                        messageCloser: " })",
-                    };
-                case "time":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".time(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "date":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".date(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "binary":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".base64(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "duration":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".duration(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "hostname":
-                case "idn-hostname":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".refine((val) => { if (typeof val !== \"string\" || val.length === 0 || val.length > 253) return false; return val.split(\".\").every((label) => label.length > 0 && label.length <= 63 && /^[A-Za-z0-9-]+$/.test(label) && label[0] !== \"-\" && label[label.length - 1] !== \"-\"); }",
-                        closer: ")",
-                        messagePrefix: ", { error: ",
-                        messageCloser: " })",
-                    };
-                case "idn-email":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".email(",
-                        closer: ")",
-                        messagePrefix: "{ error: ",
-                        messageCloser: " })",
-                    };
-                case "uri-reference":
-                case "iri":
-                case "iri-reference":
-                    formatWasHandled = true;
-                    return {
-                        opener: '.refine((val) => { try { new URL(val, "http://example.com"); return true; } catch { return false; } }',
-                        closer: ")",
-                        messagePrefix: ", { error: ",
-                        messageCloser: " })",
-                    };
-                case "json-pointer":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".refine((val) => typeof val === \"string\" && /^(?:\\/(?:[^/~]|~[01])*)*$/.test(val)",
-                        closer: ")",
-                        messagePrefix: ", { error: ",
-                        messageCloser: " })",
-                    };
-                case "relative-json-pointer":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".refine((val) => typeof val === \"string\" && /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^/~]|~[01])*))*$/.test(val)",
-                        closer: ")",
-                        messagePrefix: ", { error: ",
-                        messageCloser: " })",
-                    };
-                case "uri-template":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".refine((val) => { if (typeof val !== \"string\") return false; const opens = (val.match(/\\{/g) || []).length; const closes = (val.match(/\\}/g) || []).length; return opens === closes; }",
-                        closer: ")",
-                        messagePrefix: ", { error: ",
-                        messageCloser: " })",
-                    };
-                case "regex":
-                    formatWasHandled = true;
-                    return {
-                        opener: ".refine((val) => { try { new RegExp(val); return true; } catch { return false; } }",
-                        closer: ")",
-                        messagePrefix: ", { error: ",
-                        messageCloser: " })",
-                    };
-            }
-        });
+    let r = "z.string()";
+    let zodType = "z.ZodString";
+    if (formatFn) {
+        const params = formatError !== undefined ? `{ message: ${JSON.stringify(formatError)} }` : "";
+        if (schema.format === "date-time") {
+            r = `z.iso.datetime({ offset: true${formatError ? `, message: ${JSON.stringify(formatError)}` : ""} })`;
+        }
+        else if (schema.format === "ipv4") {
+            r = `z.ipv4(${formatError ? `{ message: ${JSON.stringify(formatError)} }` : ""})`;
+        }
+        else if (schema.format === "ipv6") {
+            r = `z.ipv6(${formatError ? `{ message: ${JSON.stringify(formatError)} }` : ""})`;
+        }
+        else {
+            r = `${formatFn}(${params})`;
+        }
+    }
+    let formatWasHandled = Boolean(formatFn);
+    if (!formatWasHandled && schema.format) {
+        switch (schema.format) {
+            case "ip":
+                r += `.refine((val) => {
+          const v4 = z.ipv4().safeParse(val).success;
+          const v6 = z.ipv6().safeParse(val).success;
+          return v4 || v6;
+        }${formatError ? `, { message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+            case "binary":
+                r = `z.base64(${formatError ? `{ message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+            case "hostname":
+            case "idn-hostname":
+                r += `.refine((val) => {
+          if (typeof val !== "string" || val.length === 0 || val.length > 253) return false;
+          return val.split(".").every((label) => {
+            return label.length > 0 && label.length <= 63 && /^[A-Za-z0-9-]+$/.test(label) && label[0] !== "-" && label[label.length - 1] !== "-";
+          });
+        }${formatError ? `, { message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+            case "uri-reference":
+            case "iri":
+            case "iri-reference":
+                r += `.refine((val) => {
+          try {
+            new URL(val, "http://example.com");
+            return true;
+          } catch {
+            return false;
+          }
+        }${formatError ? `, { message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+            case "json-pointer":
+                r += `.refine((val) => typeof val === "string" && /^(?:\\/(?:[^/~]|~[01])*)*$/.test(val)${formatError ? `, { message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+            case "relative-json-pointer":
+                r += `.refine((val) => typeof val === "string" && /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^/~]|~[01])*))*$/.test(val)${formatError ? `, { message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+            case "uri-template":
+                r += `.refine((val) => {
+          if (typeof val !== "string") return false;
+          const opens = (val.match(/\\{/g) || []).length;
+          const closes = (val.match(/\\}/g) || []).length;
+          return opens === closes;
+        }${formatError ? `, { message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+            case "regex":
+                r += `.refine((val) => {
+          try {
+            new RegExp(val);
+            return true;
+          } catch {
+            return false;
+          }
+        }${formatError ? `, { message: ${JSON.stringify(formatError)} }` : ""})`;
+                formatWasHandled = true;
+                break;
+        }
     }
     if (schema.format && !formatWasHandled) {
         refContext.onUnknownFormat?.(schema.format, refContext.path);
@@ -250,37 +118,31 @@ export const parseString = (schema, refs) => {
     r += withMessage(schema, "pattern", ({ json }) => ({
         opener: `.regex(new RegExp(${json})`,
         closer: ")",
-        messagePrefix: ", { error: ",
+        messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
     r += withMessage(schema, "minLength", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
-        messagePrefix: ", { error: ",
+        messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
     r += withMessage(schema, "maxLength", ({ json }) => ({
         opener: `.max(${json}`,
         closer: ")",
-        messagePrefix: ", { error: ",
+        messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
-    r += withMessage(schema, "contentEncoding", ({ value }) => {
-        if (value === "base64") {
-            return {
-                opener: ".base64(",
-                closer: ")",
-                messagePrefix: "{ error: ",
-                messageCloser: " })",
-            };
-        }
-    });
+    if (schema.contentEncoding === "base64" && schema.format !== "base64") {
+        const encodingError = schema.errorMessage?.contentEncoding;
+        r = `z.base64(${encodingError ? `{ message: ${JSON.stringify(encodingError)} }` : ""})`;
+    }
     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" }); }}',
                 closer: ")",
-                messagePrefix: ", { error: ",
+                messagePrefix: ", { message: ",
                 messageCloser: " })",
             };
         }
@@ -296,14 +158,12 @@ export const parseString = (schema, refs) => {
                 return {
                     opener: `.pipe(${contentExpr}`,
                     closer: ")",
-                    messagePrefix: ", { error: ",
+                    messagePrefix: ", { message: ",
                     messageCloser: " })",
                 };
             }
         });
     }
-    // Use the correct Zod type based on whether a format function was used
-    const zodType = formatInfo?.zodType ?? "z.ZodString";
     return {
         expression: r,
         type: zodType,

package/dist/types/Types.d.ts

@@ -25,9 +25,10 @@ export type JsonSchemaObject = {
     definitions?: Record<string, JsonSchema>;
     title?: string;
     description?: string;
-    examples?: Serializable[];
+    examples?: Serializable | Serializable[];
     deprecated?: boolean;
     dependentSchemas?: Record<string, JsonSchema>;
+    dependentRequired?: Record<string, string[]>;
     contains?: JsonSchema;
     minContains?: number;
     maxContains?: number;
@@ -44,6 +45,7 @@ export type JsonSchemaObject = {
     required?: string[] | boolean;
     propertyNames?: JsonSchema;
     items?: JsonSchema | JsonSchema[];
+    prefixItems?: JsonSchema[];
     additionalItems?: JsonSchema;
     minItems?: number;
     maxItems?: number;
@@ -71,6 +73,16 @@ export type JsonSchemaObject = {
 } & Record<string, unknown>;
 export type ParserSelector = (schema: JsonSchemaObject, refs: Refs) => SchemaRepresentation;
 export type ParserOverride = (schema: JsonSchemaObject, refs: Refs) => string | void;
+export type NamingContext = {
+    isRoot: boolean;
+    isLifted: boolean;
+};
+export type NamingOptions = {
+    /** Customize the const name for schemas. Defaults to appending "Schema". */
+    schemaName?: (baseName: string, ctx: NamingContext) => string;
+    /** Customize the type name for schemas. Defaults to baseName when naming is enabled. */
+    typeName?: (baseName: string, ctx: NamingContext) => string | undefined;
+};
 export type Options = {
     name?: string;
     withoutDefaults?: boolean;
@@ -78,6 +90,8 @@ export type Options = {
     withJsdocs?: boolean;
     /** Use .meta() instead of .describe() - includes id, title, description */
     withMeta?: boolean;
+    /** Customize schema and type naming for root and lifted schemas. */
+    naming?: NamingOptions;
     parserOverride?: ParserOverride;
     depth?: number;
     type?: boolean | string;
@@ -118,6 +132,14 @@ export type Options = {
      * @default false
      */
     strictOneOf?: boolean;
+    /**
+     * Root schema instance for JSON Pointer resolution (#/...).
+     */
+    root?: JsonSchema;
+    /**
+     * Full document root schema instance for cross-reference resolution.
+     */
+    documentRoot?: JsonSchema;
     /**
      * Called when a string format is encountered that has no built-in mapping.
      * Can be used to log or throw on unknown formats.
@@ -133,6 +155,16 @@ export type Options = {
      * Return a JsonSchema to register, or undefined if not found.
      */
     resolveExternalRef?: (uri: string) => JsonSchema | Promise<JsonSchema> | undefined;
+    /** Root/base URI for the document */
+    rootBaseUri?: string;
+    /** Prebuilt registry of resolved URIs/anchors */
+    refRegistry?: Map<string, {
+        schema: JsonSchema;
+        path: (string | number)[];
+        baseUri: string;
+        dynamic?: boolean;
+        anchor?: string;
+    }>;
     /**
      * Lift inline object schemas into top-level defs to improve reusability.
      * Default is ON; set enable: false to opt out.
@@ -164,7 +196,10 @@ export type Refs = Options & {
     dependencies?: Map<string, Set<string>>;
     inProgress?: Set<string>;
     refNameByPointer?: Map<string, string>;
+    refBaseNameByPointer?: Map<string, string>;
+    baseNameBySchema?: Map<string, string>;
     usedNames?: Set<string>;
+    usedBaseNames?: Set<string>;
     currentSchemaName?: string;
     cycleRefNames?: Set<string>;
     cycleComponentByName?: Map<string, number>;
@@ -180,6 +215,7 @@ export type Refs = Options & {
         dynamic?: boolean;
         anchor?: string;
     }>;
+    definitions?: Record<string, JsonSchema>;
     /** Stack of active dynamic anchors (nearest last) */
     dynamicAnchors?: {
         name: string;

package/dist/types/core/analyzeSchema.d.ts

@@ -8,6 +8,9 @@ export type AnalysisResult = {
     schema: JsonSchema;
     options: NormalizedOptions;
     refNameByPointer: Map<string, string>;
+    refBaseNameByPointer: Map<string, string>;
+    baseNameBySchema: Map<string, string>;
+    rootBaseName?: string;
     usedNames: Set<string>;
     declarations: Map<string, SchemaRepresentation>;
     dependencies: Map<string, Set<string>>;
@@ -21,5 +24,6 @@ export type AnalysisResult = {
         anchor?: string;
     }>;
     rootBaseUri: string;
+    definitions?: Record<string, JsonSchema>;
 };
 export declare const analyzeSchema: (schema: JsonSchema, options?: Options) => AnalysisResult;

package/dist/types/generators/generateBundle.d.ts

@@ -2,7 +2,7 @@ import { JsonSchema, Options } from "../Types.js";
 export type SplitDefsOptions = {
     /** Include a root schema file in addition to $defs */
     includeRoot?: boolean;
-    /** Override file name for each schema (default: `${def}.schema.ts`) */
+    /** Override file name for each schema (default: `${ def }.schema.ts`) */
     fileName?: (defName: string, ctx: {
         isRoot: boolean;
     }) => string;

package/dist/types/index.d.ts

@@ -33,6 +33,7 @@ export * from "./utils/namingService.js";
 export * from "./utils/omit.js";
 export * from "./utils/resolveRef.js";
 export * from "./utils/resolveUri.js";
+export * from "./utils/schemaNaming.js";
 export * from "./utils/schemaRepresentation.js";
 export * from "./utils/withMessage.js";
 export * from "./zodToJsonSchema.js";

package/dist/types/utils/schemaNaming.d.ts

@@ -0,0 +1,6 @@
+import { NamingContext, NamingOptions } from "../Types.js";
+export declare const defaultSchemaName: (baseName: string) => string;
+export declare const sanitizeIdentifier: (value: string) => string;
+export declare const ensureUnique: (candidate: string, used?: Set<string>) => string;
+export declare const resolveSchemaName: (baseName: string, naming: NamingOptions, ctx: NamingContext, used?: Set<string>) => string;
+export declare const resolveTypeName: (baseName: string, naming: NamingOptions, ctx: NamingContext, used?: Set<string>) => string | undefined;

package/dist/utils/cliTools.js

@@ -58,8 +58,7 @@ export function parseArgs(params, args, help) {
 }
 export function parseOrReadJSON(jsonOrPath) {
     jsonOrPath = jsonOrPath.trim();
-    if (jsonOrPath.length < 255 &&
-        statSync(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
+    if (jsonOrPath.length < 255 && statSync(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
         jsonOrPath = readFileSync(jsonOrPath, "utf-8");
     }
     return JSON.parse(jsonOrPath);

package/dist/utils/esmEmitter.js

@@ -52,7 +52,9 @@ export class EsmEmitter {
         const initializer = parseExpression(statement.expression);
         const typeNode = statement.typeAnnotation ? parseType(statement.typeAnnotation) : undefined;
         const decl = ts.factory.createVariableDeclaration(statement.name, undefined, typeNode, initializer);
-        const modifiers = statement.exported ? [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)] : undefined;
+        const modifiers = statement.exported
+            ? [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)]
+            : undefined;
         const varStmt = ts.factory.createVariableStatement(modifiers, ts.factory.createVariableDeclarationList([decl], ts.NodeFlags.Const));
         __classPrivateFieldGet(this, _EsmEmitter_statements, "f").push({ node: attachJsdoc(varStmt, statement.jsdoc) });
     }
@@ -72,7 +74,9 @@ export class EsmEmitter {
         const sf = ts.createSourceFile("out.ts", "", ts.ScriptTarget.ES2020, false, ts.ScriptKind.TS);
         const importStmts = [...__classPrivateFieldGet(this, _EsmEmitter_imports, "f").entries()]
             .sort(([a], [b]) => a.localeCompare(b))
-            .map(([source, names]) => ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([...names].sort().map((name) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name))))), ts.factory.createStringLiteral(source)));
+            .map(([source, names]) => ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([...names]
+            .sort()
+            .map((name) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name))))), ts.factory.createStringLiteral(source)));
         const allStatements = [
             ...importStmts.map((node) => ({ node })),
             ...__classPrivateFieldGet(this, _EsmEmitter_statements, "f"),

package/dist/utils/extractInlineObject.js

@@ -99,9 +99,7 @@ const sanitizeIdentifier = (value) => {
         .replace(/[^a-zA-Z0-9_$\s]/g, " ")
         .split(/\s+/)
         .filter(Boolean);
-    const pascalCase = words
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join("");
+    const pascalCase = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
     const cleaned = pascalCase.replace(/^[^a-zA-Z_$]+/, "").replace(/[^a-zA-Z0-9_$]/g, "");
     return cleaned || "InlineSchema";
 };

package/dist/utils/jsdocs.js

@@ -1,9 +1,6 @@
 export const expandJsdocs = (jsdocs) => {
     const lines = jsdocs.split("\n");
-    const result = lines.length === 1
-        ? lines[0]
-        : `\n${lines.map(x => `* ${x}`)
-            .join("\n")}\n`;
+    const result = lines.length === 1 ? lines[0] : `\n${lines.map((x) => `* ${x}`).join("\n")}\n`;
     return `/**${result}*/\n`;
 };
 export const addJsdocs = (schema, parsed) => {