typia 5.2.1 → 5.2.2-dev.20231012

package/src/programmers/TypiaProgrammer.ts

@@ -1,169 +1,169 @@
-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 URIError(
-                "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 URIError(
-                    "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 diagnostics: ts.Diagnostic[] = [];
-        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",
-                    ) ?? {},
-                    {
-                        addDiagnostic: (diag) => diagnostics.push(diag),
-                    },
-                ),
-            ],
-            program.getCompilerOptions(),
-        );
-
-        // TRACE ERRORS
-        for (const diag of diagnostics) {
-            const file: string = diag.file
-                ? path.relative(diag.file.fileName, process.cwd())
-                : "(unknown file)";
-            const category: string =
-                diag.category === ts.DiagnosticCategory.Warning
-                    ? "warning"
-                    : diag.category === ts.DiagnosticCategory.Error
-                    ? "error"
-                    : diag.category === ts.DiagnosticCategory.Suggestion
-                    ? "suggestion"
-                    : diag.category === ts.DiagnosticCategory.Message
-                    ? "message"
-                    : "unkown";
-            const [line, pos] = diag.file
-                ? (() => {
-                      const lines: string[] = diag
-                          .file!.text.substring(0, diag.start)
-                          .split("\n");
-                      if (lines.length === 0) return [0, 0];
-                      return [lines.length, lines.at(-1)!.length + 1];
-                  })()
-                : [0, 0];
-            console.error(
-                `${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`,
-            );
-        }
-        if (diagnostics.length) process.exit(-1);
-
-        // 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 (is_supported_extension(file)) container.push(next);
-            }
-        };
-
-    const is_supported_extension = (filename: string): boolean => {
-        return (
-            (filename.endsWith(".ts") && !filename.endsWith(".d.ts")) ||
-            (filename.endsWith(".tsx") && !filename.endsWith(".d.tsx"))
-        );
-    };
-}
+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 URIError(
+                "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 URIError(
+                    "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 diagnostics: ts.Diagnostic[] = [];
+        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",
+                    ) ?? {},
+                    {
+                        addDiagnostic: (diag) => diagnostics.push(diag),
+                    },
+                ),
+            ],
+            program.getCompilerOptions(),
+        );
+
+        // TRACE ERRORS
+        for (const diag of diagnostics) {
+            const file: string = diag.file
+                ? path.relative(diag.file.fileName, process.cwd())
+                : "(unknown file)";
+            const category: string =
+                diag.category === ts.DiagnosticCategory.Warning
+                    ? "warning"
+                    : diag.category === ts.DiagnosticCategory.Error
+                    ? "error"
+                    : diag.category === ts.DiagnosticCategory.Suggestion
+                    ? "suggestion"
+                    : diag.category === ts.DiagnosticCategory.Message
+                    ? "message"
+                    : "unkown";
+            const [line, pos] = diag.file
+                ? (() => {
+                      const lines: string[] = diag
+                          .file!.text.substring(0, diag.start)
+                          .split("\n");
+                      if (lines.length === 0) return [0, 0];
+                      return [lines.length, lines.at(-1)!.length + 1];
+                  })()
+                : [0, 0];
+            console.error(
+                `${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`,
+            );
+        }
+        if (diagnostics.length) process.exit(-1);
+
+        // 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 (is_supported_extension(file)) container.push(next);
+            }
+        };
+
+    const is_supported_extension = (filename: string): boolean => {
+        return (
+            (filename.endsWith(".ts") && !filename.endsWith(".d.ts")) ||
+            (filename.endsWith(".tsx") && !filename.endsWith(".d.tsx"))
+        );
+    };
+}

package/src/programmers/helpers/NotationJoiner.ts

@@ -1,146 +1,146 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace NotationJoiner {
-    export const object =
-        (rename: (str: string) => string) =>
-        (
-            input: ts.Expression,
-            entries: IExpressionEntry<ts.Expression>[],
-        ): ts.ConciseBody => {
-            if (entries.length === 0) return ts.factory.createIdentifier("{}");
-
-            const regular = entries.filter((e) => e.key.isSoleLiteral());
-            const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
-            const literal = ts.factory.createObjectLiteralExpression(
-                regular.map((entry) => {
-                    const str: string = rename(entry.key.getSoleLiteral()!);
-                    return ts.factory.createPropertyAssignment(
-                        Escaper.variable(str)
-                            ? str
-                            : ts.factory.createStringLiteral(str),
-                        entry.expression,
-                    );
-                }),
-                true,
-            );
-            if (dynamic.length === 0) return literal;
-
-            const key = ts.factory.createIdentifier("key");
-            const output = ts.factory.createIdentifier("output");
-
-            const statements: ts.Statement[] = [];
-            if (regular.length !== 0)
-                statements.push(
-                    ts.factory.createIfStatement(
-                        ts.factory.createCallExpression(
-                            IdentifierFactory.access(
-                                ts.factory.createArrayLiteralExpression(
-                                    regular.map((r) =>
-                                        ts.factory.createStringLiteral(
-                                            r.key.getSoleLiteral()!,
-                                        ),
-                                    ),
-                                ),
-                            )("some"),
-                            undefined,
-                            [
-                                ts.factory.createArrowFunction(
-                                    undefined,
-                                    undefined,
-                                    [IdentifierFactory.parameter("regular")],
-                                    undefined,
-                                    undefined,
-                                    ts.factory.createStrictEquality(
-                                        ts.factory.createIdentifier("regular"),
-                                        ts.factory.createIdentifier("key"),
-                                    ),
-                                ),
-                            ],
-                        ),
-                        ts.factory.createContinueStatement(),
-                    ),
-                );
-            statements.push(
-                ...dynamic.map((entry) =>
-                    ts.factory.createIfStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier(
-                                `RegExp(/${metadata_to_pattern(true)(
-                                    entry.key,
-                                )}/).test`,
-                            ),
-                            undefined,
-                            [key],
-                        ),
-                        ts.factory.createBlock([
-                            ts.factory.createExpressionStatement(
-                                ts.factory.createBinaryExpression(
-                                    ts.factory.createElementAccessExpression(
-                                        output,
-                                        key,
-                                    ),
-                                    ts.factory.createToken(
-                                        ts.SyntaxKind.EqualsToken,
-                                    ),
-                                    entry.expression,
-                                ),
-                            ),
-                            ts.factory.createContinueStatement(),
-                        ]),
-                    ),
-                ),
-            );
-
-            return ts.factory.createBlock([
-                StatementFactory.constant(
-                    "output",
-                    ts.factory.createAsExpression(
-                        literal,
-                        TypeFactory.keyword("any"),
-                    ),
-                ),
-                ts.factory.createForOfStatement(
-                    undefined,
-                    StatementFactory.entry("key")("value"),
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Object.entries"),
-                        undefined,
-                        [input],
-                    ),
-                    ts.factory.createBlock(statements),
-                ),
-                ts.factory.createReturnStatement(output),
-            ]);
-        };
-
-    export const tuple = (
-        children: ts.Expression[],
-        rest: ts.Expression | null,
-    ): ts.Expression => {
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
-                rest === null
-                    ? children
-                    : [...children, ts.factory.createSpreadElement(rest)],
-                true,
-            ),
-            TypeFactory.keyword("any"),
-        );
-    };
-
-    export const array = (input: ts.Expression, arrow: ts.Expression) =>
-        ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(input, "map"),
-            undefined,
-            [arrow],
-        );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace NotationJoiner {
+    export const object =
+        (rename: (str: string) => string) =>
+        (
+            input: ts.Expression,
+            entries: IExpressionEntry<ts.Expression>[],
+        ): ts.ConciseBody => {
+            if (entries.length === 0) return ts.factory.createIdentifier("{}");
+
+            const regular = entries.filter((e) => e.key.isSoleLiteral());
+            const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+            const literal = ts.factory.createObjectLiteralExpression(
+                regular.map((entry) => {
+                    const str: string = rename(entry.key.getSoleLiteral()!);
+                    return ts.factory.createPropertyAssignment(
+                        Escaper.variable(str)
+                            ? str
+                            : ts.factory.createStringLiteral(str),
+                        entry.expression,
+                    );
+                }),
+                true,
+            );
+            if (dynamic.length === 0) return literal;
+
+            const key = ts.factory.createIdentifier("key");
+            const output = ts.factory.createIdentifier("output");
+
+            const statements: ts.Statement[] = [];
+            if (regular.length !== 0)
+                statements.push(
+                    ts.factory.createIfStatement(
+                        ts.factory.createCallExpression(
+                            IdentifierFactory.access(
+                                ts.factory.createArrayLiteralExpression(
+                                    regular.map((r) =>
+                                        ts.factory.createStringLiteral(
+                                            r.key.getSoleLiteral()!,
+                                        ),
+                                    ),
+                                ),
+                            )("some"),
+                            undefined,
+                            [
+                                ts.factory.createArrowFunction(
+                                    undefined,
+                                    undefined,
+                                    [IdentifierFactory.parameter("regular")],
+                                    undefined,
+                                    undefined,
+                                    ts.factory.createStrictEquality(
+                                        ts.factory.createIdentifier("regular"),
+                                        ts.factory.createIdentifier("key"),
+                                    ),
+                                ),
+                            ],
+                        ),
+                        ts.factory.createContinueStatement(),
+                    ),
+                );
+            statements.push(
+                ...dynamic.map((entry) =>
+                    ts.factory.createIfStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier(
+                                `RegExp(/${metadata_to_pattern(true)(
+                                    entry.key,
+                                )}/).test`,
+                            ),
+                            undefined,
+                            [key],
+                        ),
+                        ts.factory.createBlock([
+                            ts.factory.createExpressionStatement(
+                                ts.factory.createBinaryExpression(
+                                    ts.factory.createElementAccessExpression(
+                                        output,
+                                        key,
+                                    ),
+                                    ts.factory.createToken(
+                                        ts.SyntaxKind.EqualsToken,
+                                    ),
+                                    entry.expression,
+                                ),
+                            ),
+                            ts.factory.createContinueStatement(),
+                        ]),
+                    ),
+                ),
+            );
+
+            return ts.factory.createBlock([
+                StatementFactory.constant(
+                    "output",
+                    ts.factory.createAsExpression(
+                        literal,
+                        TypeFactory.keyword("any"),
+                    ),
+                ),
+                ts.factory.createForOfStatement(
+                    undefined,
+                    StatementFactory.entry("key")("value"),
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Object.entries"),
+                        undefined,
+                        [input],
+                    ),
+                    ts.factory.createBlock(statements),
+                ),
+                ts.factory.createReturnStatement(output),
+            ]);
+        };
+
+    export const tuple = (
+        children: ts.Expression[],
+        rest: ts.Expression | null,
+    ): ts.Expression => {
+        return ts.factory.createAsExpression(
+            ts.factory.createArrayLiteralExpression(
+                rest === null
+                    ? children
+                    : [...children, ts.factory.createSpreadElement(rest)],
+                true,
+            ),
+            TypeFactory.keyword("any"),
+        );
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.Expression) =>
+        ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(input, "map"),
+            undefined,
+            [arrow],
+        );
+}

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;
+}