typia 4.0.0-dev.20230520 → 4.0.0-dev.20230527

package/src/transformers/ImportTransformer.ts

@@ -1,74 +1,74 @@
-import path from "path";
-import type ts from "typescript/lib/tsclibrary";
-
-import { TsNodeUtil } from "../utils/TsNodeUtil";
-
-export namespace ImportTransformer {
-    export const transform =
-        (tsc: typeof ts) =>
-        (from: string) =>
-        (to: string) =>
-        (context: ts.TransformationContext) =>
-        (file: ts.SourceFile) =>
-            transform_file(tsc)(from)(to)(context)(file);
-
-    const transform_file =
-        (tsc: typeof ts) =>
-        (top: string) =>
-        (to: string) =>
-        (context: ts.TransformationContext) =>
-        (file: ts.SourceFile): ts.SourceFile => {
-            if (file.isDeclarationFile) return file;
-
-            const from: string = get_directory_path(
-                path.resolve(TsNodeUtil.getSourceFile(tsc)(file).fileName),
-            );
-            to = from.replace(top, to);
-
-            return tsc.visitEachChild(
-                file,
-                (node) => transform_node(tsc)(top)(from)(to)(node),
-                context,
-            );
-        };
-
-    const transform_node =
-        (tsc: typeof ts) =>
-        (top: string) =>
-        (from: string) =>
-        (to: string) =>
-        (node: ts.Node) => {
-            if (
-                !tsc.isImportDeclaration(node) ||
-                !tsc.isStringLiteral(node.moduleSpecifier)
-            )
-                return node;
-
-            const text: string = node.moduleSpecifier.text;
-            if (text[0] !== ".") return node;
-
-            const location: string = path.resolve(from, text);
-            if (location.indexOf(top) === 0) return node;
-
-            const replaced: string = (() => {
-                const simple: string = path
-                    .relative(to, location)
-                    .split(path.sep)
-                    .join("/");
-                return simple[0] === "." ? simple : `./${simple}`;
-            })();
-
-            return tsc.factory.createImportDeclaration(
-                undefined,
-                node.importClause,
-                tsc.factory.createStringLiteral(replaced),
-                node.assertClause,
-            );
-        };
-}
-
-const get_directory_path = (file: string): string => {
-    const splitted: string[] = path.resolve(file).split(path.sep);
-    splitted.pop();
-    return path.resolve(splitted.join(path.sep));
-};
+import path from "path";
+import type ts from "typescript/lib/tsclibrary";
+
+import { TsNodeUtil } from "../utils/TsNodeUtil";
+
+export namespace ImportTransformer {
+    export const transform =
+        (tsc: typeof ts) =>
+        (from: string) =>
+        (to: string) =>
+        (context: ts.TransformationContext) =>
+        (file: ts.SourceFile) =>
+            transform_file(tsc)(from)(to)(context)(file);
+
+    const transform_file =
+        (tsc: typeof ts) =>
+        (top: string) =>
+        (to: string) =>
+        (context: ts.TransformationContext) =>
+        (file: ts.SourceFile): ts.SourceFile => {
+            if (file.isDeclarationFile) return file;
+
+            const from: string = get_directory_path(
+                path.resolve(TsNodeUtil.getSourceFile(tsc)(file).fileName),
+            );
+            to = from.replace(top, to);
+
+            return tsc.visitEachChild(
+                file,
+                (node) => transform_node(tsc)(top)(from)(to)(node),
+                context,
+            );
+        };
+
+    const transform_node =
+        (tsc: typeof ts) =>
+        (top: string) =>
+        (from: string) =>
+        (to: string) =>
+        (node: ts.Node) => {
+            if (
+                !tsc.isImportDeclaration(node) ||
+                !tsc.isStringLiteral(node.moduleSpecifier)
+            )
+                return node;
+
+            const text: string = node.moduleSpecifier.text;
+            if (text[0] !== ".") return node;
+
+            const location: string = path.resolve(from, text);
+            if (location.indexOf(top) === 0) return node;
+
+            const replaced: string = (() => {
+                const simple: string = path
+                    .relative(to, location)
+                    .split(path.sep)
+                    .join("/");
+                return simple[0] === "." ? simple : `./${simple}`;
+            })();
+
+            return tsc.factory.createImportDeclaration(
+                undefined,
+                node.importClause,
+                tsc.factory.createStringLiteral(replaced),
+                node.assertClause,
+            );
+        };
+}
+
+const get_directory_path = (file: string): string => {
+    const splitted: string[] = path.resolve(file).split(path.sep);
+    splitted.pop();
+    return path.resolve(splitted.join(path.sep));
+};

package/src/transformers/NodeTransformer.ts

@@ -1,13 +1,13 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { CallExpressionTransformer } from "./CallExpressionTransformer";
-import { IProject } from "./IProject";
-
-export namespace NodeTransformer {
-    export const transform =
-        (project: IProject) =>
-        (expression: ts.Node): ts.Node =>
-            project.tsc.isCallExpression(expression)
-                ? CallExpressionTransformer.transform(project)(expression)
-                : expression;
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { CallExpressionTransformer } from "./CallExpressionTransformer";
+import { IProject } from "./IProject";
+
+export namespace NodeTransformer {
+    export const transform =
+        (project: IProject) =>
+        (expression: ts.Node): ts.Node =>
+            project.tsc.isCallExpression(expression)
+                ? CallExpressionTransformer.transform(project)(expression)
+                : expression;
+}

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -1,107 +1,107 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { IJsonApplication } from "../../../schemas/IJsonApplication";
-
-import { ApplicationProgrammer } from "../../../programmers/ApplicationProgrammer";
-
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
-import { IProject } from "../../IProject";
-
-export namespace ApplicationTransformer {
-    export const transform =
-        (p: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
-
-            //----
-            // GET ARGUMENTS
-            //----
-            // VALIDATE TUPLE ARGUMENTS
-            const top: ts.Node = expression.typeArguments[0]!;
-            if (!p.tsc.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !p.tsc.isTypeNode(child)))
-                return expression;
-
-            // GET TYPES
-            const typeList: ts.Type[] = top.elements.map((child) =>
-                p.checker.getTypeFromTypeNode(child as ts.TypeNode),
-            );
-            if (
-                typeList.some((type) => TsTypeUtil.isTypeParameter(p.tsc)(type))
-            )
-                throw new Error(GENERIC_ARGUMENT);
-
-            // ADDITIONAL PARAMETERS
-            const purpose: "swagger" | "ajv" = get_parameter(
-                p,
-                "Purpose",
-                expression.typeArguments[1],
-                (str) => str === "swagger" || str === "ajv",
-                () => "swagger",
-            );
-
-            //----
-            // GENERATORS
-            //----
-            // METADATA
-            const collection: MetadataCollection = new MetadataCollection({
-                replace: MetadataCollection.replace,
-            });
-            const metadatas: Array<Metadata> = typeList.map((type) =>
-                MetadataFactory.analyze(p)({
-                    resolve: true,
-                    constant: true,
-                    validate: (meta) => {
-                        if (meta.atomics.find((str) => str === "bigint"))
-                            throw new Error(NO_BIGIT);
-                    },
-                })(collection)(type),
-            );
-
-            // APPLICATION
-            const app: IJsonApplication = ApplicationProgrammer.write({
-                purpose,
-            })(metadatas);
-
-            // RETURNS WITH LITERAL EXPRESSION
-            return LiteralFactory.generate(p.tsc)(app);
-        };
-
-    const get_parameter = <T extends string>(
-        p: IProject.IModule,
-        name: string,
-        node: ts.TypeNode | undefined,
-        predicator: (value: string) => boolean,
-        defaulter: () => T,
-    ): T => {
-        if (!node) return defaulter();
-
-        // CHECK LITERAL TYPE
-        const type: ts.Type = p.checker.getTypeFromTypeNode(node);
-        if (!TsTypeUtil.isLiteral(p.tsc)(type))
-            throw new Error(
-                `Error on typia.application(): generic argument "${name}" must be constant.`,
-            );
-
-        // GET VALUE AND VALIDATE IT
-        const value = type.value;
-        if (typeof value !== "string" || predicator(value) === false)
-            throw new Error(
-                `Error on typia.application(): invalid value on generic argument "${name}".`,
-            );
-        return value as T;
-    };
-}
-
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.application(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.application(): non-specified generic argument(s).";
-const NO_BIGIT = "Error on typia.application(): does not allow bigint type.";
+import type ts from "typescript/lib/tsclibrary";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { IJsonApplication } from "../../../schemas/IJsonApplication";
+
+import { ApplicationProgrammer } from "../../../programmers/ApplicationProgrammer";
+
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
+import { IProject } from "../../IProject";
+
+export namespace ApplicationTransformer {
+    export const transform =
+        (p: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new Error(NO_GENERIC_ARGUMENT);
+
+            //----
+            // GET ARGUMENTS
+            //----
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!p.tsc.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !p.tsc.isTypeNode(child)))
+                return expression;
+
+            // GET TYPES
+            const typeList: ts.Type[] = top.elements.map((child) =>
+                p.checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (
+                typeList.some((type) => TsTypeUtil.isTypeParameter(p.tsc)(type))
+            )
+                throw new Error(GENERIC_ARGUMENT);
+
+            // ADDITIONAL PARAMETERS
+            const purpose: "swagger" | "ajv" = get_parameter(
+                p,
+                "Purpose",
+                expression.typeArguments[1],
+                (str) => str === "swagger" || str === "ajv",
+                () => "swagger",
+            );
+
+            //----
+            // GENERATORS
+            //----
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection({
+                replace: MetadataCollection.replace,
+            });
+            const metadatas: Array<Metadata> = typeList.map((type) =>
+                MetadataFactory.analyze(p)({
+                    resolve: true,
+                    constant: true,
+                    validate: (meta) => {
+                        if (meta.atomics.find((str) => str === "bigint"))
+                            throw new Error(NO_BIGIT);
+                    },
+                })(collection)(type),
+            );
+
+            // APPLICATION
+            const app: IJsonApplication = ApplicationProgrammer.write({
+                purpose,
+            })(metadatas);
+
+            // RETURNS WITH LITERAL EXPRESSION
+            return LiteralFactory.generate(p.tsc)(app);
+        };
+
+    const get_parameter = <T extends string>(
+        p: IProject.IModule,
+        name: string,
+        node: ts.TypeNode | undefined,
+        predicator: (value: string) => boolean,
+        defaulter: () => T,
+    ): T => {
+        if (!node) return defaulter();
+
+        // CHECK LITERAL TYPE
+        const type: ts.Type = p.checker.getTypeFromTypeNode(node);
+        if (!TsTypeUtil.isLiteral(p.tsc)(type))
+            throw new Error(
+                `Error on typia.application(): generic argument "${name}" must be constant.`,
+            );
+
+        // GET VALUE AND VALIDATE IT
+        const value = type.value;
+        if (typeof value !== "string" || predicator(value) === false)
+            throw new Error(
+                `Error on typia.application(): invalid value on generic argument "${name}".`,
+            );
+        return value as T;
+    };
+}
+
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.application(): no generic argument.";
+const GENERIC_ARGUMENT =
+    "Error on typia.application(): non-specified generic argument(s).";
+const NO_BIGIT = "Error on typia.application(): does not allow bigint type.";

package/src/transformers/features/miscellaneous/AssertCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertCloneTransformer {
-    export const transform = GenericTransformer.scalar("assertClone")(
-        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
-    );
-}
+import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertCloneTransformer {
+    export const transform = GenericTransformer.scalar("assertClone")(
+        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/AssertPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertPruneTransformer {
-    export const transform = GenericTransformer.scalar("assertPrune")(
-        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
-    );
-}
+import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertPruneTransformer {
+    export const transform = GenericTransformer.scalar("assertPrune")(
+        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CloneTransformer.ts

@@ -1,9 +1,9 @@
-import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CloneTransformer {
-    export const transform = GenericTransformer.scalar("clone")(
-        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
-    );
-}
+import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CloneTransformer {
+    export const transform = GenericTransformer.scalar("clone")(
+        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CreateAssertCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertCloneTransformer {
-    export const transform = GenericTransformer.factory("createAssertClone")(
-        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
-    );
-}
+import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertCloneTransformer {
+    export const transform = GenericTransformer.factory("createAssertClone")(
+        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CreateAssertPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertPruneTransformer {
-    export const transform = GenericTransformer.factory("createAssertPrune")(
-        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
-    );
-}
+import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertPruneTransformer {
+    export const transform = GenericTransformer.factory("createAssertPrune")(
+        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CreateCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateCloneTransformer {
-    export const transform = GenericTransformer.factory("createClone")(
-        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
-    );
-}
+import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateCloneTransformer {
+    export const transform = GenericTransformer.factory("createClone")(
+        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CreateIsCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsCloneTransformer {
-    export const transform = GenericTransformer.factory("createIsClone")(
-        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
-    );
-}
+import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsCloneTransformer {
+    export const transform = GenericTransformer.factory("createIsClone")(
+        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CreateIsPruneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsPruneTransformer {
-    export const transform = GenericTransformer.factory("createIsPrune")(
-        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
-    );
-}
+import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsPruneTransformer {
+    export const transform = GenericTransformer.factory("createIsPrune")(
+        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/miscellaneous/CreatePruneTransformer.ts

@@ -1,9 +1,9 @@
-import { PruneProgrammer } from "../../../programmers/PruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreatePruneTransformer {
-    export const transform = GenericTransformer.factory("createPrune")(
-        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
-    );
-}
+import { PruneProgrammer } from "../../../programmers/PruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreatePruneTransformer {
+    export const transform = GenericTransformer.factory("createPrune")(
+        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
+    );
+}