ts-json-schema-generator 2.4.1-next.1 → 2.5.0--canary.2413.011011e.0

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/TypeFormatter/LiteralUnionTypeFormatter.ts

@@ -55,12 +55,18 @@ export class LiteralUnionTypeFormatter implements SubTypeFormatter {
             appendTypeValues(type, typeValues);
         }
 
-        const schema = {
-            type: toEnumType(Array.from(typeNames)),
-            enum: Array.from(typeValues),
-        };
-
-        return preserveLiterals ? { anyOf: [{ type: "string" }, schema] } : schema;
+        const schema =
+            typeNames.size === 1 && typeValues.size === 1
+                ? {
+                      type: toEnumType(Array.from(typeNames)),
+                      const: Array.from(typeValues)[0],
+                  }
+                : {
+                      type: toEnumType(Array.from(typeNames)),
+                      enum: Array.from(typeValues),
+                  };
+
+        return hasString ? { anyOf: [{ type: "string" }, schema] } : schema;
     }
 
     public getChildren(): BaseType[] {

package/src/TypeFormatter/PrimitiveUnionTypeFormatter.ts

@@ -6,7 +6,6 @@ import type { BaseType } from "../Type/BaseType.js";
 import { BooleanType } from "../Type/BooleanType.js";
 import { NullType } from "../Type/NullType.js";
 import { NumberType } from "../Type/NumberType.js";
-import { PrimitiveType } from "../Type/PrimitiveType.js";
 import { StringType } from "../Type/StringType.js";
 import { UnionType } from "../Type/UnionType.js";
 import { uniqueArray } from "../Utils/uniqueArray.js";
@@ -25,7 +24,15 @@ export class PrimitiveUnionTypeFormatter implements SubTypeFormatter {
     }
 
     protected isPrimitiveUnion(type: UnionType): boolean {
-        return type.getTypes().every((item) => item instanceof PrimitiveType);
+        return type
+            .getTypes()
+            .every(
+                (item) =>
+                    item instanceof StringType ||
+                    item instanceof NumberType ||
+                    item instanceof BooleanType ||
+                    item instanceof NullType,
+            );
     }
 
     protected getPrimitiveType(item: BaseType): RawTypeName {

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

@@ -0,0 +1,39 @@
+import ts from "typescript";
+
+export function getFullDescription(node: ts.Node): string | undefined {
+    const sourceFile = node.getSourceFile();
+    const jsDocNodes = ts.getJSDocCommentsAndTags(node);
+
+    if (!jsDocNodes || jsDocNodes.length === 0) {
+        return undefined;
+    }
+
+    let rawText = "";
+
+    for (const jsDoc of jsDocNodes) {
+        rawText += jsDoc.getFullText(sourceFile) + "\n";
+    }
+
+    rawText = rawText.trim();
+
+    return getTextWithoutStars(rawText).trim();
+}
+
+function getTextWithoutStars(inputText: string) {
+    const innerTextWithStars = inputText.replace(/^\/\*\*[^\S\n]*\n?/, "").replace(/(\r?\n)?[^\S\n]*\*\/$/, "");
+
+    return innerTextWithStars
+        .split(/\n/)
+        .map((line) => {
+            const trimmedLine = line.trimStart();
+
+            if (trimmedLine[0] !== "*") {
+                return line;
+            }
+
+            const textStartPos = trimmedLine[1] === " " ? 2 : 1;
+
+            return trimmedLine.substring(textStartPos);
+        })
+        .join("\n");
+}

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,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"),
     )
@@ -27,6 +27,14 @@ const args = new Command()
             jsDoc: "extended",
         }),
     )
+    .addOption(
+        new Option(
+            "--full-description",
+            "Include the full raw JSDoc comment as `fullDescription` in the schema.",
+        ).implies({
+            jsDoc: "extended",
+        }),
+    )
     .addOption(
         new Option(
             "--functions <functions>",
@@ -65,6 +73,7 @@ const config: Config = {
     topRef: args.topRef,
     jsDoc: args.jsDoc,
     markdownDescription: args.markdownDescription,
+    fullDescription: args.fullDescription,
     sortProps: !args.unstable,
     strictTuples: args.strictTuples,
     skipTypeCheck: !args.typeCheck,
@@ -75,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