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

package/src/factories/MetadataFactory.ts

@@ -1,267 +1,267 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
-import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
-import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
-import { explore_metadata } from "./internal/metadata/explore_metadata";
-import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
-import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
-
-import { ValidationPipe } from "../typings/ValidationPipe";
-
-import { ExpressionFactory } from "./ExpressionFactory";
-import { MetadataCollection } from "./MetadataCollection";
-
-export namespace MetadataFactory {
-  export type Validator = (meta: Metadata, explore: IExplore) => string[];
-
-  export interface IOptions {
-    escape: boolean;
-    constant: boolean;
-    absorb: boolean;
-    validate?: Validator;
-    onError?: (node: ts.Node | undefined, message: string) => void;
-  }
-
-  export interface IExplore {
-    top: boolean;
-    object: MetadataObject | null;
-    property: string | object | null;
-    nested: null | MetadataAlias | MetadataArrayType | MetadataTupleType;
-    escaped: boolean;
-    aliased: boolean;
-  }
-
-  export interface IError {
-    name: string;
-    explore: IExplore;
-    messages: string[];
-  }
-
-  export const analyze =
-    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type | null): ValidationPipe<Metadata, IError> => {
-      const errors: IError[] = [];
-      const meta: Metadata = explore_metadata(checker)(options)(collection)(
-        errors,
-      )(type, {
-        top: true,
-        object: null,
-        property: null,
-        nested: null,
-        escaped: false,
-        aliased: false,
-      });
-      iterate_metadata_collection(errors)(collection);
-      iterate_metadata_sort(collection)(meta);
-
-      if (options.validate)
-        errors.push(...validate(context)(options)(options.validate)(meta));
-      return errors.length
-        ? {
-            success: false,
-            errors,
-          }
-        : {
-            success: true,
-            data: meta,
-          };
-    };
-
-  /**
-   * @internal
-   */
-  export const soleLiteral = (value: string): Metadata => {
-    const meta: Metadata = Metadata.initialize();
-    meta.constants.push(
-      MetadataConstant.from({
-        values: [value],
-        type: "string",
-      }),
-    );
-    return meta;
-  };
-
-  const validate =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (functor: Validator) =>
-    (meta: Metadata): IError[] => {
-      const visitor: IValidationVisitor = {
-        functor,
-        errors: [],
-        objects: new Set(),
-        arrays: new Set(),
-        tuples: new Set(),
-        aliases: new Set(),
-      };
-      validateMeta(context)(options)(visitor)(meta, {
-        object: null,
-        property: null,
-        nested: null,
-        top: true,
-        aliased: false,
-        escaped: false,
-      });
-      return visitor.errors;
-    };
-
-  const validateMeta =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (meta: Metadata, explore: IExplore) => {
-      const result: string[] = [];
-      if (context !== undefined)
-        for (const atomic of meta.atomics)
-          for (const row of atomic.tags)
-            for (const tag of row.filter(
-              (t) => t.validate !== undefined && t.predicate === undefined,
-            ))
-              try {
-                tag.predicate = ExpressionFactory.transpile(context)(
-                  tag.validate!,
-                );
-              } catch {
-                result.push(
-                  `Unable to transpile type tag script: ${JSON.stringify(
-                    tag.validate,
-                  )}`,
-                );
-                tag.predicate = () => ts.factory.createTrue();
-              }
-      result.push(...visitor.functor(meta, explore));
-      if (result.length)
-        visitor.errors.push({
-          name: meta.getName(),
-          explore: { ...explore },
-          messages: [...new Set(result)],
-        });
-
-      for (const alias of meta.aliases)
-        validateAlias(context)(options)(visitor)(alias, explore);
-      for (const array of meta.arrays)
-        validateArray(context)(options)(visitor)(array.type, explore);
-      for (const tuple of meta.tuples)
-        validateTuple(context)(options)(visitor)(tuple.type, explore);
-      for (const obj of meta.objects)
-        validateObject(context)(options)(visitor)(obj);
-      for (const set of meta.sets)
-        validateMeta(context)(options)(visitor)(set, explore);
-      for (const map of meta.maps) {
-        validateMeta(context)(options)(visitor)(map.key, explore);
-        validateMeta(context)(options)(visitor)(map.value, explore);
-      }
-
-      if (options.escape === true && meta.escaped !== null)
-        validateMeta(context)(options)(visitor)(meta.escaped.returns, {
-          ...explore,
-          escaped: true,
-        });
-    };
-
-  const validateAlias =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (alias: MetadataAlias, explore: IExplore) => {
-      if (visitor.aliases.has(alias)) return;
-      visitor.aliases.add(alias);
-
-      validateMeta(context)(options)(visitor)(alias.value, {
-        ...explore,
-        nested: alias,
-        aliased: true,
-      });
-    };
-
-  const validateArray =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (array: MetadataArrayType, explore: IExplore) => {
-      if (visitor.arrays.has(array)) return;
-      visitor.arrays.add(array);
-
-      validateMeta(context)(options)(visitor)(array.value, {
-        ...explore,
-        nested: array,
-        top: false,
-      });
-    };
-
-  const validateTuple =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (tuple: MetadataTupleType, explore: IExplore) => {
-      if (visitor.tuples.has(tuple)) return;
-      visitor.tuples.add(tuple);
-
-      for (const elem of tuple.elements)
-        validateMeta(context)(options)(visitor)(elem, {
-          ...explore,
-          nested: tuple,
-          top: false,
-        });
-    };
-
-  const validateObject =
-    (context?: ts.TransformationContext) =>
-    (options: IOptions) =>
-    (visitor: IValidationVisitor) =>
-    (object: MetadataObject) => {
-      if (visitor.objects.has(object)) return;
-      visitor.objects.add(object);
-
-      if (options.validate) {
-        const explore: IExplore = {
-          object,
-          top: false,
-          property: null,
-          nested: null,
-          escaped: false,
-          aliased: false,
-        };
-        const errors: string[] = options.validate(
-          Metadata.create({
-            ...Metadata.initialize(),
-            objects: [object],
-          }),
-          explore,
-        );
-        if (errors.length)
-          visitor.errors.push({
-            name: object.name,
-            explore,
-            messages: [...new Set(errors)],
-          });
-      }
-
-      for (const property of object.properties)
-        validateMeta(context)(options)(visitor)(property.value, {
-          object,
-          property: property.key.isSoleLiteral()
-            ? property.key.getSoleLiteral()!
-            : {},
-          nested: null,
-          top: false,
-          aliased: false,
-          escaped: false,
-        });
-    };
-
-  interface IValidationVisitor {
-    functor: Validator;
-    errors: IError[];
-    objects: Set<MetadataObject>;
-    arrays: Set<MetadataArrayType>;
-    tuples: Set<MetadataTupleType>;
-    aliases: Set<MetadataAlias>;
-  }
-}
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
+import { explore_metadata } from "./internal/metadata/explore_metadata";
+import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
+import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
+
+import { ValidationPipe } from "../typings/ValidationPipe";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+import { MetadataCollection } from "./MetadataCollection";
+
+export namespace MetadataFactory {
+  export type Validator = (meta: Metadata, explore: IExplore) => string[];
+
+  export interface IOptions {
+    escape: boolean;
+    constant: boolean;
+    absorb: boolean;
+    validate?: Validator;
+    onError?: (node: ts.Node | undefined, message: string) => void;
+  }
+
+  export interface IExplore {
+    top: boolean;
+    object: MetadataObject | null;
+    property: string | object | null;
+    nested: null | MetadataAlias | MetadataArrayType | MetadataTupleType;
+    escaped: boolean;
+    aliased: boolean;
+  }
+
+  export interface IError {
+    name: string;
+    explore: IExplore;
+    messages: string[];
+  }
+
+  export const analyze =
+    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
+    (options: IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type | null): ValidationPipe<Metadata, IError> => {
+      const errors: IError[] = [];
+      const meta: Metadata = explore_metadata(checker)(options)(collection)(
+        errors,
+      )(type, {
+        top: true,
+        object: null,
+        property: null,
+        nested: null,
+        escaped: false,
+        aliased: false,
+      });
+      iterate_metadata_collection(errors)(collection);
+      iterate_metadata_sort(collection)(meta);
+
+      if (options.validate)
+        errors.push(...validate(context)(options)(options.validate)(meta));
+      return errors.length
+        ? {
+            success: false,
+            errors,
+          }
+        : {
+            success: true,
+            data: meta,
+          };
+    };
+
+  /**
+   * @internal
+   */
+  export const soleLiteral = (value: string): Metadata => {
+    const meta: Metadata = Metadata.initialize();
+    meta.constants.push(
+      MetadataConstant.from({
+        values: [value],
+        type: "string",
+      }),
+    );
+    return meta;
+  };
+
+  const validate =
+    (context?: ts.TransformationContext) =>
+    (options: IOptions) =>
+    (functor: Validator) =>
+    (meta: Metadata): IError[] => {
+      const visitor: IValidationVisitor = {
+        functor,
+        errors: [],
+        objects: new Set(),
+        arrays: new Set(),
+        tuples: new Set(),
+        aliases: new Set(),
+      };
+      validateMeta(context)(options)(visitor)(meta, {
+        object: null,
+        property: null,
+        nested: null,
+        top: true,
+        aliased: false,
+        escaped: false,
+      });
+      return visitor.errors;
+    };
+
+  const validateMeta =
+    (context?: ts.TransformationContext) =>
+    (options: IOptions) =>
+    (visitor: IValidationVisitor) =>
+    (meta: Metadata, explore: IExplore) => {
+      const result: string[] = [];
+      if (context !== undefined)
+        for (const atomic of meta.atomics)
+          for (const row of atomic.tags)
+            for (const tag of row.filter(
+              (t) => t.validate !== undefined && t.predicate === undefined,
+            ))
+              try {
+                tag.predicate = ExpressionFactory.transpile(context)(
+                  tag.validate!,
+                );
+              } catch {
+                result.push(
+                  `Unable to transpile type tag script: ${JSON.stringify(
+                    tag.validate,
+                  )}`,
+                );
+                tag.predicate = () => ts.factory.createTrue();
+              }
+      result.push(...visitor.functor(meta, explore));
+      if (result.length)
+        visitor.errors.push({
+          name: meta.getName(),
+          explore: { ...explore },
+          messages: [...new Set(result)],
+        });
+
+      for (const alias of meta.aliases)
+        validateAlias(context)(options)(visitor)(alias, explore);
+      for (const array of meta.arrays)
+        validateArray(context)(options)(visitor)(array.type, explore);
+      for (const tuple of meta.tuples)
+        validateTuple(context)(options)(visitor)(tuple.type, explore);
+      for (const obj of meta.objects)
+        validateObject(context)(options)(visitor)(obj);
+      for (const set of meta.sets)
+        validateMeta(context)(options)(visitor)(set, explore);
+      for (const map of meta.maps) {
+        validateMeta(context)(options)(visitor)(map.key, explore);
+        validateMeta(context)(options)(visitor)(map.value, explore);
+      }
+
+      if (options.escape === true && meta.escaped !== null)
+        validateMeta(context)(options)(visitor)(meta.escaped.returns, {
+          ...explore,
+          escaped: true,
+        });
+    };
+
+  const validateAlias =
+    (context?: ts.TransformationContext) =>
+    (options: IOptions) =>
+    (visitor: IValidationVisitor) =>
+    (alias: MetadataAlias, explore: IExplore) => {
+      if (visitor.aliases.has(alias)) return;
+      visitor.aliases.add(alias);
+
+      validateMeta(context)(options)(visitor)(alias.value, {
+        ...explore,
+        nested: alias,
+        aliased: true,
+      });
+    };
+
+  const validateArray =
+    (context?: ts.TransformationContext) =>
+    (options: IOptions) =>
+    (visitor: IValidationVisitor) =>
+    (array: MetadataArrayType, explore: IExplore) => {
+      if (visitor.arrays.has(array)) return;
+      visitor.arrays.add(array);
+
+      validateMeta(context)(options)(visitor)(array.value, {
+        ...explore,
+        nested: array,
+        top: false,
+      });
+    };
+
+  const validateTuple =
+    (context?: ts.TransformationContext) =>
+    (options: IOptions) =>
+    (visitor: IValidationVisitor) =>
+    (tuple: MetadataTupleType, explore: IExplore) => {
+      if (visitor.tuples.has(tuple)) return;
+      visitor.tuples.add(tuple);
+
+      for (const elem of tuple.elements)
+        validateMeta(context)(options)(visitor)(elem, {
+          ...explore,
+          nested: tuple,
+          top: false,
+        });
+    };
+
+  const validateObject =
+    (context?: ts.TransformationContext) =>
+    (options: IOptions) =>
+    (visitor: IValidationVisitor) =>
+    (object: MetadataObject) => {
+      if (visitor.objects.has(object)) return;
+      visitor.objects.add(object);
+
+      if (options.validate) {
+        const explore: IExplore = {
+          object,
+          top: false,
+          property: null,
+          nested: null,
+          escaped: false,
+          aliased: false,
+        };
+        const errors: string[] = options.validate(
+          Metadata.create({
+            ...Metadata.initialize(),
+            objects: [object],
+          }),
+          explore,
+        );
+        if (errors.length)
+          visitor.errors.push({
+            name: object.name,
+            explore,
+            messages: [...new Set(errors)],
+          });
+      }
+
+      for (const property of object.properties)
+        validateMeta(context)(options)(visitor)(property.value, {
+          object,
+          property: property.key.isSoleLiteral()
+            ? property.key.getSoleLiteral()!
+            : {},
+          nested: null,
+          top: false,
+          aliased: false,
+          escaped: false,
+        });
+    };
+
+  interface IValidationVisitor {
+    functor: Validator;
+    errors: IError[];
+    objects: Set<MetadataObject>;
+    arrays: Set<MetadataArrayType>;
+    tuples: Set<MetadataTupleType>;
+    aliases: Set<MetadataAlias>;
+  }
+}