ts-json-schema-generator 2.5.0--canary.76e1a68.0 → 2.5.0--canary.2413.011011e.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 { 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);
@@ -55,10 +56,13 @@ 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,
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-json-schema-generator",
-  "version": "2.5.0--canary.76e1a68.0",
+  "version": "2.5.0--canary.2413.011011e.0",
   "description": "Generate JSON schema from your Typescript sources",
   "keywords": [
     "ts",
@@ -49,52 +49,51 @@
     "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",
+    "@typescript/vfs": "1.6.2",
+    "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/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",
+    "@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/jest": "^30.0.0",
-    "@types/node": "^24.0.10",
+    "@types/node": "^24.10.1",
     "@types/normalize-path": "^3.0.2",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "auto": "^11.3.0",
-    "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",
-    "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"
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.5.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"
   }

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/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;
     }