typia 4.2.0 → 4.2.1

package/src/factories/TypeFactory.ts

@@ -1,124 +1,124 @@
-import ts from "typescript";
-
-export namespace TypeFactory {
-    export const resolve =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type): ts.Type | null =>
-            getReturnType(checker)(type)("toJSON");
-
-    export const isFunction = (type: ts.Type): boolean =>
-        getFunction(type) !== null;
-
-    const getFunction = (type: ts.Type) => {
-        const node = type.symbol?.declarations?.[0];
-        if (node === undefined) return null;
-
-        return ts.isFunctionLike(node)
-            ? node
-            : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
-            ? ts.isFunctionLike(node.initializer)
-                ? node.initializer
-                : null
-            : null;
-    };
-
-    export const getReturnType =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type) =>
-        (name: string): ts.Type | null => {
-            // FIND TO-JSON METHOD
-            const symbol: ts.Symbol | undefined = type.getProperty(name);
-            if (!symbol) return null;
-            else if (!symbol.valueDeclaration) return null;
-
-            // GET FUNCTION DECLARATION
-            const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
-                symbol,
-                symbol.valueDeclaration,
-            );
-
-            // RETURNS THE RETURN-TYPE
-            const signature: ts.Signature | undefined =
-                checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
-            return signature ? signature.getReturnType() : null;
-        };
-
-    export const getFullName =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type, symbol?: ts.Symbol): string => {
-            // PRIMITIVE
-            symbol ??= type.aliasSymbol ?? type.getSymbol();
-            if (symbol === undefined) return checker.typeToString(type);
-
-            // UNION OR INTERSECT
-            if (
-                type.aliasSymbol === undefined &&
-                type.isUnionOrIntersection()
-            ) {
-                const joiner: string = type.isIntersection() ? " & " : " | ";
-                return type.types
-                    .map((child) => getFullName(checker)(child))
-                    .join(joiner);
-            }
-
-            //----
-            // SPECIALIZATION
-            //----
-            const name: string = get_name(symbol);
-
-            // CHECK GENERIC
-            const generic: readonly ts.Type[] = type.aliasSymbol
-                ? type.aliasTypeArguments || []
-                : checker.getTypeArguments(type as ts.TypeReference);
-            return generic.length
-                ? name === "Promise"
-                    ? getFullName(checker)(generic[0]!)
-                    : `${name}<${generic
-                          .map((child) => getFullName(checker)(child))
-                          .join(", ")}>`
-                : name;
-        };
-
-    const explore_name =
-        (decl: ts.Node) =>
-        (name: string): string =>
-            ts.isModuleBlock(decl)
-                ? explore_name(decl.parent.parent)(
-                      `${decl.parent.name.getFullText().trim()}.${name}`,
-                  )
-                : name;
-
-    const get_name = (symbol: ts.Symbol): string => {
-        const parent = symbol.getDeclarations()?.[0]?.parent;
-        return parent
-            ? explore_name(parent)(symbol.escapedName.toString())
-            : "__type";
-    };
-
-    export const keyword = (
-        type:
-            | "void"
-            | "any"
-            | "unknown"
-            | "boolean"
-            | "number"
-            | "bigint"
-            | "string",
-    ) => {
-        return ts.factory.createKeywordTypeNode(
-            type === "void"
-                ? ts.SyntaxKind.VoidKeyword
-                : type === "any"
-                ? ts.SyntaxKind.AnyKeyword
-                : type === "unknown"
-                ? ts.SyntaxKind.UnknownKeyword
-                : type === "boolean"
-                ? ts.SyntaxKind.BooleanKeyword
-                : type === "number"
-                ? ts.SyntaxKind.NumberKeyword
-                : type === "bigint"
-                ? ts.SyntaxKind.BigIntKeyword
-                : ts.SyntaxKind.StringKeyword,
-        );
-    };
-}
+import ts from "typescript";
+
+export namespace TypeFactory {
+    export const resolve =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type): ts.Type | null =>
+            getReturnType(checker)(type)("toJSON");
+
+    export const isFunction = (type: ts.Type): boolean =>
+        getFunction(type) !== null;
+
+    const getFunction = (type: ts.Type) => {
+        const node = type.symbol?.declarations?.[0];
+        if (node === undefined) return null;
+
+        return ts.isFunctionLike(node)
+            ? node
+            : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
+            ? ts.isFunctionLike(node.initializer)
+                ? node.initializer
+                : null
+            : null;
+    };
+
+    export const getReturnType =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type) =>
+        (name: string): ts.Type | null => {
+            // FIND TO-JSON METHOD
+            const symbol: ts.Symbol | undefined = type.getProperty(name);
+            if (!symbol) return null;
+            else if (!symbol.valueDeclaration) return null;
+
+            // GET FUNCTION DECLARATION
+            const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
+                symbol,
+                symbol.valueDeclaration,
+            );
+
+            // RETURNS THE RETURN-TYPE
+            const signature: ts.Signature | undefined =
+                checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
+            return signature ? signature.getReturnType() : null;
+        };
+
+    export const getFullName =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type, symbol?: ts.Symbol): string => {
+            // PRIMITIVE
+            symbol ??= type.aliasSymbol ?? type.getSymbol();
+            if (symbol === undefined) return checker.typeToString(type);
+
+            // UNION OR INTERSECT
+            if (
+                type.aliasSymbol === undefined &&
+                type.isUnionOrIntersection()
+            ) {
+                const joiner: string = type.isIntersection() ? " & " : " | ";
+                return type.types
+                    .map((child) => getFullName(checker)(child))
+                    .join(joiner);
+            }
+
+            //----
+            // SPECIALIZATION
+            //----
+            const name: string = get_name(symbol);
+
+            // CHECK GENERIC
+            const generic: readonly ts.Type[] = type.aliasSymbol
+                ? type.aliasTypeArguments || []
+                : checker.getTypeArguments(type as ts.TypeReference);
+            return generic.length
+                ? name === "Promise"
+                    ? getFullName(checker)(generic[0]!)
+                    : `${name}<${generic
+                          .map((child) => getFullName(checker)(child))
+                          .join(", ")}>`
+                : name;
+        };
+
+    const explore_name =
+        (decl: ts.Node) =>
+        (name: string): string =>
+            ts.isModuleBlock(decl)
+                ? explore_name(decl.parent.parent)(
+                      `${decl.parent.name.getFullText().trim()}.${name}`,
+                  )
+                : name;
+
+    const get_name = (symbol: ts.Symbol): string => {
+        const parent = symbol.getDeclarations()?.[0]?.parent;
+        return parent
+            ? explore_name(parent)(symbol.escapedName.toString())
+            : "__type";
+    };
+
+    export const keyword = (
+        type:
+            | "void"
+            | "any"
+            | "unknown"
+            | "boolean"
+            | "number"
+            | "bigint"
+            | "string",
+    ) => {
+        return ts.factory.createKeywordTypeNode(
+            type === "void"
+                ? ts.SyntaxKind.VoidKeyword
+                : type === "any"
+                ? ts.SyntaxKind.AnyKeyword
+                : type === "unknown"
+                ? ts.SyntaxKind.UnknownKeyword
+                : type === "boolean"
+                ? ts.SyntaxKind.BooleanKeyword
+                : type === "number"
+                ? ts.SyntaxKind.NumberKeyword
+                : type === "bigint"
+                ? ts.SyntaxKind.BigIntKeyword
+                : ts.SyntaxKind.StringKeyword,
+        );
+    };
+}

package/src/functional/$string.ts

@@ -1,50 +1,50 @@
-/**
- * In the past, name of `typia` was `typescript-json`, and supported
- * JSON serialization by wrapping `fast-json-stringify. `typescript-json` was
- * a helper library of `fast-json-stringify`, which can skip manual JSON schema
- * definition just by putting pure TypeScript type.
- *
- * This `$string` function is a part of `fast-json-stringify` at that time, and
- * still being used in `typia` for the string serialization.
- *
- * @internal
- * @reference https://github.com/fastify/fast-json-stringify/blob/master/lib/serializer.js
- * @blog https://dev.to/samchon/good-bye-typescript-is-ancestor-of-typia-20000x-faster-validator-49fi
- */
-export const $string = (str: string): string => {
-    if (STR_ESCAPE.test(str) === false) return `"${str}"`;
-
-    const length: number = str.length;
-    if (length > 41) return JSON.stringify(str);
-
-    let result = "";
-    let last = -1;
-    let point = 255;
-
-    // eslint-disable-next-line
-    for (let i = 0; i < length; ++i) {
-        point = str.charCodeAt(i);
-        if (point < 32) {
-            return JSON.stringify(str);
-        }
-        if (point >= 0xd800 && point <= 0xdfff) {
-            // The current character is a surrogate.
-            return JSON.stringify(str);
-        }
-        if (
-            point === 0x22 || // '"'
-            point === 0x5c // '\'
-        ) {
-            last === -1 && (last = 0);
-            result += str.slice(last, i) + "\\";
-            last = i;
-        }
-    }
-
-    return (
-        (last === -1 && '"' + str + '"') || '"' + result + str.slice(last) + '"'
-    );
-};
-
-const STR_ESCAPE =
-    /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/;
+/**
+ * In the past, name of `typia` was `typescript-json`, and supported
+ * JSON serialization by wrapping `fast-json-stringify. `typescript-json` was
+ * a helper library of `fast-json-stringify`, which can skip manual JSON schema
+ * definition just by putting pure TypeScript type.
+ *
+ * This `$string` function is a part of `fast-json-stringify` at that time, and
+ * still being used in `typia` for the string serialization.
+ *
+ * @internal
+ * @reference https://github.com/fastify/fast-json-stringify/blob/master/lib/serializer.js
+ * @blog https://dev.to/samchon/good-bye-typescript-is-ancestor-of-typia-20000x-faster-validator-49fi
+ */
+export const $string = (str: string): string => {
+    if (STR_ESCAPE.test(str) === false) return `"${str}"`;
+
+    const length: number = str.length;
+    if (length > 41) return JSON.stringify(str);
+
+    let result = "";
+    let last = -1;
+    let point = 255;
+
+    // eslint-disable-next-line
+    for (let i = 0; i < length; ++i) {
+        point = str.charCodeAt(i);
+        if (point < 32) {
+            return JSON.stringify(str);
+        }
+        if (point >= 0xd800 && point <= 0xdfff) {
+            // The current character is a surrogate.
+            return JSON.stringify(str);
+        }
+        if (
+            point === 0x22 || // '"'
+            point === 0x5c // '\'
+        ) {
+            last === -1 && (last = 0);
+            result += str.slice(last, i) + "\\";
+            last = i;
+        }
+    }
+
+    return (
+        (last === -1 && '"' + str + '"') || '"' + result + str.slice(last) + '"'
+    );
+};
+
+const STR_ESCAPE =
+    /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/;

package/src/programmers/RandomProgrammer.ts

@@ -219,9 +219,7 @@ export namespace RandomProgrammer {
             const expressions: ts.Expression[] = [];
             if (meta.any)
                 expressions.push(
-                    ts.factory.createStringLiteral(
-                        "any type used...",
-                    ),
+                    ts.factory.createStringLiteral("any type used..."),
                 );
 
             // NULL COALESCING

package/src/programmers/TypiaProgrammer.ts

@@ -1,129 +1,129 @@
-import fs from "fs";
-import path from "path";
-import ts from "typescript";
-
-import { ImportTransformer } from "../transformers/ImportTransformer";
-
-import transform from "../transform";
-
-export namespace TypiaProgrammer {
-    export interface IProps {
-        input: string;
-        output: string;
-        project: string;
-    }
-
-    export const build = async (
-        props: TypiaProgrammer.IProps,
-    ): Promise<void> => {
-        props.input = path.resolve(props.input);
-        props.output = path.resolve(props.output);
-
-        if ((await is_directory(props.input)) === false)
-            throw new Error(
-                "Error on TypiaGenerator.generate(): input path is not a directory.",
-            );
-        else if (fs.existsSync(props.output) === false)
-            await fs.promises.mkdir(props.output, { recursive: true });
-        else if ((await is_directory(props.output)) === false) {
-            const parent: string = path.join(props.output, "..");
-            if ((await is_directory(parent)) === false)
-                throw new Error(
-                    "Error on TypiaGenerator.generate(): output path is not a directory.",
-                );
-            await fs.promises.mkdir(props.output);
-        }
-
-        // CREATE PROGRAM
-        const { options: compilerOptions } = ts.parseJsonConfigFileContent(
-            ts.readConfigFile(props.project, ts.sys.readFile).config,
-            {
-                fileExists: ts.sys.fileExists,
-                readFile: ts.sys.readFile,
-                readDirectory: ts.sys.readDirectory,
-                useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
-            },
-            path.dirname(props.project),
-        );
-
-        const program: ts.Program = ts.createProgram(
-            await (async () => {
-                const container: string[] = [];
-                await gather(props)(container)(props.input)(props.output);
-                return container;
-            })(),
-            compilerOptions,
-        );
-
-        // DO TRANSFORM
-        const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
-            program
-                .getSourceFiles()
-                .filter(
-                    (file) =>
-                        !file.isDeclarationFile &&
-                        path.resolve(file.fileName).indexOf(props.input) !== -1,
-                ),
-            [
-                ImportTransformer.transform(props.input)(props.output),
-                transform(
-                    program,
-                    ((compilerOptions.plugins as any[]) ?? []).find(
-                        (p: any) =>
-                            p.transform === "typia/lib/transform" ||
-                            p.transform === "../src/transform.ts",
-                    ) ?? {},
-                ),
-            ],
-            program.getCompilerOptions(),
-        );
-
-        // ARCHIVE TRANSFORMED FILES
-        const printer: ts.Printer = ts.createPrinter({
-            newLine: ts.NewLineKind.LineFeed,
-        });
-        for (const file of result.transformed) {
-            const to: string = path
-                .resolve(file.fileName)
-                .replace(props.input, props.output);
-
-            const content: string = printer.printFile(file);
-            await fs.promises.writeFile(to, emend(content), "utf8");
-        }
-    };
-
-    const emend = (content: string): string => {
-        if (
-            content.indexOf("typia.") === -1 ||
-            content.indexOf("import typia") !== -1 ||
-            content.indexOf("import * as typia") !== -1
-        )
-            return content;
-        return `import typia from "typia";\n\n${content}`;
-    };
-
-    const is_directory = async (current: string): Promise<boolean> => {
-        const stat: fs.Stats = await fs.promises.stat(current);
-        return stat.isDirectory();
-    };
-
-    const gather =
-        (props: IProps) =>
-        (container: string[]) =>
-        (from: string) =>
-        async (to: string) => {
-            if (from === props.output) return;
-            else if (fs.existsSync(to) === false) await fs.promises.mkdir(to);
-
-            for (const file of await fs.promises.readdir(from)) {
-                const next: string = path.join(from, file);
-                const stat: fs.Stats = await fs.promises.stat(next);
-
-                if (stat.isDirectory()) {
-                    await gather(props)(container)(next)(path.join(to, file));
-                    continue;
-                } else if (file.substring(file.length - 3) === ".ts")
-                    container.push(next);
-            }
-        };
-}
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+
+import { ImportTransformer } from "../transformers/ImportTransformer";
+
+import transform from "../transform";
+
+export namespace TypiaProgrammer {
+    export interface IProps {
+        input: string;
+        output: string;
+        project: string;
+    }
+
+    export const build = async (
+        props: TypiaProgrammer.IProps,
+    ): Promise<void> => {
+        props.input = path.resolve(props.input);
+        props.output = path.resolve(props.output);
+
+        if ((await is_directory(props.input)) === false)
+            throw new Error(
+                "Error on TypiaGenerator.generate(): input path is not a directory.",
+            );
+        else if (fs.existsSync(props.output) === false)
+            await fs.promises.mkdir(props.output, { recursive: true });
+        else if ((await is_directory(props.output)) === false) {
+            const parent: string = path.join(props.output, "..");
+            if ((await is_directory(parent)) === false)
+                throw new Error(
+                    "Error on TypiaGenerator.generate(): output path is not a directory.",
+                );
+            await fs.promises.mkdir(props.output);
+        }
+
+        // CREATE PROGRAM
+        const { options: compilerOptions } = ts.parseJsonConfigFileContent(
+            ts.readConfigFile(props.project, ts.sys.readFile).config,
+            {
+                fileExists: ts.sys.fileExists,
+                readFile: ts.sys.readFile,
+                readDirectory: ts.sys.readDirectory,
+                useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+            },
+            path.dirname(props.project),
+        );
+
+        const program: ts.Program = ts.createProgram(
+            await (async () => {
+                const container: string[] = [];
+                await gather(props)(container)(props.input)(props.output);
+                return container;
+            })(),
+            compilerOptions,
+        );
+
+        // DO TRANSFORM
+        const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
+            program
+                .getSourceFiles()
+                .filter(
+                    (file) =>
+                        !file.isDeclarationFile &&
+                        path.resolve(file.fileName).indexOf(props.input) !== -1,
+                ),
+            [
+                ImportTransformer.transform(props.input)(props.output),
+                transform(
+                    program,
+                    ((compilerOptions.plugins as any[]) ?? []).find(
+                        (p: any) =>
+                            p.transform === "typia/lib/transform" ||
+                            p.transform === "../src/transform.ts",
+                    ) ?? {},
+                ),
+            ],
+            program.getCompilerOptions(),
+        );
+
+        // ARCHIVE TRANSFORMED FILES
+        const printer: ts.Printer = ts.createPrinter({
+            newLine: ts.NewLineKind.LineFeed,
+        });
+        for (const file of result.transformed) {
+            const to: string = path
+                .resolve(file.fileName)
+                .replace(props.input, props.output);
+
+            const content: string = printer.printFile(file);
+            await fs.promises.writeFile(to, emend(content), "utf8");
+        }
+    };
+
+    const emend = (content: string): string => {
+        if (
+            content.indexOf("typia.") === -1 ||
+            content.indexOf("import typia") !== -1 ||
+            content.indexOf("import * as typia") !== -1
+        )
+            return content;
+        return `import typia from "typia";\n\n${content}`;
+    };
+
+    const is_directory = async (current: string): Promise<boolean> => {
+        const stat: fs.Stats = await fs.promises.stat(current);
+        return stat.isDirectory();
+    };
+
+    const gather =
+        (props: IProps) =>
+        (container: string[]) =>
+        (from: string) =>
+        async (to: string) => {
+            if (from === props.output) return;
+            else if (fs.existsSync(to) === false) await fs.promises.mkdir(to);
+
+            for (const file of await fs.promises.readdir(from)) {
+                const next: string = path.join(from, file);
+                const stat: fs.Stats = await fs.promises.stat(next);
+
+                if (stat.isDirectory()) {
+                    await gather(props)(container)(next)(path.join(to, file));
+                    continue;
+                } else if (file.substring(file.length - 3) === ".ts")
+                    container.push(next);
+            }
+        };
+}

package/src/programmers/helpers/OptionPredicator.ts

@@ -1,15 +1,15 @@
-import { ITransformOptions } from "../../transformers/ITransformOptions";
-
-export namespace OptionPredicator {
-    export const numeric = (options: ITransformOptions): boolean =>
-        finite(options) || options.numeric === true;
-
-    export const functional = (options: ITransformOptions): boolean =>
-        options.functional === true;
-
-    export const finite = (options: ITransformOptions): boolean =>
-        options.finite === true;
-
-    export const undefined = (options: ITransformOptions): boolean =>
-        options.undefined !== false;
-}
+import { ITransformOptions } from "../../transformers/ITransformOptions";
+
+export namespace OptionPredicator {
+    export const numeric = (options: ITransformOptions): boolean =>
+        finite(options) || options.numeric === true;
+
+    export const functional = (options: ITransformOptions): boolean =>
+        options.functional === true;
+
+    export const finite = (options: ITransformOptions): boolean =>
+        options.finite === true;
+
+    export const undefined = (options: ITransformOptions): boolean =>
+        options.undefined !== false;
+}