typia 3.8.6 → 4.0.0-dev.20230517

package/src/transformers/internal/GenericTransformer.ts

@@ -1,97 +1,103 @@
-import ts from "typescript";
-
-import { IProject } from "../IProject";
-
-export namespace GenericTransformer {
-    export const scalar =
-        (method: string) =>
-        (
-            programmer: (
-                project: IProject,
-            ) => (
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-        ) =>
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression) => {
-            // CHECK PARAMETER
-            if (expression.arguments.length !== 1)
-                throw new Error(`Error on typia.${method}(): no input value.`);
-
-            // GET TYPE INFO
-            const [type, node, generic]: [ts.Type, ts.Node, boolean] =
-                expression.typeArguments && expression.typeArguments[0]
-                    ? [
-                          project.checker.getTypeFromTypeNode(
-                              expression.typeArguments[0],
-                          ),
-                          expression.typeArguments[0],
-                          true,
-                      ]
-                    : [
-                          project.checker.getTypeAtLocation(
-                              expression.arguments[0]!,
-                          ),
-                          expression.arguments[0]!,
-                          false,
-                      ];
-            if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                programmer(project)(modulo)(
-                    type,
-                    generic
-                        ? node.getFullText().trim()
-                        : name(project.checker)(type)(node),
-                ),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-
-    export const factory =
-        (method: string) =>
-        (
-            programmer: (
-                project: IProject,
-            ) => (
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-        ) =>
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression) => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0])
-                throw new Error(
-                    `Error on typia.${method}(): generic argument is not specified.`,
-                );
-
-            // GET TYPE INFO
-            const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-            if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
-
-            // DO TRANSFORM
-            return programmer(project)(modulo)(type, node.getFullText().trim());
-        };
-
-    const name =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type) =>
-        (node: ts.Node): string =>
-            checker.typeToString(
-                type,
-                node,
-                ts.TypeFormatFlags.NodeBuilderFlagsMask,
-            );
-}
+import ts from "typescript/lib/tsclibrary";
+
+import { TsNodeUtil } from "../../utils/TsNodeUtil";
+import { TsTypeUtil } from "../../utils/TsTypeUtil";
+
+import { IProject } from "../IProject";
+
+export namespace GenericTransformer {
+    export const scalar =
+        (method: string) =>
+        (
+            programmer: (
+                project: IProject,
+            ) => (
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+        ) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
+            // CHECK PARAMETER
+            if (expression.arguments.length !== 1)
+                throw new Error(`Error on typia.${method}(): no input value.`);
+
+            // GET TYPE INFO
+            const [type, node, generic]: [ts.Type, ts.Node, boolean] =
+                expression.typeArguments && expression.typeArguments[0]
+                    ? [
+                          project.checker.getTypeFromTypeNode(
+                              expression.typeArguments[0],
+                          ),
+                          expression.typeArguments[0],
+                          true,
+                      ]
+                    : [
+                          project.checker.getTypeAtLocation(
+                              expression.arguments[0]!,
+                          ),
+                          expression.arguments[0]!,
+                          false,
+                      ];
+            if (TsTypeUtil.isTypeParameter(type))
+                throw new Error(
+                    `Error on typia.${method}(): non-specified generic argument.`,
+                );
+
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                programmer(project)(modulo)(
+                    type,
+                    generic
+                        ? TsNodeUtil.getFullText(node).trim()
+                        : name(project.checker)(type)(node),
+                ),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+
+    export const factory =
+        (method: string) =>
+        (
+            programmer: (
+                project: IProject,
+            ) => (
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+        ) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0])
+                throw new Error(
+                    `Error on typia.${method}(): generic argument is not specified.`,
+                );
+
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+            if (TsTypeUtil.isTypeParameter(type))
+                throw new Error(
+                    `Error on typia.${method}(): non-specified generic argument.`,
+                );
+
+            // DO TRANSFORM
+            return programmer(project)(modulo)(
+                type,
+                TsNodeUtil.getFullText(node).trim(),
+            );
+        };
+
+    const name =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type) =>
+        (node: ts.Node): string =>
+            checker.typeToString(
+                type,
+                node,
+                ts.TypeFormatFlags.NodeBuilderFlagsMask,
+            );
+}

package/src/utils/TsNodeUtil.ts

@@ -0,0 +1,12 @@
+import ts from "typescript/lib/tsclibrary";
+
+export namespace TsNodeUtil {
+    export const getFullText = (node: ts.Node, file?: ts.SourceFile): string =>
+        (file ?? getSourceFile(node)).text.substring(node.pos, node.end);
+
+    export const getSourceFile = (node: ts.Node) => {
+        while (node && node.kind !== ts.SyntaxKind.SourceFile)
+            node = node.parent;
+        return node as ts.SourceFile;
+    };
+}

package/src/utils/TsSymbolUtil.ts

@@ -0,0 +1,41 @@
+import { JSDocTagInfo } from "typescript";
+import ts from "typescript/lib/tsclibrary";
+
+export namespace TsSymbolUtil {
+    export const comments = (symbol: ts.Symbol): string | undefined => {
+        const node = symbol.declarations?.[0];
+        if (!node) return undefined;
+
+        const comments: ReadonlyArray<ts.JSDoc | ts.JSDocTag> =
+            ts.getJSDocCommentsAndTags(node);
+        return comments.map((c) => c.comment).join("");
+    };
+
+    export const getCommentTags = (
+        symbol: ts.Symbol,
+    ): JSDocTagInfo[] | undefined => {
+        const node = symbol.declarations?.[0];
+        if (!node) return undefined;
+
+        const tagList: readonly ts.JSDocTag[] = ts.getJSDocTags(node);
+        return tagList.map((tag) => ({
+            name: tag.tagName.escapedText.toString(),
+            text:
+                tag.comment === undefined
+                    ? undefined
+                    : typeof tag.comment === "string"
+                    ? [{ text: tag.comment, kind: "text" }]
+                    : tag.comment.map((text) => ({
+                          text: text.text,
+                          kind:
+                              text.kind === ts.SyntaxKind.JSDocText
+                                  ? "text"
+                                  : text.kind === ts.SyntaxKind.JSDocLink
+                                  ? "link"
+                                  : text.kind === ts.SyntaxKind.JSDocLinkCode
+                                  ? "link-code"
+                                  : "link-plain",
+                      })),
+        }));
+    };
+}

package/src/utils/TsTypeUtil.ts

@@ -0,0 +1,30 @@
+import ts from "typescript/lib/tsclibrary";
+
+export namespace TsTypeUtil {
+    export const isLiteral = (type: ts.Type): type is ts.LiteralType =>
+        !!(
+            type.flags &
+            (ts.TypeFlags.StringLiteral |
+                ts.TypeFlags.NumberLiteral |
+                ts.TypeFlags.BigIntLiteral)
+        );
+
+    export const isTypeParameter = (type: ts.Type): type is ts.TypeParameter =>
+        !!(type.flags & ts.TypeFlags.TypeParameter);
+
+    export const isUnionOrIntersection = (
+        type: ts.Type,
+    ): type is ts.UnionOrIntersectionType =>
+        !!(type.flags & ts.TypeFlags.UnionOrIntersection);
+
+    export const isUnion = (type: ts.Type): type is ts.UnionType =>
+        !!(type.flags & ts.TypeFlags.Union);
+
+    export const isIntersection = (
+        type: ts.Type,
+    ): type is ts.IntersectionType =>
+        !!(type.flags & ts.TypeFlags.Intersection);
+
+    export const isClass = (type: ts.Type): type is ts.InterfaceType =>
+        !!((ts as any).getObjectFlags(type) & ts.ObjectFlags.Class);
+}