typia 3.8.8 → 3.9.0-dev.20230603

package/src/factories/MetadataCollection.ts

@@ -1,7 +1,13 @@
 import ts from "typescript";
 
+import { IMetadataCollection } from "../metadata/IMetadataCollection";
 import { Metadata } from "../metadata/Metadata";
+import { MetadataArray } from "../metadata/MetadataArray";
+import { MetadataDefinition } from "../metadata/MetadataDefinition";
 import { MetadataObject } from "../metadata/MetadataObject";
+import { MetadataTuple } from "../metadata/MetadataTuple";
+
+import { Writable } from "../typings/Writable";
 
 import { MapUtil } from "../utils/MapUtil";
 
@@ -9,78 +15,211 @@ import { CommentFactory } from "./CommentFactory";
 import { TypeFactory } from "./TypeFactory";
 
 export class MetadataCollection {
-    private readonly dict_: Map<ts.Type, MetadataObject>;
+    private readonly objects_: Map<ts.Type, MetadataObject>;
+    private readonly object_unions_: Map<string, MetadataObject[]>;
+    private readonly definitions_: Map<ts.Type, MetadataDefinition>;
+    private readonly arrays_: Map<ts.Type, MetadataArray>;
+    private readonly tuples_: Map<ts.Type, MetadataTuple>;
+
     private readonly names_: Map<string, Map<ts.Type, string>>;
-    private readonly unions_: Map<string, MetadataObject[]>;
-    private index_: number;
+    private object_index_: number;
+    private recursive_array_index_: number;
+    private recursive_tuple_index_: number;
 
     public constructor(
         private readonly options?: Partial<MetadataCollection.IOptions>,
     ) {
-        this.dict_ = new Map();
+        this.objects_ = new Map();
+        this.object_unions_ = new Map();
+        this.definitions_ = new Map();
+        this.arrays_ = new Map();
+        this.tuples_ = new Map();
+
         this.names_ = new Map();
-        this.unions_ = new Map();
-        this.index_ = 0;
+        this.object_index_ = 0;
+        this.recursive_array_index_ = 0;
+        this.recursive_tuple_index_ = 0;
+    }
+
+    /* -----------------------------------------------------------
+        ACCESSORS
+    ----------------------------------------------------------- */
+    public definitions(): MetadataDefinition[] {
+        return [...this.definitions_.values()];
     }
 
     public objects(): MetadataObject[] {
-        return [...this.dict_.values()];
+        return [...this.objects_.values()];
     }
+
     public unions(): MetadataObject[][] {
-        return [...this.unions_.values()];
+        return [...this.object_unions_.values()];
     }
 
+    public arrays(): MetadataArray[] {
+        return [...this.arrays_.values()];
+    }
+
+    public tuples(): MetadataTuple[] {
+        return [...this.tuples_.values()];
+    }
+
+    private getName(checker: ts.TypeChecker, type: ts.Type): string {
+        const name: string = (() => {
+            const str: string = TypeFactory.getFullName(checker)(type);
+            return this.options?.replace ? this.options.replace(str) : str;
+        })();
+
+        const duplicates: Map<ts.Type, string> = MapUtil.take(this.names_)(
+            name,
+            () => new Map(),
+        );
+        const oldbie: string | undefined = duplicates.get(type);
+        if (oldbie !== undefined) return oldbie;
+
+        const addicted: string = duplicates.size
+            ? `${name}.o${duplicates.size}`
+            : name;
+        duplicates.set(type, addicted);
+        return addicted;
+    }
+
+    /**
+     * @internal
+     */
+    public getUnionIndex(meta: Metadata): number {
+        const key: string = meta.objects.map((obj) => obj.name).join(" | ");
+        MapUtil.take(this.object_unions_)(key, () => meta.objects);
+        return [...this.object_unions_.keys()].indexOf(key);
+    }
+
+    /* -----------------------------------------------------------
+        INSTANCES
+    ----------------------------------------------------------- */
     public emplace(
         checker: ts.TypeChecker,
         type: ts.Type,
     ): [MetadataObject, boolean] {
-        const oldbie = this.dict_.get(type);
+        const oldbie = this.objects_.get(type);
         if (oldbie !== undefined) return [oldbie, false];
 
-        const $id: string = this.get_name(checker, type);
+        const $id: string = this.getName(checker, type);
         const obj: MetadataObject = MetadataObject.create({
             name: $id,
             properties: [],
             description:
                 (type.symbol && CommentFactory.description(type.symbol)) ??
                 undefined,
-            jsDocTags: type.symbol?.getJsDocTags() || [],
+            jsDocTags: type.symbol?.getJsDocTags() ?? [],
             validated: false,
-            index: this.index_++,
-            recursive: false,
+            index: this.object_index_++,
+            recursive: null!,
             nullables: [],
         });
-        this.dict_.set(type, obj);
+        this.objects_.set(type, obj);
         return [obj, true];
     }
 
+    public emplaceDefinition(
+        checker: ts.TypeChecker,
+        type: ts.Type,
+        symbol: ts.Symbol,
+    ): [MetadataDefinition, boolean, (meta: Metadata) => void] {
+        const oldbie = this.definitions_.get(type);
+        if (oldbie !== undefined) return [oldbie, false, () => {}];
+
+        const $id: string = this.getName(checker, type);
+        const def: MetadataDefinition = MetadataDefinition.create({
+            name: $id,
+            value: null!,
+            description: CommentFactory.description(symbol) ?? null,
+            recursive: null!,
+            nullables: [],
+            jsDocTags: symbol.getJsDocTags() ?? [],
+        });
+        this.definitions_.set(type, def);
+        return [def, true, (meta) => (Writable(def).value = meta)];
+    }
+
+    public emplaceArray(
+        checker: ts.TypeChecker,
+        type: ts.Type,
+    ): [MetadataArray, boolean, (meta: Metadata) => void] {
+        const oldbie = this.arrays_.get(type);
+        if (oldbie !== undefined) return [oldbie, false, () => {}];
+
+        const $id = this.getName(checker, type);
+        const array: MetadataArray = MetadataArray.create({
+            name: $id,
+            value: null!,
+            index: null,
+            recursive: null!,
+            nullables: [],
+        });
+        this.arrays_.set(type, array);
+        return [array, true, (meta) => (Writable(array).value = meta)];
+    }
+
+    public emplaceTuple(
+        checker: ts.TypeChecker,
+        type: ts.TupleType,
+    ): [MetadataTuple, boolean, (elements: Metadata[]) => void] {
+        const oldbie = this.tuples_.get(type);
+        if (oldbie !== undefined) return [oldbie, false, () => {}];
+
+        const $id = this.getName(checker, type);
+        const tuple: MetadataTuple = MetadataTuple.create({
+            name: $id,
+            elements: null!,
+            index: null,
+            recursive: null!,
+            nullables: [],
+        });
+        this.tuples_.set(type, tuple);
+        return [
+            tuple,
+            true,
+            (elements) => (Writable(tuple).elements = elements),
+        ];
+    }
+
     /**
      * @internal
      */
-    public getUnionIndex(meta: Metadata): number {
-        const key: string = meta.objects.map((obj) => obj.name).join(" | ");
-        MapUtil.take(this.unions_)(key, () => meta.objects);
-        return [...this.unions_.keys()].indexOf(key);
+    public setObjectRecursive(obj: MetadataObject, recursive: boolean): void {
+        Writable(obj).recursive = recursive;
     }
 
-    private get_name(checker: ts.TypeChecker, type: ts.Type): string {
-        const name: string = (() => {
-            const str: string = TypeFactory.getFullName(checker)(type);
-            return this.options?.replace ? this.options.replace(str) : str;
-        })();
+    /**
+     * @internal
+     */
+    public setDefinitionRecursive(
+        def: MetadataDefinition,
+        recursive: boolean,
+    ): void {
+        Writable(def).recursive = recursive;
+    }
 
-        const duplicates: Map<ts.Type, string> = MapUtil.take(this.names_)(
-            name,
-            () => new Map(),
-        );
-        const oldbie: string | undefined = duplicates.get(type);
-        if (oldbie !== undefined) return oldbie;
+    /**
+     * @internal
+     */
+    public setArrayRecursive(array: MetadataArray, recursive: boolean): void {
+        Writable(array).recursive = recursive;
+        if (recursive) Writable(array).index = this.recursive_array_index_++;
+    }
 
-        const addicted: string = duplicates.size
-            ? `${name}.o${duplicates.size}`
-            : name;
-        duplicates.set(type, addicted);
-        return addicted;
+    public setTupleRecursive(tuple: MetadataTuple, recursive: boolean): void {
+        Writable(tuple).recursive = recursive;
+        if (recursive) Writable(tuple).index = this.recursive_tuple_index_++;
+    }
+
+    public toJSON(): IMetadataCollection {
+        return {
+            objects: this.objects().map((o) => o.toJSON()),
+            definitions: this.definitions().map((d) => d.toJSON()),
+            arrays: [...this.arrays_.values()].map((a) => a.toJSON()),
+            tuples: [...this.tuples_.values()].map((t) => t.toJSON()),
+        };
     }
 }
 export namespace MetadataCollection {

package/src/factories/MetadataFactory.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { Metadata } from "../metadata/Metadata";
 import { explore_metadata } from "./internal/metadata/explore_metadata";
+import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
+import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
 
 import { MetadataCollection } from "./MetadataCollection";
 
@@ -9,6 +11,7 @@ export namespace MetadataFactory {
     export interface IOptions {
         resolve: boolean;
         constant: boolean;
+        absorb: boolean;
         validate?: (meta: Metadata) => void;
     }
 
@@ -17,37 +20,12 @@ export namespace MetadataFactory {
         (options: IOptions) =>
         (collection: MetadataCollection) =>
         (type: ts.Type | null): Metadata => {
-            // CONSTRUCT SCHEMA WITH OBJECTS
-            const metadata: Metadata = explore_metadata(checker)(options)(
+            const meta: Metadata = explore_metadata(checker)(options)(
                 collection,
             )(type, false);
-
-            // FIND RECURSIVE OBJECTS
-            for (const object of collection.objects())
-                object.recursive = object.properties.some((prop) =>
-                    isRecursive(object.name)(prop.value),
-                );
-
-            // RETURNS
-            return metadata;
-        };
-
-    const isRecursive =
-        (name: string) =>
-        (meta: Metadata): boolean => {
-            const similar = (str: string) =>
-                name === str ||
-                name.indexOf(`<${str},`) !== -1 ||
-                name.indexOf(`, ${str}>`) !== -1 ||
-                name.indexOf(`, ${str},`) !== -1;
-            return (
-                meta.objects.some((obj) => similar(obj.name)) ||
-                meta.arrays.some((arr) => isRecursive(name)(arr)) ||
-                meta.tuples.some((tuple) =>
-                    tuple.some((m) => isRecursive(name)(m.rest ?? m)),
-                ) ||
-                meta.maps.some((map) => isRecursive(name)(map.value))
-            );
+            iterate_metadata_collection(collection);
+            iterate_metadata_sort(collection)(meta);
+            return meta;
         };
 
     /**

package/src/factories/MetadataTagFactory.ts

@@ -277,6 +277,7 @@ const validate = (
             );
 };
 
+// @todo: must block repeated array and tuple type
 const has_atomic =
     (metadata: Metadata) =>
     (type: "string" | "number"): boolean =>
@@ -285,11 +286,13 @@ const has_atomic =
                 ? (atom: string) => atom === type || atom === "bigint"
                 : (atom: string) => atom === type,
         ) !== undefined ||
-        metadata.arrays.some((child) => has_atomic(child)(type)) ||
+        metadata.arrays.some((child) => has_atomic(child.value)(type)) ||
         metadata.tuples.some((tuple) =>
-            tuple.some((child) => has_atomic(child)(type)),
+            tuple.elements.some((child) => has_atomic(child)(type)),
         );
 
 const has_array = (metadata: Metadata): boolean =>
     metadata.arrays.length !== 0 ||
-    metadata.tuples.some((tuple) => tuple.some((child) => has_array(child)));
+    metadata.tuples.some((tuple) =>
+        tuple.elements.some((child) => has_array(child)),
+    );

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

@@ -0,0 +1,34 @@
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataArray } from "../../../metadata/MetadataArray";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_array =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataArray => {
+        // CHECK EXISTENCE
+        const [array, newbie, setValue] = collection.emplaceArray(
+            checker,
+            type,
+        );
+        ArrayUtil.add(array.nullables, nullable);
+        if (newbie === false) return array;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type.getNumberIndexType()!,
+            false,
+            false,
+        );
+        setValue(value);
+
+        return array;
+    };

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

@@ -0,0 +1,35 @@
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataDefinition } from "../../../metadata/MetadataDefinition";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_definition =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataDefinition => {
+        // CHECK EXISTENCE
+        const [alias, newbie, closure] = collection.emplaceDefinition(
+            checker,
+            type,
+            type.aliasSymbol!,
+        );
+        ArrayUtil.add(alias.nullables, nullable);
+        if (newbie === false) return alias;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type,
+            false,
+            true,
+        );
+        closure(value);
+
+        return alias;
+    };

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

@@ -23,6 +23,7 @@ export const emplace_metadata_object =
         // EMPLACE OBJECT
         const [obj, newbie] = collection.emplace(checker, parent);
         ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
+
         if (newbie === false) return obj;
 
         // PREPARE ASSETS
@@ -49,9 +50,9 @@ export const emplace_metadata_object =
                 filter?: (doc: ts.JSDocTagInfo) => boolean,
             ): MetadataProperty => {
                 // COMMENTS AND TAGS
-                const description: string | undefined = symbol
-                    ? CommentFactory.description(symbol)
-                    : undefined;
+                const description: string | null = symbol
+                    ? CommentFactory.description(symbol) ?? null
+                    : null;
                 const jsDocTags: ts.JSDocTagInfo[] = (
                     symbol?.getJsDocTags() ?? []
                 ).filter(filter ?? (() => true));
@@ -131,7 +132,6 @@ export const emplace_metadata_object =
                 (doc) => doc.name !== "default",
             );
         }
-
         return obj;
     };
 

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

@@ -0,0 +1,50 @@
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataTuple } from "../../../metadata/MetadataTuple";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_tuple =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
+        // CHECK EXISTENCE
+        const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
+        ArrayUtil.add(tuple.nullables, nullable);
+        if (newbie === false) return tuple;
+
+        // CONSTRUCT ELEMENT TYPES
+        const flagList: readonly ts.ElementFlags[] =
+            type.elementFlags ??
+            (type.target as ts.TupleType)?.elementFlags ??
+            [];
+        const elements: Metadata[] = checker
+            .getTypeArguments(type as ts.TypeReference)
+            .map((elem, i) => {
+                const child: Metadata = explore_metadata(checker)(options)(
+                    collection,
+                )(elem, false, false);
+
+                // CHECK OPTIONAL
+                const flag: ts.ElementFlags | undefined = flagList[i];
+                if (flag === ts.ElementFlags.Optional)
+                    Writable(child).optional = true;
+
+                // REST TYPE
+                if (flag !== ts.ElementFlags.Rest) return child;
+                const wrapper: Metadata = Metadata.initialize();
+                Writable(wrapper).rest = child;
+                return wrapper;
+            });
+        closure(elements);
+
+        return tuple;
+    };

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

@@ -1,7 +1,6 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -13,48 +12,26 @@ export const explore_metadata =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type | null, parentResolved: boolean): Metadata => {
+    (
+        type: ts.Type | null,
+        parentResolved: boolean,
+        aliased: boolean = false,
+    ): Metadata => {
         // CONSTRUCT METADATA
         const meta: Metadata = Metadata.initialize(parentResolved);
-        if (type !== null)
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                type,
-                parentResolved,
-            );
-
-        // SORT OBJECTS
-        if (meta.objects.length > 1) {
-            meta.objects.sort((x, y) =>
-                MetadataObject.covers(x, y)
-                    ? -1
-                    : MetadataObject.covers(y, x)
-                    ? 1
-                    : 0,
-            );
-            if (parentResolved === false)
-                meta.union_index = collection.getUnionIndex(meta);
-        }
+        const out = (meta: Metadata) => {
+            if (options.validate) options.validate(meta);
+            return meta;
+        };
+        if (type === null) return out(meta);
 
-        // SORT ARRAYS AND TUPLES
-        if (meta.arrays.length > 1)
-            meta.arrays.sort((x, y) =>
-                Metadata.covers(x, y) ? -1 : Metadata.covers(y, x) ? 1 : 0,
-            );
-        if (meta.tuples.length > 1)
-            meta.tuples.sort((x, y) => {
-                const xt = Metadata.initialize();
-                const yt = Metadata.initialize();
-
-                xt.tuples.push(x);
-                yt.tuples.push(y);
-
-                return Metadata.covers(xt, yt)
-                    ? -1
-                    : Metadata.covers(yt, xt)
-                    ? 1
-                    : 0;
-            });
+        // ITERATE TYPESCRIPT TYPES
+        iterate_metadata(checker)(options)(collection)(
+            meta,
+            type,
+            parentResolved,
+            aliased,
+        );
 
         // EMEND ATOMICS
         for (const type of meta.atomics) {
@@ -85,8 +62,5 @@ export const explore_metadata =
             meta.atomics.find((type) => type === "string") !== undefined
         )
             meta.templates.splice(0, meta.templates.length);
-
-        // RETURNS WITH VALIDATION
-        if (options.validate) options.validate(meta);
-        return meta;
+        return out(meta);
     };

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

@@ -9,6 +9,7 @@ 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_definition } from "./iterate_metadata_definition";
 import { iterate_metadata_map } from "./iterate_metadata_map";
 import { iterate_metadata_native } from "./iterate_metadata_native";
 import { iterate_metadata_object } from "./iterate_metadata_object";
@@ -22,14 +23,23 @@ export const iterate_metadata =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): void => {
+    (
+        meta: Metadata,
+        type: ts.Type,
+        parentResolved: boolean,
+        aliased: boolean,
+    ): void => {
         if (type.isTypeParameter() === true)
             throw new Error(
                 `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
             );
-
-        // CHECK UNION & toJSON()
+        // CHECK SPECIAL CASES
         if (
+            (aliased !== true &&
+                iterate_metadata_definition(checker)(options)(collection)(
+                    meta,
+                    type,
+                )) ||
             iterate_metadata_union(checker)(options)(collection)(
                 meta,
                 type,

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

@@ -1,29 +1,25 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
+import { MetadataArray } from "../../../metadata/MetadataArray";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
+import { emplace_metadata_array } from "./emplace_metadata_array";
 
 export const iterate_metadata_array =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
     (meta: Metadata, type: ts.Type): boolean => {
-        if (
-            !(checker as any).isArrayType(type) &&
-            !(checker as any).isArrayLikeType(type)
-        )
+        if (!checker.isArrayType(type) && !checker.isArrayLikeType(type))
             return false;
 
-        const value: ts.Type | null = type.getNumberIndexType() || null;
-        ArrayUtil.set(
-            meta.arrays,
-            explore_metadata(checker)(options)(collection)(value, false),
-            (elem) => elem.getName(),
-        );
+        const array: MetadataArray = emplace_metadata_array(checker)(options)(
+            collection,
+        )(type, meta.nullable);
+        ArrayUtil.add(meta.arrays, array, (elem) => elem.name === array.name);
         return true;
     };