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

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_native.ts

@@ -21,12 +21,6 @@ export const iterate_metadata_native =
             return true;
         }
 
-        const complicate = COMPLICATES.get(name);
-        if (complicate && validator(complicate)) {
-            ArrayUtil.set(meta.natives, complicate.name ?? name, (str) => str);
-            return true;
-        }
-
         for (const generic of GENERICS)
             if (
                 name.substring(0, generic.name.length) === generic.name &&
@@ -190,9 +184,6 @@ const SIMPLES: Map<string, IClassInfo> = new Map([
         },
     ],
 ]);
-const COMPLICATES: Map<string, IClassInfo> = new Map([
-    [`'buffer'.global.Buffer`, getBinaryProps("Buffer")],
-]);
 const GENERICS: Array<IClassInfo & { name: string }> = [
     "WeakMap",
     "WeakSet",

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_resolve.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataResolved } from "../../../schemas/metadata/MetadataResolved";
+import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
 
 import { Writable } from "../../../typings/Writable";
 
@@ -22,25 +22,25 @@ export const iterate_metadata_resolve =
         resolved: boolean,
         aliased: boolean,
     ): boolean => {
-        if (options.resolve === false || resolved === true) return false;
+        if (options.escape === false || resolved === true) return false;
 
         const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
         if (escaped === null) return false;
 
-        if (meta.resolved === null) {
-            Writable(meta).resolved = MetadataResolved.create({
+        if (meta.escaped === null) {
+            Writable(meta).escaped = MetadataEscaped.create({
                 original: Metadata.initialize(),
                 returns: Metadata.initialize(),
             });
         }
         iterate_metadata(checker)(options)(collection)(
-            meta.resolved!.original,
+            meta.escaped!.original,
             type,
             true,
             aliased,
         );
         iterate_metadata(checker)(options)(collection)(
-            meta.resolved!.returns,
+            meta.escaped!.returns,
             escaped,
             true,
             aliased,

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

@@ -27,8 +27,8 @@ const iterate =
         // ITERATE CHILDREN
         for (const map of meta.maps) iterate(visited)(collection)(map.value);
         for (const set of meta.sets) iterate(visited)(collection)(set);
-        if (meta.resolved !== null)
-            iterate(visited)(collection)(meta.resolved.returns);
+        if (meta.escaped !== null)
+            iterate(visited)(collection)(meta.escaped.returns);
         if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
 
         // SORT OBJECTS
@@ -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/json.ts

@@ -340,7 +340,7 @@ export function isStringify<T>(input: T): string | null;
  * `typia.json.isStringify()` is a combination function of {@link is} and
  * {@link stringify}. Therefore, it converts an input value to JSON
  * (JavaScript Object Notation) string, with type checking.
- *f
+ *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * `null` value. Otherwise, there's no problem on the `input` value, JSON string
  * would be returned.
@@ -430,8 +430,8 @@ Object.assign(validateStringify, Namespace.json.stringify("validateStringify"));
 /**
  * Creates a reusable {@link isParse} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -459,8 +459,8 @@ Object.assign(createIsParse, isParse);
 /**
  * Creates a reusable {@link assertParse} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -488,8 +488,8 @@ Object.assign(createAssertParse, assertParse);
 /**
  * Creates a reusable {@link validateParse} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -521,8 +521,8 @@ Object.assign(createValidateParse, validateParse);
 /**
  * Creates a reusable {@link stringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -550,8 +550,8 @@ Object.assign(createStringify, stringify);
 /**
  * Creates a reusable {@link assertStringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -579,8 +579,8 @@ Object.assign(createAssertStringify, assertStringify);
 /**
  * Creates a reusable {@link isStringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -608,8 +608,8 @@ Object.assign(createIsStringify, isStringify);
 /**
  * Creates a reusable {@link validateStringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon