typia 5.0.0-dev.20230824 → 5.0.0-dev.20230827

package/src/factories/MetadataTypeTagFactory.ts

@@ -0,0 +1,263 @@
+import { IMetadataTypeTag } from "../schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../schemas/metadata/MetadataProperty";
+
+export namespace MetadataTypeTagFactory {
+    export const analyze =
+        (type: "bigint" | "number" | "string" | "array") =>
+        (objects: MetadataObject[]): IMetadataTypeTag[] => {
+            //----
+            // VALIDATION PROCESS
+            //----
+            const filtered: MetadataObject[] = objects.filter((obj) => {
+                // 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(", ")}`,
+                    );
+
+                tag.properties.forEach((p) => {
+                    const key: string | null = p.key.getSoleLiteral();
+                    if (key === null) return;
+                    else if (FIELDS.includes(key) === false) return;
+                    validate_property(key, p.value);
+                });
+                return true;
+            });
+            if (filtered.length === 0) return [];
+
+            //----
+            // CONSTRUCT TYPE TAGS
+            //----
+            // CREATE 1ST
+            const tagList: ITypeTag[] = filtered.map(create_metadata_type_tag);
+            const output: IMetadataTypeTag[] = tagList.map((tag) => ({
+                target: tag.target,
+                name: tag.name,
+                kind: tag.kind,
+                value: tag.value,
+                validate: tag.validate[type]!,
+                exclusive: tag.exclusive,
+            }));
+            validate(type)(output);
+            return output;
+        };
+
+    export const validate =
+        (type: "bigint" | "number" | "string" | "array") =>
+        (tagList: IMetadataTypeTag[]) => {
+            for (const tag of tagList)
+                if (tag.target.includes(type))
+                    error(null)(`target must constains ${type} type - ${tag}`);
+
+            tagList.forEach((tag, i) => {
+                if (tag.exclusive === false) return;
+                else if (tag.exclusive === true) {
+                    const some: boolean = tagList.some(
+                        (opposite, j) => i !== j && opposite.kind === tag.kind,
+                    );
+                    if (some === true)
+                        throw error(null)(
+                            `kind '${tag.kind}' can't be duplicated`,
+                        );
+                } else if (Array.isArray(tag.exclusive)) {
+                    const some: IMetadataTypeTag | undefined = tagList.find(
+                        (opposite, j) =>
+                            i !== j &&
+                            opposite.kind === tag.kind &&
+                            (tag.exclusive as string[]).includes(opposite.name),
+                    );
+                    if (some !== undefined)
+                        throw error(null)(
+                            `kind '${tag.kind}' can't be used with '${some.name}'`,
+                        );
+                }
+            });
+        };
+
+    const validate_property = (key: string, value: Metadata) => {
+        if (
+            // TARGET
+            key === "target" &&
+            (value.constants.length !== 1 ||
+                value.constants[0]!.values.length !== value.size() ||
+                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" &&
+            (value.size() !== 1 ||
+                value.constants.length !== 1 ||
+                value.constants[0]!.type !== "string" ||
+                value.constants[0]!.values.length !== 1)
+        )
+            throw error(key)("must be a string literal type");
+        else if (
+            // VALUE
+            key === "value" &&
+            (value.size() > 1 ||
+                (value.size() !== 0 &&
+                    (value.constants.length !== 1 ||
+                        value.constants[0]!.values.length !== 1)))
+        )
+            throw error(key)(
+                "must be a constant literal type or undefined value",
+            );
+        else if (key === "exclusive") get_exclusive(key)(value);
+        else if (key === "validate") {
+            //----
+            // VALIDATE
+            //----
+            // STRING CASE
+            const single: boolean =
+                value.size() === 1 &&
+                value.constants.length === 1 &&
+                value.constants[0]!.type === "string" &&
+                value.constants[0]!.values.length === 1;
+            if (single === true) return;
+
+            // RECORD<TARGET, STRING>
+            const target: string[] | undefined = value.objects[0]?.properties
+                .map((p) => p.key.getSoleLiteral()!)
+                .filter((str) => str !== null) as string[] | undefined;
+            if (target === undefined)
+                throw error("target")(
+                    `must be one of 'bigint', 'number', 'string', 'array'`,
+                );
+            const variadic: boolean =
+                value.size() === 1 &&
+                value.objects.length === 1 &&
+                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.`,
+                );
+        }
+    };
+
+    const create_metadata_type_tag = (obj: MetadataObject): ITypeTag => {
+        const find = (key: string): MetadataProperty | undefined =>
+            obj.properties[0]?.value.objects[0]?.properties.find(
+                (p) => p.key.getSoleLiteral() === key,
+            );
+
+        const target = find("target")!.value.constants[0]!
+            .values[0] as ITypeTag["target"];
+        const kind: string = find("kind")!.value.constants[0]!
+            .values[0] as string;
+        const value: boolean | bigint | number | string | undefined =
+            find("value")?.value.constants[0]?.values[0];
+        const exclusive: string[] | boolean | undefined = get_exclusive(
+            "exclusive",
+        )(find("exclusive")?.value);
+        const validate: Record<string, string> = (() => {
+            const validate = find("validate")!.value;
+            if (validate.constants.length)
+                return {
+                    [target]: 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,
+            exclusive: exclusive ?? false,
+        };
+    };
+
+    const get_exclusive =
+        (key: string) =>
+        (value: Metadata | undefined): boolean | string[] => {
+            if (value === undefined) return false;
+            else if (
+                value.size() === 1 &&
+                value.constants.length === 1 &&
+                value.constants[0]!.type === "boolean" &&
+                value.constants[0]!.values.length === 1
+            )
+                return value.constants[0]!.values[0]! as boolean;
+            else if (
+                value.size() === 1 &&
+                value.tuples.length === 1 &&
+                value.tuples[0]!.type.elements.every(
+                    (elem) =>
+                        elem.size() === 1 &&
+                        elem.constants.length === 1 &&
+                        elem.constants[0]!.type === "string" &&
+                        elem.constants[0]!.values.length === 1,
+                )
+            )
+                return value.tuples[0]!.type.elements.map(
+                    (elem) => elem.constants[0]!.values[0]! as string,
+                );
+            throw error(key)(
+                "must a boolean literal type or a tuple of string literal types.",
+            );
+        };
+}
+
+interface ITypeTag {
+    name: string;
+    target: "bigint" | "number" | "string" | "array";
+    kind: string;
+    value?: boolean | bigint | number | string;
+    validate: Record<string, string>;
+    exclusive: boolean | 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/factories/NumericRangeFactory.ts

@@ -0,0 +1,33 @@
+import ts from "typescript";
+
+import { ProtobufAtomic } from "../typings/ProtobufAtomic";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+
+export namespace NumericRangeFactory {
+    export const number =
+        (context: ts.TransformationContext) =>
+        (type: ProtobufAtomic.Numeric) =>
+        (input: ts.Expression): ts.Expression =>
+            ExpressionFactory.transpile(context)(NUMBER_TEXT[type])(input);
+
+    export const bigint =
+        (context: ts.TransformationContext) =>
+        (type: ProtobufAtomic.BigNumeric) =>
+        (input: ts.Expression): ts.Expression =>
+            ExpressionFactory.transpile(context)(BIGINT_TEXT[type])(input);
+}
+
+const NUMBER_TEXT = {
+    int32: `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`,
+    uint32: `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`,
+    int64: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`,
+    uint64: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`,
+    float: `-1.175494351e38 <= $input && $input <= 3.4028235e38`,
+    double: `true`,
+};
+
+const BIGINT_TEXT = {
+    int64: `true`,
+    uint64: `BigInt(0) <= $input`,
+};

package/src/factories/ProtobufFactory.ts

@@ -71,6 +71,22 @@ export namespace ProtobufFactory {
                 );
         }
         //----
+        // ATOMIC CASES
+        //----
+        else if (meta.atomics.length) {
+            const numbers = ProtobufUtil.getNumbers(meta);
+            const bigints = ProtobufUtil.getBigints(meta);
+
+            for (const type of ["int64", "uint64"])
+                if (
+                    numbers.some((n) => n === type) &&
+                    bigints.some((b) => b === type)
+                )
+                    throw notSupportedError({ method })(
+                        `${type} cannot be used in both number and bigint types. Recommend to remove from number type`,
+                    );
+        }
+        //----
         // ARRRAY CASES
         //----
         // DO NOT ALLOW MULTI-DIMENTIONAL ARRAY
@@ -182,7 +198,7 @@ export namespace ProtobufFactory {
             meta.objects.some(
                 (obj) =>
                     isDynamicObject(obj) &&
-                    obj.properties.some((p) => p.value.isBinaryUnion()),
+                    obj.properties.some((p) => ProtobufUtil.isUnion(p.value)),
             )
         )
             throw notSupportedError({ method })(
@@ -191,20 +207,18 @@ export namespace ProtobufFactory {
         //----
         // MAP CASES
         //----
-        // MAP TYPE, BUT PROPERTY KEY TYPE IS NOT STRING
-        // @todo -> need to allow other typed keys
+        // KEY TYPE ISUNION
         else if (
             meta.maps.length &&
-            meta.maps.some(
-                (m) =>
-                    m.key.isBinaryUnion() ||
-                    (m.key.atomics.find((v) => v.type === "string") ===
-                        undefined &&
-                        m.key.constants.find((c) => c.type === "string") ===
-                            undefined),
-            )
+            meta.maps.some((m) => ProtobufUtil.isUnion(m.key))
+        )
+            throw notSupportedError({ method })("union key typed map");
+        // KEY TYPE IS NOT ATOMIC
+        else if (
+            meta.maps.length &&
+            meta.maps.some((m) => ProtobufUtil.getAtomics(m.key).length !== 1)
         )
-            throw notSupportedError({ method })("non-string key typed map");
+            throw notSupportedError({ method })("non-atomic key typed map");
         // MAP TYPE, BUT PROPERTY KEY TYPE IS OPTIONAL
         else if (
             meta.maps.length &&
@@ -227,7 +241,7 @@ export namespace ProtobufFactory {
         // UNION IN MAP
         else if (
             meta.maps.length &&
-            meta.maps.some((m) => m.value.isBinaryUnion())
+            meta.maps.some((m) => ProtobufUtil.isUnion(m.value))
         )
             throw notSupportedError({ method })("union type in map");
     };

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

@@ -1,4 +1,5 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -21,7 +22,11 @@ export const emend_metadata_atomics = (meta: Metadata) => {
             ArrayUtil.take(
                 meta.atomics,
                 (a) => a.type === "boolean",
-                () => ({ type: "boolean" as const, tags: [] }),
+                () =>
+                    MetadataAtomic.create({
+                        type: "boolean" as const,
+                        tags: [],
+                    }),
             );
         }
     }

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

@@ -7,7 +7,6 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataTagFactory } from "../../MetadataTagFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const emplace_metadata_alias =
@@ -31,10 +30,5 @@ export const emplace_metadata_alias =
             true,
         );
         closure(value);
-        alias.tags.push(
-            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
-                () => alias.name,
-            ),
-        );
         return alias;
     };

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

@@ -61,7 +61,6 @@ export const emplace_metadata_object =
                     value,
                     description,
                     jsDocTags,
-                    tags: [],
                 });
                 obj.properties.push(property);
                 return property;

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

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -19,7 +20,7 @@ export const iterate_metadata_atomic = (
         if (filter(info.atomic) || filter(info.literal)) {
             ArrayUtil.add(
                 meta.atomics,
-                { type: info.name, tags: [] },
+                MetadataAtomic.create({ type: info.name, tags: [] }),
                 (x, y) => x.type === y.type,
             );
             return true;

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

@@ -1,10 +1,8 @@
 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_comment_tags = (obj: MetadataObject) => {
     if (obj.tagged_ === true) return;
@@ -20,12 +18,10 @@ export const iterate_metadata_comment_tags = (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,18 +1,17 @@
 import ts from "typescript";
 
-import { $clone } from "../../../functional/$clone";
-
 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";
-import { iterate_metadata_type_tags } from "./iterate_metadata_type_tags";
 
 export const iterate_metadata_intersection =
     (checker: ts.TypeChecker) =>
@@ -58,7 +57,11 @@ 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;
 
         // VALIDATE EACH TYPES
         const individuals: (readonly [Metadata, number])[] = children
@@ -122,7 +125,7 @@ export const iterate_metadata_intersection =
                                 elem,
                                 (a, b) => a === b,
                             );
-                    else meta.constants.push($clone(c));
+                    else meta.constants.push({ ...c });
                 }
             }
             return true;
@@ -139,10 +142,10 @@ export const iterate_metadata_intersection =
         )
             ArrayUtil.add(
                 meta.atomics,
-                {
+                MetadataAtomic.create({
                     type: atomics.values().next().value as "string",
                     tags: [],
-                },
+                }),
                 (a, b) => a.type === b.type,
             );
         else if (target === "array") {
@@ -159,9 +162,9 @@ export const iterate_metadata_intersection =
 
         // ASSIGN TAGS
         if (objects.length && target !== "boolean") {
-            const tags: IMetadataTypeTag[] = iterate_metadata_type_tags(target)(
-                objects.map((om) => om.objects).flat(),
-            );
+            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

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/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.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),