typia 4.0.0-dev.20230519-3 → 4.0.0-dev.20230527

package/src/executable/setup/PluginConfigurator.ts

@@ -1,70 +1,70 @@
-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 Error(
-                `${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 Error(
-                    `"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 Error(
+                `${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 Error(
+                    `"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,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
-`;
-
-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 === "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 === "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,14 +1,14 @@
-import { SymbolDisplayPart } from "typescript";
-
-export namespace CommentFactory {
-    export const string = (comments: SymbolDisplayPart[]): string =>
-        comments
-            .map((part) => part.text)
-            .map((str) => str.split("\r\n").join("\n"))
-            .join("");
-
-    /**
-     * @deprecated
-     */
-    export const generate = string;
-}
+import { SymbolDisplayPart } from "typescript";
+
+export namespace CommentFactory {
+    export const string = (comments: SymbolDisplayPart[]): string =>
+        comments
+            .map((part) => part.text)
+            .map((str) => str.split("\r\n").join("\n"))
+            .join("");
+
+    /**
+     * @deprecated
+     */
+    export const generate = string;
+}

package/src/factories/ExpressionFactory.ts

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

package/src/factories/IdentifierFactory.ts

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