ts-json-schema-generator 2.4.1--canary.2413.85be772.0 → 2.4.1--canary.2417.cbf58ef.0

package/factory/parser.ts

@@ -12,6 +12,7 @@ import { AnyTypeNodeParser } from "../src/NodeParser/AnyTypeNodeParser.js";
 import { ArrayLiteralExpressionNodeParser } from "../src/NodeParser/ArrayLiteralExpressionNodeParser.js";
 import { ArrayNodeParser } from "../src/NodeParser/ArrayNodeParser.js";
 import { AsExpressionNodeParser } from "../src/NodeParser/AsExpressionNodeParser.js";
+import { BinaryExpressionNodeParser } from "../src/NodeParser/BinaryExpressionNodeParser.js";
 import { BooleanLiteralNodeParser } from "../src/NodeParser/BooleanLiteralNodeParser.js";
 import { BooleanTypeNodeParser } from "../src/NodeParser/BooleanTypeNodeParser.js";
 import { CallExpressionParser } from "../src/NodeParser/CallExpressionParser.js";
@@ -62,6 +63,7 @@ import { SatisfiesNodeParser } from "../src/NodeParser/SatisfiesNodeParser.js";
 import { PromiseNodeParser } from "../src/NodeParser/PromiseNodeParser.js";
 import { SpreadElementNodeParser } from "../src/NodeParser/SpreadElementNodeParser.js";
 import { IdentifierNodeParser } from "../src/NodeParser/IdentifierNodeParser.js";
+import { castArray } from "../src/Utils/castArray.js";
 
 export type ParserAugmentor = (parser: MutableParser) => void;
 
@@ -73,7 +75,10 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         return new ExposeNodeParser(typeChecker, nodeParser, config.expose, config.jsDoc);
     }
     function withTopRef(nodeParser: NodeParser): NodeParser {
-        return new TopRefNodeParser(chainNodeParser, config.type, config.topRef);
+        const typeArr = castArray(config.type);
+        // If we have multiple types, don't set a top-level $ref.
+        const topRefFullName = typeArr && typeArr.length === 1 ? typeArr[0] : undefined;
+        return new TopRefNodeParser(chainNodeParser, topRefFullName, config.topRef);
     }
     function withJsDoc(nodeParser: SubNodeParser): SubNodeParser {
         const extraTags = new Set(config.extraTags);
@@ -114,6 +119,7 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         .addNodeParser(new NeverTypeNodeParser())
         .addNodeParser(new ObjectTypeNodeParser())
         .addNodeParser(new AsExpressionNodeParser(chainNodeParser))
+        .addNodeParser(new BinaryExpressionNodeParser(chainNodeParser))
         .addNodeParser(new SatisfiesNodeParser(chainNodeParser))
         .addNodeParser(withJsDoc(new ParameterParser(chainNodeParser)))
         .addNodeParser(new StringLiteralNodeParser())

package/factory/program.ts

@@ -1,10 +1,9 @@
-import { globSync } from "glob";
 import * as path from "node:path";
 import normalize from "normalize-path";
-import type { CompilerOptions } from "typescript";
 import ts from "typescript";
 import type { CompletedConfig, Config } from "../src/Config.js";
 import { BuildError } from "../src/Error/Errors.js";
+import { globSync } from "glob";
 
 function loadTsConfigFile(configFile: string) {
     const raw = ts.sys.readFile(configFile);
@@ -56,13 +55,10 @@ function getTsConfig(config: Config) {
             noEmit: true,
             emitDecoratorMetadata: true,
             experimentalDecorators: true,
-            target: ts.ScriptTarget.ES2022,
+            target: ts.ScriptTarget.ES5,
             module: ts.ModuleKind.CommonJS,
             strictNullChecks: false,
-            skipLibCheck: true,
-            skipDefaultLibCheck: true,
-            esModuleInterop: true,
-        } satisfies CompilerOptions,
+        },
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-json-schema-generator",
-  "version": "2.4.1--canary.2413.85be772.0",
+  "version": "2.4.1--canary.2417.cbf58ef.0",
   "description": "Generate JSON schema from your Typescript sources",
   "keywords": [
     "ts",
@@ -49,51 +49,53 @@
     "prepublishOnly": "npm run build",
     "release": "npm run build && auto shipit",
     "run": "tsx ts-json-schema-generator.ts",
-    "test": "tsx --test \"test/**/*.test.ts\"",
-    "test:fast": "cross-env FAST_TEST=1 tsx --test \"test/**/*.test.ts\"",
-    "test:update": "cross-env FAST_TEST=1 UPDATE_SCHEMA=true tsx --test \"test/**/*.test.ts\"",
-    "test:coverage": "c8 --reporter lcov --reporter text tsx --test \"test/**/*.test.ts\"",
+    "test": "jest test/ --verbose",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest test/ --verbose --runInBand",
+    "test:coverage": "npm run jest -- test/ --collectCoverage=true",
+    "test:fast": "cross-env FAST_TEST=1 jest test/ --verbose",
+    "test:update": "cross-env UPDATE_SCHEMA=true npm run test:fast",
     "watch": "tsc -w"
   },
   "dependencies": {
     "@types/json-schema": "^7.0.15",
-    "@typescript/vfs": "1.6.2",
-    "commander": "^14.0.0",
+    "commander": "^14.0.2",
     "glob": "^13.0.0",
     "json5": "^2.2.3",
     "normalize-path": "^3.0.0",
     "safe-stable-stringify": "^2.5.0",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3",
+    "@typescript/vfs": "1.6.2"
   },
   "devDependencies": {
-    "@auto-it/conventional-commits": "^11.3.0",
-    "@auto-it/first-time-contributor": "^11.3.0",
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
-    "@babel/preset-typescript": "^7.27.1",
-    "@eslint/js": "^9.30.1",
+    "@auto-it/conventional-commits": "^11.3.6",
+    "@auto-it/first-time-contributor": "^11.3.6",
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@eslint/js": "^9.39.1",
     "@types/eslint": "^9.6.1",
-    "@types/node": "^24.0.10",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.1",
     "@types/normalize-path": "^3.0.2",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "auto": "^11.3.0",
-    "c8": "^10.1.3",
-    "chai": "^6.0.1",
-    "cross-env": "^10.0.0",
+    "auto": "^11.3.6",
+    "chai": "^6.2.1",
+    "cross-env": "^10.1.0",
     "eslint": "9.39.1",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-prettier": "^5.5.1",
-    "globals": "^16.3.0",
-    "prettier": "^3.6.2",
-    "try": "^1.0.1",
-    "tsx": "^4.20.3",
-    "typescript-eslint": "^8.35.1",
-    "vega": "^6.1.2",
-    "vega-lite": "^6.2.0"
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.5.0",
+    "jest": "^30.2.0",
+    "jest-junit": "^16.0.0",
+    "prettier": "^3.7.3",
+    "tsx": "^4.21.0",
+    "typescript-eslint": "^8.48.0",
+    "vega": "^6.2.0",
+    "vega-lite": "^6.4.1"
   },
-  "packageManager": "npm@11.4.2",
+  "packageManager": "npm@11.6.4",
   "engines": {
     "node": ">=18.0.0"
   }

package/src/Config.ts

@@ -8,10 +8,10 @@ export interface Config {
     path?: string;
 
     /**
-     * Name of the type/interface to generate schema for.
+     * Name of the type(s)/interface(s) to generate schema for.
      * Use "*" to generate schemas for all exported types.
      */
-    type?: string;
+    type?: string | string[];
 
     /**
      * Minify the output JSON schema (no whitespace).

package/src/Error/BaseError.ts

@@ -12,6 +12,8 @@ export type PartialDiagnostic = Omit<ts.Diagnostic, "category" | "file" | "start
     category?: ts.DiagnosticCategory;
 };
 
+const isTTY = process.env.TTY || process.stdout.isTTY;
+
 /**
  * Base error for ts-json-schema-generator
  */
@@ -49,7 +51,7 @@ export abstract class BaseError extends Error {
         );
     }
 
-    format(isTTY = process.env.TTY || process.stdout.isTTY): string {
+    format() {
         const formatter = isTTY ? ts.formatDiagnosticsWithColorAndContext : ts.formatDiagnostics;
 
         return formatter([this.diagnostic], {

package/src/NodeParser/BinaryExpressionNodeParser.ts

@@ -0,0 +1,99 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import { AnyType } from "../Type/AnyType.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { BooleanType } from "../Type/BooleanType.js";
+import { LiteralType } from "../Type/LiteralType.js";
+import { NumberType } from "../Type/NumberType.js";
+import { StringType } from "../Type/StringType.js";
+import { UnionType } from "../Type/UnionType.js";
+import { AliasType } from "../Type/AliasType.js";
+
+export class BinaryExpressionNodeParser implements SubNodeParser {
+    public constructor(protected childNodeParser: NodeParser) {}
+
+    public supportsNode(node: ts.Node): boolean {
+        return node.kind === ts.SyntaxKind.BinaryExpression;
+    }
+
+    public createType(node: ts.BinaryExpression, context: Context): BaseType {
+        const leftType = this.childNodeParser.createType(node.left, context);
+        const rightType = this.childNodeParser.createType(node.right, context);
+
+        if (leftType instanceof AnyType || rightType instanceof AnyType) {
+            return new AnyType();
+        }
+
+        if (this.isStringLike(leftType) || this.isStringLike(rightType)) {
+            return new StringType();
+        }
+
+        if (this.isDefinitelyNumberLike(leftType) && this.isDefinitelyNumberLike(rightType)) {
+            return new NumberType();
+        }
+
+        if (this.isBooleanLike(leftType) && this.isBooleanLike(rightType)) {
+            return new BooleanType();
+        }
+
+        // Anything else (objects, any, unknown, weird unions, etc.) return
+        // 'string' because at runtime + will usually go through ToPrimitive and
+        // end up in the "string concatenation" branch when non-numeric stuff is
+        // involved.
+        return new StringType();
+    }
+
+    private isStringLike(type: BaseType): boolean {
+        if (type instanceof AliasType) {
+            return this.isStringLike(type.getType());
+        }
+
+        if (type instanceof StringType) {
+            return true;
+        }
+
+        if (type instanceof LiteralType && type.isString()) {
+            return true;
+        }
+
+        // Any union member being string-like is enough.
+        if (type instanceof UnionType) {
+            return type.getTypes().some((t) => this.isStringLike(t));
+        }
+
+        return false;
+    }
+
+    private isBooleanLike(type: BaseType): boolean {
+        if (type instanceof BooleanType) {
+            return true;
+        }
+
+        if (type instanceof LiteralType && typeof type.getValue() === "boolean") {
+            return true;
+        }
+
+        return false;
+    }
+
+    private isDefinitelyNumberLike(type: BaseType): boolean {
+        if (type instanceof AliasType) {
+            return this.isDefinitelyNumberLike(type.getType());
+        }
+
+        if (type instanceof NumberType) {
+            return true;
+        }
+
+        if (type instanceof LiteralType && typeof type.getValue() === "number") {
+            return true;
+        }
+
+        if (type instanceof UnionType) {
+            return type.getTypes().every((t) => this.isDefinitelyNumberLike(t));
+        }
+
+        return false;
+    }
+}

package/src/SchemaGenerator.ts

@@ -10,6 +10,7 @@ import type { TypeFormatter } from "./TypeFormatter.js";
 import type { StringMap } from "./Utils/StringMap.js";
 import { hasJsDocTag } from "./Utils/hasJsDocTag.js";
 import { removeUnreachable } from "./Utils/removeUnreachable.js";
+import { castArray } from "./Utils/castArray.js";
 import { symbolAtNode } from "./Utils/symbolAtNode.js";
 
 export class SchemaGenerator {
@@ -20,8 +21,8 @@ export class SchemaGenerator {
         protected readonly config?: Config,
     ) {}
 
-    public createSchema(fullName?: string): Schema {
-        const rootNodes = this.getRootNodes(fullName);
+    public createSchema(fullNames?: string | string[]): Schema {
+        const rootNodes = this.getRootNodes(castArray(fullNames));
         return this.createSchemaFromNodes(rootNodes);
     }
 
@@ -60,9 +61,15 @@ export class SchemaGenerator {
         };
     }
 
-    protected getRootNodes(fullName: string | undefined): ts.Node[] {
-        if (fullName && fullName !== "*") {
-            return [this.findNamedNode(fullName)];
+    protected getRootNodes(fullNames: string[] | undefined): ts.Node[] {
+        // ["*"] means generate everything.
+        if (fullNames && fullNames.includes("*") && fullNames.length > 1) {
+            throw new Error("Cannot mix '*' with specific type names");
+        }
+
+        const generateAll = !fullNames || fullNames.length === 0 || (fullNames.length === 1 && fullNames[0] === "*");
+        if (!generateAll) {
+            return fullNames.map((name) => this.findNamedNode(name));
         }
 
         const rootFileNames = this.program.getRootFileNames();

package/src/Type/AnnotatedType.ts

@@ -1,9 +1,7 @@
 import { BaseType } from "./BaseType.js";
 import { hash } from "../Utils/nodeKey.js";
 
-export interface Annotations {
-    [name: string]: any;
-}
+export type Annotations = Record<string, unknown>;
 
 export class AnnotatedType extends BaseType {
     public constructor(

package/src/Type/UnknownType.ts

@@ -5,7 +5,7 @@ export class UnknownType extends BaseType {
         /**
          * If the source for this UnknownType was from a failed operation than to an actual `unknown` type present in the source code.
          */
-        readonly erroredSource = false,
+        readonly erroredSource: boolean,
     ) {
         super();
     }

package/src/TypeFormatter/AnnotatedTypeFormatter.ts

@@ -8,7 +8,7 @@ import type { TypeFormatter } from "../TypeFormatter.js";
 import { derefType } from "../Utils/derefType.js";
 
 export function makeNullable(def: Definition): Definition {
-    const union = (def.oneOf || def.anyOf) as Definition[] | undefined;
+    const union: Definition[] | undefined = (def.oneOf as Definition[]) || def.anyOf;
     if (union && union.filter((d: Definition) => d.type === "null").length === 0) {
         union.push({ type: "null" });
     } else if (def.type && def.type !== "object") {
@@ -58,7 +58,7 @@ export class AnnotatedTypeFormatter implements SubTypeFormatter {
         if ("discriminator" in annotations) {
             const deref = derefType(type.getType());
             if (deref instanceof UnionType) {
-                deref.setDiscriminator(annotations.discriminator);
+                deref.setDiscriminator(annotations.discriminator as string);
                 delete annotations.discriminator;
             } else {
                 throw new JsonTypeError(

package/src/Utils/castArray.ts

@@ -0,0 +1,7 @@
+export function castArray<T>(input: undefined | T | T[]): undefined | T[] {
+    if (input === undefined) {
+        return undefined;
+    }
+
+    return Array.isArray(input) ? input : [input];
+}

package/src/Utils/narrowType.ts

@@ -16,12 +16,7 @@ import { derefType } from "./derefType.js";
  *                    kept, when returning false it is removed.
  * @return The narrowed down type.
  */
-export function narrowType(
-    type: BaseType,
-    // TODO: remove the next line
-
-    predicate: (type: BaseType) => boolean,
-): BaseType {
+export function narrowType(type: BaseType, predicate: (type: BaseType) => boolean): BaseType {
     const derefed = derefType(type);
     if (derefed instanceof UnionType || derefed instanceof EnumType) {
         let changed = false;

package/src/Utils/nodeKey.ts

@@ -2,7 +2,9 @@ import stringify from "safe-stable-stringify";
 import type { Node } from "typescript";
 import type { Context } from "../NodeParser.js";
 
-export function hash(a: string | boolean | number | (string | boolean | number)[] | object): string | number {
+export function hash(
+    a: string | boolean | number | (string | boolean | number | Record<string, unknown>)[] | Record<string, unknown>,
+): string | number {
     if (typeof a === "number") {
         return a;
     }

package/ts-json-schema-generator.ts

@@ -11,14 +11,14 @@ import pkg from "./package.json";
 
 const args = new Command()
     .option("-p, --path <path>", "Source file path")
-    .option("-t, --type <name>", "Type name")
+    .option("-t, --type <name...>", "Type name(s)")
     .option("-i, --id <name>", "$id for generated schema")
     .option("-f, --tsconfig <path>", "Custom tsconfig.json path")
     .addOption(
         new Option("-e, --expose <expose>", "Type exposing").choices(["all", "none", "export"]).default("export"),
     )
     .addOption(
-        new Option("-j, --jsDoc <extended>", "Read JsDoc annotations")
+        new Option("-j, --jsDoc <extended>", "Read JSDoc annotations")
             .choices(["none", "basic", "extended"])
             .default("extended"),
     )
@@ -84,7 +84,7 @@ const config: Config = {
 };
 
 try {
-    const schema = createGenerator(config).createSchema(args.type);
+    const schema = createGenerator(config).createSchema(config.type);
 
     const stringify = config.sortProps ? stableStringify : JSON.stringify;
     // need as string since TS can't figure out that the string | undefined case doesn't happen