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

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -1,46 +1,46 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
-
-import { TsNodeUtil } from "../../../utils/TsNodeUtil";
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
-import { IProject } from "../../IProject";
-
-export namespace RandomTransformer {
-    export const transform =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(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(NO_GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                RandomProgrammer.write({
-                    ...project,
-                    options: {
-                        ...project.options,
-                        functional: false,
-                        numeric: false,
-                    },
-                })(modulo)()(type, TsNodeUtil.getFullText(node).trim()),
-                undefined,
-                expression.arguments.length
-                    ? [expression.arguments[0]!]
-                    : undefined,
-            );
-        };
-}
-
-const NOT_SPECIFIED =
-    "Error on typia.random(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.random(): non-specified generic argument.";
+import type ts from "typescript/lib/tsclibrary";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { TsNodeUtil } from "../../../utils/TsNodeUtil";
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
+import { IProject } from "../../IProject";
+
+export namespace RandomTransformer {
+    export const transform =
+        (p: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
+
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
+                throw new Error(NO_GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return p.tsc.factory.createCallExpression(
+                RandomProgrammer.write({
+                    ...p,
+                    options: {
+                        ...p.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                })(modulo)()(type, TsNodeUtil.getFullText(p.tsc)(node).trim()),
+                undefined,
+                expression.arguments.length
+                    ? [expression.arguments[0]!]
+                    : undefined,
+            );
+        };
+}
+
+const NOT_SPECIFIED =
+    "Error on typia.random(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.random(): non-specified generic argument.";

package/src/transformers/internal/GenericTransformer.ts

@@ -1,103 +1,101 @@
-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,
-            );
-}
+import type 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,
+        ) =>
+        (p: 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]
+                    ? [
+                          p.checker.getTypeFromTypeNode(
+                              expression.typeArguments[0],
+                          ),
+                          expression.typeArguments[0],
+                          true,
+                      ]
+                    : [
+                          p.checker.getTypeAtLocation(expression.arguments[0]!),
+                          expression.arguments[0]!,
+                          false,
+                      ];
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
+                throw new Error(
+                    `Error on typia.${method}(): non-specified generic argument.`,
+                );
+
+            // DO TRANSFORM
+            return p.tsc.factory.createCallExpression(
+                programmer(p)(modulo)(
+                    type,
+                    generic
+                        ? TsNodeUtil.getFullText(p.tsc)(node).trim()
+                        : name(p)(type)(node),
+                ),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+
+    export const factory =
+        (method: string) =>
+        (
+            programmer: (
+                project: IProject,
+            ) => (
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+        ) =>
+        (p: 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 = p.checker.getTypeFromTypeNode(node);
+
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
+                throw new Error(
+                    `Error on typia.${method}(): non-specified generic argument.`,
+                );
+
+            // DO TRANSFORM
+            return programmer(p)(modulo)(
+                type,
+                TsNodeUtil.getFullText(p.tsc)(node).trim(),
+            );
+        };
+
+    const name =
+        (project: IProject) =>
+        (type: ts.Type) =>
+        (node: ts.Node): string =>
+            project.checker.typeToString(
+                type,
+                node,
+                project.tsc.TypeFormatFlags.NodeBuilderFlagsMask,
+            );
+}

package/src/utils/TsNodeUtil.ts

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

package/src/utils/TsSymbolUtil.ts

@@ -1,41 +1,146 @@
-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",
-                      })),
-        }));
-    };
-}
+import { JSDocTagInfo } from "typescript";
+import type ts from "typescript/lib/tsclibrary";
+
+import { TsNodeUtil } from "./TsNodeUtil";
+
+export namespace TsSymbolUtil {
+    export const comments =
+        (tsc: typeof ts) =>
+        (symbol: ts.Symbol): string | undefined => {
+            const node = symbol.declarations?.[0];
+            if (!node) return undefined;
+
+            const range: ts.TextRange = tsc.getCommentRange(node);
+            const text: string = TsNodeUtil.getSourceFile(tsc)(
+                node,
+            ).text.substring(range.pos, range.end);
+            return filter(text).join("\n");
+        };
+
+    export const getCommentTags =
+        (tsc: typeof ts) =>
+        (symbol: ts.Symbol): JSDocTagInfo[] | undefined => {
+            const node = symbol.declarations?.[0];
+            if (!node) return undefined;
+
+            const tagList: ts.JSDocTag[] = tsc
+                .getJSDocTags(node)
+                .map(emendTag(tsc));
+            // if (
+            //     tagList.some(
+            //         (tag) => tag.tagName.escapedText.toString() === "type",
+            //     )
+            // ) {
+            //     const entire = tsc.getJSDocCommentsAndTags(node);
+            //     const texts = entire.map((e) =>
+            //         tsc.isJSDoc(e) ? jsDocToText(e) : jsTagToText(e),
+            //     );
+            //     console.log(texts);
+            // }
+
+            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 === tsc.SyntaxKind.JSDocText
+                                      ? "text"
+                                      : text.kind === tsc.SyntaxKind.JSDocLink
+                                      ? "link"
+                                      : text.kind ===
+                                        tsc.SyntaxKind.JSDocLinkCode
+                                      ? "link-code"
+                                      : "link-plain",
+                          })),
+            }));
+        };
+
+    const emendTag =
+        (tsc: typeof ts) =>
+        (tag: ts.JSDocTag): ts.JSDocTag => {
+            if (tag.comment !== undefined) return tag;
+
+            const tagName: string = tag.tagName.escapedText.toString();
+            const comment: string = TsNodeUtil.getSourceFile(tsc)(tag)
+                .text.substring(tag.pos, tag.end)
+                .replace(`@${tagName}`, "")
+                .split("\n")
+                .map((str) => trim(str))
+                .filter((str) => !!str.length)
+                .join("\n");
+            return comment.length
+                ? {
+                      ...tag,
+                      comment,
+                  }
+                : tag;
+        };
+
+    const filter = (text: string): string[] => {
+        const elements: string[] = text.split("\n");
+        const first: number = lastIndexOf(elements)((elem) =>
+            elem.trim().startsWith("/**"),
+        );
+        const last: number = lastIndexOf(elements)((elem) =>
+            elem.trim().endsWith("*/"),
+        );
+
+        const cut: string[] = elements.slice(first, last + 1);
+        return cut
+            .map((elem, i) => {
+                if (i === 0) elem = elem.substring(elem.lastIndexOf("/**") + 3);
+                if (i === cut.length - 1)
+                    elem = elem.substring(0, elem.lastIndexOf("*/"));
+                return trim(elem);
+            })
+            .filter((elem) => elem.length > 0);
+    };
+
+    const lastIndexOf =
+        <T>(array: T[]) =>
+        (pred: (elem: T) => boolean) => {
+            for (let i = array.length - 1; i >= 0; i--)
+                if (pred(array[i]!)) return i;
+            return -1;
+        };
+
+    const trim = (str: string): string => {
+        const vulnerable = (ch: string) =>
+            ch === " " ||
+            ch === "\n" ||
+            ch == "\r" ||
+            ch === "\t" ||
+            ch === "*";
+        let start: number;
+        let end: number;
+        for (start = 0; start < str.length; ++start)
+            if (!vulnerable(str.charAt(start))) break;
+        for (end = str.length - 1; end >= 0; --end)
+            if (!vulnerable(str.charAt(end))) break;
+        return start > end ? "" : str.substring(start, end + 1).trim();
+    };
+}
+
+// const jsDocToText = (doc: ts.JSDoc): string =>
+//     [jsCommentToText(doc.comment), ...(doc.tags ?? []).map(jsTagToText)]
+//         .filter((str) => !!str.length)
+//         .join(" ");
+
+// const jsTagToText = (doc: ts.JSDocTag): string =>
+//     ["@" + doc.tagName.escapedText.toString(), jsCommentToText(doc.comment)]
+//         .filter((str) => !!str.length)
+//         .join(" ");
+
+// const jsCommentToText = (
+//     comment: string | ts.NodeArray<ts.JSDocComment> | undefined,
+// ): string =>
+//     comment === undefined
+//         ? ""
+//         : typeof comment === "string"
+//         ? comment
+//         : comment.map((c) => c.text).join("");

package/src/utils/TsTypeUtil.ts

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