typia 3.6.1 → 3.6.3

package/src/executable/setup/PackageManager.ts

@@ -1,92 +1,92 @@
-import fs from "fs";
-import path from "path";
-
-import { CommandExecutor } from "./CommandExecutor";
-import { FileRetriever } from "./FileRetriever";
-
-export class PackageManager {
-    public manager: string = "npm";
-    public get file(): string {
-        return path.join(this.directory, "package.json");
-    }
-
-    public static async mount(): Promise<PackageManager> {
-        const location: string | null = await FileRetriever.directory(
-            "package.json",
-        )(process.cwd());
-        if (location === null)
-            throw new Error(`Unable to find "package.json" file`);
-
-        return new PackageManager(
-            location,
-            await this.load(path.join(location, "package.json")),
-        );
-    }
-
-    public async save(modifier: (data: Package.Data) => void): Promise<void> {
-        const content: string = await fs.promises.readFile(this.file, "utf8");
-        this.data = JSON.parse(content);
-        modifier(this.data);
-
-        return fs.promises.writeFile(
-            this.file,
-            JSON.stringify(this.data, null, 2),
-            "utf8",
-        );
-    }
-
-    public install(props: {
-        dev: boolean;
-        silent?: boolean;
-        modulo: string;
-        version?: string;
-    }): boolean {
-        const container = props.dev
-            ? this.data.devDependencies
-            : this.data.dependencies;
-        if (
-            !!container?.[props.modulo] &&
-            FileRetriever.file(path.join("node_modules", props.modulo))(
-                this.directory,
-            ) !== null
-        )
-            return false;
-
-        const middle: string =
-            this.manager === "yarn"
-                ? `add${props.dev ? " -D" : ""}`
-                : `install ${props.dev ? "--save-dev" : "--save"}`;
-        CommandExecutor.run(
-            `${this.manager} ${middle} ${props.modulo}${
-                props.version ? `@${props.version}` : ""
-            }`,
-            !!props.silent,
-        );
-        return true;
-    }
-
-    public erase(props: { modulo: string; silent?: boolean }): void {
-        const middle: string = this.manager === "yarn" ? "remove" : "uninstall";
-        CommandExecutor.run(
-            `${this.manager} ${middle} ${props.modulo}`,
-            !!props.silent,
-        );
-    }
-
-    private constructor(
-        public readonly directory: string,
-        public data: Package.Data,
-    ) {}
-
-    private static async load(file: string): Promise<Package.Data> {
-        const content: string = await fs.promises.readFile(file, "utf8");
-        return JSON.parse(content);
-    }
-}
-export namespace Package {
-    export interface Data {
-        scripts?: Record<string, string>;
-        dependencies?: Record<string, string>;
-        devDependencies?: Record<string, string>;
-    }
-}
+import fs from "fs";
+import path from "path";
+
+import { CommandExecutor } from "./CommandExecutor";
+import { FileRetriever } from "./FileRetriever";
+
+export class PackageManager {
+    public manager: string = "npm";
+    public get file(): string {
+        return path.join(this.directory, "package.json");
+    }
+
+    public static async mount(): Promise<PackageManager> {
+        const location: string | null = await FileRetriever.directory(
+            "package.json",
+        )(process.cwd());
+        if (location === null)
+            throw new Error(`Unable to find "package.json" file`);
+
+        return new PackageManager(
+            location,
+            await this.load(path.join(location, "package.json")),
+        );
+    }
+
+    public async save(modifier: (data: Package.Data) => void): Promise<void> {
+        const content: string = await fs.promises.readFile(this.file, "utf8");
+        this.data = JSON.parse(content);
+        modifier(this.data);
+
+        return fs.promises.writeFile(
+            this.file,
+            JSON.stringify(this.data, null, 2),
+            "utf8",
+        );
+    }
+
+    public install(props: {
+        dev: boolean;
+        silent?: boolean;
+        modulo: string;
+        version?: string;
+    }): boolean {
+        const container = props.dev
+            ? this.data.devDependencies
+            : this.data.dependencies;
+        if (
+            !!container?.[props.modulo] &&
+            FileRetriever.file(path.join("node_modules", props.modulo))(
+                this.directory,
+            ) !== null
+        )
+            return false;
+
+        const middle: string =
+            this.manager === "yarn"
+                ? `add${props.dev ? " -D" : ""}`
+                : `install ${props.dev ? "--save-dev" : "--save"}`;
+        CommandExecutor.run(
+            `${this.manager} ${middle} ${props.modulo}${
+                props.version ? `@${props.version}` : ""
+            }`,
+            !!props.silent,
+        );
+        return true;
+    }
+
+    public erase(props: { modulo: string; silent?: boolean }): void {
+        const middle: string = this.manager === "yarn" ? "remove" : "uninstall";
+        CommandExecutor.run(
+            `${this.manager} ${middle} ${props.modulo}`,
+            !!props.silent,
+        );
+    }
+
+    private constructor(
+        public readonly directory: string,
+        public data: Package.Data,
+    ) {}
+
+    private static async load(file: string): Promise<Package.Data> {
+        const content: string = await fs.promises.readFile(file, "utf8");
+        return JSON.parse(content);
+    }
+}
+export namespace Package {
+    export interface Data {
+        scripts?: Record<string, string>;
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    }
+}

package/src/executable/setup/PluginConfigurator.ts

@@ -1,99 +1,99 @@
-import type Comment from "comment-json";
-import fs from "fs";
-import path from "path";
-
-import { TypiaSetupWizard } from "../TypiaSetupWizard";
-import { FileRetriever } from "./FileRetriever";
-import { PackageManager } from "./PackageManager";
-
-export namespace PluginConfigurator {
-    export async function configure(
-        pack: PackageManager,
-        args: TypiaSetupWizard.IArguments,
-    ): Promise<void> {
-        // INSTALL COMMENT-JSON
-        const installed: boolean = pack.install({
-            dev: true,
-            modulo: "comment-json",
-            version: "4.2.3",
-            silent: true,
-        });
-
-        // DO CONFIGURE
-        const error: Error | null = await (async () => {
-            try {
-                await _Configure(pack, args);
-                return null;
-            } catch (exp) {
-                return exp as Error;
-            }
-        })();
-
-        // REMOVE IT
-        if (installed)
-            pack.erase({
-                modulo: "comment-json",
-                silent: true,
-            });
-        if (error !== null) throw error;
-    }
-
-    async function _Configure(
-        pack: PackageManager,
-        args: TypiaSetupWizard.IArguments,
-    ): Promise<void> {
-        // GET COMPILER-OPTIONS
-        const Comment: typeof import("comment-json") =
-            await FileRetriever.require(
-                path.join("node_modules", "comment-json"),
-            )(pack.directory);
-
-        const config: Comment.CommentObject = Comment.parse(
-            await fs.promises.readFile(args.project!, "utf8"),
-        ) as Comment.CommentObject;
-        const compilerOptions = config.compilerOptions as
-            | Comment.CommentObject
-            | undefined;
-        if (compilerOptions === undefined)
-            throw new Error(
-                `${args.project} file does not have "compilerOptions" property.`,
-            );
-
-        // PREPARE PLUGINS
-        const plugins: Comment.CommentArray<Comment.CommentObject> = (() => {
-            const plugins = compilerOptions.plugins as
-                | Comment.CommentArray<Comment.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 = compilerOptions.strict === true;
-        const oldbie: Comment.CommentObject | undefined = plugins.find(
-            (p) =>
-                typeof p === "object" &&
-                p !== null &&
-                p.transform === "typia/lib/transform",
-        );
-        if (strict === true && oldbie !== undefined) return;
-
-        // DO CONFIGURE
-        compilerOptions.strict = true;
-        if (oldbie === undefined)
-            plugins.push(
-                Comment.parse(`
-                        {
-                            "transform": "typia/lib/transform"
-                        }`) as Comment.CommentObject,
-            );
-        await fs.promises.writeFile(
-            args.project!,
-            Comment.stringify(config, null, 2),
-        );
-    }
-}
+import type Comment from "comment-json";
+import fs from "fs";
+import path from "path";
+
+import { TypiaSetupWizard } from "../TypiaSetupWizard";
+import { FileRetriever } from "./FileRetriever";
+import { PackageManager } from "./PackageManager";
+
+export namespace PluginConfigurator {
+    export async function configure(
+        pack: PackageManager,
+        args: TypiaSetupWizard.IArguments,
+    ): Promise<void> {
+        // INSTALL COMMENT-JSON
+        const installed: boolean = pack.install({
+            dev: true,
+            modulo: "comment-json",
+            version: "4.2.3",
+            silent: true,
+        });
+
+        // DO CONFIGURE
+        const error: Error | null = await (async () => {
+            try {
+                await _Configure(pack, args);
+                return null;
+            } catch (exp) {
+                return exp as Error;
+            }
+        })();
+
+        // REMOVE IT
+        if (installed)
+            pack.erase({
+                modulo: "comment-json",
+                silent: true,
+            });
+        if (error !== null) throw error;
+    }
+
+    async function _Configure(
+        pack: PackageManager,
+        args: TypiaSetupWizard.IArguments,
+    ): Promise<void> {
+        // GET COMPILER-OPTIONS
+        const Comment: typeof import("comment-json") =
+            await FileRetriever.require(
+                path.join("node_modules", "comment-json"),
+            )(pack.directory);
+
+        const config: Comment.CommentObject = Comment.parse(
+            await fs.promises.readFile(args.project!, "utf8"),
+        ) as Comment.CommentObject;
+        const compilerOptions = config.compilerOptions as
+            | Comment.CommentObject
+            | undefined;
+        if (compilerOptions === undefined)
+            throw new Error(
+                `${args.project} file does not have "compilerOptions" property.`,
+            );
+
+        // PREPARE PLUGINS
+        const plugins: Comment.CommentArray<Comment.CommentObject> = (() => {
+            const plugins = compilerOptions.plugins as
+                | Comment.CommentArray<Comment.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 = compilerOptions.strict === true;
+        const oldbie: Comment.CommentObject | undefined = plugins.find(
+            (p) =>
+                typeof p === "object" &&
+                p !== null &&
+                p.transform === "typia/lib/transform",
+        );
+        if (strict === true && oldbie !== undefined) return;
+
+        // DO CONFIGURE
+        compilerOptions.strict = true;
+        if (oldbie === undefined)
+            plugins.push(
+                Comment.parse(`
+                        {
+                            "transform": "typia/lib/transform"
+                        }`) as Comment.CommentObject,
+            );
+        await fs.promises.writeFile(
+            args.project!,
+            Comment.stringify(config, null, 2),
+        );
+    }
+}

package/src/executable/typia.ts

@@ -1,38 +1,38 @@
-#!/usr/bin/env node
-import { TypiaGenerateWizard } from "./TypiaGenerateWizard";
-import { TypiaSetupWizard } from "./TypiaSetupWizard";
-
-const USAGE = `Wrong command has been detected. Use like below:
-
-  npx typia setup \\
-    --compiler (ttypescript|ts-patch) \\
-    --manager (npm|pnpm|yarn) \\
-    --project {tsconfig.json file path}
-
-    - npx typia setup
-    - npx typia setup --compiler ts-patch
-    - 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> {
-    const type: string | undefined = process.argv[2];
-    if (type === "setup") await TypiaSetupWizard.setup();
-    else if (type === "generate") await TypiaGenerateWizard.generate();
-    else halt(USAGE);
-}
-main().catch((exp) => {
-    console.error(exp);
-    process.exit(-1);
-});
+#!/usr/bin/env node
+import { TypiaGenerateWizard } from "./TypiaGenerateWizard";
+import { TypiaSetupWizard } from "./TypiaSetupWizard";
+
+const USAGE = `Wrong command has been detected. Use like below:
+
+  npx typia setup \\
+    --compiler (ttypescript|ts-patch) \\
+    --manager (npm|pnpm|yarn) \\
+    --project {tsconfig.json file path}
+
+    - npx typia setup
+    - npx typia setup --compiler ts-patch
+    - 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> {
+    const type: string | undefined = process.argv[2];
+    if (type === "setup") await TypiaSetupWizard.setup();
+    else if (type === "generate") 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,
+        );
+    }
+}