ts-json-schema-generator 2.5.0-next.8 → 2.5.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";
@@ -118,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,9 +1,10 @@
 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";
+import fs from "node:fs";
 
 function loadTsConfigFile(configFile: string) {
     const raw = ts.sys.readFile(configFile);
@@ -55,16 +56,19 @@ function getTsConfig(config: Config) {
             noEmit: true,
             emitDecoratorMetadata: true,
             experimentalDecorators: true,
-            target: ts.ScriptTarget.ES5,
+            target: ts.ScriptTarget.ES2022,
             module: ts.ModuleKind.CommonJS,
             strictNullChecks: false,
-        },
+            skipLibCheck: true,
+            skipDefaultLibCheck: true,
+            esModuleInterop: true,
+        } satisfies CompilerOptions,
     };
 }
 
 export function createProgram(config: CompletedConfig): ts.Program {
     const rootNamesFromPath = config.path
-        ? globSync(normalize(path.resolve(config.path))).map((rootName) => normalize(rootName))
+        ? fs.globSync(normalize(path.resolve(config.path))).map((rootName) => normalize(rootName))
         : [];
     const tsconfig = getTsConfig(config);
     const rootNames = rootNamesFromPath.length ? rootNamesFromPath : tsconfig.fileNames;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-json-schema-generator",
-  "version": "2.5.0-next.8",
+  "version": "2.5.0",
   "description": "Generate JSON schema from your Typescript sources",
   "keywords": [
     "ts",
@@ -49,53 +49,48 @@
     "prepublishOnly": "npm run build",
     "release": "npm run build && auto shipit",
     "run": "tsx ts-json-schema-generator.ts",
-    "test": "jest test/ --verbose",
-    "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",
+    "test": "tsx --test \"test/**/*.test.ts\"",
+    "test:debug": "tsx --inspect-brk --test-concurrency=1 --test",
+    "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\"",
     "watch": "tsc -w"
   },
   "dependencies": {
     "@types/json-schema": "^7.0.15",
-    "commander": "^14.0.0",
-    "glob": "^13.0.0",
+    "commander": "^14.0.2",
     "json5": "^2.2.3",
     "normalize-path": "^3.0.0",
     "safe-stable-stringify": "^2.5.0",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.3",
-    "@typescript/vfs": "1.6.2"
+    "typescript": "^5.9.3"
   },
   "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",
+    "@eslint/js": "^9.39.1",
     "@types/eslint": "^9.6.1",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^24.0.10",
+    "@types/node": "^24.10.1",
     "@types/normalize-path": "^3.0.2",
+    "@typescript/vfs": "1.6.2",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "auto": "^11.3.0",
-    "chai": "^6.0.1",
-    "cross-env": "^10.0.0",
-    "eslint": "9.39.1",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-prettier": "^5.5.1",
-    "globals": "^16.3.0",
-    "jest": "^30.0.4",
-    "jest-junit": "^16.0.0",
-    "prettier": "^3.6.2",
-    "tsx": "^4.20.3",
-    "typescript-eslint": "^8.35.1",
-    "vega": "^6.1.2",
-    "vega-lite": "^6.2.0"
+    "auto": "^11.3.6",
+    "c8": "^10.1.3",
+    "cross-env": "^10.1.0",
+    "eslint": "9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^17.0.0",
+    "prettier": "^3.7.3",
+    "try": "^1.0.1",
+    "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"
+    "node": ">=22.0.0"
   }
 }

package/src/Error/BaseError.ts

@@ -12,8 +12,6 @@ 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
  */
@@ -51,7 +49,7 @@ export abstract class BaseError extends Error {
         );
     }
 
-    format() {
+    format(isTTY = process.env.TTY || process.stdout.isTTY): string {
         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/NodeParser/IndexedAccessTypeNodeParser.ts

@@ -79,7 +79,10 @@ export class IndexedAccessTypeNodeParser implements SubNodeParser {
                         return objectType;
                     }
 
-                    throw new LogicError(node, `Invalid index "${type.getValue()}" in type "${objectType.getId()}"`);
+                    // When the indexed property does not exist (e.g. constrained generics with
+                    // narrower instantiations), treat it as never so optional properties are dropped
+                    // instead of throwing.
+                    return new NeverType();
                 }
 
                 throw new LogicError(node, `No additional properties in type "${objectType.getId()}"`);

package/src/NodeParser/MappedTypeNodeParser.ts

@@ -4,6 +4,7 @@ import type { NodeParser } from "../NodeParser.js";
 import { Context } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import { AnnotatedType } from "../Type/AnnotatedType.js";
+import { AnyType } from "../Type/AnyType.js";
 import { ArrayType } from "../Type/ArrayType.js";
 import type { BaseType } from "../Type/BaseType.js";
 import { DefinitionType } from "../Type/DefinitionType.js";
@@ -52,18 +53,21 @@ export class MappedTypeNodeParser implements SubNodeParser {
             return new ObjectType(id, [], this.getProperties(node, new UnionType([keyListType]), context), false);
         }
 
+        const maybeUnionType = this.childNodeParser.createType(
+            node.type!,
+            this.createSubContext(node, keyListType, context),
+        );
+        if (maybeUnionType instanceof UnionType && constraintType?.getId() === "number") {
+            // Then we turn it into an array
+            return maybeUnionType instanceof NeverType ? new NeverType() : new ArrayType(maybeUnionType);
+        }
+
         if (
             keyListType instanceof StringType ||
             keyListType instanceof NumberType ||
-            keyListType instanceof SymbolType
+            keyListType instanceof SymbolType ||
+            keyListType instanceof AnyType
         ) {
-            if (constraintType?.getId() === "number") {
-                const type = this.childNodeParser.createType(
-                    node.type!,
-                    this.createSubContext(node, keyListType, context),
-                );
-                return type instanceof NeverType ? new NeverType() : new ArrayType(type);
-            }
             // Key type widens to `string`
             const type = this.childNodeParser.createType(node.type!, this.createSubContext(node, keyListType, context));
             // const resultType = type instanceof NeverType ? new NeverType() : new ObjectType(id, [], [], type);

package/src/SchemaGenerator.ts

@@ -8,6 +8,7 @@ import type { BaseType } from "./Type/BaseType.js";
 import { DefinitionType } from "./Type/DefinitionType.js";
 import type { TypeFormatter } from "./TypeFormatter.js";
 import type { StringMap } from "./Utils/StringMap.js";
+import { AnnotatedType } from "./Type/AnnotatedType.js";
 import { hasJsDocTag } from "./Utils/hasJsDocTag.js";
 import { removeUnreachable } from "./Utils/removeUnreachable.js";
 import { castArray } from "./Utils/castArray.js";
@@ -124,21 +125,35 @@ export class SchemaGenerator {
             });
 
         const ids = new Map<string, string>();
+        const baseIds = new Map<string, string>();
         for (const child of children) {
             const name = child.getName();
             const previousId = ids.get(name);
-            // remove def prefix from ids to avoid false alarms
-            // FIXME: we probably shouldn't be doing this as there is probably something wrong with the deduplication
+            // Strip def- prefixes from IDs. DefinitionType.getId() returns "def-{innerType.getId()}"
+            // and for generic types, nested DefinitionTypes also add def- prefixes. Stripping all
+            // of them normalizes the comparison for types that may be wrapped differently.
             const childId = child.getId().replace(/def-/g, "");
+            // Also track the base type ID (without AnnotatedType wrapper) to handle cases where
+            // the same type appears with different annotations (e.g., a discriminated union type
+            // referenced directly vs from a property - one has @discriminator annotation, one doesn't)
+            const innerType = child.getType();
+            const baseChildId = (innerType instanceof AnnotatedType ? innerType.getType() : innerType).getId();
+            const previousBaseId = baseIds.get(name);
 
             if (previousId && childId !== previousId) {
+                // Check if the base type (without annotations) matches - if so, it's just
+                // annotation differences, not truly different types
+                if (previousBaseId === baseChildId) {
+                    continue;
+                }
                 throw new MultipleDefinitionsError(
                     name,
                     child,
-                    children.find((c) => c.getId() === previousId),
+                    children.find((c) => c.getId().replace(/def-/g, "") === previousId),
                 );
             }
             ids.set(name, childId);
+            baseIds.set(name, baseChildId);
         }
 
         children.reduce((definitions, child) => {

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: boolean,
+        readonly erroredSource = false,
     ) {
         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: Definition[] | undefined = (def.oneOf as Definition[]) || def.anyOf;
+    const union = (def.oneOf || def.anyOf) as Definition[] | undefined;
     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/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
-    // eslint-disable-next-line no-shadow
-    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,23 +11,14 @@ import pkg from "./package.json";
 
 const args = new Command()
     .option("-p, --path <path>", "Source file path")
-    .option(
-        "-t, --type <name>",
-        "Type name (can be passed multiple times)",
-        (value: string, previous: string[] | undefined) => {
-            if (previous) {
-                return previous.concat(value);
-            }
-            return [value];
-        },
-    )
+    .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"),
     )