typia 7.0.0-dev.20241003 → 7.0.0-dev.20241007

package/src/executable/setup/PluginConfigurator.ts

@@ -1,69 +1,69 @@
-import comments from "comment-json";
-import fs from "fs";
-
-import { TypiaSetupWizard } from "../TypiaSetupWizard";
-
-export namespace PluginConfigurator {
-  export async function configure(
-    args: TypiaSetupWizard.IArguments,
-  ): Promise<void> {
-    // GET COMPILER-OPTIONS
-    const config: comments.CommentObject = comments.parse(
-      await fs.promises.readFile(args.project!, "utf8"),
-    ) as comments.CommentObject;
-    const compilerOptions = config.compilerOptions as
-      | comments.CommentObject
-      | undefined;
-    if (compilerOptions === undefined)
-      throw new ReferenceError(
-        `${args.project} file does not have "compilerOptions" property.`,
-      );
-
-    // PREPARE PLUGINS
-    const plugins: comments.CommentArray<comments.CommentObject> = (() => {
-      const plugins = compilerOptions.plugins as
-        | comments.CommentArray<comments.CommentObject>
-        | undefined;
-      if (plugins === undefined) return (compilerOptions.plugins = [] as any);
-      else if (!Array.isArray(plugins))
-        throw new TypeError(
-          `"plugins" property of ${args.project} must be array type.`,
-        );
-      return plugins;
-    })();
-
-    const strict: boolean | undefined = compilerOptions.strict as
-      | boolean
-      | undefined;
-    const strictNullChecks: boolean | undefined =
-      compilerOptions.strictNullChecks as boolean | undefined;
-    const oldbie: comments.CommentObject | undefined = plugins.find(
-      (p) =>
-        typeof p === "object" &&
-        p !== null &&
-        p.transform === "typia/lib/transform",
-    );
-    if (
-      strictNullChecks !== false &&
-      (strict === true || strictNullChecks === true) &&
-      oldbie !== undefined
-    )
-      return;
-
-    // DO CONFIGURE
-    compilerOptions.strictNullChecks = true;
-    if (strict === undefined && strictNullChecks === undefined)
-      compilerOptions.strict = true;
-    if (oldbie === undefined)
-      plugins.push(
-        comments.parse(`
-                        {
-                            "transform": "typia/lib/transform"
-                        }`) as comments.CommentObject,
-      );
-    await fs.promises.writeFile(
-      args.project!,
-      comments.stringify(config, null, 2),
-    );
-  }
-}
+import comments from "comment-json";
+import fs from "fs";
+
+import { TypiaSetupWizard } from "../TypiaSetupWizard";
+
+export namespace PluginConfigurator {
+  export async function configure(
+    args: TypiaSetupWizard.IArguments,
+  ): Promise<void> {
+    // GET COMPILER-OPTIONS
+    const config: comments.CommentObject = comments.parse(
+      await fs.promises.readFile(args.project!, "utf8"),
+    ) as comments.CommentObject;
+    const compilerOptions = config.compilerOptions as
+      | comments.CommentObject
+      | undefined;
+    if (compilerOptions === undefined)
+      throw new ReferenceError(
+        `${args.project} file does not have "compilerOptions" property.`,
+      );
+
+    // PREPARE PLUGINS
+    const plugins: comments.CommentArray<comments.CommentObject> = (() => {
+      const plugins = compilerOptions.plugins as
+        | comments.CommentArray<comments.CommentObject>
+        | undefined;
+      if (plugins === undefined) return (compilerOptions.plugins = [] as any);
+      else if (!Array.isArray(plugins))
+        throw new TypeError(
+          `"plugins" property of ${args.project} must be array type.`,
+        );
+      return plugins;
+    })();
+
+    const strict: boolean | undefined = compilerOptions.strict as
+      | boolean
+      | undefined;
+    const strictNullChecks: boolean | undefined =
+      compilerOptions.strictNullChecks as boolean | undefined;
+    const oldbie: comments.CommentObject | undefined = plugins.find(
+      (p) =>
+        typeof p === "object" &&
+        p !== null &&
+        p.transform === "typia/lib/transform",
+    );
+    if (
+      strictNullChecks !== false &&
+      (strict === true || strictNullChecks === true) &&
+      oldbie !== undefined
+    )
+      return;
+
+    // DO CONFIGURE
+    compilerOptions.strictNullChecks = true;
+    if (strict === undefined && strictNullChecks === undefined)
+      compilerOptions.strict = true;
+    if (oldbie === undefined)
+      plugins.push(
+        comments.parse(`
+                        {
+                            "transform": "typia/lib/transform"
+                        }`) as comments.CommentObject,
+      );
+    await fs.promises.writeFile(
+      args.project!,
+      comments.stringify(config, null, 2),
+    );
+  }
+}

package/src/executable/typia.ts

@@ -1,55 +1,55 @@
-#!/usr/bin/env node
-const USAGE = `Wrong command has been detected. Use like below:
-
-  npx typia setup \\
-    --manager (npm|pnpm|yarn) \\
-    --project {tsconfig.json file path}
-
-    - npx typia setup
-    - npx typia setup --manager pnpm
-    - npx typia setup --project tsconfig.test.json
-
-  npx typia generate 
-    --input {directory} \\
-    --output {directory}
-
-    --npx typia generate --input src/templates --output src/functinoal
-`;
-
-const halt = (desc: string): never => {
-  console.error(desc);
-  process.exit(-1);
-};
-
-const main = async (): Promise<void> => {
-  try {
-    await import("comment-json");
-    await import("inquirer");
-    await import("commander");
-  } catch {
-    halt(`typia has not been installed. Run "npm i typia" before.`);
-  }
-
-  const type: string | undefined = process.argv[2];
-  if (type === "setup") {
-    const { TypiaSetupWizard } = await import("./TypiaSetupWizard");
-    await TypiaSetupWizard.setup();
-  } else if (type === "patch") {
-    const { TypiaPatchWizard } = await import("./TypiaPatchWizard");
-    await TypiaPatchWizard.main();
-  } else if (type === "generate") {
-    try {
-      await import("typescript");
-    } catch {
-      halt(
-        `typescript has not been installed. Run "npm i -D typescript" before.`,
-      );
-    }
-    const { TypiaGenerateWizard } = await import("./TypiaGenerateWizard");
-    await TypiaGenerateWizard.generate();
-  } else halt(USAGE);
-};
-main().catch((exp) => {
-  console.error(exp);
-  process.exit(-1);
-});
+#!/usr/bin/env node
+const USAGE = `Wrong command has been detected. Use like below:
+
+  npx typia setup \\
+    --manager (npm|pnpm|yarn) \\
+    --project {tsconfig.json file path}
+
+    - npx typia setup
+    - npx typia setup --manager pnpm
+    - npx typia setup --project tsconfig.test.json
+
+  npx typia generate 
+    --input {directory} \\
+    --output {directory}
+
+    --npx typia generate --input src/templates --output src/functinoal
+`;
+
+const halt = (desc: string): never => {
+  console.error(desc);
+  process.exit(-1);
+};
+
+const main = async (): Promise<void> => {
+  try {
+    await import("comment-json");
+    await import("inquirer");
+    await import("commander");
+  } catch {
+    halt(`typia has not been installed. Run "npm i typia" before.`);
+  }
+
+  const type: string | undefined = process.argv[2];
+  if (type === "setup") {
+    const { TypiaSetupWizard } = await import("./TypiaSetupWizard");
+    await TypiaSetupWizard.setup();
+  } else if (type === "patch") {
+    const { TypiaPatchWizard } = await import("./TypiaPatchWizard");
+    await TypiaPatchWizard.main();
+  } else if (type === "generate") {
+    try {
+      await import("typescript");
+    } catch {
+      halt(
+        `typescript has not been installed. Run "npm i -D typescript" before.`,
+      );
+    }
+    const { TypiaGenerateWizard } = await import("./TypiaGenerateWizard");
+    await TypiaGenerateWizard.generate();
+  } else halt(USAGE);
+};
+main().catch((exp) => {
+  console.error(exp);
+  process.exit(-1);
+});

package/src/factories/CommentFactory.ts

@@ -1,79 +1,79 @@
-import ts from "typescript";
-
-export namespace CommentFactory {
-  export const description = (
-    symbol: ts.Symbol,
-    includeTags: boolean = false,
-  ): string | undefined => {
-    const node = symbol.declarations?.[0];
-    if (!node) return undefined;
-
-    // FOR LEGACY TS < 5.2
-    const [major, minor] = ts.versionMajorMinor.split(".").map(Number) as [
-      number,
-      number,
-    ];
-    if (major < 5 || (major === 5 && minor < 1)) {
-      const content: string[] = [];
-      const main: string = ts.displayPartsToString(
-        symbol.getDocumentationComment(undefined),
-      );
-      if (main.length) {
-        content.push(main);
-        if (includeTags && symbol.getJsDocTags().length) content.push("");
-      }
-      if (includeTags)
-        for (const tag of symbol.getJsDocTags()) {
-          content.push(
-            tag.text
-              ? `@${tag.name} ${ts.displayPartsToString(tag.text)}`
-              : `@${tag.name}`,
-          );
-        }
-      return content.length
-        ? content.map((line) => line.split("\r\n").join("\n")).join("\n")
-        : undefined;
-    }
-
-    // NEW FEATURE OF TS 5.2
-    const elements: readonly (ts.JSDoc | ts.JSDocTag)[] =
-      ts.getJSDocCommentsAndTags(node);
-    if (elements.length === 0) return undefined;
-
-    const content: string[] = [];
-    for (const comment of elements) {
-      if (ts.isJSDoc(comment)) {
-        const parsed: string | undefined = ts.getTextOfJSDocComment(
-          comment.comment,
-        );
-        if (parsed?.length) {
-          content.push(parsed);
-          if (includeTags && comment.tags?.length) content.push("");
-        }
-        if (includeTags)
-          for (const tag of comment.tags ?? [])
-            content.push(parseJSDocTag(tag));
-      } else if (includeTags) content.push(parseJSDocTag(comment));
-    }
-    const output: string = content
-      .map((line) => line.split("\r\n").join("\n"))
-      .join("\n");
-    return output.length ? output : undefined;
-  };
-
-  export const merge = (comments: ts.SymbolDisplayPart[]): string =>
-    comments
-      .map((part) => part.text)
-      .map((str) => str.split("\r\n").join("\n"))
-      .join("");
-}
-
-const parseJSDocTag = (tag: ts.JSDocTag): string => {
-  const name: string | undefined = (
-    tag as ts.JSDocParameterTag
-  ).name?.getText();
-  const parsed: string | undefined = ts.getTextOfJSDocComment(tag.comment);
-  return [`@${tag.tagName.text}`, name, parsed]
-    .filter((str) => !!str?.length)
-    .join(" ");
-};
+import ts from "typescript";
+
+export namespace CommentFactory {
+  export const description = (
+    symbol: ts.Symbol,
+    includeTags: boolean = false,
+  ): string | undefined => {
+    const node = symbol.declarations?.[0];
+    if (!node) return undefined;
+
+    // FOR LEGACY TS < 5.2
+    const [major, minor] = ts.versionMajorMinor.split(".").map(Number) as [
+      number,
+      number,
+    ];
+    if (major < 5 || (major === 5 && minor < 1)) {
+      const content: string[] = [];
+      const main: string = ts.displayPartsToString(
+        symbol.getDocumentationComment(undefined),
+      );
+      if (main.length) {
+        content.push(main);
+        if (includeTags && symbol.getJsDocTags().length) content.push("");
+      }
+      if (includeTags)
+        for (const tag of symbol.getJsDocTags()) {
+          content.push(
+            tag.text
+              ? `@${tag.name} ${ts.displayPartsToString(tag.text)}`
+              : `@${tag.name}`,
+          );
+        }
+      return content.length
+        ? content.map((line) => line.split("\r\n").join("\n")).join("\n")
+        : undefined;
+    }
+
+    // NEW FEATURE OF TS 5.2
+    const elements: readonly (ts.JSDoc | ts.JSDocTag)[] =
+      ts.getJSDocCommentsAndTags(node);
+    if (elements.length === 0) return undefined;
+
+    const content: string[] = [];
+    for (const comment of elements) {
+      if (ts.isJSDoc(comment)) {
+        const parsed: string | undefined = ts.getTextOfJSDocComment(
+          comment.comment,
+        );
+        if (parsed?.length) {
+          content.push(parsed);
+          if (includeTags && comment.tags?.length) content.push("");
+        }
+        if (includeTags)
+          for (const tag of comment.tags ?? [])
+            content.push(parseJSDocTag(tag));
+      } else if (includeTags) content.push(parseJSDocTag(comment));
+    }
+    const output: string = content
+      .map((line) => line.split("\r\n").join("\n"))
+      .join("\n");
+    return output.length ? output : undefined;
+  };
+
+  export const merge = (comments: ts.SymbolDisplayPart[]): string =>
+    comments
+      .map((part) => part.text)
+      .map((str) => str.split("\r\n").join("\n"))
+      .join("");
+}
+
+const parseJSDocTag = (tag: ts.JSDocTag): string => {
+  const name: string | undefined = (
+    tag as ts.JSDocParameterTag
+  ).name?.getText();
+  const parsed: string | undefined = ts.getTextOfJSDocComment(tag.comment);
+  return [`@${tag.tagName.text}`, name, parsed]
+    .filter((str) => !!str?.length)
+    .join(" ");
+};

package/src/factories/ExpressionFactory.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { RandomGenerator } from "../utils/RandomGenerator";
+import { $randomFormatUuid } from "../internal/$randomFormatUuid";
 
 export namespace ExpressionFactory {
   export const number = (value: number) =>
@@ -84,7 +84,7 @@ export namespace ExpressionFactory {
   export const currying = (props: {
     function: ts.Expression;
     arguments: ts.Expression[];
-  }) => {
+  }): ts.CallExpression => {
     if (props.arguments.length === 0)
       return ts.factory.createCallExpression(
         props.function,
@@ -134,7 +134,7 @@ export namespace ExpressionFactory {
     script: string,
   ) => {
     const file: ts.SourceFile = ts.createSourceFile(
-      `${RandomGenerator.uuid()}.ts`,
+      `${$randomFormatUuid()}.ts`,
       script,
       ts.ScriptTarget.ESNext,
       true,

package/src/factories/JsonMetadataFactory.ts

@@ -1,63 +1,63 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-
-import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
-
-import { TransformerError } from "../transformers/TransformerError";
-
-import { MetadataCollection } from "./MetadataCollection";
-import { MetadataFactory } from "./MetadataFactory";
-
-export namespace JsonMetadataFactory {
-  export interface IProps {
-    method: string;
-    checker: ts.TypeChecker;
-    transformer?: ts.TransformationContext;
-    type: ts.Type;
-  }
-
-  export const analyze = (props: IProps): [MetadataCollection, Metadata] => {
-    const collection = new MetadataCollection();
-    const result = MetadataFactory.analyze({
-      checker: props.checker,
-      transformer: props.transformer,
-      options: {
-        escape: true,
-        constant: true,
-        absorb: true,
-        validate,
-      },
-      collection,
-      type: props.type,
-    });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: props.method,
-        errors: result.errors,
-      });
-    return [collection, result.data];
-  };
-
-  export const validate = (meta: Metadata) => {
-    const output: string[] = [];
-    if (
-      meta.atomics.some((a) => a.type === "bigint") ||
-      meta.constants.some((c) => c.type === "bigint")
-    )
-      output.push("JSON does not support bigint type.");
-    if (
-      meta.tuples.some((t) =>
-        t.type.elements.some((e) => e.isRequired() === false),
-      ) ||
-      meta.arrays.some((a) => a.type.value.isRequired() === false)
-    )
-      output.push("JSON does not support undefined type in array.");
-    if (meta.maps.length) output.push("JSON does not support Map type.");
-    if (meta.sets.length) output.push("JSON does not support Set type.");
-    for (const native of meta.natives)
-      if (AtomicPredicator.native(native) === false && native !== "Date")
-        output.push(`JSON does not support ${native} type.`);
-    return output;
-  };
-}
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+
+import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
+
+import { TransformerError } from "../transformers/TransformerError";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+
+export namespace JsonMetadataFactory {
+  export interface IProps {
+    method: string;
+    checker: ts.TypeChecker;
+    transformer?: ts.TransformationContext;
+    type: ts.Type;
+  }
+
+  export const analyze = (props: IProps): [MetadataCollection, Metadata] => {
+    const collection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.checker,
+      transformer: props.transformer,
+      options: {
+        escape: true,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection,
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: props.method,
+        errors: result.errors,
+      });
+    return [collection, result.data];
+  };
+
+  export const validate = (meta: Metadata) => {
+    const output: string[] = [];
+    if (
+      meta.atomics.some((a) => a.type === "bigint") ||
+      meta.constants.some((c) => c.type === "bigint")
+    )
+      output.push("JSON does not support bigint type.");
+    if (
+      meta.tuples.some((t) =>
+        t.type.elements.some((e) => e.isRequired() === false),
+      ) ||
+      meta.arrays.some((a) => a.type.value.isRequired() === false)
+    )
+      output.push("JSON does not support undefined type in array.");
+    if (meta.maps.length) output.push("JSON does not support Map type.");
+    if (meta.sets.length) output.push("JSON does not support Set type.");
+    for (const native of meta.natives)
+      if (AtomicPredicator.native(native) === false && native !== "Date")
+        output.push(`JSON does not support ${native} type.`);
+    return output;
+  };
+}

package/src/factories/LiteralFactory.ts

@@ -4,15 +4,15 @@ import { ExpressionFactory } from "./ExpressionFactory";
 import { IdentifierFactory } from "./IdentifierFactory";
 
 export namespace LiteralFactory {
-  export const generate = (input: any): ts.Expression => {
+  export const write = (input: any): ts.Expression => {
     if (input === null) return ts.factory.createNull();
     else if (ts.isIdentifier(input)) return input;
-    else if (input instanceof Array) return generate_array(input);
-    else if (typeof input === "object") return generate_object(input);
-    else if (typeof input === "string") return generate_string(input);
-    else if (typeof input === "boolean") return generate_value(input);
-    else if (typeof input === "number") return generate_value(input);
-    else if (typeof input === "bigint") return generate_bigint(input);
+    else if (input instanceof Array) return writeArray(input);
+    else if (typeof input === "object") return writeObject(input);
+    else if (typeof input === "boolean") return writeBoolean(input);
+    else if (typeof input === "bigint") return writeBigint(input);
+    else if (typeof input === "number") return writeNumber(input);
+    else if (typeof input === "string") return writeStrinng(input);
     // unreachable code
     else if (typeof input === "function")
       return ts.factory.createIdentifier("undefined");
@@ -20,28 +20,31 @@ export namespace LiteralFactory {
       throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
   };
 
-  const generate_object = (obj: object): ts.ObjectLiteralExpression =>
+  const writeObject = (obj: object): ts.ObjectLiteralExpression =>
     ts.factory.createObjectLiteralExpression(
       Object.entries(obj)
         .filter((tuple) => tuple[1] !== undefined)
         .map(([key, value]) =>
           ts.factory.createPropertyAssignment(
             IdentifierFactory.identifier(key),
-            generate(value),
+            write(value),
           ),
         ),
       true,
     );
 
-  const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
-    ts.factory.createArrayLiteralExpression(array.map(generate), true);
+  const writeArray = (array: any[]): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(array.map(write), true);
 
-  const generate_value = (value: number | boolean | bigint): ts.Expression =>
-    ts.factory.createIdentifier(value.toString());
+  const writeBoolean = (value: boolean): ts.Expression =>
+    value ? ts.factory.createTrue() : ts.factory.createFalse();
 
-  const generate_bigint = (value: bigint): ts.Expression =>
+  const writeNumber = (value: number): ts.Expression =>
+    ExpressionFactory.number(value);
+
+  const writeBigint = (value: bigint): ts.Expression =>
     ExpressionFactory.bigint(value);
 
-  const generate_string = (value: string): ts.StringLiteral =>
+  const writeStrinng = (value: string): ts.StringLiteral =>
     ts.factory.createStringLiteral(value);
 }