typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/factories/MetadataCollection.ts

@@ -1,91 +1,222 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
+import { IMetadataCollection } from "../metadata/IMetadataCollection";
 import { Metadata } from "../metadata/Metadata";
+import { MetadataAlias } from "../metadata/MetadataAlias";
+import { MetadataArray } from "../metadata/MetadataArray";
 import { MetadataObject } from "../metadata/MetadataObject";
+import { MetadataTuple } from "../metadata/MetadataTuple";
 
-import { IProject } from "../transformers/IProject";
+import { Writable } from "../typings/Writable";
 
 import { MapUtil } from "../utils/MapUtil";
-import { TsSymbolUtil } from "../utils/TsSymbolUtil";
 
+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 aliases_: Map<ts.Type, MetadataAlias>;
+    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.aliases_ = 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 aliases(): MetadataAlias[] {
+        return [...this.aliases_.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(
-        p: IProject.IModule,
+        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(p, type);
+        const $id: string = this.getName(checker, type);
         const obj: MetadataObject = MetadataObject.create({
             name: $id,
             properties: [],
-            description: type.symbol
-                ? TsSymbolUtil.comments(p.tsc)(type.symbol)
-                : undefined,
-            jsDocTags:
-                (type.symbol
-                    ? TsSymbolUtil.getCommentTags(p.tsc)(type.symbol)
-                    : undefined) ?? [],
+            description:
+                (type.symbol && CommentFactory.description(type.symbol)) ??
+                undefined,
+            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 emplaceAlias(
+        checker: ts.TypeChecker,
+        type: ts.Type,
+        symbol: ts.Symbol,
+    ): [MetadataAlias, boolean, (meta: Metadata) => void] {
+        const oldbie = this.aliases_.get(type);
+        if (oldbie !== undefined) return [oldbie, false, () => {}];
+
+        const $id: string = this.getName(checker, type);
+        const alias: MetadataAlias = MetadataAlias.create({
+            name: $id,
+            value: null!,
+            description: CommentFactory.description(symbol) ?? null,
+            recursive: null!,
+            nullables: [],
+            jsDocTags: symbol.getJsDocTags() ?? [],
+        });
+        this.aliases_.set(type, alias);
+        return [alias, true, (meta) => (Writable(alias).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(p: IProject.IModule, type: ts.Type): string {
-        const name: string = (() => {
-            const str: string = TypeFactory.getFullName(p)(type);
-            return this.options?.replace ? this.options.replace(str) : str;
-        })();
+    /**
+     * @internal
+     */
+    public setAliasRecursive(alias: MetadataAlias, recursive: boolean): void {
+        Writable(alias).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()),
+            aliases: this.aliases().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

@@ -1,9 +1,9 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { Metadata } from "../metadata/Metadata";
 import { explore_metadata } from "./internal/metadata/explore_metadata";
-
-import { IProject } from "../transformers/IProject";
+import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
+import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
 
 import { MetadataCollection } from "./MetadataCollection";
 
@@ -11,43 +11,30 @@ export namespace MetadataFactory {
     export interface IOptions {
         resolve: boolean;
         constant: boolean;
+        absorb: boolean;
         validate?: (meta: Metadata) => void;
     }
 
     export const analyze =
-        (project: IProject.IModule) =>
+        (checker: ts.TypeChecker) =>
         (options: IOptions) =>
         (collection: MetadataCollection) =>
         (type: ts.Type | null): Metadata => {
-            // CONSTRUCT SCHEMA WITH OBJECTS
-            const metadata: Metadata =
-                explore_metadata(project)(options)(collection)(false)(type);
-
-            // FIND RECURSIVE OBJECTS
-            for (const object of collection.objects())
-                object.recursive = object.properties.some((prop) =>
-                    isRecursive(object.name)(prop.value),
-                );
-
-            // RETURNS
-            return metadata;
+            const meta: Metadata = explore_metadata(checker)(options)(
+                collection,
+            )(type, false);
+            iterate_metadata_collection(collection);
+            iterate_metadata_sort(collection)(meta);
+            return meta;
         };
 
-    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))
-            );
-        };
+    /**
+     * @deprecated Use `analyze` function instead
+     */
+    export const generate = (
+        checker: ts.TypeChecker,
+        collection: MetadataCollection,
+        type: ts.Type,
+        options: IOptions,
+    ) => analyze(checker)(options)(collection)(type);
 }

package/src/factories/MetadataTagFactory.ts

@@ -1,4 +1,4 @@
-import { JSDocTagInfo } from "typescript";
+import ts from "typescript";
 
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
@@ -6,7 +6,7 @@ import { Metadata } from "../metadata/Metadata";
 export namespace MetadataTagFactory {
     export const generate =
         (metadata: Metadata) =>
-        (tagList: JSDocTagInfo[]) =>
+        (tagList: ts.JSDocTagInfo[]) =>
         (identifier: () => string): IMetadataTag[] => {
             const output: IMetadataTag[] = [];
             for (const tag of tagList) {
@@ -24,13 +24,13 @@ export namespace MetadataTagFactory {
     const parse = (
         identifier: () => string,
         metadata: Metadata,
-        tag: JSDocTagInfo,
+        tag: ts.JSDocTagInfo,
         output: IMetadataTag[],
     ): IMetadataTag | null => {
         const closure = _PARSER[tag.name];
         if (closure === undefined) return null;
 
-        const text: string | undefined = tag.text?.[0]?.text;
+        const text = (tag.text || [])[0]?.text;
         if (text === undefined)
             throw new Error(`${LABEL}: no tag value on ${identifier()}`);
 
@@ -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/StatementFactory.ts

@@ -1,20 +1,24 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 export namespace StatementFactory {
-    export const constant =
-        (tsc: typeof ts) => (name: string, initializer?: ts.Expression) =>
-            tsc.factory.createVariableStatement(
-                undefined,
-                tsc.factory.createVariableDeclarationList(
-                    [
-                        tsc.factory.createVariableDeclaration(
-                            name,
-                            undefined,
-                            undefined,
-                            initializer,
-                        ),
-                    ],
-                    tsc.NodeFlags.Const,
-                ),
-            );
+    export const constant = (name: string, initializer?: ts.Expression) =>
+        ts.factory.createVariableStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [
+                    ts.factory.createVariableDeclaration(
+                        name,
+                        undefined,
+                        undefined,
+                        initializer,
+                    ),
+                ],
+                ts.NodeFlags.Const,
+            ),
+        );
+
+    export const transpile = (script: string) =>
+        ts.factory.createExpressionStatement(
+            ts.factory.createIdentifier(ts.transpile(script)),
+        );
 }

package/src/factories/TemplateFactory.ts

@@ -1,52 +1,46 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 export namespace TemplateFactory {
-    export const generate =
-        (tsc: typeof ts) =>
-        (expressions: ts.Expression[]): ts.Expression => {
-            if (expressions.every((exp) => tsc.isStringLiteral(exp)))
-                return tsc.factory.createStringLiteral(
-                    (expressions as ts.StringLiteral[])
-                        .map((str) => str.text)
-                        .join(""),
-                );
-
-            const it: IIterator = {
-                value: "",
-                index: 0,
-            };
-            gather(tsc)(expressions)(it);
-
-            const head: ts.TemplateHead = tsc.factory.createTemplateHead(
-                it.value,
+    export const generate = (expressions: ts.Expression[]): ts.Expression => {
+        if (expressions.every((exp) => ts.isStringLiteral(exp)))
+            return ts.factory.createStringLiteral(
+                (expressions as ts.StringLiteral[])
+                    .map((str) => str.text)
+                    .join(""),
             );
-            const spans: ts.TemplateSpan[] = [];
 
-            while (true) {
-                const elem: ts.Expression = expressions[it.index++]!;
-                gather(tsc)(expressions)(it);
-
-                const broken: boolean = it.index === expressions.length;
-                spans.push(
-                    tsc.factory.createTemplateSpan(
-                        elem,
-                        broken
-                            ? tsc.factory.createTemplateTail(it.value)
-                            : tsc.factory.createTemplateMiddle(it.value),
-                    ),
-                );
-                if (broken === true) break;
-            }
-            return tsc.factory.createTemplateExpression(head, spans);
+        const it: IIterator = {
+            value: "",
+            index: 0,
         };
+        gather(expressions)(it);
+
+        const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
+        const spans: ts.TemplateSpan[] = [];
+
+        while (true) {
+            const elem: ts.Expression = expressions[it.index++]!;
+            gather(expressions)(it);
+
+            const broken: boolean = it.index === expressions.length;
+            spans.push(
+                ts.factory.createTemplateSpan(
+                    elem,
+                    broken
+                        ? ts.factory.createTemplateTail(it.value)
+                        : ts.factory.createTemplateMiddle(it.value),
+                ),
+            );
+            if (broken === true) break;
+        }
+        return ts.factory.createTemplateExpression(head, spans);
+    };
 
     const gather =
-        (tsc: typeof ts) =>
         (expressions: ts.Expression[]) =>
         (it: IIterator): void => {
             const found: number = expressions.findIndex(
-                (elem, index) =>
-                    index >= it.index && !tsc.isStringLiteral(elem),
+                (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
             );
 
             const last: number = found !== -1 ? found : expressions.length;