typia 6.7.2 → 6.8.0-dev.20240811

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -1,124 +1,124 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
-
-import { ValidationPipe } from "../../../typings/ValidationPipe";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace JsonApplicationTransformer {
-  export const transform =
-    (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      if (!expression.typeArguments?.length)
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: "no generic argument.",
-        });
-
-      //----
-      // GET ARGUMENTS
-      //----
-      // VALIDATE TUPLE ARGUMENTS
-      const top: ts.Node = expression.typeArguments[0]!;
-      if (!ts.isTupleTypeNode(top)) return expression;
-      else if (top.elements.some((child) => !ts.isTypeNode(child)))
-        return expression;
-
-      // GET TYPES
-      const types: ts.Type[] = top.elements.map((child) =>
-        project.checker.getTypeFromTypeNode(child as ts.TypeNode),
-      );
-      if (types.some((t) => t.isTypeParameter()))
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: "non-specified generic argument(s).",
-        });
-
-      // ADDITIONAL PARAMETERS
-      const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
-        checker: project.checker,
-        name: "Version",
-        is: (str) => str === "3.0" || str === "3.1",
-        cast: (str) => str as "3.0" | "3.1",
-        default: () => "3.1",
-      })(expression.typeArguments[1]);
-
-      //----
-      // GENERATORS
-      //----
-      // METADATA
-      const collection: MetadataCollection = new MetadataCollection({
-        replace: MetadataCollection.replace,
-      });
-      const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
-        types.map((type) =>
-          MetadataFactory.analyze(
-            project.checker,
-            project.context,
-          )({
-            escape: true,
-            constant: true,
-            absorb: false,
-            validate: JsonApplicationProgrammer.validate,
-          })(collection)(type),
-        );
-
-      // REPORT BUG IF REQUIRED
-      const metadatas: Metadata[] = [];
-      const errors: MetadataFactory.IError[] = [];
-      for (const r of results) {
-        if (r.success === false) errors.push(...r.errors);
-        else metadatas.push(r.data);
-      }
-      if (errors.length)
-        throw TransformerError.from("typia.json.application")(errors);
-
-      // APPLICATION
-      const app: IJsonApplication<any> =
-        JsonApplicationProgrammer.write(version)(metadatas);
-      return LiteralFactory.generate(app);
-    };
-
-  const get_parameter =
-    <Value>(props: {
-      checker: ts.TypeChecker;
-      name: string;
-      is: (value: string) => boolean;
-      cast: (value: string) => Value;
-      default: () => Value;
-    }) =>
-    (node: ts.TypeNode | undefined): Value => {
-      if (!node) return props.default();
-
-      // CHECK LITERAL TYPE
-      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
-      if (
-        !type.isLiteral() &&
-        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
-      )
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: `generic argument "${props.name}" must be constant.`,
-        });
-
-      // GET VALUE AND VALIDATE IT
-      const value = type.isLiteral()
-        ? type.value
-        : props.checker.typeToString(type);
-      if (typeof value !== "string" || props.is(value) === false)
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: `invalid value on generic argument "${props.name}".`,
-        });
-      return props.cast(value);
-    };
-}
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonApplicationTransformer {
+  export const transform =
+    (project: IProject) =>
+    (expression: ts.CallExpression): ts.Expression => {
+      if (!expression.typeArguments?.length)
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: "no generic argument.",
+        });
+
+      //----
+      // GET ARGUMENTS
+      //----
+      // VALIDATE TUPLE ARGUMENTS
+      const top: ts.Node = expression.typeArguments[0]!;
+      if (!ts.isTupleTypeNode(top)) return expression;
+      else if (top.elements.some((child) => !ts.isTypeNode(child)))
+        return expression;
+
+      // GET TYPES
+      const types: ts.Type[] = top.elements.map((child) =>
+        project.checker.getTypeFromTypeNode(child as ts.TypeNode),
+      );
+      if (types.some((t) => t.isTypeParameter()))
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: "non-specified generic argument(s).",
+        });
+
+      // ADDITIONAL PARAMETERS
+      const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
+        checker: project.checker,
+        name: "Version",
+        is: (str) => str === "3.0" || str === "3.1",
+        cast: (str) => str as "3.0" | "3.1",
+        default: () => "3.1",
+      })(expression.typeArguments[1]);
+
+      //----
+      // GENERATORS
+      //----
+      // METADATA
+      const collection: MetadataCollection = new MetadataCollection({
+        replace: MetadataCollection.replace,
+      });
+      const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+        types.map((type) =>
+          MetadataFactory.analyze(
+            project.checker,
+            project.context,
+          )({
+            escape: true,
+            constant: true,
+            absorb: false,
+            validate: JsonApplicationProgrammer.validate,
+          })(collection)(type),
+        );
+
+      // REPORT BUG IF REQUIRED
+      const metadatas: Metadata[] = [];
+      const errors: MetadataFactory.IError[] = [];
+      for (const r of results) {
+        if (r.success === false) errors.push(...r.errors);
+        else metadatas.push(r.data);
+      }
+      if (errors.length)
+        throw TransformerError.from("typia.json.application")(errors);
+
+      // APPLICATION
+      const app: IJsonApplication<any> =
+        JsonApplicationProgrammer.write(version)(metadatas);
+      return LiteralFactory.generate(app);
+    };
+
+  const get_parameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

package/src/transformers/features/misc/MiscLiteralsTransformer.ts

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { MiscLiteralsProgrammer } from "../../../programmers/misc/MiscLiteralsProgrammer";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace MiscLiteralsTransformer {
-  export const transform =
-    (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      // CHECK GENERIC ARGUMENT EXISTENCE
-      if (!expression.typeArguments?.[0])
-        throw new TransformerError({
-          code: "typia.misc.literals",
-          message: "generic argument is not specified.",
-        });
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: "typia.misc.literals",
-          message: "non-specified generic argument.",
-        });
-
-      // DO TRANSFORM
-      return MiscLiteralsProgrammer.write(project)(type);
-    };
-}
+import ts from "typescript";
+
+import { MiscLiteralsProgrammer } from "../../../programmers/misc/MiscLiteralsProgrammer";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace MiscLiteralsTransformer {
+  export const transform =
+    (project: IProject) =>
+    (expression: ts.CallExpression): ts.Expression => {
+      // CHECK GENERIC ARGUMENT EXISTENCE
+      if (!expression.typeArguments?.[0])
+        throw new TransformerError({
+          code: "typia.misc.literals",
+          message: "generic argument is not specified.",
+        });
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = expression.typeArguments[0];
+      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: "typia.misc.literals",
+          message: "non-specified generic argument.",
+        });
+
+      // DO TRANSFORM
+      return MiscLiteralsProgrammer.write(project)(type);
+    };
+}

package/src/transformers/features/protobuf/ProtobufMessageTransformer.ts

@@ -1,33 +1,33 @@
-import ts from "typescript";
-
-import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace ProtobufMessageTransformer {
-  export const transform =
-    (project: IProject) =>
-    (_modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      // CHECK GENERIC ARGUMENT EXISTENCE
-      if (!expression.typeArguments || !expression.typeArguments[0])
-        throw new TransformerError({
-          code: "typia.protobuf.message",
-          message: "generic argument is not specified.",
-        });
-
-      // GET TYPE INFO
-      const type: ts.Type = project.checker.getTypeFromTypeNode(
-        expression.typeArguments[0],
-      );
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: "tyipa.protobuf.message",
-          message: "non-specified generic argument.",
-        });
-
-      // DO TRANSFORM
-      return ProtobufMessageProgrammer.write(project)(type);
-    };
-}
+import ts from "typescript";
+
+import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ProtobufMessageTransformer {
+  export const transform =
+    (project: IProject) =>
+    (_modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression): ts.Expression => {
+      // CHECK GENERIC ARGUMENT EXISTENCE
+      if (!expression.typeArguments || !expression.typeArguments[0])
+        throw new TransformerError({
+          code: "typia.protobuf.message",
+          message: "generic argument is not specified.",
+        });
+
+      // GET TYPE INFO
+      const type: ts.Type = project.checker.getTypeFromTypeNode(
+        expression.typeArguments[0],
+      );
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: "tyipa.protobuf.message",
+          message: "non-specified generic argument.",
+        });
+
+      // DO TRANSFORM
+      return ProtobufMessageProgrammer.write(project)(type);
+    };
+}

package/src/transformers/features/reflect/ReflectMetadataTransformer.ts

@@ -1,62 +1,62 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace ReflectMetadataTransformer {
-  export const transform =
-    (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      if (!expression.typeArguments?.length)
-        throw new TransformerError({
-          code: "typia.reflect.metadata",
-          message: "no generic argument.",
-        });
-
-      // VALIDATE TUPLE ARGUMENTS
-      const top: ts.Node = expression.typeArguments[0]!;
-      if (!ts.isTupleTypeNode(top)) return expression;
-      else if (top.elements.some((child) => !ts.isTypeNode(child)))
-        return expression;
-
-      // GET TYPES
-      const types: ts.Type[] = top.elements.map((child) =>
-        project.checker.getTypeFromTypeNode(child as ts.TypeNode),
-      );
-      if (types.some((t) => t.isTypeParameter()))
-        throw new TransformerError({
-          code: "typia.reflect.metadata",
-          message: "non-specified generic argument(s).",
-        });
-
-      // METADATA
-      const collection: MetadataCollection = new MetadataCollection();
-      const metadatas: Array<Metadata> = types.map((type) => {
-        const result = MetadataFactory.analyze(
-          project.checker,
-          project.context,
-        )({
-          escape: true,
-          constant: true,
-          absorb: true,
-        })(collection)(type);
-        if (result.success === false)
-          throw TransformerError.from("typia.reflect.metadata")(result.errors);
-        return result.data;
-      });
-
-      // CONVERT TO PRIMITIVE TYPE
-      const app: IMetadataApplication = {
-        metadatas: metadatas.map((metadata) => metadata.toJSON()),
-        components: collection.toJSON(),
-      };
-      return LiteralFactory.generate(app);
-    };
-}
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ReflectMetadataTransformer {
+  export const transform =
+    (project: IProject) =>
+    (expression: ts.CallExpression): ts.Expression => {
+      if (!expression.typeArguments?.length)
+        throw new TransformerError({
+          code: "typia.reflect.metadata",
+          message: "no generic argument.",
+        });
+
+      // VALIDATE TUPLE ARGUMENTS
+      const top: ts.Node = expression.typeArguments[0]!;
+      if (!ts.isTupleTypeNode(top)) return expression;
+      else if (top.elements.some((child) => !ts.isTypeNode(child)))
+        return expression;
+
+      // GET TYPES
+      const types: ts.Type[] = top.elements.map((child) =>
+        project.checker.getTypeFromTypeNode(child as ts.TypeNode),
+      );
+      if (types.some((t) => t.isTypeParameter()))
+        throw new TransformerError({
+          code: "typia.reflect.metadata",
+          message: "non-specified generic argument(s).",
+        });
+
+      // METADATA
+      const collection: MetadataCollection = new MetadataCollection();
+      const metadatas: Array<Metadata> = types.map((type) => {
+        const result = MetadataFactory.analyze(
+          project.checker,
+          project.context,
+        )({
+          escape: true,
+          constant: true,
+          absorb: true,
+        })(collection)(type);
+        if (result.success === false)
+          throw TransformerError.from("typia.reflect.metadata")(result.errors);
+        return result.data;
+      });
+
+      // CONVERT TO PRIMITIVE TYPE
+      const app: IMetadataApplication = {
+        metadatas: metadatas.map((metadata) => metadata.toJSON()),
+        components: collection.toJSON(),
+      };
+      return LiteralFactory.generate(app);
+    };
+}