ts-json-schema-generator 2.4.1--canary.2306.1ddde9f.0 → 2.4.1--canary.2413.e57678e.0

package/factory/generator.ts

@@ -7,7 +7,7 @@ import { createProgram } from "./program.js";
 
 export function createGenerator(config: Config): SchemaGenerator {
     const completedConfig = { ...DEFAULT_CONFIG, ...config };
-    const program = createProgram(completedConfig);
+    const program = config.tsProgram || createProgram(completedConfig);
     const parser = createParser(program, completedConfig);
     const formatter = createFormatter(completedConfig);
 

package/factory/parser.ts

@@ -16,6 +16,7 @@ import { BooleanLiteralNodeParser } from "../src/NodeParser/BooleanLiteralNodePa
 import { BooleanTypeNodeParser } from "../src/NodeParser/BooleanTypeNodeParser.js";
 import { CallExpressionParser } from "../src/NodeParser/CallExpressionParser.js";
 import { ConditionalTypeNodeParser } from "../src/NodeParser/ConditionalTypeNodeParser.js";
+import { NewExpressionParser } from "../src/NodeParser/NewExpressionParser.js";
 import { ConstructorNodeParser } from "../src/NodeParser/ConstructorNodeParser.js";
 import { EnumNodeParser } from "../src/NodeParser/EnumNodeParser.js";
 import { ExpressionWithTypeArgumentsNodeParser } from "../src/NodeParser/ExpressionWithTypeArgumentsNodeParser.js";
@@ -149,6 +150,7 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         .addNodeParser(new SpreadElementNodeParser(chainNodeParser))
 
         .addNodeParser(new CallExpressionParser(typeChecker, chainNodeParser))
+        .addNodeParser(new NewExpressionParser(typeChecker, chainNodeParser))
         .addNodeParser(new PropertyAccessExpressionParser(typeChecker, chainNodeParser))
 
         .addNodeParser(withCircular(withExpose(withJsDoc(new TypeAliasNodeParser(typeChecker, chainNodeParser)))))

package/factory/program.ts

@@ -1,9 +1,9 @@
+import { globSync } from "glob";
 import * as path from "node:path";
 import normalize from "normalize-path";
-import ts from "typescript";
+import ts, { CompilerOptions } 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 +55,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.4.1--canary.2306.1ddde9f.0",
+  "version": "2.4.1--canary.2413.e57678e.0",
   "description": "Generate JSON schema from your Typescript sources",
   "keywords": [
     "ts",
@@ -49,16 +49,17 @@
     "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": "tsx --test \"test/**/*.test.ts\"",
+    "test:coverage": "c8 --reporter lcov --reporter text npm run test",
+    "test:fast": "cross-env FAST_TEST=1 npm run test",
     "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",
-    "glob": "^11.0.3",
+    "glob": "^13.0.0",
     "json5": "^2.2.3",
     "normalize-path": "^3.0.0",
     "safe-stable-stringify": "^2.5.0",
@@ -73,21 +74,20 @@
     "@babel/preset-typescript": "^7.27.1",
     "@eslint/js": "^9.30.1",
     "@types/eslint": "^9.6.1",
-    "@types/jest": "^30.0.0",
     "@types/node": "^24.0.10",
     "@types/normalize-path": "^3.0.2",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "auto": "^11.3.0",
-    "chai": "^5.2.0",
-    "cross-env": "^7.0.3",
-    "eslint": "9.30.1",
+    "c8": "^10.1.3",
+    "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",
+    "try": "^1.0.1",
     "tsx": "^4.20.3",
     "typescript-eslint": "^8.35.1",
     "vega": "^6.1.2",

package/src/Config.ts

@@ -1,29 +1,149 @@
+import type ts from "typescript";
+
 export interface Config {
+    /**
+     * Glob pattern(s) for source TypeScript files to process.
+     * If not provided, falls back to files from tsconfig.
+     */
     path?: string;
+
+    /**
+     * Name of the type/interface to generate schema for.
+     * Use "*" to generate schemas for all exported types.
+     */
     type?: string;
+
+    /**
+     * Minify the output JSON schema (no whitespace).
+     * When false, the schema is pretty-printed with 2-space indentation.
+     * @default false
+     */
     minify?: boolean;
+
+    /**
+     * Sets the `$id` property in the root of the generated schema.
+     * Used for schema identification and referencing.
+     */
     schemaId?: string;
+
+    /**
+     * Path to a custom tsconfig.json file for TypeScript compilation.
+     * If not provided, uses default TypeScript configuration.
+     */
     tsconfig?: string;
+
+    /**
+     * Controls which types are exposed as definitions in the schema.
+     * - "all": Exposes all types except type literals
+     * - "none": Exposes no types automatically
+     * - "export": Only exposes exported types (respects @internal JSDoc tag)
+     * @default "export"
+     */
     expose?: "all" | "none" | "export";
+
+    /**
+     * Wraps the root type in a `$ref` definition.
+     * When false, inlines the root type definition directly.
+     * @default true
+     */
     topRef?: boolean;
+
+    /**
+     * Controls how JSDoc comments are parsed and included in the schema.
+     * - "none": Ignores all JSDoc annotations
+     * - "basic": Parses standard JSON Schema JSDoc tags
+     * - "extended": Parses all tags plus descriptions, examples, and type overrides
+     * @default "extended"
+     */
     jsDoc?: "none" | "extended" | "basic";
+
+    /**
+     * Adds a `markdownDescription` field alongside `description` in the schema.
+     * Preserves markdown formatting including newlines.
+     * Only works with `jsDoc: "extended"`.
+     * @default false
+     */
     markdownDescription?: boolean;
+
+    /**
+     * Includes the complete raw JSDoc comment as `fullDescription` in the schema.
+     * Only works with `jsDoc: "extended"`.
+     * @default false
+     */
     fullDescription?: boolean;
+
+    /**
+     * Sorts object properties alphabetically in the output.
+     * @default true
+     */
     sortProps?: boolean;
+
+    /**
+     * Controls whether tuples allow additional items beyond their defined length.
+     * @default false
+     */
     strictTuples?: boolean;
+
+    /**
+     * Skips TypeScript type checking to improve performance.
+     * Speeds up generation but may miss type errors.
+     * @default false
+     */
     skipTypeCheck?: boolean;
+
+    /**
+     * URI-encodes `$ref` values (e.g., `#/definitions/Foo%3CBar%3E`).
+     * When false, uses raw names in reference paths.
+     * @default true
+     */
     encodeRefs?: boolean;
+
+    /**
+     * Array of additional JSDoc tag names to include in the schema.
+     * Custom tags (e.g., `@customProperty`) are parsed and included in output.
+     * Values are parsed as JSON5.
+     * @default []
+     */
     extraTags?: string[];
+
+    /**
+     * Sets default value for `additionalProperties` on objects without index signatures.
+     * When false, objects get `additionalProperties: false` by default.
+     * When true, allows additional properties on all objects.
+     * @default false
+     */
     additionalProperties?: boolean;
+
+    /**
+     * Controls discriminator style for discriminated unions.
+     * - "json-schema": Uses `if`/`then`/`allOf` with properties containing discriminator enum
+     * - "open-api": Uses OpenAPI 3.x style with `discriminator: { propertyName }` and `oneOf`
+     * @default "json-schema"
+     */
     discriminatorType?: "json-schema" | "open-api";
+
+    /**
+     * Controls how function types are handled in the schema.
+     * - "fail": Throws error when encountering function types
+     * - "comment": Generates schema with `$comment` describing the function signature
+     * - "hide": Treats functions as NeverType (excluded from schema)
+     * @default "comment"
+     */
     functions?: FunctionOptions;
+
+    /**
+     * Pre-compiled TypeScript Program instance to use.
+     * Bypasses the default setup of a TypeScript program, and so some configuration options may not be applied.
+     * Useful for programmatic usage with existing TypeScript compilation, or for vfs scenarios where you do not want file-system representation.
+     */
+    tsProgram?: ts.Program;
 }
 
 export type CompletedConfig = Config & typeof DEFAULT_CONFIG;
 
 export type FunctionOptions = "fail" | "comment" | "hide";
 
-export const DEFAULT_CONFIG: Omit<Required<Config>, "path" | "type" | "schemaId" | "tsconfig"> = {
+export const DEFAULT_CONFIG: Omit<Required<Config>, "path" | "type" | "schemaId" | "tsconfig" | "tsProgram"> = {
     expose: "export",
     topRef: true,
     jsDoc: "extended",

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/NewExpressionParser.ts

@@ -0,0 +1,46 @@
+import ts from "typescript";
+import type { NodeParser } from "../NodeParser.js";
+import { Context } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { UnknownNodeError } from "../Error/Errors.js";
+
+export class NewExpressionParser implements SubNodeParser {
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser,
+    ) {}
+
+    public supportsNode(node: ts.NewExpression): boolean {
+        return node.kind === ts.SyntaxKind.NewExpression;
+    }
+
+    public createType(node: ts.NewExpression, context: Context): BaseType {
+        const type = this.typeChecker.getTypeAtLocation(node);
+
+        const symbol = type.symbol || type.aliasSymbol;
+
+        const decl =
+            this.typeChecker.typeToTypeNode(type, node, ts.NodeBuilderFlags.IgnoreErrors) ||
+            symbol?.valueDeclaration ||
+            symbol?.declarations?.[0];
+
+        if (!decl) {
+            throw new UnknownNodeError(node);
+        }
+
+        return this.childNodeParser.createType(decl, this.createSubContext(node, context));
+    }
+
+    protected createSubContext(node: ts.NewExpression, parentContext: Context): Context {
+        const subContext = new Context(node);
+
+        if (node.arguments) {
+            for (const arg of node.arguments) {
+                const type = this.childNodeParser.createType(arg, parentContext);
+                subContext.pushArgument(type);
+            }
+        }
+        return subContext;
+    }
+}

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") {