typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230827

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -1,10 +1,10 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { MetadataCollection } from "../../MetadataCollection";
-import { iterate_metadata_tag } from "./iterate_metadata_tag";
+import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
 
 export const iterate_metadata_collection = (
     collection: MetadataCollection,
@@ -24,7 +24,7 @@ export const iterate_metadata_collection = (
             );
         }
     for (const obj of collection.objects()) {
-        iterate_metadata_tag(obj);
+        iterate_metadata_comment_tags(obj);
         if (obj.recursive === null) {
             const visited: Set<Metadata> = new Set();
             collection.setObjectRecursive(
@@ -39,22 +39,26 @@ export const iterate_metadata_collection = (
 
 const isArrayRecursive =
     (visited: Set<Metadata>) =>
-    (array: MetadataArray) =>
+    (array: MetadataArrayType) =>
     (meta: Metadata): boolean => {
         if (visited.has(meta)) return false;
         visited.add(meta);
 
         return (
             meta.arrays.some(
-                (a) => a === array || isArrayRecursive(visited)(array)(a.value),
+                (a) =>
+                    a.type === array ||
+                    isArrayRecursive(visited)(array)(a.type.value),
             ) ||
             meta.aliases.some((alias) =>
                 isArrayRecursive(visited)(array)(alias.value),
             ) ||
             meta.tuples.some(
                 (t) =>
-                    !t.recursive &&
-                    t.elements.some((e) => isArrayRecursive(visited)(array)(e)),
+                    !t.type.recursive &&
+                    t.type.elements.some((e) =>
+                        isArrayRecursive(visited)(array)(e),
+                    ),
             ) ||
             meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
             meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
@@ -66,7 +70,7 @@ const isArrayRecursive =
 
 const isTupleRecursive =
     (visited: Set<Metadata>) =>
-    (tuple: MetadataTuple) =>
+    (tuple: MetadataTupleType) =>
     (meta: Metadata): boolean => {
         if (visited.has(meta)) return false;
         visited.add(meta);
@@ -74,12 +78,15 @@ const isTupleRecursive =
         return (
             meta.tuples.some(
                 (t) =>
-                    t === tuple ||
-                    t.elements.some((e) => isTupleRecursive(visited)(tuple)(e)),
+                    t.type === tuple ||
+                    t.type.elements.some((e) =>
+                        isTupleRecursive(visited)(tuple)(e),
+                    ),
             ) ||
             meta.arrays.some(
                 (a) =>
-                    !a.recursive && isTupleRecursive(visited)(tuple)(a.value),
+                    !a.type.recursive &&
+                    isTupleRecursive(visited)(tuple)(a.type.value),
             ) ||
             meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
             meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
@@ -112,13 +119,13 @@ const isObjectRecursive =
             ) ||
             meta.arrays.some(
                 (array) =>
-                    !array.recursive &&
-                    isObjectRecursive(visited)(obj)(array.value),
+                    !array.type.recursive &&
+                    isObjectRecursive(visited)(obj)(array.type.value),
             ) ||
             meta.tuples.some(
                 (tuple) =>
-                    !tuple.recursive &&
-                    tuple.elements.some((elem) =>
+                    !tuple.type.recursive &&
+                    tuple.type.elements.some((elem) =>
                         isObjectRecursive(visited)(obj)(elem),
                     ),
             ) ||

package/src/factories/internal/metadata/{iterate_metadata_tag.ts → iterate_metadata_comment_tags.ts}

@@ -1,12 +1,10 @@
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 
-import { Writable } from "../../../typings/Writable";
-
 import { Escaper } from "../../../utils/Escaper";
 
-import { MetadataTagFactory } from "../../MetadataTagFactory";
+import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
 
-export const iterate_metadata_tag = (obj: MetadataObject) => {
+export const iterate_metadata_comment_tags = (obj: MetadataObject) => {
     if (obj.tagged_ === true) return;
     obj.tagged_ = true;
 
@@ -20,12 +18,10 @@ export const iterate_metadata_tag = (obj: MetadataObject) => {
                 ? key.slice(1, -1)
                 : null;
 
-        Writable(prop).tags = MetadataTagFactory.generate(prop.value)(
-            prop.jsDocTags,
-        )(
+        MetadataCommentTagFactory.analyze(
             variable !== null
                 ? () => `${obj.name}.${variable}`
                 : () => `${obj.name}[${key}]`,
-        );
+        )(prop.value)(prop.jsDocTags);
     }
 };

package/src/factories/internal/metadata/iterate_metadata_intersection.ts

@@ -1,11 +1,17 @@
 import ts from "typescript";
 
+import { IMetadataTypeTag } from "../../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataTypeTagFactory } from "../../MetadataTypeTagFactory";
 import { explore_metadata } from "./explore_metadata";
 import { iterate_metadata } from "./iterate_metadata";
+import { iterate_metadata_array } from "./iterate_metadata_array";
 
 export const iterate_metadata_intersection =
     (checker: ts.TypeChecker) =>
@@ -51,30 +57,121 @@ export const iterate_metadata_intersection =
                 aliased,
             );
             return true;
-        }
+        } else if (
+            // ONLY OBJECT TYPES -> SPECIAL LOGIC FOR TS V5.2
+            children.every((c) => c.objects.length === 1 && c.size() === 1)
+        )
+            return false;
 
-        // ABSORB TO ATOMIC (OR CONSTANT) TYPE
-        const atomics: Metadata[] = children.filter(
-            (c) =>
-                (c.atomics.length ? 1 : 0 + c.constants.length ? 1 : 0) ===
-                c.bucket(),
+        // VALIDATE EACH TYPES
+        const individuals: (readonly [Metadata, number])[] = children
+            .map((child, i) => [child, i] as const)
+            .filter(
+                ([c]) =>
+                    c.size() === 1 &&
+                    (c.atomics.length === 1 || c.arrays.length === 1),
+            );
+        const constants: Metadata[] = children.filter(
+            (m) =>
+                m.size() ===
+                m.constants
+                    .map((c) => c.values.length)
+                    .reduce((a, b) => a + b, 0) +
+                    m.templates.length,
         );
         const objects: Metadata[] = children.filter(
-            (c) => c.objects.length && c.objects.length === c.size(),
+            (c) =>
+                c.nullable === false &&
+                c.isRequired() === true &&
+                c.objects.length &&
+                c.objects.length === c.size() &&
+                c.objects.every((o) =>
+                    o.properties.every((p) => p.value.optional),
+                ),
         );
+        const atomics: Set<"boolean" | "bigint" | "number" | "string"> =
+            new Set(
+                individuals.map(([c]) => c.atomics.map((a) => a.type)).flat(),
+            );
+        const arrays: Set<string> = new Set(
+            individuals.map(([c]) => c.arrays.map((a) => a.type.name)).flat(),
+        );
+
+        // ESCAPE WHEN ONLY CONSTANT TYPES EXIST
         if (
-            atomics.length === 0 ||
-            atomics.length + objects.length !== children.length
+            atomics.size + arrays.size > 1 ||
+            individuals.length + objects.length + constants.length !==
+                children.length
         )
             throw new Error(message(children));
+        else if (atomics.size === 0 && arrays.size === 0 && constants.length) {
+            for (const m of constants) {
+                for (const tpl of m.templates)
+                    ArrayUtil.add(
+                        meta.templates,
+                        tpl,
+                        (a, b) =>
+                            a.map((ab) => ab.getName()).join(" | ") ===
+                            b.map((bb) => bb.getName()).join(" | "),
+                    );
+                for (const c of m.constants) {
+                    const oldbie = meta.constants.find(
+                        (o) => o.type === c.type,
+                    );
+                    if (oldbie)
+                        for (const elem of c.values)
+                            ArrayUtil.add(
+                                oldbie.values,
+                                elem,
+                                (a, b) => a === b,
+                            );
+                    else meta.constants.push({ ...c });
+                }
+            }
+            return true;
+        }
 
-        const least: Metadata = atomics.reduce((x, y) => {
-            if (Metadata.covers(x, y)) return y;
-            else if (Metadata.covers(y, x)) return x;
-            throw new Error(message(children));
-        });
-        Object.assign(meta, Metadata.merge(meta, least));
-        collection.entire_.add(least);
+        // RE-GENERATE TYPE
+        const target: "boolean" | "bigint" | "number" | "string" | "array" =
+            atomics.size ? atomics.values().next().value : "array";
+        if (
+            target === "boolean" ||
+            target === "bigint" ||
+            target === "number" ||
+            target === "string"
+        )
+            ArrayUtil.add(
+                meta.atomics,
+                MetadataAtomic.create({
+                    type: atomics.values().next().value as "string",
+                    tags: [],
+                }),
+                (a, b) => a.type === b.type,
+            );
+        else if (target === "array") {
+            const name: string = arrays.values().next().value;
+            if (!meta.arrays.some((a) => a.type.name === name)) {
+                iterate_metadata_array(checker)(options)(collection)(
+                    meta,
+                    type.types[
+                        individuals.find((i) => i[0].arrays.length === 1)![1]
+                    ]!,
+                );
+            }
+        }
+
+        // ASSIGN TAGS
+        if (objects.length && target !== "boolean") {
+            const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze(
+                target,
+            )(objects.map((om) => om.objects).flat());
+            if (tags.length)
+                if (target === "array") meta.arrays.at(-1)!.tags.push(tags);
+                else
+                    meta.atomics
+                        .find((a) => a.type === target)!
+                        .tags.push(tags);
+        }
         return true;
     };
 

package/src/factories/internal/metadata/iterate_metadata_object.ts

@@ -23,16 +23,16 @@ export const iterate_metadata_object =
                 (type as any).intrinsicName !== "object"
             )
                 return false;
-            else if (
-                type.isIntersection() &&
-                !type.types.every(
-                    (child) =>
-                        (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
-                        !checker.isArrayType(child) &&
-                        !checker.isTupleType(child),
-                )
-            )
-                return false;
+            // else if (
+            //     type.isIntersection() &&
+            //     !type.types.every(
+            //         (child) =>
+            //             (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
+            //             !checker.isArrayType(child) &&
+            //             !checker.isTupleType(child),
+            //     )
+            // )
+            //     return false;
         }
 
         const obj: MetadataObject = emplace_metadata_object(checker)(options)(

package/src/factories/internal/metadata/iterate_metadata_sort.ts

@@ -46,9 +46,9 @@ const iterate =
         // SORT ARRAYS AND TUPLES
         if (meta.arrays.length > 1)
             meta.arrays.sort((x, y) =>
-                Metadata.covers(x.value, y.value)
+                Metadata.covers(x.type.value, y.type.value)
                     ? -1
-                    : Metadata.covers(y.value, x.value)
+                    : Metadata.covers(y.type.value, x.type.value)
                     ? 1
                     : 0,
             );

package/src/factories/internal/metadata/iterate_metadata_tuple.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -16,9 +17,16 @@ export const iterate_metadata_tuple =
     (meta: Metadata, type: ts.TupleType): boolean => {
         if (!checker.isTupleType(type)) return false;
 
-        const tuple: MetadataTuple = emplace_metadata_tuple(checker)(options)(
-            collection,
-        )(type, meta.nullable);
-        ArrayUtil.add(meta.tuples, tuple, (elem) => elem.name === tuple.name);
+        const tupleType: MetadataTupleType = emplace_metadata_tuple(checker)(
+            options,
+        )(collection)(type, meta.nullable);
+        ArrayUtil.add(
+            meta.tuples,
+            MetadataTuple.create({
+                type: tupleType,
+                tags: [],
+            }),
+            (elem) => elem.type.name === tupleType.name,
+        );
         return true;
     };

package/src/functional/$any.ts

@@ -1,2 +1,4 @@
+import { $clone } from "./$clone";
+
 export const $any = (val: any): any =>
-    val !== undefined ? JSON.parse(JSON.stringify(val)) : undefined;
+    val !== undefined ? $clone(val) : undefined;

package/src/functional/$clone.ts

@@ -0,0 +1,4 @@
+import { Primitive } from "../Primitive";
+
+export const $clone = <T>(value: T): Primitive<T> =>
+    JSON.parse(JSON.stringify(value));

package/src/functional/Namespace.ts

@@ -9,14 +9,6 @@ import { $any } from "./$any";
 import { $every } from "./$every";
 import { $guard } from "./$guard";
 import { $is_between } from "./$is_between";
-import { $is_custom } from "./$is_custom";
-import { $is_date } from "./$is_date";
-import { $is_datetime } from "./$is_datetime";
-import { $is_email } from "./$is_email";
-import { $is_ipv4 } from "./$is_ipv4";
-import { $is_ipv6 } from "./$is_ipv6";
-import { $is_url } from "./$is_url";
-import { $is_uuid } from "./$is_uuid";
 import { $join } from "./$join";
 import { $number } from "./$number";
 import { $report } from "./$report";
@@ -30,15 +22,7 @@ import { $tail } from "./$tail";
  */
 export namespace Namespace {
     export const is = () => ({
-        is_uuid: $is_uuid,
-        is_email: $is_email,
-        is_url: $is_url,
-        is_ipv4: $is_ipv4,
-        is_ipv6: $is_ipv6,
         is_between: $is_between,
-        is_date: $is_date,
-        is_datetime: $is_datetime,
-        is_custom: $is_custom,
     });
 
     export const assert = (method: string) => ({

package/src/module.ts

@@ -1,18 +1,15 @@
-import { $dictionary } from "./functional/$dictionary";
 import { Namespace } from "./functional/Namespace";
 
 import { IMetadataApplication } from "./schemas/metadata/IMetadataApplication";
 
-import { MapUtil } from "./utils/MapUtil";
-
-import { CustomValidatorMap } from "./CustomValidatorMap";
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
 
 export * as json from "./json";
-export * as protobuf from "./protobuf";
 export * as misc from "./misc";
+export * as protobuf from "./protobuf";
+export * as tags from "./tags";
 
 export * from "./schemas/json/IJsonApplication";
 export * from "./schemas/json/IJsonComponents";
@@ -23,56 +20,6 @@ export * from "./Primitive";
 export * from "./Resolved";
 export * from "./TypeGuardError";
 
-/**
- * Custom validators.
- *
- * If you want to add a custom validation logic utilizing comment tags,
- * add a closure function with its tag and type name. Below example code
- * would helpful to understand how to use this instance.
- *
- * ```ts
- * typia.customValidators.insert("powerOf")("number")(
- *     (text: string) => {
- *         const denominator: number = Math.log(Number(text));
- *         return (value: number) => {
- *             value = Math.log(value) / denominator;
- *             return value === Math.floor(value);
- *         };
- *     }
- * );
- * typia.customValidators.insert("dollar")("string")(
- *     () => (value: string) => value.startsWith("$"),
- * );
- *
- * interface TagCustom {
- *    /**
- *     * @powerOf 10
- *     *\/
- *    powerOf: number;
- *
- *    /**
- *     * @dollar
- *     *\/
- *    dollar: string;
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export const customValidators: CustomValidatorMap = {
-    size: (name?: string) =>
-        name ? $dictionary.get(name)?.size ?? 0 : $dictionary.size,
-    has: (name) => (type) => $dictionary.get(name)?.has(type) ?? false,
-    get: (name) => (type) => $dictionary.get(name)?.get(type),
-    insert: (name) => (type) => (closure) => {
-        const internal = MapUtil.take($dictionary)(name, () => new Map());
-        if (internal.has(type)) return false;
-        internal.set(type, closure);
-        return true;
-    },
-    erase: (name) => (type) => $dictionary.get(name)?.delete(type) ?? false,
-};
-
 /* -----------------------------------------------------------
     BASIC VALIDATORS
 ----------------------------------------------------------- */

package/src/programmers/AssertProgrammer.ts

@@ -31,29 +31,65 @@ export namespace AssertProgrammer {
                 trace: true,
                 numeric: OptionPredicator.numeric(project.options),
                 equals,
-                atomist: (explore) => (tuple) => (input) =>
+                atomist: (explore) => (entry) => (input) =>
                     [
-                        tuple.expression,
-                        ...tuple.tags.map((tag) =>
-                            ts.factory.createLogicalOr(
-                                tag.expression,
-                                create_guard_call(importer)(
-                                    explore.from === "top"
-                                        ? ts.factory.createTrue()
-                                        : ts.factory.createIdentifier(
-                                              "_exceptionable",
+                        ...(entry.expression ? [entry.expression] : []),
+                        ...(entry.conditions.length === 0
+                            ? []
+                            : entry.conditions.length === 1
+                            ? entry.conditions[0]!.map((cond) =>
+                                  ts.factory.createLogicalOr(
+                                      cond.expression,
+                                      create_guard_call(importer)(
+                                          explore.from === "top"
+                                              ? ts.factory.createTrue()
+                                              : ts.factory.createIdentifier(
+                                                    "_exceptionable",
+                                                ),
+                                      )(
+                                          ts.factory.createIdentifier(
+                                              explore.postfix
+                                                  ? `_path + ${explore.postfix}`
+                                                  : "_path",
                                           ),
-                                )(
-                                    ts.factory.createIdentifier(
-                                        explore.postfix
-                                            ? `_path + ${explore.postfix}`
-                                            : "_path",
-                                    ),
-                                    tag.expected,
-                                    input,
-                                ),
-                            ),
-                        ),
+                                          cond.expected,
+                                          input,
+                                      ),
+                                  ),
+                              )
+                            : [
+                                  ts.factory.createLogicalOr(
+                                      entry.conditions
+                                          .map((set) =>
+                                              set
+                                                  .map((s) => s.expression)
+                                                  .reduce((a, b) =>
+                                                      ts.factory.createLogicalAnd(
+                                                          a,
+                                                          b,
+                                                      ),
+                                                  ),
+                                          )
+                                          .reduce((a, b) =>
+                                              ts.factory.createLogicalOr(a, b),
+                                          ),
+                                      create_guard_call(importer)(
+                                          explore.from === "top"
+                                              ? ts.factory.createTrue()
+                                              : ts.factory.createIdentifier(
+                                                    "_exceptionable",
+                                                ),
+                                      )(
+                                          ts.factory.createIdentifier(
+                                              explore.postfix
+                                                  ? `_path + ${explore.postfix}`
+                                                  : "_path",
+                                          ),
+                                          entry.expected,
+                                          input,
+                                      ),
+                                  ),
+                              ]),
                     ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
                 combiner: combiner(equals)(importer),
                 joiner: joiner(equals)(importer),