typia 4.0.9 → 4.0.10-dev.20230616

package/src/factories/MetadataTagFactory.ts

@@ -84,7 +84,7 @@ export namespace MetadataTagFactory {
             NUMBER
         ----------------------------------------------------------- */
         type: (_identifier, metadata, text, _output) => {
-            return has_atomic(metadata)("number") &&
+            return has_atomic("number")(new Set())(metadata) &&
                 (text === "int" || text === "uint")
                 ? { kind: "type", value: text }
                 : text === "{int}" || text === "{uint}"
@@ -169,15 +169,19 @@ export namespace MetadataTagFactory {
         /* -----------------------------------------------------------
             STRING
         ----------------------------------------------------------- */
+        // Ignore arbitrary @format values in the internal metadata,
+        // these are currently only supported on the typia.application() API.
         format: (identifier, metadata, str, output) => {
-            validate(identifier, metadata, output, "format", "string", [
-                "pattern",
-            ]);
-
-            // Ignore arbitrary @format values in the internal metadata,
-            // these are currently only supported on the typia.application() API.
             const value: IMetadataTag.IFormat["value"] | undefined =
                 FORMATS.get(str);
+            validate(
+                identifier,
+                metadata,
+                output,
+                "format",
+                value === "date" || value === "datetime" ? "Date" : "string",
+                ["pattern"],
+            );
             if (value === undefined) return null;
             return {
                 kind: "format",
@@ -255,14 +259,20 @@ const validate = (
     metadata: Metadata,
     output: IMetadataTag[],
     kind: IMetadataTag["kind"],
-    type: "array" | "string" | "number",
+    type: "array" | "string" | "number" | "Date",
     neighbors: IMetadataTag["kind"][],
 ): void => {
     // TYPE CHECKING
     if (type === "array") {
-        if (has_array(metadata) === false)
+        if (has_array(new Set())(metadata) === false)
             throw new Error(WRONG_TYPE(kind, "array", identifier));
-    } else if (has_atomic(metadata)(type) === false)
+    } else if (type === "Date") {
+        if (
+            has_native("Date")(new Set())(metadata) === false &&
+            has_atomic("string")(new Set())(metadata) === false
+        )
+            throw new Error(WRONG_TYPE(kind, "string", identifier));
+    } else if (has_atomic(type)(new Set())(metadata) === false)
         throw new Error(WRONG_TYPE(kind, type, identifier));
 
     // DUPLICATED TAG
@@ -281,20 +291,65 @@ const validate = (
 
 // @todo: must block repeated array and tuple type
 const has_atomic =
-    (metadata: Metadata) =>
-    (type: "string" | "number"): boolean =>
-        metadata.atomics.find(
-            type === "number"
-                ? (atom: string) => atom === type || atom === "bigint"
-                : (atom: string) => atom === type,
-        ) !== undefined ||
-        metadata.arrays.some((child) => has_atomic(child.value)(type)) ||
-        metadata.tuples.some((tuple) =>
-            tuple.elements.some((child) => has_atomic(child)(type)),
+    (type: "string" | "number") =>
+    (visited: Set<Metadata>) =>
+    (metadata: Metadata): boolean => {
+        if (visited.has(metadata)) return false;
+        visited.add(metadata);
+        return (
+            metadata.atomics.find(
+                type === "number"
+                    ? (atom: string) => atom === type || atom === "bigint"
+                    : (atom: string) => atom === type,
+            ) !== undefined ||
+            metadata.arrays.some((array) =>
+                has_atomic(type)(visited)(array.value),
+            ) ||
+            metadata.tuples.some((tuple) =>
+                tuple.elements.some(has_atomic(type)(visited)),
+            ) ||
+            metadata.aliases.some((alias) =>
+                has_atomic(type)(visited)(alias.value),
+            ) ||
+            (metadata.resolved !== null &&
+                has_atomic(type)(visited)(metadata.resolved.returns))
         );
+    };
 
-const has_array = (metadata: Metadata): boolean =>
-    metadata.arrays.length !== 0 ||
-    metadata.tuples.some((tuple) =>
-        tuple.elements.some((child) => has_array(child)),
-    );
+const has_native =
+    (type: string) =>
+    (visited: Set<Metadata>) =>
+    (metadata: Metadata): boolean => {
+        if (visited.has(metadata)) return false;
+        visited.add(metadata);
+        return (
+            metadata.natives.find((native) => native === type) !== undefined ||
+            metadata.arrays.some((child) =>
+                has_native(type)(visited)(child.value),
+            ) ||
+            metadata.tuples.some((tuple) =>
+                tuple.elements.some(has_native(type)(visited)),
+            ) ||
+            metadata.aliases.some((alias) =>
+                has_native(type)(visited)(alias.value),
+            ) ||
+            (metadata.resolved !== null &&
+                has_native(type)(visited)(metadata.resolved.returns))
+        );
+    };
+
+const has_array =
+    (visited: Set<Metadata>) =>
+    (metadata: Metadata): boolean => {
+        if (visited.has(metadata)) return false;
+        visited.add(metadata);
+        return (
+            metadata.arrays.length !== 0 ||
+            metadata.tuples.some((tuple) =>
+                tuple.elements.some(has_array(visited)),
+            ) ||
+            metadata.aliases.some((alias) => has_array(visited)(alias.value)) ||
+            (metadata.resolved !== null &&
+                has_array(visited)(metadata.resolved.returns))
+        );
+    };

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

@@ -1,33 +1,33 @@
-import { Metadata } from "../../../metadata/Metadata";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-export const emend_metadata_atomics = (meta: Metadata) => {
-    // ATOMICS
-    for (const type of meta.atomics) {
-        const index: number = meta.constants.findIndex((c) => c.type === type);
-        if (index !== -1) meta.constants.splice(index, 1);
-    }
-
-    // BOOLEAN
-    {
-        const index: number = meta.constants.findIndex(
-            (c) => c.type === "boolean",
-        );
-        if (index !== -1 && meta.constants[index]!.values.length === 2) {
-            meta.constants.splice(index, 1);
-            ArrayUtil.take(
-                meta.atomics,
-                (type) => type === "boolean",
-                () => "boolean",
-            );
-        }
-    }
-
-    // TEMPLATE
-    if (
-        meta.templates.length &&
-        meta.atomics.find((type) => type === "string") !== undefined
-    )
-        meta.templates.splice(0, meta.templates.length);
-};
+import { Metadata } from "../../../metadata/Metadata";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+export const emend_metadata_atomics = (meta: Metadata) => {
+    // ATOMICS
+    for (const type of meta.atomics) {
+        const index: number = meta.constants.findIndex((c) => c.type === type);
+        if (index !== -1) meta.constants.splice(index, 1);
+    }
+
+    // BOOLEAN
+    {
+        const index: number = meta.constants.findIndex(
+            (c) => c.type === "boolean",
+        );
+        if (index !== -1 && meta.constants[index]!.values.length === 2) {
+            meta.constants.splice(index, 1);
+            ArrayUtil.take(
+                meta.atomics,
+                (type) => type === "boolean",
+                () => "boolean",
+            );
+        }
+    }
+
+    // TEMPLATE
+    if (
+        meta.templates.length &&
+        meta.atomics.find((type) => type === "string") !== undefined
+    )
+        meta.templates.splice(0, meta.templates.length);
+};

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

@@ -1,37 +1,40 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emend_metadata_atomics } from "./emend_metadata_atomics";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const explore_metadata =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (
-        type: ts.Type | null,
-        parentResolved: boolean,
-        aliased: boolean = false,
-    ): Metadata => {
-        // CONSTRUCT METADATA
-        const meta: Metadata = Metadata.initialize(parentResolved);
-        const out = (meta: Metadata) => {
-            if (options.validate) options.validate(meta);
-            return meta;
-        };
-        if (type === null) return out(meta);
-
-        // ITERATE TYPESCRIPT TYPES
-        iterate_metadata(checker)(options)(collection)(
-            meta,
-            type,
-            parentResolved,
-            aliased,
-        );
-        emend_metadata_atomics(meta);
-        if (meta.resolved) emend_metadata_atomics(meta.resolved);
-        return out(meta);
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emend_metadata_atomics } from "./emend_metadata_atomics";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (
+        type: ts.Type | null,
+        parentResolved: boolean,
+        aliased: boolean = false,
+    ): Metadata => {
+        // CONSTRUCT METADATA
+        const meta: Metadata = Metadata.initialize(parentResolved);
+        const out = (meta: Metadata) => {
+            if (options.validate) options.validate(meta);
+            return meta;
+        };
+        if (type === null) return out(meta);
+
+        // ITERATE TYPESCRIPT TYPES
+        iterate_metadata(checker)(options)(collection)(
+            meta,
+            type,
+            parentResolved,
+            aliased,
+        );
+        emend_metadata_atomics(meta);
+        if (meta.resolved) {
+            emend_metadata_atomics(meta.resolved.original);
+            emend_metadata_atomics(meta.resolved.returns);
+        }
+        return out(meta);
+    };

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

@@ -1,85 +1,85 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-// import { ArrayUtil } from "../../../utils/ArrayUtil";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata_alias } from "./iterate_metadata_alias";
-import { iterate_metadata_array } from "./iterate_metadata_array";
-import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-import { iterate_metadata_constant } from "./iterate_metadata_constant";
-import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
-import { iterate_metadata_map } from "./iterate_metadata_map";
-import { iterate_metadata_native } from "./iterate_metadata_native";
-import { iterate_metadata_object } from "./iterate_metadata_object";
-import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
-import { iterate_metadata_set } from "./iterate_metadata_set";
-import { iterate_metadata_template } from "./iterate_metadata_template";
-import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
-import { iterate_metadata_union } from "./iterate_metadata_union";
-
-export const iterate_metadata =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (
-        meta: Metadata,
-        type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
-    ): void => {
-        if (type.isTypeParameter() === true)
-            throw new Error(
-                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
-            );
-        // CHECK SPECIAL CASES
-        if (
-            (aliased !== true &&
-                iterate_metadata_alias(checker)(options)(collection)(
-                    meta,
-                    type,
-                )) ||
-            iterate_metadata_intersection(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-                aliased,
-            ) ||
-            iterate_metadata_union(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-            ) ||
-            iterate_metadata_resolve(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-                aliased,
-            )
-        )
-            return;
-
-        // ITERATE CASES
-        iterate_metadata_coalesce(meta, type) ||
-            iterate_metadata_constant(checker)(options)(meta, type) ||
-            iterate_metadata_template(checker)(options)(collection)(
-                meta,
-                type,
-            ) ||
-            iterate_metadata_atomic(meta, type) ||
-            iterate_metadata_tuple(checker)(options)(collection)(
-                meta,
-                type as ts.TupleType,
-            ) ||
-            iterate_metadata_array(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_native(checker)(meta, type) ||
-            iterate_metadata_map(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_set(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_object(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-            );
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+// import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata_alias } from "./iterate_metadata_alias";
+import { iterate_metadata_array } from "./iterate_metadata_array";
+import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+import { iterate_metadata_constant } from "./iterate_metadata_constant";
+import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
+import { iterate_metadata_map } from "./iterate_metadata_map";
+import { iterate_metadata_native } from "./iterate_metadata_native";
+import { iterate_metadata_object } from "./iterate_metadata_object";
+import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
+import { iterate_metadata_set } from "./iterate_metadata_set";
+import { iterate_metadata_template } from "./iterate_metadata_template";
+import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
+import { iterate_metadata_union } from "./iterate_metadata_union";
+
+export const iterate_metadata =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        resolved: boolean,
+        aliased: boolean,
+    ): void => {
+        if (type.isTypeParameter() === true)
+            throw new Error(
+                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
+            );
+        // CHECK SPECIAL CASES
+        if (
+            (aliased !== true &&
+                iterate_metadata_alias(checker)(options)(collection)(
+                    meta,
+                    type,
+                )) ||
+            iterate_metadata_intersection(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+                aliased,
+            ) ||
+            iterate_metadata_union(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+            ) ||
+            iterate_metadata_resolve(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+                aliased,
+            )
+        )
+            return;
+
+        // ITERATE CASES
+        iterate_metadata_coalesce(meta, type) ||
+            iterate_metadata_constant(checker)(options)(meta, type) ||
+            iterate_metadata_template(checker)(options)(collection)(
+                meta,
+                type,
+            ) ||
+            iterate_metadata_atomic(meta, type) ||
+            iterate_metadata_tuple(checker)(options)(collection)(
+                meta,
+                type as ts.TupleType,
+            ) ||
+            iterate_metadata_array(checker)(options)(collection)(meta, type) ||
+            iterate_metadata_native(checker)(meta, type) ||
+            iterate_metadata_map(checker)(options)(collection)(meta, type) ||
+            iterate_metadata_set(checker)(options)(collection)(meta, type) ||
+            iterate_metadata_object(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+            );
+    };

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

@@ -56,7 +56,7 @@ const isArrayRecursive =
             meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
             meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
             (meta.resolved !== null &&
-                isArrayRecursive(visited)(array)(meta.resolved)) ||
+                isArrayRecursive(visited)(array)(meta.resolved.returns)) ||
             (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
         );
     };
@@ -84,7 +84,7 @@ const isTupleRecursive =
                 isTupleRecursive(visited)(tuple)(d.value),
             ) ||
             (meta.resolved !== null &&
-                isTupleRecursive(visited)(tuple)(meta.resolved)) ||
+                isTupleRecursive(visited)(tuple)(meta.resolved.returns)) ||
             (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
         );
     };
@@ -124,7 +124,7 @@ const isObjectRecursive =
             ) ||
             meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
             (meta.resolved !== null &&
-                isObjectRecursive(visited)(obj)(meta.resolved)) ||
+                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
             (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
         );
     };

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

@@ -1,38 +1,49 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { Writable } from "../../../typings/Writable";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-// import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-
-export const iterate_metadata_resolve =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (
-        meta: Metadata,
-        type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
-    ): boolean => {
-        if (options.resolve === 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 = Metadata.initialize();
-        iterate_metadata(checker)(options)(collection)(
-            meta.resolved!,
-            escaped,
-            true,
-            aliased,
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataResolved } from "../../../metadata/MetadataResolved";
+
+import { Writable } from "../../../typings/Writable";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+// import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+
+export const iterate_metadata_resolve =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        resolved: boolean,
+        aliased: boolean,
+    ): boolean => {
+        if (options.resolve === 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({
+                original: Metadata.initialize(),
+                returns: Metadata.initialize(),
+            });
+        }
+        iterate_metadata(checker)(options)(collection)(
+            meta.resolved!.original,
+            type,
+            true,
+            aliased,
+        );
+        iterate_metadata(checker)(options)(collection)(
+            meta.resolved!.returns,
+            escaped,
+            true,
+            aliased,
+        );
+        return true;
+    };

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

@@ -27,7 +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);
+        if (meta.resolved !== null)
+            iterate(visited)(collection)(meta.resolved.returns);
         if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
 
         // SORT OBJECTS

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

@@ -1,24 +1,24 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const iterate_metadata_union =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
-        if (!type.isUnion()) return false;
-        type.types.forEach((t) =>
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                t,
-                parentResolved,
-                false,
-            ),
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const iterate_metadata_union =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+        if (!type.isUnion()) return false;
+        type.types.forEach((t) =>
+            iterate_metadata(checker)(options)(collection)(
+                meta,
+                t,
+                parentResolved,
+                false,
+            ),
+        );
+        return true;
+    };

package/src/metadata/IMetadata.ts

@@ -2,6 +2,7 @@ import { Atomic } from "../typings/Atomic";
 
 import { IMetadataConstant } from "./IMetadataConstant";
 import { IMetadataEntry } from "./IMetadataEntry";
+import { IMetadataResolved } from "./IMetadataResolved";
 
 export interface IMetadata {
     any: boolean;
@@ -13,7 +14,7 @@ export interface IMetadata {
     atomics: Atomic.Literal[];
     constants: IMetadataConstant[];
     templates: IMetadata[][];
-    resolved: IMetadata | null;
+    resolved: IMetadataResolved | null;
 
     rest: IMetadata | null;
     arrays: string[];

package/src/metadata/IMetadataResolved.ts

@@ -0,0 +1,6 @@
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataResolved {
+    original: IMetadata;
+    returns: IMetadata;
+}