typia 5.3.0-dev.20231122 → 5.3.0-dev.20231126

package/src/factories/JsonMetadataFactory.ts

@@ -1,53 +1,53 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-
-import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
-
-import { TransformerError } from "../transformers/TransformerError";
-
-import { MetadataCollection } from "./MetadataCollection";
-import { MetadataFactory } from "./MetadataFactory";
-
-export namespace JsonMetadataFactory {
-  export const analyze =
-    (method: string) =>
-    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
-    (type: ts.Type): [MetadataCollection, Metadata] => {
-      const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        checker,
-        context,
-      )({
-        escape: true,
-        constant: true,
-        absorb: true,
-        validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(method)(result.errors);
-      return [collection, result.data];
-    };
-
-  export const validate = (meta: Metadata) => {
-    const output: string[] = [];
-    if (
-      meta.atomics.some((a) => a.type === "bigint") ||
-      meta.constants.some((c) => c.type === "bigint")
-    )
-      output.push("JSON does not support bigint type.");
-    if (
-      meta.tuples.some((t) =>
-        t.type.elements.some((e) => e.isRequired() === false),
-      ) ||
-      meta.arrays.some((a) => a.type.value.isRequired() === false)
-    )
-      output.push("JSON does not support undefined type in array.");
-    if (meta.maps.length) output.push("JSON does not support Map type.");
-    if (meta.sets.length) output.push("JSON does not support Set type.");
-    for (const native of meta.natives)
-      if (AtomicPredicator.native(native) === false && native !== "Date")
-        output.push(`JSON does not support ${native} type.`);
-    return output;
-  };
-}
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+
+import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
+
+import { TransformerError } from "../transformers/TransformerError";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+
+export namespace JsonMetadataFactory {
+  export const analyze =
+    (method: string) =>
+    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
+    (type: ts.Type): [MetadataCollection, Metadata] => {
+      const collection = new MetadataCollection();
+      const result = MetadataFactory.analyze(
+        checker,
+        context,
+      )({
+        escape: true,
+        constant: true,
+        absorb: true,
+        validate,
+      })(collection)(type);
+      if (result.success === false)
+        throw TransformerError.from(method)(result.errors);
+      return [collection, result.data];
+    };
+
+  export const validate = (meta: Metadata) => {
+    const output: string[] = [];
+    if (
+      meta.atomics.some((a) => a.type === "bigint") ||
+      meta.constants.some((c) => c.type === "bigint")
+    )
+      output.push("JSON does not support bigint type.");
+    if (
+      meta.tuples.some((t) =>
+        t.type.elements.some((e) => e.isRequired() === false),
+      ) ||
+      meta.arrays.some((a) => a.type.value.isRequired() === false)
+    )
+      output.push("JSON does not support undefined type in array.");
+    if (meta.maps.length) output.push("JSON does not support Map type.");
+    if (meta.sets.length) output.push("JSON does not support Set type.");
+    for (const native of meta.natives)
+      if (AtomicPredicator.native(native) === false && native !== "Date")
+        output.push(`JSON does not support ${native} type.`);
+    return output;
+  };
+}

package/src/factories/LiteralFactory.ts

@@ -1,47 +1,47 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "./ExpressionFactory";
-import { IdentifierFactory } from "./IdentifierFactory";
-
-export namespace LiteralFactory {
-  export const generate = (input: any): ts.Expression => {
-    if (input === null) return ts.factory.createNull();
-    else if (ts.isIdentifier(input)) return input;
-    else if (input instanceof Array) return generate_array(input);
-    else if (typeof input === "object") return generate_object(input);
-    else if (typeof input === "string") return generate_string(input);
-    else if (typeof input === "boolean") return generate_value(input);
-    else if (typeof input === "number") return generate_value(input);
-    else if (typeof input === "bigint") return generate_bigint(input);
-    // unreachable code
-    else if (typeof input === "function")
-      return ts.factory.createIdentifier("undefined");
-    else
-      throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
-  };
-
-  const generate_object = (obj: object): ts.ObjectLiteralExpression =>
-    ts.factory.createObjectLiteralExpression(
-      Object.entries(obj)
-        .filter((tuple) => tuple[1] !== undefined)
-        .map(([key, value]) =>
-          ts.factory.createPropertyAssignment(
-            IdentifierFactory.identifier(key),
-            generate(value),
-          ),
-        ),
-      true,
-    );
-
-  const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
-    ts.factory.createArrayLiteralExpression(array.map(generate), true);
-
-  const generate_value = (value: number | boolean | bigint): ts.Expression =>
-    ts.factory.createIdentifier(value.toString());
-
-  const generate_bigint = (value: bigint): ts.Expression =>
-    ExpressionFactory.bigint(value);
-
-  const generate_string = (value: string): ts.StringLiteral =>
-    ts.factory.createStringLiteral(value);
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+import { IdentifierFactory } from "./IdentifierFactory";
+
+export namespace LiteralFactory {
+  export const generate = (input: any): ts.Expression => {
+    if (input === null) return ts.factory.createNull();
+    else if (ts.isIdentifier(input)) return input;
+    else if (input instanceof Array) return generate_array(input);
+    else if (typeof input === "object") return generate_object(input);
+    else if (typeof input === "string") return generate_string(input);
+    else if (typeof input === "boolean") return generate_value(input);
+    else if (typeof input === "number") return generate_value(input);
+    else if (typeof input === "bigint") return generate_bigint(input);
+    // unreachable code
+    else if (typeof input === "function")
+      return ts.factory.createIdentifier("undefined");
+    else
+      throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
+  };
+
+  const generate_object = (obj: object): ts.ObjectLiteralExpression =>
+    ts.factory.createObjectLiteralExpression(
+      Object.entries(obj)
+        .filter((tuple) => tuple[1] !== undefined)
+        .map(([key, value]) =>
+          ts.factory.createPropertyAssignment(
+            IdentifierFactory.identifier(key),
+            generate(value),
+          ),
+        ),
+      true,
+    );
+
+  const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(array.map(generate), true);
+
+  const generate_value = (value: number | boolean | bigint): ts.Expression =>
+    ts.factory.createIdentifier(value.toString());
+
+  const generate_bigint = (value: bigint): ts.Expression =>
+    ExpressionFactory.bigint(value);
+
+  const generate_string = (value: string): ts.StringLiteral =>
+    ts.factory.createStringLiteral(value);
+}