typia 9.3.0-dev.20250511 → 9.3.0

package/src/factories/JsonMetadataFactory.ts

@@ -1,83 +1,83 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-
-import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
-
-import { TransformerError } from "../transformers/TransformerError";
-
-import { ValidationPipe } from "../typings/ValidationPipe";
-
-import { MetadataCollection } from "./MetadataCollection";
-import { MetadataFactory } from "./MetadataFactory";
-
-export namespace JsonMetadataFactory {
-  export interface IProps {
-    method: string;
-    checker: ts.TypeChecker;
-    transformer?: ts.TransformationContext;
-    type: ts.Type;
-    validate?: MetadataFactory.Validator;
-  }
-  export interface IOutput {
-    collection: MetadataCollection;
-    metadata: Metadata;
-  }
-
-  export const analyze = (props: IProps): IOutput => {
-    const collection: MetadataCollection = new MetadataCollection();
-    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-      MetadataFactory.analyze({
-        checker: props.checker,
-        transformer: props.transformer,
-        options: {
-          absorb: true,
-          escape: true,
-          constant: true,
-          validate: props.validate
-            ? (meta, explore) => {
-                const errors: string[] = validate(meta);
-                errors.push(...props.validate!(meta, explore));
-                return errors;
-              }
-            : validate,
-        },
-        collection,
-        type: props.type,
-      });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: props.method,
-        errors: result.errors,
-      });
-    return {
-      collection,
-      metadata: 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.name) === false &&
-        native.name !== "Date"
-      )
-        output.push(`JSON does not support ${native.name} 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 { ValidationPipe } from "../typings/ValidationPipe";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+
+export namespace JsonMetadataFactory {
+  export interface IProps {
+    method: string;
+    checker: ts.TypeChecker;
+    transformer?: ts.TransformationContext;
+    type: ts.Type;
+    validate?: MetadataFactory.Validator;
+  }
+  export interface IOutput {
+    collection: MetadataCollection;
+    metadata: Metadata;
+  }
+
+  export const analyze = (props: IProps): IOutput => {
+    const collection: MetadataCollection = new MetadataCollection();
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        checker: props.checker,
+        transformer: props.transformer,
+        options: {
+          absorb: true,
+          escape: true,
+          constant: true,
+          validate: props.validate
+            ? (meta, explore) => {
+                const errors: string[] = validate(meta);
+                errors.push(...props.validate!(meta, explore));
+                return errors;
+              }
+            : validate,
+        },
+        collection,
+        type: props.type,
+      });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: props.method,
+        errors: result.errors,
+      });
+    return {
+      collection,
+      metadata: 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.name) === false &&
+        native.name !== "Date"
+      )
+        output.push(`JSON does not support ${native.name} type.`);
+    return output;
+  };
+}

package/src/factories/LiteralFactory.ts

@@ -1,52 +1,52 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "./ExpressionFactory";
-import { IdentifierFactory } from "./IdentifierFactory";
-
-export namespace LiteralFactory {
-  export const write = (input: any): ts.Expression => {
-    if (input === null) return ts.factory.createNull();
-    else if (ts.isArrowFunction(input)) return input;
-    else if (ts.isCallExpression(input)) return input;
-    else if (ts.isIdentifier(input)) return input;
-    else if (input instanceof Array) return writeArray(input);
-    else if (typeof input === "object") return writeObject(input);
-    else if (typeof input === "boolean") return writeBoolean(input);
-    else if (typeof input === "bigint") return writeBigint(input);
-    else if (typeof input === "number") return writeNumber(input);
-    else if (typeof input === "string") return writeStrinng(input);
-    // unreachable code
-    else if (typeof input === "function")
-      return ts.factory.createIdentifier("undefined");
-    else
-      throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
-  };
-
-  const writeObject = (obj: object): ts.ObjectLiteralExpression =>
-    ts.factory.createObjectLiteralExpression(
-      Object.entries(obj)
-        .filter((tuple) => tuple[1] !== undefined)
-        .map(([key, value]) =>
-          ts.factory.createPropertyAssignment(
-            IdentifierFactory.identifier(key),
-            write(value),
-          ),
-        ),
-      true,
-    );
-
-  const writeArray = (array: any[]): ts.ArrayLiteralExpression =>
-    ts.factory.createArrayLiteralExpression(array.map(write), true);
-
-  const writeBoolean = (value: boolean): ts.Expression =>
-    value ? ts.factory.createTrue() : ts.factory.createFalse();
-
-  const writeNumber = (value: number): ts.Expression =>
-    ExpressionFactory.number(value);
-
-  const writeBigint = (value: bigint): ts.Expression =>
-    ExpressionFactory.bigint(value);
-
-  const writeStrinng = (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 write = (input: any): ts.Expression => {
+    if (input === null) return ts.factory.createNull();
+    else if (ts.isArrowFunction(input)) return input;
+    else if (ts.isCallExpression(input)) return input;
+    else if (ts.isIdentifier(input)) return input;
+    else if (input instanceof Array) return writeArray(input);
+    else if (typeof input === "object") return writeObject(input);
+    else if (typeof input === "boolean") return writeBoolean(input);
+    else if (typeof input === "bigint") return writeBigint(input);
+    else if (typeof input === "number") return writeNumber(input);
+    else if (typeof input === "string") return writeStrinng(input);
+    // unreachable code
+    else if (typeof input === "function")
+      return ts.factory.createIdentifier("undefined");
+    else
+      throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
+  };
+
+  const writeObject = (obj: object): ts.ObjectLiteralExpression =>
+    ts.factory.createObjectLiteralExpression(
+      Object.entries(obj)
+        .filter((tuple) => tuple[1] !== undefined)
+        .map(([key, value]) =>
+          ts.factory.createPropertyAssignment(
+            IdentifierFactory.identifier(key),
+            write(value),
+          ),
+        ),
+      true,
+    );
+
+  const writeArray = (array: any[]): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(array.map(write), true);
+
+  const writeBoolean = (value: boolean): ts.Expression =>
+    value ? ts.factory.createTrue() : ts.factory.createFalse();
+
+  const writeNumber = (value: number): ts.Expression =>
+    ExpressionFactory.number(value);
+
+  const writeBigint = (value: bigint): ts.Expression =>
+    ExpressionFactory.bigint(value);
+
+  const writeStrinng = (value: string): ts.StringLiteral =>
+    ts.factory.createStringLiteral(value);
+}