typia 5.3.0-dev.20231117 → 5.3.0-dev.20231119

package/src/factories/MetadataFactory.ts

@@ -1,271 +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>;
+  }
+}