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

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}

@@ -6,7 +6,7 @@ import { Escaper } from "../../../utils/Escaper";
 
 import { MetadataTagFactory } from "../../MetadataTagFactory";
 
-export const iterate_metadata_tag = (obj: MetadataObject) => {
+export const iterate_metadata_comment_tags = (obj: MetadataObject) => {
     if (obj.tagged_ === true) return;
     obj.tagged_ = true;
 

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

@@ -1,11 +1,18 @@
 import ts from "typescript";
 
+import { $clone } from "../../../functional/$clone";
+
+import { IMetadataTypeTag } from "../../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 import { iterate_metadata } from "./iterate_metadata";
+import { iterate_metadata_array } from "./iterate_metadata_array";
+import { iterate_metadata_type_tags } from "./iterate_metadata_type_tags";
 
 export const iterate_metadata_intersection =
     (checker: ts.TypeChecker) =>
@@ -53,28 +60,115 @@ export const iterate_metadata_intersection =
             return true;
         }
 
-        // 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($clone(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,
+                {
+                    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[] = iterate_metadata_type_tags(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/factories/internal/metadata/iterate_metadata_type_tags.ts

@@ -0,0 +1,183 @@
+import { IMetadataTypeTag } from "../../../schemas/metadata/IMetadataTypeTag";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
+
+export const iterate_metadata_type_tags =
+    (type: "bigint" | "number" | "string" | "array") =>
+    (objects: MetadataObject[]): IMetadataTypeTag[] => {
+        const filtered: MetadataObject[] = objects.filter((obj) => {
+            //----
+            // VALIDATION PROCESS
+            //----
+            // ONLY ONE PROPERTY
+            if (obj.properties.length !== 1) return false;
+
+            // THE TAG.TYPE PROPERTY MUST BE
+            const top: MetadataProperty = obj.properties[0]!;
+            if (
+                top.key.getSoleLiteral() !== "typia.tag" ||
+                top.value.size() !== 1 ||
+                top.value.objects.length !== 1
+            )
+                return false;
+            else if (top.value.optional === false)
+                throw error(null)("must be optional object");
+
+            // CHECK LIST OF PROPERTIES
+            const tag: MetadataObject = top.value.objects[0]!;
+            const statics: string[] = tag.properties
+                .map((p) => p.key.getSoleLiteral()!)
+                .filter((str) => str !== null);
+            if (FIELDS.some((f) => !statics.includes(f)))
+                throw error(null)(
+                    `must have four properties - ${FIELDS.map(
+                        (str) => `'${str}'`,
+                    ).join(", ")}`,
+                );
+
+            for (const p of tag.properties) {
+                const key: string | null = p.key.getSoleLiteral();
+                if (key === null) continue;
+                else if (FIELDS.includes(key) === false) continue;
+                else if (
+                    // TARGET
+                    key === "target" &&
+                    (p.value.constants.length !== 1 ||
+                        p.value.constants[0]!.values.length !==
+                            p.value.size() ||
+                        p.value.constants[0]!.values.some(
+                            (v) =>
+                                v !== "bigint" &&
+                                v !== "number" &&
+                                v !== "string" &&
+                                v !== "array",
+                        ))
+                )
+                    throw error(key)(
+                        `must be one of 'bigint', 'number', 'string', 'array'`,
+                    );
+                else if (
+                    // KIND
+                    key === "kind" &&
+                    (p.value.size() !== 1 ||
+                        p.value.constants.length !== 1 ||
+                        p.value.constants[0]!.type !== "string" ||
+                        p.value.constants[0]!.values.length !== 1)
+                )
+                    throw error(key)("must be a string literal type");
+                else if (
+                    // VALUE
+                    key === "value" &&
+                    (p.value.size() !== 1 ||
+                        p.value.constants.length !== 1 ||
+                        p.value.constants[0]!.values.length !== 1)
+                )
+                    throw error(key)("must be a constant literal type");
+                else if (key === "validate") {
+                    //----
+                    // VALIDATE
+                    //----
+                    // STRING CASE
+                    const single: boolean =
+                        p.value.size() === 1 &&
+                        p.value.constants.length === 1 &&
+                        p.value.constants[0]!.type === "string" &&
+                        p.value.constants[0]!.values.length === 1;
+                    if (single === true) continue;
+
+                    // RECORD<TARGET, STRING>
+                    const target: string[] | undefined =
+                        p.value.objects[0]?.properties.find(
+                            (p) => p.key.getSoleLiteral()! === "target",
+                        )?.value?.constants?.[0]?.values as
+                            | string[]
+                            | undefined;
+                    if (target === undefined)
+                        throw error("target")(
+                            `must be one of 'bigint', 'number', 'string', 'array'`,
+                        );
+                    const variadic: boolean =
+                        p.value.size() === 1 &&
+                        p.value.objects.length === 1 &&
+                        p.value.objects[0]!.properties.every(
+                            (vp) =>
+                                vp.value.size() === 1 &&
+                                vp.value.isRequired() &&
+                                vp.value.nullable === false &&
+                                vp.value.constants.length === 1 &&
+                                vp.value.constants[0]!.type === "string" &&
+                                vp.value.constants[0]!.values.length === 1 &&
+                                target.includes(vp.key.getSoleLiteral()!),
+                        );
+                    if (variadic === false)
+                        throw error(key)(
+                            `must be a string literal type or Record<Target, string> type.`,
+                        );
+                }
+            }
+            return true;
+        });
+
+        const tagList: ITypedTag[] = filtered.map((obj) => {
+            const find = (key: string): MetadataProperty =>
+                obj.properties[0]!.value.objects[0]!.properties.find(
+                    (p) => p.key.getSoleLiteral() === key,
+                )!;
+
+            const target = find("target").value.constants[0]!
+                .values as ITypedTag["target"];
+            const kind: string = find("kind").value.constants[0]!
+                .values[0] as string;
+            const value: boolean | bigint | number | string =
+                find("value").value.constants[0]!.values[0]!;
+            const validate: Record<string, string> = (() => {
+                const validate = find("validate").value;
+                if (validate.constants.length)
+                    return {
+                        [target[0]!]: validate.constants[0]!
+                            .values[0] as string,
+                    };
+                return Object.fromEntries(
+                    validate.objects[0]!.properties.map((p) => [
+                        p.key.getSoleLiteral()!,
+                        p.value.constants[0]!.values[0]! as string,
+                    ]),
+                );
+            })();
+
+            return { name: obj.name, target, kind, value, validate };
+        });
+        if (filtered.length === 0) return [];
+
+        for (const tag of tagList)
+            if (tag.target.includes(type))
+                error(null)(
+                    `target must constains ${type} type - ${JSON.stringify(
+                        tag,
+                    )}`,
+                );
+
+        return tagList.map((tag) => ({
+            name: tag.name,
+            kind: tag.kind,
+            value: tag.value,
+            validate: tag.validate[type]!,
+        }));
+    };
+
+interface ITypedTag {
+    name: string;
+    target: Array<"bigint" | "number" | "string" | "array">;
+    kind: string;
+    value: boolean | bigint | number | string;
+    validate: Record<string, string>;
+}
+
+const FIELDS = ["target", "kind", "value", "validate"];
+
+const error = (property: string | null) => (msg: string) =>
+    new Error(
+        `Error on typia.MetadataFactory.analyze(): the property '${
+            property === null ? `["typia.tag"]` : `["typia.tag.${property}"]`
+        }' ${msg}.`,
+    );

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/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

@@ -33,7 +33,7 @@ export namespace AssertProgrammer {
                 equals,
                 atomist: (explore) => (tuple) => (input) =>
                     [
-                        tuple.expression,
+                        ...(tuple.expression ? [tuple.expression] : []),
                         ...tuple.tags.map((tag) =>
                             ts.factory.createLogicalOr(
                                 tag.expression,