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

package/src/factories/TemplateFactory.ts

@@ -1,58 +1,64 @@
-import ts from "typescript/lib/tsclibrary";
-
-export namespace TemplateFactory {
-    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 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 =
-        (expressions: ts.Expression[]) =>
-        (it: IIterator): void => {
-            const found: number = expressions.findIndex(
-                (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
-            );
-
-            const last: number = found !== -1 ? found : expressions.length;
-            it.value = expressions
-                .slice(it.index, last)
-                .map((elem) => (elem as ts.StringLiteral).text)
-                .reduce((x, y) => x + y, "");
-            it.index = last;
-        };
-
-    interface IIterator {
-        value: string;
-        index: number;
-    }
-}
+import type ts from "typescript/lib/tsclibrary";
+
+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,
+            );
+            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 gather =
+        (tsc: typeof ts) =>
+        (expressions: ts.Expression[]) =>
+        (it: IIterator): void => {
+            const found: number = expressions.findIndex(
+                (elem, index) =>
+                    index >= it.index && !tsc.isStringLiteral(elem),
+            );
+
+            const last: number = found !== -1 ? found : expressions.length;
+            it.value = expressions
+                .slice(it.index, last)
+                .map((elem) => (elem as ts.StringLiteral).text)
+                .reduce((x, y) => x + y, "");
+            it.index = last;
+        };
+
+    interface IIterator {
+        value: string;
+        index: number;
+    }
+}

package/src/factories/TypeFactory.ts

@@ -1,136 +1,145 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { TsNodeUtil } from "../utils/TsNodeUtil";
-import { TsTypeUtil } from "../utils/TsTypeUtil";
-
-export namespace TypeFactory {
-    export const resolve =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type): ts.Type | null =>
-            getReturnType(checker)(type)("toJSON");
-
-    export const isFunction = (type: ts.Type): boolean =>
-        getFunction(type) !== null;
-
-    const getFunction = (type: ts.Type) => {
-        const node = type.symbol?.declarations?.[0];
-        if (node === undefined) return null;
-
-        return ts.isFunctionLike(node)
-            ? node
-            : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
-            ? ts.isFunctionLike(node.initializer)
-                ? node.initializer
-                : null
-            : null;
-    };
-
-    export const getReturnType =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type) =>
-        (name: string): ts.Type | null => {
-            // FIND TO-JSON METHOD
-            const symbol: ts.Symbol | undefined = checker.getPropertyOfType(
-                type,
-                name,
-            );
-            if (!symbol) return null;
-            else if (!symbol.valueDeclaration) return null;
-
-            // GET FUNCTION DECLARATION
-            const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
-                symbol,
-                symbol.valueDeclaration,
-            );
-
-            // RETURNS THE RETURN-TYPE
-            const signature: ts.Signature | undefined =
-                checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
-            return signature
-                ? checker.getReturnTypeOfSignature(signature)
-                : null;
-        };
-
-    export const getFullName =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type, symbol?: ts.Symbol): string => {
-            // PRIMITIVE
-            symbol ??= type.aliasSymbol ?? type.symbol;
-            if (symbol === undefined) return checker.typeToString(type);
-
-            // UNION OR INTERSECT
-            if (
-                type.aliasSymbol === undefined &&
-                TsTypeUtil.isUnionOrIntersection(type)
-            ) {
-                const joiner: string = TsTypeUtil.isIntersection(type)
-                    ? " & "
-                    : " | ";
-                return type.types
-                    .map((child) => getFullName(checker)(child))
-                    .join(joiner);
-            }
-
-            //----
-            // SPECIALIZATION
-            //----
-            const name: string = get_name(symbol);
-
-            // CHECK GENERIC
-            const generic: readonly ts.Type[] = type.aliasSymbol
-                ? type.aliasTypeArguments || []
-                : checker.getTypeArguments(type as ts.TypeReference);
-            return generic.length
-                ? name === "Promise"
-                    ? getFullName(checker)(generic[0]!)
-                    : `${name}<${generic
-                          .map((child) => getFullName(checker)(child))
-                          .join(", ")}>`
-                : name;
-        };
-
-    const explore_name =
-        (decl: ts.Node) =>
-        (name: string): string =>
-            ts.isModuleBlock(decl)
-                ? explore_name(decl.parent.parent)(
-                      `${TsNodeUtil.getFullText(
-                          decl.parent.name,
-                      ).trim()}.${name}`,
-                  )
-                : name;
-
-    const get_name = (symbol: ts.Symbol): string => {
-        const parent = symbol.declarations?.[0]?.parent;
-        return parent
-            ? explore_name(parent)(symbol.escapedName.toString())
-            : "__type";
-    };
-
-    export const keyword = (
-        type:
-            | "void"
-            | "any"
-            | "unknown"
-            | "boolean"
-            | "number"
-            | "bigint"
-            | "string",
-    ) => {
-        return ts.factory.createKeywordTypeNode(
-            type === "void"
-                ? ts.SyntaxKind.VoidKeyword
-                : type === "any"
-                ? ts.SyntaxKind.AnyKeyword
-                : type === "unknown"
-                ? ts.SyntaxKind.UnknownKeyword
-                : type === "boolean"
-                ? ts.SyntaxKind.BooleanKeyword
-                : type === "number"
-                ? ts.SyntaxKind.NumberKeyword
-                : type === "bigint"
-                ? ts.SyntaxKind.BigIntKeyword
-                : ts.SyntaxKind.StringKeyword,
-        );
-    };
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { IProject } from "../transformers/IProject";
+
+import { TsNodeUtil } from "../utils/TsNodeUtil";
+import { TsTypeUtil } from "../utils/TsTypeUtil";
+
+export namespace TypeFactory {
+    export const resolve =
+        (project: IProject.IModule) =>
+        (type: ts.Type): ts.Type | null =>
+            getReturnType(project)(type)("toJSON");
+
+    export const isFunction =
+        (tsc: typeof ts) =>
+        (type: ts.Type): boolean =>
+            getFunction(tsc)(type) !== null;
+
+    const getFunction = (tsc: typeof ts) => (type: ts.Type) => {
+        const node = type.symbol?.declarations?.[0];
+        if (node === undefined) return null;
+
+        return tsc.isFunctionLike(node)
+            ? node
+            : tsc.isPropertyAssignment(node) || tsc.isPropertyDeclaration(node)
+            ? tsc.isFunctionLike(node.initializer)
+                ? node.initializer
+                : null
+            : null;
+    };
+
+    export const getReturnType =
+        ({ tsc, checker }: IProject.IModule) =>
+        (type: ts.Type) =>
+        (name: string): ts.Type | null => {
+            // FIND TO-JSON METHOD
+            const symbol: ts.Symbol | undefined = checker.getPropertyOfType(
+                type,
+                name,
+            );
+            if (!symbol) return null;
+            else if (!symbol.valueDeclaration) return null;
+
+            // GET FUNCTION DECLARATION
+            const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
+                symbol,
+                symbol.valueDeclaration,
+            );
+
+            // RETURNS THE RETURN-TYPE
+            const signature: ts.Signature | undefined =
+                checker.getSignaturesOfType(functor, tsc.SignatureKind.Call)[0];
+            return signature
+                ? checker.getReturnTypeOfSignature(signature)
+                : null;
+        };
+
+    export const getFullName =
+        (p: IProject.IModule) =>
+        (type: ts.Type, symbol?: ts.Symbol): string => {
+            // PRIMITIVE
+            symbol ??= type.aliasSymbol ?? type.symbol;
+            if (symbol === undefined) return p.checker.typeToString(type);
+
+            // UNION OR INTERSECT
+            if (
+                type.aliasSymbol === undefined &&
+                TsTypeUtil.isUnionOrIntersection(p.tsc)(type)
+            ) {
+                const joiner: string = TsTypeUtil.isIntersection(p.tsc)(type)
+                    ? " & "
+                    : " | ";
+                return type.types
+                    .map((child) => getFullName(p)(child))
+                    .join(joiner);
+            }
+
+            //----
+            // SPECIALIZATION
+            //----
+            const name: string = get_name(p.tsc)(symbol);
+
+            // CHECK GENERIC
+            const generic: readonly ts.Type[] = type.aliasSymbol
+                ? type.aliasTypeArguments ?? []
+                : p.checker.getTypeArguments(type as ts.TypeReference);
+            return generic.length
+                ? name === "Promise"
+                    ? getFullName(p)(generic[0]!)
+                    : `${name}<${generic
+                          .map((child) => getFullName(p)(child))
+                          .join(", ")}>`
+                : name;
+        };
+
+    const explore_name =
+        (tsc: typeof ts) =>
+        (decl: ts.Node) =>
+        (name: string): string =>
+            tsc.isModuleBlock(decl)
+                ? explore_name(tsc)(decl.parent.parent)(
+                      `${TsNodeUtil.getFullText(tsc)(
+                          decl.parent.name,
+                      ).trim()}.${name}`,
+                  )
+                : name;
+
+    const get_name =
+        (tsc: typeof ts) =>
+        (symbol: ts.Symbol): string => {
+            const parent = symbol.declarations?.[0]?.parent;
+            return parent
+                ? explore_name(tsc)(parent)(symbol.escapedName.toString())
+                : "__type";
+        };
+
+    export const keyword =
+        (tsc: typeof ts) =>
+        (
+            type:
+                | "void"
+                | "any"
+                | "unknown"
+                | "boolean"
+                | "number"
+                | "bigint"
+                | "string",
+        ) => {
+            return tsc.factory.createKeywordTypeNode(
+                type === "void"
+                    ? tsc.SyntaxKind.VoidKeyword
+                    : type === "any"
+                    ? tsc.SyntaxKind.AnyKeyword
+                    : type === "unknown"
+                    ? tsc.SyntaxKind.UnknownKeyword
+                    : type === "boolean"
+                    ? tsc.SyntaxKind.BooleanKeyword
+                    : type === "number"
+                    ? tsc.SyntaxKind.NumberKeyword
+                    : type === "bigint"
+                    ? tsc.SyntaxKind.BigIntKeyword
+                    : tsc.SyntaxKind.StringKeyword,
+            );
+        };
+}

package/src/factories/ValueFactory.ts

@@ -1,12 +1,15 @@
-import ts from "typescript/lib/tsclibrary";
-
-export namespace ValueFactory {
-    export const NULL = () => ts.factory.createNull();
-    export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
-    export const BOOLEAN = (value: boolean) =>
-        value ? ts.factory.createTrue() : ts.factory.createFalse();
-    export const INPUT = (str: string = "input") =>
-        ts.factory.createIdentifier(str);
-    export const TYPEOF = (input: ts.Expression) =>
-        ts.factory.createTypeOfExpression(input);
-}
+import type ts from "typescript/lib/tsclibrary";
+
+export namespace ValueFactory {
+    export const NULL = (tsc: typeof ts) => tsc.factory.createNull();
+    export const UNDEFINED = (tsc: typeof ts) =>
+        tsc.factory.createIdentifier("undefined");
+    export const BOOLEAN = (tsc: typeof ts) => (value: boolean) =>
+        value ? tsc.factory.createTrue() : tsc.factory.createFalse();
+    export const INPUT =
+        (tsc: typeof ts) =>
+        (str: string = "input") =>
+            tsc.factory.createIdentifier(str);
+    export const TYPEOF = (tsc: typeof ts) => (input: ts.Expression) =>
+        tsc.factory.createTypeOfExpression(input);
+}