typia 3.5.0-dev.20221222 → 3.5.0-dev.20230107

package/src/Primitive.ts

@@ -1,82 +1,82 @@
-/**
- * Primitive type.
- *
- * `Primitive` is a type of TMP (Type Meta Programming) type who converts its argument as a
- * primitive type.
- *
- * If the target argument is a built-in class who returns its origin primitive type through
- * the `valueOf()` method like the `String` or `Number`, its return type would be the
- * `string` or `number`.
- *
- * Otherwise, the target argument is a type of custom class, all of its custom method would
- * be erased and its prototype would be changed to the primitive `object`. Therefore, return
- * type of the TMP type finally be the primitive object.
- *
- * In addition, if the target argument is a type of custom class and it has a special
- * method `toJSON()`, return type of this `Primitive` would be not `Primitive<Instance>`
- * but `Primitive<ReturnType<Instance.toJSON>>`.
- *
- * Before                  | After
- * ------------------------|----------------------------------------
- * `Boolean`               | `boolean`
- * `Number`                | `number`
- * `String`                | `string`
- * `Class`                 | `object`
- * `Class` with `toJSON()` | `Primitive<ReturnType<Class.toJSON>>`
- * Others                  | No change
- *
- * @template Instance Target argument type.
- * @author Jenogho Nam - https://github.com/samchon
- */
-export type Primitive<T> = _Equal<T, _Primitive<T>> extends true
-    ? T
-    : _Primitive<T>;
-
-type _Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-
-type _Primitive<Instance> = _ValueOf<Instance> extends object
-    ? Instance extends object
-        ? Instance extends IJsonable<infer Raw>
-            ? _ValueOf<Raw> extends object
-                ? Raw extends object
-                    ? _PrimitiveObject<Raw> // object would be primitified
-                    : never // cannot be
-                : _ValueOf<Raw> // atomic value
-            : _PrimitiveObject<Instance> // object would be primitified
-        : never // cannot be
-    : _ValueOf<Instance>;
-
-type _PrimitiveObject<Instance extends object> = Instance extends Array<infer T>
-    ? _Primitive<T>[]
-    : {
-          [P in keyof Instance]: Instance[P] extends Function
-              ? never
-              : _Primitive<Instance[P]>;
-      };
-
-type _ValueOf<Instance> = _IsValueOf<Instance, Boolean> extends true
-    ? boolean
-    : _IsValueOf<Instance, Number> extends true
-    ? number
-    : _IsValueOf<Instance, String> extends true
-    ? string
-    : Instance;
-
-type _IsValueOf<
-    Instance,
-    Object extends IValueOf<any>,
-> = Instance extends Object
-    ? Object extends IValueOf<infer Primitive>
-        ? Instance extends Primitive
-            ? false
-            : true // not Primitive, but Object
-        : false // cannot be
-    : false;
-
-interface IValueOf<T> {
-    valueOf(): T;
-}
-
-interface IJsonable<T> {
-    toJSON(): T;
-}
+/**
+ * Primitive type.
+ *
+ * `Primitive` is a type of TMP (Type Meta Programming) type who converts its argument as a
+ * primitive type.
+ *
+ * If the target argument is a built-in class who returns its origin primitive type through
+ * the `valueOf()` method like the `String` or `Number`, its return type would be the
+ * `string` or `number`.
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom method would
+ * be erased and its prototype would be changed to the primitive `object`. Therefore, return
+ * type of the TMP type finally be the primitive object.
+ *
+ * In addition, if the target argument is a type of custom class and it has a special
+ * method `toJSON()`, return type of this `Primitive` would be not `Primitive<Instance>`
+ * but `Primitive<ReturnType<Instance.toJSON>>`.
+ *
+ * Before                  | After
+ * ------------------------|----------------------------------------
+ * `Boolean`               | `boolean`
+ * `Number`                | `number`
+ * `String`                | `string`
+ * `Class`                 | `object`
+ * `Class` with `toJSON()` | `Primitive<ReturnType<Class.toJSON>>`
+ * Others                  | No change
+ *
+ * @template Instance Target argument type.
+ * @author Jenogho Nam - https://github.com/samchon
+ */
+export type Primitive<T> = _Equal<T, _Primitive<T>> extends true
+    ? T
+    : _Primitive<T>;
+
+type _Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type _Primitive<Instance> = _ValueOf<Instance> extends object
+    ? Instance extends object
+        ? Instance extends IJsonable<infer Raw>
+            ? _ValueOf<Raw> extends object
+                ? Raw extends object
+                    ? _PrimitiveObject<Raw> // object would be primitified
+                    : never // cannot be
+                : _ValueOf<Raw> // atomic value
+            : _PrimitiveObject<Instance> // object would be primitified
+        : never // cannot be
+    : _ValueOf<Instance>;
+
+type _PrimitiveObject<Instance extends object> = Instance extends Array<infer T>
+    ? _Primitive<T>[]
+    : {
+          [P in keyof Instance]: Instance[P] extends Function
+              ? never
+              : _Primitive<Instance[P]>;
+      };
+
+type _ValueOf<Instance> = _IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : _IsValueOf<Instance, Number> extends true
+    ? number
+    : _IsValueOf<Instance, String> extends true
+    ? string
+    : Instance;
+
+type _IsValueOf<
+    Instance,
+    Object extends IValueOf<any>,
+> = Instance extends Object
+    ? Object extends IValueOf<infer Primitive>
+        ? Instance extends Primitive
+            ? false
+            : true // not Primitive, but Object
+        : false // cannot be
+    : false;
+
+interface IValueOf<T> {
+    valueOf(): T;
+}
+
+interface IJsonable<T> {
+    toJSON(): T;
+}

package/src/TypeGuardError.ts

@@ -1,36 +1,36 @@
-export class TypeGuardError extends Error {
-    public readonly method: string;
-    public readonly path: string | undefined;
-    public readonly expected: string;
-    public readonly value: any;
-
-    public constructor(props: TypeGuardError.IProps) {
-        // MESSAGE CONSTRUCTION
-        super(
-            props.message ||
-                `Error on ${props.method}(): invalid type${
-                    props.path ? ` on ${props.path}` : ""
-                }, expect to be ${props.expected}`,
-        );
-
-        // INHERITANCE POLYFILL
-        const proto = new.target.prototype;
-        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
-        else (this as any).__proto__ = proto;
-
-        // ASSIGN MEMBERS
-        this.method = props.method;
-        this.path = props.path;
-        this.expected = props.expected;
-        this.value = props.value;
-    }
-}
-export namespace TypeGuardError {
-    export interface IProps {
-        method: string;
-        path?: string;
-        expected: string;
-        value: any;
-        message?: string;
-    }
-}
+export class TypeGuardError extends Error {
+    public readonly method: string;
+    public readonly path: string | undefined;
+    public readonly expected: string;
+    public readonly value: any;
+
+    public constructor(props: TypeGuardError.IProps) {
+        // MESSAGE CONSTRUCTION
+        super(
+            props.message ||
+                `Error on ${props.method}(): invalid type${
+                    props.path ? ` on ${props.path}` : ""
+                }, expect to be ${props.expected}`,
+        );
+
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+        else (this as any).__proto__ = proto;
+
+        // ASSIGN MEMBERS
+        this.method = props.method;
+        this.path = props.path;
+        this.expected = props.expected;
+        this.value = props.value;
+    }
+}
+export namespace TypeGuardError {
+    export interface IProps {
+        method: string;
+        path?: string;
+        expected: string;
+        value: any;
+        message?: string;
+    }
+}

package/src/executable/internal/CommandParser.ts

@@ -1,15 +1,15 @@
-export namespace CommandParser {
-    export function parse(argList: string[]): Record<string, string> {
-        const output: Record<string, string> = {};
-        argList.forEach((arg, i) => {
-            if (arg.startsWith("--") === false) return;
-
-            const key = arg.slice(2);
-            const value: string | undefined = argList[i + 1];
-            if (value === undefined || value.startsWith("--")) return;
-
-            output[key] = value;
-        });
-        return output;
-    }
-}
+export namespace CommandParser {
+    export function parse(argList: string[]): Record<string, string> {
+        const output: Record<string, string> = {};
+        argList.forEach((arg, i) => {
+            if (arg.startsWith("--") === false) return;
+
+            const key = arg.slice(2);
+            const value: string | undefined = argList[i + 1];
+            if (value === undefined || value.startsWith("--")) return;
+
+            output[key] = value;
+        });
+        return output;
+    }
+}

package/src/executable/internal/TypiaSetupWizard.ts

@@ -3,19 +3,24 @@ import type Comment from "comment-json";
 import fs from "fs";
 
 export namespace TypiaSetupWizard {
-    export async function ttypescript(manager: string): Promise<void> {
+    export interface IArguments {
+        manager: "npm" | "pnpm" | "yarn";
+        project: string;
+    }
+
+    export async function ttypescript(args: IArguments): Promise<void> {
         // INSTALL
-        const pack: any = await prepare(manager);
-        add(manager)(pack)("ttypescript", true);
-        add(manager)(pack)("ts-node", true);
+        const pack: any = await prepare(args.manager);
+        add(args.manager)(pack)("ttypescript", true);
+        add(args.manager)(pack)("ts-node", true);
 
         // TSCONFIG.JSON
-        await configure(manager)(pack);
+        await configure(args)(pack);
     }
 
-    export async function tsPatch(manager: string): Promise<void> {
+    export async function tsPatch(args: IArguments): Promise<void> {
         // INSTALL
-        add(manager)(await prepare(manager))("ts-patch", true);
+        add(args.manager)(await prepare(args.manager))("ts-patch", true);
         execute("npx ts-patch install");
 
         // PACKAGE.JSON
@@ -37,7 +42,7 @@ export namespace TypiaSetupWizard {
         );
 
         // TSCONFIG.JSON
-        await configure(manager)(pack);
+        await configure(args)(pack);
     }
 
     async function prepare(manager: string): Promise<any> {
@@ -54,22 +59,25 @@ export namespace TypiaSetupWizard {
     }
 
     const configure =
-        (manager: string) =>
+        (args: IArguments) =>
         async (pack: any): Promise<void> => {
             // VALIDATE PRERATATION
-            if (fs.existsSync("tsconfig.json") === false) {
-                execute("npx tsc --init");
-                if (fs.existsSync("tsconfig.json") === false)
-                    halt(() => {})("tsconfig.json file does not exist.");
+            if (fs.existsSync(args.project) === false) {
+                if (args.project === "tsconfig.json") execute("npx tsc --init");
+                if (fs.existsSync(args.project) === false)
+                    halt(() => {})(`${args.project} file does not exist.`);
             }
 
+            // INSTALL COMMENT-JSON FOR A WHILE
             const temporary: boolean = !fs.existsSync(
                 "node_modules/comment-json",
             );
-            if (temporary === true) add(manager)(pack)("comment-json", true);
+            if (temporary === true)
+                add(args.manager)(pack)("comment-json", true);
 
             const halter: (msg: string) => never = halt(() => {
-                if (temporary === true) remove(manager)("comment-json", true);
+                if (temporary === true)
+                    remove(args.manager)("comment-json", true);
             });
 
             // READ TSCONFIG FILE
@@ -77,16 +85,17 @@ export namespace TypiaSetupWizard {
                 process.cwd() + "/node_modules/comment-json"
             );
             const config: Comment.CommentObject = Comment.parse(
-                await fs.promises.readFile("tsconfig.json", "utf8"),
+                await fs.promises.readFile(args.project, "utf8"),
             ) as Comment.CommentObject;
             const options = config.compilerOptions as
                 | Comment.CommentObject
                 | undefined;
             if (options === undefined)
                 halter(
-                    `tsconfig.json file does not have "compilerOptions" property.`,
+                    `${args.project} file does not have "compilerOptions" property.`,
                 );
 
+            // PREPARE PLUGINS
             const plugins: Comment.CommentArray<Comment.CommentObject> =
                 (() => {
                     const plugins = options.plugins as
@@ -96,7 +105,7 @@ export namespace TypiaSetupWizard {
                         return (options.plugins = [] as any);
                     else if (!Array.isArray(plugins))
                         halter(
-                            `"plugins" property of tsconfig.json must be array type.`,
+                            `"plugins" property of ${args.project} must be array type.`,
                         );
                     return plugins;
                 })();
@@ -112,7 +121,7 @@ export namespace TypiaSetupWizard {
 
             if (strict === true && oldbie !== undefined) {
                 console.log(
-                    "you've been already configured the tsconfig.json file.",
+                    `you've been already configured the ${args.project} file.`,
                 );
             } else {
                 // DO CONFIGURE
@@ -125,11 +134,11 @@ export namespace TypiaSetupWizard {
                             }`) as Comment.CommentObject,
                     );
                 await fs.promises.writeFile(
-                    "tsconfig.json",
+                    args.project,
                     Comment.stringify(config, null, 2),
                 );
             }
-            if (temporary === true) remove(manager)("comment-json", false);
+            if (temporary === true) remove(args.manager)("comment-json", false);
         };
 }
 

package/src/executable/typia.ts

@@ -1,46 +1,48 @@
-#!/usr/bin/env node
-import { CommandParser } from "./internal/CommandParser";
-import { TypiaSetupWizard } from "./internal/TypiaSetupWizard";
-
-const USAGE = `Wrong command has been detected. Use like below:
-
-  npx typia setup \\
-    --compiler (ttypescript|ts-patch) \\
-    --manager (npm|pnpm|yarn)
-
-  - npx typia setup
-  - npx typia setup --compiler ttypescript
-  - npx typia setup --compiler ts-patch
-  - npx typia setup --manager pnpm`;
-
-function halt(desc: string): never {
-    console.error(desc);
-    process.exit(-1);
-}
-
-async function setup(): Promise<void> {
-    const options: Record<string, string> = CommandParser.parse(
-        process.argv.slice(3),
-    );
-    const manager: string = options.manager ?? "npm";
-    const compiler: string = options.compiler ?? "ttypescript";
-
-    if (
-        (compiler !== "ttypescript" && compiler !== "ts-patch") ||
-        (manager !== "npm" && manager !== "pnpm" && manager !== "yarn")
-    )
-        halt(USAGE);
-    else if (compiler === "ttypescript")
-        await TypiaSetupWizard.ttypescript(manager);
-    else await TypiaSetupWizard.tsPatch(manager);
-}
-
-async function main(): Promise<void> {
-    const type: string | undefined = process.argv[2];
-    if (type === "setup") await setup();
-    else halt(USAGE);
-}
-main().catch((exp) => {
-    console.error(exp);
-    process.exit(-1);
-});
+#!/usr/bin/env node
+import { CommandParser } from "./internal/CommandParser";
+import { TypiaSetupWizard } from "./internal/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`;
+
+function halt(desc: string): never {
+    console.error(desc);
+    process.exit(-1);
+}
+
+async function setup(): Promise<void> {
+    const options: Record<string, string> = CommandParser.parse(
+        process.argv.slice(3),
+    );
+    const manager: string = options.manager ?? "npm";
+    const compiler: string = options.compiler ?? "ttypescript";
+    const project: string = options.project ?? "tsconfig.json";
+
+    if (
+        (compiler !== "ttypescript" && compiler !== "ts-patch") ||
+        (manager !== "npm" && manager !== "pnpm" && manager !== "yarn")
+    )
+        halt(USAGE);
+    else if (compiler === "ttypescript")
+        await TypiaSetupWizard.ttypescript({ manager, project });
+    else await TypiaSetupWizard.tsPatch({ manager, project });
+}
+
+async function main(): Promise<void> {
+    const type: string | undefined = process.argv[2];
+    if (type === "setup") await setup();
+    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,66 +1,66 @@
-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),
-        );
-    }
-}
+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),
+        );
+    }
+}