typia 5.2.6 → 5.3.0-dev.20231112

package/src/executable/TypiaSetupWizard.ts

@@ -1,142 +1,142 @@
-import fs from "fs";
-
-import { ArgumentParser } from "./setup/ArgumentParser";
-import { CommandExecutor } from "./setup/CommandExecutor";
-import { PackageManager } from "./setup/PackageManager";
-import { PluginConfigurator } from "./setup/PluginConfigurator";
-
-export namespace TypiaSetupWizard {
-    export interface IArguments {
-        manager: "npm" | "pnpm" | "yarn";
-        project: string | null;
-    }
-
-    export async function setup(): Promise<void> {
-        console.log("----------------------------------------");
-        console.log(" Typia Setup Wizard");
-        console.log("----------------------------------------");
-
-        // PREPARE ASSETS
-        const pack: PackageManager = await PackageManager.mount();
-        const args: IArguments = await ArgumentParser.parse(pack)(inquiry);
-
-        // INSTALL TYPESCRIPT COMPILERS
-        pack.install({ dev: true, modulo: "ts-patch", version: "latest" });
-        pack.install({ dev: true, modulo: "ts-node", version: "latest" });
-        pack.install({ dev: true, modulo: "typescript", version: "5.2.2" });
-        args.project ??= (() => {
-            const runner: string =
-                pack.manager === "npm" ? "npx" : pack.manager;
-            CommandExecutor.run(`${runner} tsc --init`);
-            return (args.project = "tsconfig.json");
-        })();
-
-        // SETUP TRANSFORMER
-        await pack.save((data) => {
-            // COMPOSE PREPARE COMMAND
-            data.scripts ??= {};
-            if (
-                typeof data.scripts.prepare === "string" &&
-                data.scripts.prepare.trim().length
-            ) {
-                if (data.scripts.prepare.indexOf("ts-patch install") === -1)
-                    data.scripts.prepare =
-                        "ts-patch install && " + data.scripts.prepare;
-            } else data.scripts.prepare = "ts-patch install";
-
-            // FOR OLDER VERSIONS
-            if (typeof data.scripts.postinstall === "string") {
-                data.scripts.postinstall = data.scripts.postinstall
-                    .split("&&")
-                    .map((str) => str.trim())
-                    .filter((str) => str.indexOf("ts-patch install") === -1)
-                    .join(" && ");
-                if (data.scripts.postinstall.length === 0)
-                    delete data.scripts.postinstall;
-            }
-        });
-        CommandExecutor.run(`${pack.manager} run prepare`);
-
-        // CONFIGURE TYPIA
-        await PluginConfigurator.configure(args);
-    }
-
-    const inquiry: ArgumentParser.Inquiry<IArguments> = async (
-        pack,
-        command,
-        prompt,
-        action,
-    ) => {
-        // PREPARE ASSETS
-        command.option("--manager [manager", "package manager");
-        command.option("--project [project]", "tsconfig.json file location");
-
-        // INTERNAL PROCEDURES
-        const questioned = { value: false };
-        const select =
-            (name: string) =>
-            (message: string) =>
-            async <Choice extends string>(
-                choices: Choice[],
-                filter?: (choice: string) => Choice,
-            ): Promise<Choice> => {
-                questioned.value = true;
-                return (
-                    await prompt()({
-                        type: "list",
-                        name: name,
-                        message: message,
-                        choices: choices,
-                        ...(filter
-                            ? {
-                                  filter,
-                              }
-                            : {}),
-                    })
-                )[name];
-            };
-        const configure = async (): Promise<string | null> => {
-            const fileList: string[] = await (
-                await fs.promises.readdir(process.cwd())
-            )
-                .filter(
-                    (str) =>
-                        str.substring(0, 8) === "tsconfig" &&
-                        str.substring(str.length - 5) === ".json",
-                )
-                .sort((x, y) =>
-                    x === "tsconfig.json"
-                        ? -1
-                        : y === "tsconfig.json"
-                        ? 1
-                        : x < y
-                        ? -1
-                        : 1,
-                );
-            if (fileList.length === 0) {
-                if (process.cwd() !== pack.directory)
-                    throw new URIError(`Unable to find "tsconfig.json" file.`);
-                return null;
-            } else if (fileList.length === 1) return fileList[0]!;
-            return select("tsconfig")("TS Config File")(fileList);
-        };
-
-        // DO CONSTRUCT
-        return action(async (options) => {
-            pack.manager = options.manager ??= await select("manager")(
-                "Package Manager",
-            )(
-                [
-                    "npm" as const,
-                    "pnpm" as const,
-                    "yarn (berry is not supported)" as "yarn",
-                ],
-                (value) => value.split(" ")[0] as "yarn",
-            );
-            options.project ??= await configure();
-
-            if (questioned.value) console.log("");
-            return options as IArguments;
-        });
-    };
-}
+import fs from "fs";
+
+import { ArgumentParser } from "./setup/ArgumentParser";
+import { CommandExecutor } from "./setup/CommandExecutor";
+import { PackageManager } from "./setup/PackageManager";
+import { PluginConfigurator } from "./setup/PluginConfigurator";
+
+export namespace TypiaSetupWizard {
+    export interface IArguments {
+        manager: "npm" | "pnpm" | "yarn";
+        project: string | null;
+    }
+
+    export async function setup(): Promise<void> {
+        console.log("----------------------------------------");
+        console.log(" Typia Setup Wizard");
+        console.log("----------------------------------------");
+
+        // PREPARE ASSETS
+        const pack: PackageManager = await PackageManager.mount();
+        const args: IArguments = await ArgumentParser.parse(pack)(inquiry);
+
+        // INSTALL TYPESCRIPT COMPILERS
+        pack.install({ dev: true, modulo: "ts-patch", version: "latest" });
+        pack.install({ dev: true, modulo: "ts-node", version: "latest" });
+        pack.install({ dev: true, modulo: "typescript", version: "5.2.2" });
+        args.project ??= (() => {
+            const runner: string =
+                pack.manager === "npm" ? "npx" : pack.manager;
+            CommandExecutor.run(`${runner} tsc --init`);
+            return (args.project = "tsconfig.json");
+        })();
+
+        // SETUP TRANSFORMER
+        await pack.save((data) => {
+            // COMPOSE PREPARE COMMAND
+            data.scripts ??= {};
+            if (
+                typeof data.scripts.prepare === "string" &&
+                data.scripts.prepare.trim().length
+            ) {
+                if (data.scripts.prepare.indexOf("ts-patch install") === -1)
+                    data.scripts.prepare =
+                        "ts-patch install && " + data.scripts.prepare;
+            } else data.scripts.prepare = "ts-patch install";
+
+            // FOR OLDER VERSIONS
+            if (typeof data.scripts.postinstall === "string") {
+                data.scripts.postinstall = data.scripts.postinstall
+                    .split("&&")
+                    .map((str) => str.trim())
+                    .filter((str) => str.indexOf("ts-patch install") === -1)
+                    .join(" && ");
+                if (data.scripts.postinstall.length === 0)
+                    delete data.scripts.postinstall;
+            }
+        });
+        CommandExecutor.run(`${pack.manager} run prepare`);
+
+        // CONFIGURE TYPIA
+        await PluginConfigurator.configure(args);
+    }
+
+    const inquiry: ArgumentParser.Inquiry<IArguments> = async (
+        pack,
+        command,
+        prompt,
+        action,
+    ) => {
+        // PREPARE ASSETS
+        command.option("--manager [manager", "package manager");
+        command.option("--project [project]", "tsconfig.json file location");
+
+        // INTERNAL PROCEDURES
+        const questioned = { value: false };
+        const select =
+            (name: string) =>
+            (message: string) =>
+            async <Choice extends string>(
+                choices: Choice[],
+                filter?: (choice: string) => Choice,
+            ): Promise<Choice> => {
+                questioned.value = true;
+                return (
+                    await prompt()({
+                        type: "list",
+                        name: name,
+                        message: message,
+                        choices: choices,
+                        ...(filter
+                            ? {
+                                  filter,
+                              }
+                            : {}),
+                    })
+                )[name];
+            };
+        const configure = async (): Promise<string | null> => {
+            const fileList: string[] = await (
+                await fs.promises.readdir(process.cwd())
+            )
+                .filter(
+                    (str) =>
+                        str.substring(0, 8) === "tsconfig" &&
+                        str.substring(str.length - 5) === ".json",
+                )
+                .sort((x, y) =>
+                    x === "tsconfig.json"
+                        ? -1
+                        : y === "tsconfig.json"
+                        ? 1
+                        : x < y
+                        ? -1
+                        : 1,
+                );
+            if (fileList.length === 0) {
+                if (process.cwd() !== pack.directory)
+                    throw new URIError(`Unable to find "tsconfig.json" file.`);
+                return null;
+            } else if (fileList.length === 1) return fileList[0]!;
+            return select("tsconfig")("TS Config File")(fileList);
+        };
+
+        // DO CONSTRUCT
+        return action(async (options) => {
+            pack.manager = options.manager ??= await select("manager")(
+                "Package Manager",
+            )(
+                [
+                    "npm" as const,
+                    "pnpm" as const,
+                    "yarn (berry is not supported)" as "yarn",
+                ],
+                (value) => value.split(" ")[0] as "yarn",
+            );
+            options.project ??= await configure();
+
+            if (questioned.value) console.log("");
+            return options as IArguments;
+        });
+    };
+}

package/src/executable/setup/CommandExecutor.ts

@@ -1,8 +1,8 @@
-import cp from "child_process";
-
-export namespace CommandExecutor {
-    export const run = (str: string): void => {
-        console.log(`\n$ ${str}`);
-        cp.execSync(str, { stdio: "inherit" });
-    };
-}
+import cp from "child_process";
+
+export namespace CommandExecutor {
+    export const run = (str: string): void => {
+        console.log(`\n$ ${str}`);
+        cp.execSync(str, { stdio: "inherit" });
+    };
+}

package/src/factories/ExpressionFactory.ts

@@ -133,9 +133,7 @@ export namespace ExpressionFactory {
             );
 
     export const transpile =
-        (context: ts.TransformationContext) =>
-        (script: string) =>
-        (input: ts.Expression): ts.Expression => {
+        (context: ts.TransformationContext) => (script: string) => {
             const file: ts.SourceFile = ts.createSourceFile(
                 `${RandomGenerator.uuid()}.ts`,
                 script,
@@ -152,16 +150,17 @@ export namespace ExpressionFactory {
                 throw new TypeError(
                     "Error on ExpressionFactory.transpile(): statement is not an expression statement.",
                 );
-
-            const visitor = (node: ts.Node): ts.Node => {
-                if (ts.isIdentifier(node) && node.text === "$input")
-                    return input;
-                return ts.visitEachChild(
-                    (ts.factory as any).cloneNode(node),
-                    visitor,
-                    context,
-                );
+            return (input: ts.Expression): ts.Expression => {
+                const visitor = (node: ts.Node): ts.Node => {
+                    if (ts.isIdentifier(node) && node.text === "$input")
+                        return input;
+                    return ts.visitEachChild(
+                        (ts.factory as any).cloneNode(node),
+                        visitor,
+                        context,
+                    );
+                };
+                return visitor(statement.expression) as ts.Expression;
             };
-            return visitor(statement.expression) as ts.Expression;
         };
 }

package/src/factories/JsonMetadataFactory.ts

@@ -1,50 +1,53 @@
-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 const analyze =
-        (method: string) =>
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type): [MetadataCollection, Metadata] => {
-            const collection = new MetadataCollection();
-            const result = MetadataFactory.analyze(checker)({
-                escape: true,
-                constant: true,
-                absorb: true,
-                validate,
-            })(collection)(type);
-            if (result.success === false)
-                throw TransformerError.from(method)(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 const analyze =
+        (method: string) =>
+        (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
+        (type: ts.Type): [MetadataCollection, Metadata] => {
+            const collection = new MetadataCollection();
+            const result = MetadataFactory.analyze(
+                checker,
+                context,
+            )({
+                escape: true,
+                constant: true,
+                absorb: true,
+                validate,
+            })(collection)(type);
+            if (result.success === false)
+                throw TransformerError.from(method)(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

@@ -14,6 +14,8 @@ export namespace LiteralFactory {
         else if (typeof input === "number") return generate_value(input);
         else if (typeof input === "bigint") return generate_bigint(input);
         // unreachable code
+        else if (typeof input === "function")
+            return ts.factory.createIdentifier("undefined");
         else
             throw new TypeError(
                 "Error on LiteralFactory.generate(): unknown type.",