typia 3.8.0-dev.20230413 → 3.8.0-dev.20230416

package/src/factories/TypiaFileFactory.ts

@@ -1,120 +1,120 @@
-import fs from "fs";
-import path from "path";
-import ts from "typescript";
-
-import { ImportTransformer } from "../transformers/ImportTransformer";
-
-import transform from "../transform";
-
-export namespace TypiaFileFactory {
-    export interface IProps {
-        input: string;
-        output: string;
-        project: string;
-    }
-
-    export async function generate(
-        props: TypiaFileFactory.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 { config } = ts.readConfigFile(props.project, ts.sys.readFile);
-
-        const program: ts.Program = ts.createProgram(
-            await (async () => {
-                const container: string[] = [];
-                await gather(props)(container)(props.input)(props.output);
-                return container;
-            })(),
-            config.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,
-                    (config.compilerOptions.plugins ?? []).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 TypiaFileFactory {
+    export interface IProps {
+        input: string;
+        output: string;
+        project: string;
+    }
+
+    export async function generate(
+        props: TypiaFileFactory.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 { config } = ts.readConfigFile(props.project, ts.sys.readFile);
+
+        const program: ts.Program = ts.createProgram(
+            await (async () => {
+                const container: string[] = [];
+                await gather(props)(container)(props.input)(props.output);
+                return container;
+            })(),
+            config.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,
+                    (config.compilerOptions.plugins ?? []).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/factories/ValueFactory.ts

@@ -1,12 +1,12 @@
-import ts from "typescript";
-
-export namespace ValueFactory {
-    export const NULL = () => ts.factory.createNull();
-    export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
-    export const BOOLEAN = (value: boolean) =>
-        value ? ts.factory.createTrue() : ts.factory.createFalse();
-    export const INPUT = (str: string = "input") =>
-        ts.factory.createIdentifier(str);
-    export const TYPEOF = (input: ts.Expression) =>
-        ts.factory.createTypeOfExpression(input);
-}
+import ts from "typescript";
+
+export namespace ValueFactory {
+    export const NULL = () => ts.factory.createNull();
+    export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
+    export const BOOLEAN = (value: boolean) =>
+        value ? ts.factory.createTrue() : ts.factory.createFalse();
+    export const INPUT = (str: string = "input") =>
+        ts.factory.createIdentifier(str);
+    export const TYPEOF = (input: ts.Expression) =>
+        ts.factory.createTypeOfExpression(input);
+}

package/src/factories/internal/metadata/MetadataHelper.ts

@@ -1,12 +1,12 @@
-import { Metadata } from "../../../metadata/Metadata";
-
-export namespace MetadataHelper {
-    export function literal_to_metadata(key: string): Metadata {
-        const metadata: Metadata = Metadata.initialize();
-        metadata.constants.push({
-            type: "string",
-            values: [key],
-        });
-        return metadata;
-    }
-}
+import { Metadata } from "../../../metadata/Metadata";
+
+export namespace MetadataHelper {
+    export function literal_to_metadata(key: string): Metadata {
+        const metadata: Metadata = Metadata.initialize();
+        metadata.constants.push({
+            type: "string",
+            values: [key],
+        });
+        return metadata;
+    }
+}

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -1,142 +1,142 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { CommentFactory } from "../../CommentFactory";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataTagFactory } from "../../MetadataTagFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_object =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (parent: ts.Type, nullable: boolean): MetadataObject => {
-        // EMPLACE OBJECT
-        const [obj, newbie] = collection.emplace(checker, parent);
-        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
-        if (newbie === false) return obj;
-
-        // PREPARE ASSETS
-        const isClass: boolean = parent.isClass();
-        const pred: (node: ts.Declaration) => boolean = isClass
-            ? (node) => {
-                  const kind: ts.SyntaxKind | undefined = node
-                      .getChildren()[0]
-                      ?.getChildren()[0]?.kind;
-                  return (
-                      kind !== ts.SyntaxKind.PrivateKeyword &&
-                      kind !== ts.SyntaxKind.ProtectedKeyword &&
-                      (ts.isParameter(node) || isProperty(node))
-                  );
-              }
-            : (node) => isProperty(node);
-
-        const insert =
-            (key: Metadata) =>
-            (value: Metadata) =>
-            (identifier: () => string) =>
-            (
-                symbol: ts.Symbol | undefined,
-                filter?: (doc: ts.JSDocTagInfo) => boolean,
-            ): MetadataProperty => {
-                // COMMENTS AND TAGS
-                const description: string | undefined =
-                    CommentFactory.generate(
-                        symbol?.getDocumentationComment(checker) || [],
-                    ) || undefined;
-                const jsDocTags: ts.JSDocTagInfo[] = (
-                    symbol?.getJsDocTags() || []
-                ).filter(filter || (() => true));
-
-                // THE PROPERTY
-                const property = MetadataProperty.create({
-                    key,
-                    value,
-                    description,
-                    jsDocTags,
-                    tags: MetadataTagFactory.generate(
-                        () => identifier(),
-                        value,
-                        jsDocTags,
-                    ),
-                });
-                obj.properties.push(property);
-                return property;
-            };
-
-        //----
-        // REGULAR PROPERTIES
-        //----
-        for (const prop of parent.getApparentProperties()) {
-            // CHECK INTERNAL TAG
-            if (
-                (prop.getJsDocTags(checker) || []).find(
-                    (tag) => tag.name === "internal",
-                ) !== undefined
-            )
-                continue;
-
-            // CHECK NODE IS A FORMAL PROPERTY
-            const [node, type] = (() => {
-                const node = (prop.getDeclarations() || [])[0] as
-                    | ts.PropertyDeclaration
-                    | undefined;
-                const type: ts.Type | undefined = node
-                    ? checker.getTypeOfSymbolAtLocation(prop, node)
-                    : "getTypeOfPropertyOfType" in checker
-                    ? (checker as any).getTypeOfPropertyOfType(
-                          parent,
-                          prop.name,
-                      )
-                    : undefined;
-                return [node, type];
-            })();
-            if ((node && pred(node) === false) || type === undefined) continue;
-
-            // GET EXACT TYPE
-            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
-            const value: Metadata = explore_metadata(checker)(options)(
-                collection,
-            )(type, false);
-
-            // INSERT WITH REQUIRED CONFIGURATION
-            if (node?.questionToken) Writable(value).required = false;
-            insert(key)(value)(() => `${obj.name}.${prop.name}`)(prop);
-        }
-
-        //----
-        // DYNAMIC PROPERTIES
-        //----
-        for (const index of checker.getIndexInfosOfType(parent)) {
-            // GET EXACT TYPE
-            const analyzer = (type: ts.Type) =>
-                explore_metadata(checker)(options)(collection)(type, false);
-            const key: Metadata = analyzer(index.keyType);
-            const value: Metadata = analyzer(index.type);
-
-            // INSERT WITH REQUIRED CONFIGURATION
-            insert(key)(value)(() => `${obj.name}[${key.getName()}]`)(
-                index.declaration?.parent
-                    ? checker.getSymbolAtLocation(index.declaration.parent)
-                    : undefined,
-                (doc) => doc.name !== "default",
-            );
-        }
-
-        return obj;
-    };
-
-const isProperty = (node: ts.Declaration) =>
-    ts.isPropertyDeclaration(node) ||
-    ts.isPropertyAssignment(node) ||
-    ts.isPropertySignature(node) ||
-    ts.isTypeLiteralNode(node);
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataTagFactory } from "../../MetadataTagFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_object =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (parent: ts.Type, nullable: boolean): MetadataObject => {
+        // EMPLACE OBJECT
+        const [obj, newbie] = collection.emplace(checker, parent);
+        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
+        if (newbie === false) return obj;
+
+        // PREPARE ASSETS
+        const isClass: boolean = parent.isClass();
+        const pred: (node: ts.Declaration) => boolean = isClass
+            ? (node) => {
+                  const kind: ts.SyntaxKind | undefined = node
+                      .getChildren()[0]
+                      ?.getChildren()[0]?.kind;
+                  return (
+                      kind !== ts.SyntaxKind.PrivateKeyword &&
+                      kind !== ts.SyntaxKind.ProtectedKeyword &&
+                      (ts.isParameter(node) || isProperty(node))
+                  );
+              }
+            : (node) => isProperty(node);
+
+        const insert =
+            (key: Metadata) =>
+            (value: Metadata) =>
+            (identifier: () => string) =>
+            (
+                symbol: ts.Symbol | undefined,
+                filter?: (doc: ts.JSDocTagInfo) => boolean,
+            ): MetadataProperty => {
+                // COMMENTS AND TAGS
+                const description: string | undefined =
+                    CommentFactory.generate(
+                        symbol?.getDocumentationComment(checker) || [],
+                    ) || undefined;
+                const jsDocTags: ts.JSDocTagInfo[] = (
+                    symbol?.getJsDocTags() || []
+                ).filter(filter || (() => true));
+
+                // THE PROPERTY
+                const property = MetadataProperty.create({
+                    key,
+                    value,
+                    description,
+                    jsDocTags,
+                    tags: MetadataTagFactory.generate(
+                        () => identifier(),
+                        value,
+                        jsDocTags,
+                    ),
+                });
+                obj.properties.push(property);
+                return property;
+            };
+
+        //----
+        // REGULAR PROPERTIES
+        //----
+        for (const prop of parent.getApparentProperties()) {
+            // CHECK INTERNAL TAG
+            if (
+                (prop.getJsDocTags(checker) || []).find(
+                    (tag) => tag.name === "internal",
+                ) !== undefined
+            )
+                continue;
+
+            // CHECK NODE IS A FORMAL PROPERTY
+            const [node, type] = (() => {
+                const node = (prop.getDeclarations() || [])[0] as
+                    | ts.PropertyDeclaration
+                    | undefined;
+                const type: ts.Type | undefined = node
+                    ? checker.getTypeOfSymbolAtLocation(prop, node)
+                    : "getTypeOfPropertyOfType" in checker
+                    ? (checker as any).getTypeOfPropertyOfType(
+                          parent,
+                          prop.name,
+                      )
+                    : undefined;
+                return [node, type];
+            })();
+            if ((node && pred(node) === false) || type === undefined) continue;
+
+            // GET EXACT TYPE
+            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
+            const value: Metadata = explore_metadata(checker)(options)(
+                collection,
+            )(type, false);
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            if (node?.questionToken) Writable(value).required = false;
+            insert(key)(value)(() => `${obj.name}.${prop.name}`)(prop);
+        }
+
+        //----
+        // DYNAMIC PROPERTIES
+        //----
+        for (const index of checker.getIndexInfosOfType(parent)) {
+            // GET EXACT TYPE
+            const analyzer = (type: ts.Type) =>
+                explore_metadata(checker)(options)(collection)(type, false);
+            const key: Metadata = analyzer(index.keyType);
+            const value: Metadata = analyzer(index.type);
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            insert(key)(value)(() => `${obj.name}[${key.getName()}]`)(
+                index.declaration?.parent
+                    ? checker.getSymbolAtLocation(index.declaration.parent)
+                    : undefined,
+                (doc) => doc.name !== "default",
+            );
+        }
+
+        return obj;
+    };
+
+const isProperty = (node: ts.Declaration) =>
+    ts.isPropertyDeclaration(node) ||
+    ts.isPropertyAssignment(node) ||
+    ts.isPropertySignature(node) ||
+    ts.isTypeLiteralNode(node);