typia 3.5.2 → 3.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "3.5.2",
+  "version": "3.5.4",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/IRandomGenerator.ts

@@ -1,16 +1,16 @@
 export interface IRandomGenerator {
     boolean(): boolean;
-    int(minimum?: number, maximum?: number): number;
+    integer(minimum?: number, maximum?: number): number;
     number(minimum?: number, maximum?: number): number;
     bigint(minimum?: bigint, maximum?: bigint): bigint;
     string(length?: number): string;
     array<T>(closure: (index: number) => T, count?: number): T[];
 
-    uuid?(): string;
-    email?(): string;
-    url?(): string;
-    ipv4?(): string;
-    ipv6?(): string;
-    pattern?(regex: RegExp): string;
-    date?(): string;
+    uuid(): string;
+    email(): string;
+    url(): string;
+    ipv4(): string;
+    ipv6(): string;
+    pattern(regex: RegExp): string;
+    date(): string;
 }

package/src/executable/{internal/ArgumentParser.ts → TypiaSetupWizard.ts}

@@ -1,80 +1,71 @@
-import type CommanderModule from "commander";
 import fs from "fs";
-import type * as InquirerModule from "inquirer";
 import path from "path";
 
-import { PackageManager } from "./PackageManager";
+import { ArgumentParser } from "./setup/ArgumentParser";
+import { CommandExecutor } from "./setup/CommandExecutor";
+import { PackageManager } from "./setup/PackageManager";
+import { PluginConfigurator } from "./setup/PluginConfigurator";
 
-export namespace ArgumentParser {
+export namespace TypiaSetupWizard {
     export interface IArguments {
         compiler: "ts-patch" | "ttypescript";
         manager: "npm" | "pnpm" | "yarn";
         project: string | null;
     }
 
-    export async function parse(pack: PackageManager): Promise<IArguments> {
-        // INSTALL TEMPORARY PACKAGES
-        const newbie = {
-            commander: pack.install({
-                dev: true,
-                modulo: "commander",
-                silent: true,
-            }),
-            inquirer: pack.install({
-                dev: true,
-                modulo: "inquirer",
-                version: "8.2.5",
-                silent: true,
-            }),
-        };
+    export async function setup(): Promise<void> {
+        console.log("----------------------------------------");
+        console.log(" Typia Setup Wizard");
+        console.log("----------------------------------------");
 
-        // TAKE OPTIONS
-        const output: IArguments | Error = await (async () => {
-            try {
-                return await _Parse(pack);
-            } catch (error) {
-                return error as Error;
-            }
+        // PREPARE ASSETS
+        const pack: PackageManager = await PackageManager.mount();
+        const args: IArguments = await ArgumentParser.parse(pack)(true)(
+            inquiry,
+        );
+
+        // INSTALL TYPESCRIPT
+        pack.install({ dev: true, modulo: "typescript" });
+        args.project ??= (() => {
+            CommandExecutor.run("npx tsc --init", false);
+            return (args.project = "tsconfig.json");
         })();
+        pack.install({ dev: true, modulo: "ts-node" });
 
-        // REMOVE TEMPORARY PACKAGES
-        if (newbie.commander) pack.erase({ modulo: "commander", silent: true });
-        if (newbie.inquirer) pack.erase({ modulo: "inquirer", silent: true });
+        // INSTALL COMPILER
+        pack.install({ dev: true, modulo: args.compiler });
+        if (args.compiler === "ts-patch") {
+            await pack.save((data) => {
+                data.scripts ??= {};
+                if (
+                    typeof data.scripts.prepare === "string" &&
+                    data.scripts.prepare.indexOf("ts-patch install") === -1
+                )
+                    data.scripts.prepare =
+                        "ts-patch install && " + data.scripts.prepare;
+                else data.scripts.prepare = "ts-patch install";
+            });
+            CommandExecutor.run("npm run prepare", false);
+        }
 
-        // RETURNS
-        if (output instanceof Error) throw output;
-        return output;
+        // INSTALL AND CONFIGURE TYPIA
+        pack.install({ dev: false, modulo: "typia" });
+        await PluginConfigurator.configure(pack, args);
     }
 
-    async function _Parse(pack: PackageManager): Promise<IArguments> {
+    const inquiry: ArgumentParser.Inquiry<IArguments> = async (
+        pack,
+        command,
+        prompt,
+        action,
+    ) => {
         // PREPARE ASSETS
-        const { createPromptModule }: typeof InquirerModule = await import(
-            path.join(pack.directory, "node_modules", "inquirer")
-        );
-        const { program }: typeof CommanderModule = await import(
-            path.join(pack.directory, "node_modules", "commander")
-        );
-
-        program.option("--compiler [compiler]", "compiler type");
-        program.option("--manager [manager", "package manager");
-        program.option("--project [project]", "tsconfig.json file location");
+        command.option("--compiler [compiler]", "compiler type");
+        command.option("--manager [manager", "package manager");
+        command.option("--project [project]", "tsconfig.json file location");
 
         // INTERNAL PROCEDURES
         const questioned = { value: false };
-        const action = (
-            closure: (options: Partial<IArguments>) => Promise<IArguments>,
-        ) => {
-            return new Promise<IArguments>((resolve, reject) => {
-                program.action(async (options) => {
-                    try {
-                        resolve(await closure(options));
-                    } catch (exp) {
-                        reject(exp);
-                    }
-                });
-                program.parseAsync().catch(reject);
-            });
-        };
         const select =
             (name: string) =>
             (message: string) =>
@@ -83,7 +74,7 @@ export namespace ArgumentParser {
             ): Promise<Choice> => {
                 questioned.value = true;
                 return (
-                    await createPromptModule()({
+                    await prompt()({
                         type: "list",
                         name: name,
                         message: message,
@@ -112,7 +103,7 @@ export namespace ArgumentParser {
             if (options.compiler === undefined) {
                 console.log(COMPILER_DESCRIPTION);
                 options.compiler = await select("compiler")(`Compiler`)(
-                    pack.data.scripts?.build === "nest build"
+                    is_nest_cli(pack)
                         ? ["ts-patch" as const, "ttypescript" as const]
                         : ["ttypescript" as const, "ts-patch" as const],
                 );
@@ -128,6 +119,14 @@ export namespace ArgumentParser {
             if (questioned.value) console.log("");
             return options as IArguments;
         });
+    };
+
+    function is_nest_cli(pack: PackageManager): boolean {
+        return (
+            (typeof pack.data.scripts?.build === "string" &&
+                pack.data.scripts.build.indexOf("nest build") !== -1) ||
+            fs.existsSync(path.join(pack.directory, "nest-cli.json"))
+        );
     }
 }
 

package/src/executable/setup/ArgumentParser.ts

@@ -0,0 +1,89 @@
+import type CommanderModule from "commander";
+import type * as InquirerModule from "inquirer";
+import path from "path";
+
+import { PackageManager } from "./PackageManager";
+
+export namespace ArgumentParser {
+    export type Inquiry<T> = (
+        pack: PackageManager,
+        command: CommanderModule.Command,
+        prompt: (
+            opt?: InquirerModule.StreamOptions,
+        ) => InquirerModule.PromptModule,
+        action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
+    ) => Promise<T>;
+
+    export const parse =
+        (pack: PackageManager) =>
+        (erase: boolean) =>
+        async <T>(
+            inquiry: (
+                pack: PackageManager,
+                command: CommanderModule.Command,
+                prompt: (
+                    opt?: InquirerModule.StreamOptions,
+                ) => InquirerModule.PromptModule,
+                action: (
+                    closure: (options: Partial<T>) => Promise<T>,
+                ) => Promise<T>,
+            ) => Promise<T>,
+        ): Promise<T> => {
+            // INSTALL TEMPORARY PACKAGES
+            const newbie = {
+                commander: pack.install({
+                    dev: true,
+                    modulo: "commander",
+                    version: "10.0.0",
+                    silent: true,
+                }),
+                inquirer: pack.install({
+                    dev: true,
+                    modulo: "inquirer",
+                    version: "8.2.5",
+                    silent: true,
+                }),
+            };
+
+            // LOAD INSTALLED MODULES
+            const { program: command }: typeof CommanderModule = await import(
+                path.join(pack.directory, "node_modules", "commander")
+            );
+            const { createPromptModule: prompt }: typeof InquirerModule =
+                await import(
+                    path.join(pack.directory, "node_modules", "inquirer")
+                );
+
+            // TAKE OPTIONS
+            const action = (closure: (options: Partial<T>) => Promise<T>) =>
+                new Promise<T>((resolve, reject) => {
+                    command.action(async (options) => {
+                        try {
+                            resolve(await closure(options));
+                        } catch (exp) {
+                            reject(exp);
+                        }
+                    });
+                    command.parseAsync().catch(reject);
+                });
+            const output: T | Error = await (async () => {
+                try {
+                    return await inquiry(pack, command, prompt, action);
+                } catch (error) {
+                    return error as Error;
+                }
+            })();
+
+            // REMOVE TEMPORARY PACKAGES
+            if (erase === true) {
+                if (newbie.commander)
+                    pack.erase({ modulo: "commander", silent: true });
+                if (newbie.inquirer)
+                    pack.erase({ modulo: "inquirer", silent: true });
+            }
+
+            // RETURNS
+            if (output instanceof Error) throw output;
+            return output;
+        };
+}

package/src/executable/{internal → setup}/PluginConfigurator.ts

@@ -2,18 +2,19 @@ import type Comment from "comment-json";
 import fs from "fs";
 import path from "path";
 
-import { ArgumentParser } from "./ArgumentParser";
+import { TypiaSetupWizard } from "../TypiaSetupWizard";
 import { PackageManager } from "./PackageManager";
 
 export namespace PluginConfigurator {
     export async function configure(
         pack: PackageManager,
-        args: ArgumentParser.IArguments,
+        args: TypiaSetupWizard.IArguments,
     ): Promise<void> {
         // INSTALL COMMENT-JSON
         const installed: boolean = pack.install({
             dev: true,
             modulo: "comment-json",
+            version: "4.2.3",
             silent: true,
         });
 
@@ -38,7 +39,7 @@ export namespace PluginConfigurator {
 
     async function _Configure(
         pack: PackageManager,
-        args: ArgumentParser.IArguments,
+        args: TypiaSetupWizard.IArguments,
     ): Promise<void> {
         // GET COMPILER-OPTIONS
         const Comment: typeof import("comment-json") = await import(

package/src/executable/typia.ts

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
-import { ArgumentParser } from "./internal/ArgumentParser";
-import { CommandExecutor } from "./internal/CommandExecutor";
-import { PackageManager } from "./internal/PackageManager";
-import { PluginConfigurator } from "./internal/PluginConfigurator";
+import { TypiaSetupWizard } from "./TypiaSetupWizard";
 
 const USAGE = `Wrong command has been detected. Use like below:
 
@@ -21,46 +18,9 @@ function halt(desc: string): never {
     process.exit(-1);
 }
 
-async function setup(): Promise<void> {
-    console.log("----------------------------------------");
-    console.log(" Typia Setup Wizard");
-    console.log("----------------------------------------");
-
-    // LOAD PACKAGE.JSON INFO
-    const pack: PackageManager = await PackageManager.mount();
-
-    // TAKE ARGUMENTS
-    const args: ArgumentParser.IArguments = await ArgumentParser.parse(pack);
-
-    // INSTALL TYPESCRIPT
-    pack.install({ dev: true, modulo: "typescript" });
-    args.project ??= (() => {
-        CommandExecutor.run("npx tsc --init", false);
-        return (args.project = "tsconfig.json");
-    })();
-    pack.install({ dev: true, modulo: "ts-node" });
-
-    // INSTALL COMPILER
-    pack.install({ dev: true, modulo: args.compiler });
-    if (args.compiler === "ts-patch") {
-        await pack.save((data) => {
-            data.scripts ??= {};
-            if (typeof data.scripts.prepare === "string")
-                data.scripts.prepare =
-                    "ts-patch install && " + data.scripts.prepare;
-            else data.scripts.prepare = "ts-patch install";
-        });
-        CommandExecutor.run("npm run prepare", false);
-    }
-
-    // INSTALL AND CONFIGURE TYPIA
-    pack.install({ dev: false, modulo: "typia" });
-    await PluginConfigurator.configure(pack, args);
-}
-
 async function main(): Promise<void> {
     const type: string | undefined = process.argv[2];
-    if (type === "setup") await setup();
+    if (type === "setup") await TypiaSetupWizard.setup();
     else halt(USAGE);
 }
 main().catch((exp) => {

package/src/module.ts

@@ -3,6 +3,7 @@ import { Namespace } from "./functional/Namespace";
 import { IMetadataApplication } from "./metadata/IMetadataApplication";
 import { IJsonApplication } from "./schemas/IJsonApplication";
 
+import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Primitive } from "./Primitive";
 import { TypeGuardError } from "./TypeGuardError";
@@ -10,9 +11,10 @@ import { TypeGuardError } from "./TypeGuardError";
 export * from "./schemas/IJsonApplication";
 export * from "./schemas/IJsonComponents";
 export * from "./schemas/IJsonSchema";
+export * from "./IRandomGenerator";
+export * from "./IValidation";
 export * from "./Primitive";
 export * from "./TypeGuardError";
-export * from "./IValidation";
 
 /* ===========================================================
     SINGLE FUNCTIONS
@@ -853,11 +855,12 @@ export function metadata(): never {
  * would be generated instead.
  *
  * @template T Type of data to generate
+ * @param generator Random data generator
  * @return Randomly generated data
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function random(): never;
+export function random(generator?: Partial<IRandomGenerator>): never;
 
 /**
  * Generate random data.
@@ -870,11 +873,12 @@ export function random(): never;
  * would be generated instead.
  *
  * @template T Type of data to generate
+ * @param generator Random data generator
  * @return Randomly generated data
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function random<T>(): Primitive<T>;
+export function random<T>(generator?: Partial<IRandomGenerator>): Primitive<T>;
 
 /**
  * @internal
@@ -1466,12 +1470,12 @@ export function createIsParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsParse<T>(): (input: string) => T | null;
+export function createIsParse<T>(): (input: string) => Primitive<T> | null;
 
 /**
  * @internal
  */
-export function createIsParse<T>(): (input: string) => T | null {
+export function createIsParse<T>(): (input: string) => Primitive<T> | null {
     halt("createIsParse");
 }
 Object.assign(createIsParse, isParse);
@@ -1495,12 +1499,12 @@ export function createAssertParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertParse<T>(): (input: string) => T;
+export function createAssertParse<T>(): (input: string) => Primitive<T>;
 
 /**
  * @internal
  */
-export function createAssertParse<T>(): (input: string) => T {
+export function createAssertParse<T>(): (input: string) => Primitive<T> {
     halt("createAssertParse");
 }
 Object.assign(createAssertParse, assertParse);
@@ -1524,12 +1528,16 @@ export function createValidateParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateParse<T>(): (input: string) => IValidation<T>;
+export function createValidateParse<T>(): (
+    input: string,
+) => IValidation<Primitive<T>>;
 
 /**
  * @internal
  */
-export function createValidateParse<T>(): (input: string) => IValidation<T> {
+export function createValidateParse<T>(): (
+    input: string,
+) => IValidation<Primitive<T>> {
     halt("createValidateParse");
 }
 Object.assign(createValidateParse, validateParse);
@@ -1661,22 +1669,26 @@ Object.assign(createValidateStringify, validateStringify);
  * Creates a reusable {@link random} function.
  *
  * @danger You have to specify the generic argument `T`
+ * @param generator Random data generator
  * @return Nothing until specifying the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createRandom(): never;
+export function createRandom(generator?: Partial<IRandomGenerator>): never;
 
 /**
  * Creates a resuable {@link random} function.
  *
  * @template T Type of the input value
+ * @param generator Random data generator
  * @returns A reusable `random` function
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createRandom<T>(): () => Primitive<T>;
+export function createRandom<T>(
+    generator?: Partial<IRandomGenerator>,
+): () => Primitive<T>;
 
 /**
  * @internal