typia 3.8.0-dev.20230413 → 3.8.0-dev.20230415

package/src/executable/typia.ts

@@ -1,52 +1,52 @@
-#!/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
-`;
-
-function halt(desc: string): never {
-    console.error(desc);
-    process.exit(-1);
-}
-
-async function main(): 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 === "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
+`;
+
+function halt(desc: string): never {
+    console.error(desc);
+    process.exit(-1);
+}
+
+async function main(): 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 === "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,10 +1,10 @@
-import ts from "typescript";
-
-export namespace CommentFactory {
-    export function generate(comments: ts.SymbolDisplayPart[]): string {
-        return comments
-            .map((part) => part.text)
-            .map((str) => str.split("\r\n").join("\n"))
-            .join("");
-    }
-}
+import ts from "typescript";
+
+export namespace CommentFactory {
+    export function generate(comments: ts.SymbolDisplayPart[]): string {
+        return comments
+            .map((part) => part.text)
+            .map((str) => str.split("\r\n").join("\n"))
+            .join("");
+    }
+}

package/src/factories/ExpressionFactory.ts

@@ -1,77 +1,77 @@
-import ts from "typescript";
-
-export namespace ExpressionFactory {
-    export function isRequired(input: ts.Expression): ts.Expression {
-        return ts.factory.createStrictInequality(
-            ts.factory.createIdentifier("undefined"),
-            input,
-        );
-    }
-
-    export function isArray(input: ts.Expression): ts.Expression {
-        return ts.factory.createCallExpression(
-            ts.factory.createIdentifier("Array.isArray"),
-            undefined,
-            [input],
-        );
-    }
-
-    export function isObject(
-        input: ts.Expression,
-        options: {
-            checkNull: boolean;
-            checkArray: boolean;
-        },
-    ): ts.Expression {
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("object"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-        ];
-        if (options.checkNull === true)
-            conditions.push(
-                ts.factory.createStrictInequality(
-                    ts.factory.createNull(),
-                    input,
-                ),
-            );
-        if (options.checkArray === true)
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    ts.factory.createFalse(),
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Array.isArray"),
-                        undefined,
-                        [input],
-                    ),
-                ),
-            );
-
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    }
-
-    export function isInstanceOf(
-        input: ts.Expression,
-        type: string,
-    ): ts.Expression {
-        return ts.factory.createBinaryExpression(
-            input,
-            ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
-            ts.factory.createIdentifier(type),
-        );
-    }
-
-    export function coalesce(
-        x: ts.Expression,
-        y: ts.Expression,
-    ): ts.Expression {
-        return ts.factory.createBinaryExpression(
-            x,
-            ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-            y,
-        );
-    }
-}
+import ts from "typescript";
+
+export namespace ExpressionFactory {
+    export function isRequired(input: ts.Expression): ts.Expression {
+        return ts.factory.createStrictInequality(
+            ts.factory.createIdentifier("undefined"),
+            input,
+        );
+    }
+
+    export function isArray(input: ts.Expression): ts.Expression {
+        return ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Array.isArray"),
+            undefined,
+            [input],
+        );
+    }
+
+    export function isObject(
+        input: ts.Expression,
+        options: {
+            checkNull: boolean;
+            checkArray: boolean;
+        },
+    ): ts.Expression {
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("object"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+        if (options.checkNull === true)
+            conditions.push(
+                ts.factory.createStrictInequality(
+                    ts.factory.createNull(),
+                    input,
+                ),
+            );
+        if (options.checkArray === true)
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createFalse(),
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Array.isArray"),
+                        undefined,
+                        [input],
+                    ),
+                ),
+            );
+
+        return conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    }
+
+    export function isInstanceOf(
+        input: ts.Expression,
+        type: string,
+    ): ts.Expression {
+        return ts.factory.createBinaryExpression(
+            input,
+            ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
+            ts.factory.createIdentifier(type),
+        );
+    }
+
+    export function coalesce(
+        x: ts.Expression,
+        y: ts.Expression,
+    ): ts.Expression {
+        return ts.factory.createBinaryExpression(
+            x,
+            ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+            y,
+        );
+    }
+}

package/src/factories/IdentifierFactory.ts

@@ -1,59 +1,59 @@
-import ts from "typescript";
-
-import { Escaper } from "../utils/Escaper";
-
-export namespace IdentifierFactory {
-    export function generate(name: string) {
-        return Escaper.variable(name)
-            ? ts.factory.createIdentifier(name)
-            : ts.factory.createStringLiteral(name);
-    }
-
-    export function join(prefix: ts.Expression, name: string) {
-        const postfix = generate(name);
-        return ts.isStringLiteral(postfix)
-            ? ts.factory.createElementAccessExpression(prefix, postfix)
-            : ts.factory.createPropertyAccessExpression(prefix, postfix);
-    }
-
-    export function postfix(str: string): string {
-        return Escaper.variable(str)
-            ? `".${str}"`
-            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
-    }
-
-    export function parameter(
-        name: string | ts.BindingName,
-        type?: ts.TypeNode,
-        init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
-    ) {
-        // instead of ts.version >= "4.8"
-        if (ts.getDecorators !== undefined)
-            return ts.factory.createParameterDeclaration(
-                undefined,
-                undefined,
-                name,
-                init?.kind === ts.SyntaxKind.QuestionToken
-                    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                    : undefined,
-                type,
-                init && init.kind !== ts.SyntaxKind.QuestionToken
-                    ? init
-                    : undefined,
-            );
-        // eslint-disable-next-line
-        return (ts.factory.createParameterDeclaration as any)(
-            undefined,
-            undefined,
-            undefined,
-            name,
-            init?.kind === ts.SyntaxKind.QuestionToken
-                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined,
-            type,
-            init && init.kind !== ts.SyntaxKind.QuestionToken
-                ? init
-                : undefined,
-        );
-    }
-}
+import ts from "typescript";
+
+import { Escaper } from "../utils/Escaper";
+
+export namespace IdentifierFactory {
+    export function generate(name: string) {
+        return Escaper.variable(name)
+            ? ts.factory.createIdentifier(name)
+            : ts.factory.createStringLiteral(name);
+    }
+
+    export function join(prefix: ts.Expression, name: string) {
+        const postfix = generate(name);
+        return ts.isStringLiteral(postfix)
+            ? ts.factory.createElementAccessExpression(prefix, postfix)
+            : ts.factory.createPropertyAccessExpression(prefix, postfix);
+    }
+
+    export function postfix(str: string): string {
+        return Escaper.variable(str)
+            ? `".${str}"`
+            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+    }
+
+    export function parameter(
+        name: string | ts.BindingName,
+        type?: ts.TypeNode,
+        init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
+    ) {
+        // instead of ts.version >= "4.8"
+        if (ts.getDecorators !== undefined)
+            return ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                name,
+                init?.kind === ts.SyntaxKind.QuestionToken
+                    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                    : undefined,
+                type,
+                init && init.kind !== ts.SyntaxKind.QuestionToken
+                    ? init
+                    : undefined,
+            );
+        // eslint-disable-next-line
+        return (ts.factory.createParameterDeclaration as any)(
+            undefined,
+            undefined,
+            undefined,
+            name,
+            init?.kind === ts.SyntaxKind.QuestionToken
+                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined,
+            type,
+            init && init.kind !== ts.SyntaxKind.QuestionToken
+                ? init
+                : undefined,
+        );
+    }
+}

package/src/factories/LiteralFactory.ts

@@ -1,44 +1,44 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "./IdentifierFactory";
-
-export namespace LiteralFactory {
-    export function generate(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_value(input);
-        else throw new Error("Unknown type.");
-    }
-
-    function generate_object(obj: object): ts.ObjectLiteralExpression {
-        const properties = Object.entries(obj)
-            .filter((tuple) => tuple[1] !== undefined)
-            .map(([key, value]) =>
-                ts.factory.createPropertyAssignment(
-                    IdentifierFactory.generate(key),
-                    generate(value),
-                ),
-            );
-        return ts.factory.createObjectLiteralExpression(properties, true);
-    }
-
-    function generate_array(array: any[]): ts.ArrayLiteralExpression {
-        return ts.factory.createArrayLiteralExpression(
-            array.map(generate),
-            true,
-        );
-    }
-
-    function generate_value(value: number | boolean | bigint): ts.Identifier {
-        return ts.factory.createIdentifier(value.toString());
-    }
-
-    function generate_string(value: string): ts.StringLiteral {
-        return ts.factory.createStringLiteral(value);
-    }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "./IdentifierFactory";
+
+export namespace LiteralFactory {
+    export function generate(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_value(input);
+        else throw new Error("Unknown type.");
+    }
+
+    function generate_object(obj: object): ts.ObjectLiteralExpression {
+        const properties = Object.entries(obj)
+            .filter((tuple) => tuple[1] !== undefined)
+            .map(([key, value]) =>
+                ts.factory.createPropertyAssignment(
+                    IdentifierFactory.generate(key),
+                    generate(value),
+                ),
+            );
+        return ts.factory.createObjectLiteralExpression(properties, true);
+    }
+
+    function generate_array(array: any[]): ts.ArrayLiteralExpression {
+        return ts.factory.createArrayLiteralExpression(
+            array.map(generate),
+            true,
+        );
+    }
+
+    function generate_value(value: number | boolean | bigint): ts.Identifier {
+        return ts.factory.createIdentifier(value.toString());
+    }
+
+    function generate_string(value: string): ts.StringLiteral {
+        return ts.factory.createStringLiteral(value);
+    }
+}