typia 4.0.0-dev.20230517 → 4.0.0-dev.20230519

package/src/factories/ExpressionFactory.ts

@@ -1,70 +1,77 @@
-import ts from "typescript/lib/tsclibrary";
-
-export namespace ExpressionFactory {
-    export const isRequired = (input: ts.Expression): ts.Expression =>
-        ts.factory.createStrictInequality(
-            ts.factory.createIdentifier("undefined"),
-            input,
-        );
-
-    export const isArray = (input: ts.Expression): ts.Expression =>
-        ts.factory.createCallExpression(
-            ts.factory.createIdentifier("Array.isArray"),
-            undefined,
-            [input],
-        );
-
-    export const isObject =
-        (options: { checkNull: boolean; checkArray: boolean }) =>
-        (input: ts.Expression): ts.Expression => {
-            const conditions: ts.Expression[] = [
-                ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral("object"),
-                    ts.factory.createTypeOfExpression(input),
-                ),
-            ];
-            if (options.checkNull === true)
-                conditions.push(
-                    ts.factory.createStrictInequality(
-                        ts.factory.createNull(),
-                        input,
-                    ),
-                );
-            if (options.checkArray === true)
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createFalse(),
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Array.isArray"),
-                            undefined,
-                            [input],
-                        ),
-                    ),
-                );
-
-            return conditions.length === 1
-                ? conditions[0]!
-                : conditions.reduce((x, y) =>
-                      ts.factory.createLogicalAnd(x, y),
-                  );
-        };
-
-    export const isInstanceOf =
-        (type: string) =>
-        (input: ts.Expression): ts.Expression => {
-            return ts.factory.createBinaryExpression(
-                input,
-                ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
-                ts.factory.createIdentifier(type),
-            );
-        };
-
-    export const coalesce =
-        (x: ts.Expression) =>
-        (y: ts.Expression): ts.Expression =>
-            ts.factory.createBinaryExpression(
-                x,
-                ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                y,
-            );
-}
+import type ts from "typescript/lib/tsclibrary";
+
+export namespace ExpressionFactory {
+    export const isRequired =
+        (tsc: typeof ts) =>
+        (input: ts.Expression): ts.Expression =>
+            tsc.factory.createStrictInequality(
+                tsc.factory.createIdentifier("undefined"),
+                input,
+            );
+
+    export const isArray =
+        (tsc: typeof ts) =>
+        (input: ts.Expression): ts.Expression =>
+            tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier("Array.isArray"),
+                undefined,
+                [input],
+            );
+
+    export const isObject =
+        (tsc: typeof ts) =>
+        (options: { checkNull: boolean; checkArray: boolean }) =>
+        (input: ts.Expression): ts.Expression => {
+            const conditions: ts.Expression[] = [
+                tsc.factory.createStrictEquality(
+                    tsc.factory.createStringLiteral("object"),
+                    tsc.factory.createTypeOfExpression(input),
+                ),
+            ];
+            if (options.checkNull === true)
+                conditions.push(
+                    tsc.factory.createStrictInequality(
+                        tsc.factory.createNull(),
+                        input,
+                    ),
+                );
+            if (options.checkArray === true)
+                conditions.push(
+                    tsc.factory.createStrictEquality(
+                        tsc.factory.createFalse(),
+                        tsc.factory.createCallExpression(
+                            tsc.factory.createIdentifier("Array.isArray"),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+
+            return conditions.length === 1
+                ? conditions[0]!
+                : conditions.reduce((x, y) =>
+                      tsc.factory.createLogicalAnd(x, y),
+                  );
+        };
+
+    export const isInstanceOf =
+        (tsc: typeof ts) =>
+        (type: string) =>
+        (input: ts.Expression): ts.Expression => {
+            return tsc.factory.createBinaryExpression(
+                input,
+                tsc.factory.createToken(tsc.SyntaxKind.InstanceOfKeyword),
+                tsc.factory.createIdentifier(type),
+            );
+        };
+
+    export const coalesce =
+        (tsc: typeof ts) =>
+        (x: ts.Expression) =>
+        (y: ts.Expression): ts.Expression =>
+            tsc.factory.createBinaryExpression(
+                x,
+                tsc.factory.createToken(tsc.SyntaxKind.QuestionQuestionToken),
+                y,
+            );
+}

package/src/factories/IdentifierFactory.ts

@@ -1,63 +1,62 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { Escaper } from "../utils/Escaper";
-
-export namespace IdentifierFactory {
-    export const identifier = (name: string) =>
-        Escaper.variable(name)
-            ? ts.factory.createIdentifier(name)
-            : ts.factory.createStringLiteral(name);
-
-    /**
-     * @deprecated Use `access()` function instead.
-     */
-    export const join = (prefix: ts.Expression, name: string) =>
-        access(prefix)(name);
-
-    export const access = (target: ts.Expression) => (property: string) => {
-        const postfix = identifier(property);
-        return ts.isStringLiteral(postfix)
-            ? ts.factory.createElementAccessExpression(target, postfix)
-            : ts.factory.createPropertyAccessExpression(target, postfix);
-    };
-
-    export const postfix = (str: string): string =>
-        Escaper.variable(str)
-            ? `".${str}"`
-            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
-
-    export const parameter = (
-        name: string | ts.BindingName,
-        type?: ts.TypeNode,
-        init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
-    ) => {
-        // instead of ts.version >= "4.8"
-        if (ts.getDecorators !== undefined)
-            return ts.factory.createParameterDeclaration(
-                undefined,
-                undefined,
-                name,
-                init?.kind === ts.SyntaxKind.QuestionToken
-                    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                    : undefined,
-                type,
-                init && init.kind !== ts.SyntaxKind.QuestionToken
-                    ? init
-                    : undefined,
-            );
-        // eslint-disable-next-line
-        return (ts.factory.createParameterDeclaration as any)(
-            undefined,
-            undefined,
-            undefined,
-            name,
-            init?.kind === ts.SyntaxKind.QuestionToken
-                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined,
-            type,
-            init && init.kind !== ts.SyntaxKind.QuestionToken
-                ? init
-                : undefined,
-        );
-    };
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { Escaper } from "../utils/Escaper";
+
+export namespace IdentifierFactory {
+    export const identifier = (tsc: typeof ts) => (name: string) =>
+        Escaper.variable(name)
+            ? tsc.factory.createIdentifier(name)
+            : tsc.factory.createStringLiteral(name);
+
+    export const access =
+        (tsc: typeof ts) => (target: ts.Expression) => (property: string) => {
+            const postfix = identifier(tsc)(property);
+            return tsc.isStringLiteral(postfix)
+                ? tsc.factory.createElementAccessExpression(target, postfix)
+                : tsc.factory.createPropertyAccessExpression(target, postfix);
+        };
+
+    export const postfix = (str: string): string =>
+        Escaper.variable(str)
+            ? `".${str}"`
+            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+
+    export const parameter =
+        (tsc: typeof ts) =>
+        (
+            name: string | ts.BindingName,
+            type?: ts.TypeNode,
+            init?:
+                | ts.Expression
+                | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
+        ) => {
+            // instead of ts.version >= "4.8"
+            if (tsc.getDecorators !== undefined)
+                return tsc.factory.createParameterDeclaration(
+                    undefined,
+                    undefined,
+                    name,
+                    init?.kind === tsc.SyntaxKind.QuestionToken
+                        ? tsc.factory.createToken(tsc.SyntaxKind.QuestionToken)
+                        : undefined,
+                    type,
+                    init && init.kind !== tsc.SyntaxKind.QuestionToken
+                        ? init
+                        : undefined,
+                );
+            // eslint-disable-next-line
+            return (tsc.factory.createParameterDeclaration as any)(
+                undefined,
+                undefined,
+                undefined,
+                name,
+                init?.kind === tsc.SyntaxKind.QuestionToken
+                    ? tsc.factory.createToken(tsc.SyntaxKind.QuestionToken)
+                    : undefined,
+                type,
+                init && init.kind !== tsc.SyntaxKind.QuestionToken
+                    ? init
+                    : undefined,
+            );
+        };
+}

package/src/factories/LiteralFactory.ts

@@ -1,39 +1,57 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { IdentifierFactory } from "./IdentifierFactory";
-
-export namespace LiteralFactory {
-    export const generate = (input: any): ts.Expression => {
-        if (input === null) return ts.factory.createNull();
-        else if (ts.isIdentifier(input)) return input;
-        else if (input instanceof Array) return generate_array(input);
-        else if (typeof input === "object") return generate_object(input);
-        else if (typeof input === "string") return generate_string(input);
-        else if (typeof input === "boolean") return generate_value(input);
-        else if (typeof input === "number") return generate_value(input);
-        else if (typeof input === "bigint") return generate_value(input);
-        else throw new Error("Unknown type.");
-    };
-
-    const generate_object = (obj: object): ts.ObjectLiteralExpression =>
-        ts.factory.createObjectLiteralExpression(
-            Object.entries(obj)
-                .filter((tuple) => tuple[1] !== undefined)
-                .map(([key, value]) =>
-                    ts.factory.createPropertyAssignment(
-                        IdentifierFactory.identifier(key),
-                        generate(value),
-                    ),
-                ),
-            true,
-        );
-
-    const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
-        ts.factory.createArrayLiteralExpression(array.map(generate), true);
-
-    const generate_value = (value: number | boolean | bigint): ts.Identifier =>
-        ts.factory.createIdentifier(value.toString());
-
-    const generate_string = (value: string): ts.StringLiteral =>
-        ts.factory.createStringLiteral(value);
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { IdentifierFactory } from "./IdentifierFactory";
+
+export namespace LiteralFactory {
+    export const generate =
+        (tsc: typeof ts) =>
+        (input: any): ts.Expression => {
+            if (input === null) return tsc.factory.createNull();
+            else if (tsc.isIdentifier(input)) return input;
+            else if (input instanceof Array) return generate_array(tsc)(input);
+            else if (typeof input === "object")
+                return generate_object(tsc)(input);
+            else if (typeof input === "string")
+                return generate_string(tsc)(input);
+            else if (typeof input === "boolean")
+                return generate_value(tsc)(input);
+            else if (typeof input === "number")
+                return generate_value(tsc)(input);
+            else if (typeof input === "bigint")
+                return generate_value(tsc)(input);
+            else throw new Error("Unknown type.");
+        };
+
+    const generate_object =
+        (tsc: typeof ts) =>
+        (obj: object): ts.ObjectLiteralExpression =>
+            tsc.factory.createObjectLiteralExpression(
+                Object.entries(obj)
+                    .filter((tuple) => tuple[1] !== undefined)
+                    .map(([key, value]) =>
+                        tsc.factory.createPropertyAssignment(
+                            IdentifierFactory.identifier(tsc)(key),
+                            generate(tsc)(value),
+                        ),
+                    ),
+                true,
+            );
+
+    const generate_array =
+        (tsc: typeof ts) =>
+        (array: any[]): ts.ArrayLiteralExpression =>
+            tsc.factory.createArrayLiteralExpression(
+                array.map(generate(tsc)),
+                true,
+            );
+
+    const generate_value =
+        (tsc: typeof ts) =>
+        (value: number | boolean | bigint): ts.Identifier =>
+            tsc.factory.createIdentifier(value.toString());
+
+    const generate_string =
+        (tsc: typeof ts) =>
+        (value: string): ts.StringLiteral =>
+            tsc.factory.createStringLiteral(value);
+}

package/src/factories/MetadataCollection.ts

@@ -1,121 +1,123 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../metadata/Metadata";
-import { MetadataObject } from "../metadata/MetadataObject";
-
-import { MapUtil } from "../utils/MapUtil";
-import { TsSymbolUtil } from "../utils/TsSymbolUtil";
-
-import { TypeFactory } from "./TypeFactory";
-
-export class MetadataCollection {
-    private readonly dict_: Map<ts.Type, MetadataObject>;
-    private readonly names_: Map<string, Map<ts.Type, string>>;
-    private readonly unions_: Map<string, MetadataObject[]>;
-    private index_: number;
-
-    public constructor(
-        private readonly options?: Partial<MetadataCollection.IOptions>,
-    ) {
-        this.dict_ = new Map();
-        this.names_ = new Map();
-        this.unions_ = new Map();
-        this.index_ = 0;
-    }
-
-    public objects(): MetadataObject[] {
-        return [...this.dict_.values()];
-    }
-    public unions(): MetadataObject[][] {
-        return [...this.unions_.values()];
-    }
-
-    public emplace(
-        checker: ts.TypeChecker,
-        type: ts.Type,
-    ): [MetadataObject, boolean] {
-        const oldbie = this.dict_.get(type);
-        if (oldbie !== undefined) return [oldbie, false];
-
-        const $id: string = this.get_name(checker, type);
-        const obj: MetadataObject = MetadataObject.create({
-            name: $id,
-            properties: [],
-            description: type.symbol
-                ? TsSymbolUtil.comments(type.symbol)
-                : undefined,
-            jsDocTags:
-                (type.symbol
-                    ? TsSymbolUtil.getCommentTags(type.symbol)
-                    : undefined) ?? [],
-            validated: false,
-            index: this.index_++,
-            recursive: false,
-            nullables: [],
-        });
-        this.dict_.set(type, obj);
-        return [obj, true];
-    }
-
-    /**
-     * @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);
-    }
-
-    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;
-        })();
-
-        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;
-    }
-}
-export namespace MetadataCollection {
-    export interface IOptions {
-        replace?(str: string): string;
-    }
-
-    export const replace = (str: string): string => {
-        for (const [before, after] of REPLACERS)
-            str = str.split(before).join(after);
-        return str;
-    };
-
-    export const escape = (str: string): string => {
-        for (const [before, after] of REPLACERS)
-            if (after !== "") str = str.split(after).join(before);
-        return str;
-    };
-}
-const REPLACERS: [string, string][] = [
-    ["$", "_dollar_"],
-    ["&", "_and_"],
-    ["|", "_or_"],
-    ["{", "_blt_"],
-    ["}", "_bgt_"],
-    ["<", "_lt_"],
-    [">", "_gt_"],
-    ["[", "_alt_"],
-    ["]", "_agt_"],
-    [",", "_comma_"],
-    ["`", "_backquote_"],
-    ["'", "_singlequote_"],
-    ['"', "_doublequote_"],
-    [" ", "_space_"],
-];
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../metadata/Metadata";
+import { MetadataObject } from "../metadata/MetadataObject";
+
+import { IProject } from "../transformers/IProject";
+
+import { MapUtil } from "../utils/MapUtil";
+import { TsSymbolUtil } from "../utils/TsSymbolUtil";
+
+import { TypeFactory } from "./TypeFactory";
+
+export class MetadataCollection {
+    private readonly dict_: Map<ts.Type, MetadataObject>;
+    private readonly names_: Map<string, Map<ts.Type, string>>;
+    private readonly unions_: Map<string, MetadataObject[]>;
+    private index_: number;
+
+    public constructor(
+        private readonly options?: Partial<MetadataCollection.IOptions>,
+    ) {
+        this.dict_ = new Map();
+        this.names_ = new Map();
+        this.unions_ = new Map();
+        this.index_ = 0;
+    }
+
+    public objects(): MetadataObject[] {
+        return [...this.dict_.values()];
+    }
+    public unions(): MetadataObject[][] {
+        return [...this.unions_.values()];
+    }
+
+    public emplace(
+        p: IProject.IModule,
+        type: ts.Type,
+    ): [MetadataObject, boolean] {
+        const oldbie = this.dict_.get(type);
+        if (oldbie !== undefined) return [oldbie, false];
+
+        const $id: string = this.get_name(p, 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) ?? [],
+            validated: false,
+            index: this.index_++,
+            recursive: false,
+            nullables: [],
+        });
+        this.dict_.set(type, obj);
+        return [obj, true];
+    }
+
+    /**
+     * @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);
+    }
+
+    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;
+        })();
+
+        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;
+    }
+}
+export namespace MetadataCollection {
+    export interface IOptions {
+        replace?(str: string): string;
+    }
+
+    export const replace = (str: string): string => {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    };
+
+    export const escape = (str: string): string => {
+        for (const [before, after] of REPLACERS)
+            if (after !== "") str = str.split(after).join(before);
+        return str;
+    };
+}
+const REPLACERS: [string, string][] = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];