@ttsc/factory 0.15.6 → 0.15.7

package/lib/TsPrinter.mjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TsPrinter = void 0;
+const comments_1 = require("./comments");
 const doc_1 = require("./internal/doc");
-const syntax_1 = require("./syntax");
 const escapeString = (text, singleQuote) => {
     const escaped = text
         .replace(/\\/g, "\\\\")
@@ -87,13 +87,37 @@ class TsPrinter {
             close,
         ]), opts.forceBreak === true);
     }
-    /** Semicolon-separated member block (`{ a; b }`), e.g. interfaces. */
-    memberBlock(items, forceBreak) {
-        if (items.length === 0)
+    /**
+     * Semicolon-separated member block (`{ a; b }`), e.g. interfaces.
+     *
+     * A bare {@link import("./ast").Identifier} member acts as a blank-line spacer
+     * (the legacy `createIdentifier("\n")` codegen idiom): it inserts an empty
+     * line between members and carries no `;` terminator, matching the legacy
+     * printer.
+     */
+    memberBlock(members, forceBreak) {
+        const inner = [];
+        let first = true;
+        let blank = false;
+        for (const member of members) {
+            if (member.kind === "Identifier") {
+                blank = true;
+                continue;
+            }
+            if (!first)
+                inner.push(";", doc_1.line);
+            if (blank) {
+                inner.push(doc_1.hardline);
+                blank = false;
+            }
+            inner.push(this.emit(member));
+            first = false;
+        }
+        if (inner.length === 0)
             return "{}";
         return (0, doc_1.group)((0, doc_1.concat)([
             "{",
-            (0, doc_1.indent)((0, doc_1.concat)([doc_1.line, (0, doc_1.join)((0, doc_1.concat)([";", doc_1.line]), items)])),
+            (0, doc_1.indent)((0, doc_1.concat)([doc_1.line, (0, doc_1.concat)(inner)])),
             (0, doc_1.ifBreak)(";"),
             doc_1.line,
             "}",
@@ -111,9 +135,10 @@ class TsPrinter {
         ]);
     }
     typeArguments(args) {
+        // type-argument / type-parameter lists disallow a trailing comma (TS1009)
         return args && args.length
             ? this.delim("<", args.map((a) => this.emit(a)), ">", {
-                trailingComma: true,
+                trailingComma: false,
             })
             : "";
     }
@@ -150,6 +175,51 @@ class TsPrinter {
         return body ? (0, doc_1.concat)([" ", this.emit(body)]) : ";";
     }
     emit(node) {
+        const body = this.emitNode(node);
+        const leading = (0, comments_1.getSyntheticLeadingComments)(node);
+        const trailing = (0, comments_1.getSyntheticTrailingComments)(node);
+        if ((leading === undefined || leading.length === 0) &&
+            (trailing === undefined || trailing.length === 0))
+            return body;
+        const parts = [];
+        if (leading !== undefined)
+            for (const comment of leading)
+                parts.push(this.leadingComment(comment));
+        parts.push(body);
+        if (trailing !== undefined)
+            for (const comment of trailing)
+                parts.push(this.trailingComment(comment));
+        return (0, doc_1.concat)(parts);
+    }
+    /** Render a leading comment followed by its node separator. */
+    leadingComment(comment) {
+        // a `//` comment must terminate the line; a `/* */` honours its own flag
+        const newLine = comment.kind === "//" /* SyntaxKind.SingleLineCommentTrivia */ ||
+            comment.hasTrailingNewLine === true;
+        return (0, doc_1.concat)([this.commentBody(comment), newLine ? doc_1.hardline : " "]);
+    }
+    /** Render a trailing comment preceded by its node separator. */
+    trailingComment(comment) {
+        const newLine = comment.kind === "//" /* SyntaxKind.SingleLineCommentTrivia */ ||
+            comment.hasTrailingNewLine === true;
+        return (0, doc_1.concat)([
+            comment.hasLeadingNewLine === true ? doc_1.hardline : " ",
+            this.commentBody(comment),
+            newLine ? doc_1.hardline : "",
+        ]);
+    }
+    /** Render the delimited comment body, re-flowing embedded line breaks. */
+    commentBody(comment) {
+        if (comment.kind === "//" /* SyntaxKind.SingleLineCommentTrivia */)
+            return (0, doc_1.concat)(["//", comment.text]);
+        // re-emit embedded newlines as hardlines so each line re-indents in place
+        return (0, doc_1.concat)([
+            "/*",
+            (0, doc_1.join)(doc_1.hardline, comment.text.replace(/\r\n?/g, "\n").split("\n")),
+            "*/",
+        ]);
+    }
+    emitNode(node) {
         switch (node.kind) {
             /* names & tokens */
             case "Identifier":
@@ -159,7 +229,7 @@ class TsPrinter {
             case "QualifiedName":
                 return (0, doc_1.concat)([this.emit(node.left), ".", this.emit(node.right)]);
             case "Token":
-                return (0, syntax_1.tokenToString)(node.token);
+                return node.token;
             case "Decorator":
                 return (0, doc_1.concat)(["@", this.emit(node.expression)]);
             /* literals */
@@ -221,13 +291,13 @@ class TsPrinter {
                 return (0, doc_1.group)((0, doc_1.concat)([
                     this.emit(node.left),
                     " ",
-                    (0, syntax_1.tokenToString)(node.operator),
+                    node.operator,
                     (0, doc_1.indent)((0, doc_1.concat)([doc_1.line, this.emit(node.right)])),
                 ]));
             case "PrefixUnaryExpression":
-                return (0, doc_1.concat)([(0, syntax_1.tokenToString)(node.operator), this.emit(node.operand)]);
+                return (0, doc_1.concat)([node.operator, this.emit(node.operand)]);
             case "PostfixUnaryExpression":
-                return (0, doc_1.concat)([this.emit(node.operand), (0, syntax_1.tokenToString)(node.operator)]);
+                return (0, doc_1.concat)([this.emit(node.operand), node.operator]);
             case "ConditionalExpression":
                 return (0, doc_1.group)((0, doc_1.concat)([
                     this.emit(node.condition),
@@ -283,14 +353,14 @@ class TsPrinter {
                 return (0, doc_1.concat)(["typeof ", this.emit(node.expression)]);
             /* types */
             case "KeywordTypeNode":
-                return (0, syntax_1.tokenToString)(node.keyword);
+                return node.keyword;
             case "TypeReferenceNode":
                 return (0, doc_1.concat)([
                     this.emit(node.typeName),
                     this.typeArguments(node.typeArguments),
                 ]);
             case "ArrayTypeNode":
-                return (0, doc_1.concat)([this.emit(node.elementType), "[]"]);
+                return (0, doc_1.concat)([this.postfixTypeOperand(node.elementType), "[]"]);
             case "UnionTypeNode":
                 return this.binaryType("|", node.types.map((t) => this.emit(t)));
             case "IntersectionTypeNode":
@@ -298,7 +368,7 @@ class TsPrinter {
             case "LiteralTypeNode":
                 return this.emit(node.literal);
             case "TypeLiteralNode":
-                return this.memberBlock(node.members.map((m) => this.emit(m)), false);
+                return this.memberBlock(node.members, false);
             case "FunctionTypeNode":
                 return (0, doc_1.concat)([
                     this.typeArguments(node.typeParameters),
@@ -313,14 +383,10 @@ class TsPrinter {
             case "ParenthesizedTypeNode":
                 return (0, doc_1.concat)(["(", this.emit(node.type), ")"]);
             case "TypeOperatorNode":
-                return (0, doc_1.concat)([
-                    (0, syntax_1.tokenToString)(node.operator),
-                    " ",
-                    this.emit(node.type),
-                ]);
+                return (0, doc_1.concat)([node.operator, " ", this.emit(node.type)]);
             case "IndexedAccessTypeNode":
                 return (0, doc_1.concat)([
-                    this.emit(node.objectType),
+                    this.postfixTypeOperand(node.objectType),
                     "[",
                     this.emit(node.indexType),
                     "]",
@@ -377,7 +443,7 @@ class TsPrinter {
                 ]);
             case "HeritageClause":
                 return (0, doc_1.concat)([
-                    (0, syntax_1.tokenToString)(node.token),
+                    node.token,
                     " ",
                     (0, doc_1.join)(", ", node.types.map((t) => this.emit(t))),
                 ]);
@@ -389,7 +455,11 @@ class TsPrinter {
                     ";",
                 ]);
             case "VariableDeclarationList": {
-                const keyword = node.flags === 2 ? "const" : node.flags === 1 ? "let" : "var";
+                const keyword = node.flags === "const" /* NodeFlags.Const */
+                    ? "const"
+                    : node.flags === "let" /* NodeFlags.Let */
+                        ? "let"
+                        : "var";
                 return (0, doc_1.concat)([
                     keyword,
                     " ",
@@ -500,7 +570,7 @@ class TsPrinter {
                     this.typeArguments(node.typeParameters),
                     this.heritage(node.heritageClauses),
                     " ",
-                    this.memberBlock(node.members.map((m) => this.emit(m)), true),
+                    this.memberBlock(node.members, true),
                 ]);
             case "TypeAliasDeclaration":
                 return (0, doc_1.concat)([
@@ -790,14 +860,14 @@ class TsPrinter {
                 return (0, doc_1.concat)(["infer ", this.emit(node.typeParameter)]);
             case "MappedTypeNode": {
                 const ro = node.readonlyToken
-                    ? (0, syntax_1.tokenToString)(node.readonlyToken.token) === "readonly"
+                    ? node.readonlyToken.token === "readonly"
                         ? "readonly "
-                        : `${(0, syntax_1.tokenToString)(node.readonlyToken.token)}readonly `
+                        : `${node.readonlyToken.token}readonly `
                     : "";
                 const q = node.questionToken
-                    ? (0, syntax_1.tokenToString)(node.questionToken.token) === "?"
+                    ? node.questionToken.token === "?"
                         ? "?"
-                        : `${(0, syntax_1.tokenToString)(node.questionToken.token)}?`
+                        : `${node.questionToken.token}?`
                     : "";
                 return (0, doc_1.concat)([
                     "{ ",
@@ -902,11 +972,7 @@ class TsPrinter {
                     this.statementBlock(node.members.map((m) => this.emit(m))),
                 ]);
             case "MetaProperty":
-                return (0, doc_1.concat)([
-                    (0, syntax_1.tokenToString)(node.keywordToken),
-                    ".",
-                    this.emit(node.name),
-                ]);
+                return (0, doc_1.concat)([node.keywordToken, ".", this.emit(node.name)]);
             case "CommaListExpression":
                 return (0, doc_1.join)(", ", node.elements.map((e) => this.emit(e)));
             case "ComputedPropertyName":
@@ -954,10 +1020,311 @@ class TsPrinter {
                 ]);
             case "NonNullChain":
                 return (0, doc_1.concat)([this.emit(node.expression), "!"]);
+            /* jsx */
+            case "JsxElement":
+                return (0, doc_1.group)((0, doc_1.concat)([
+                    this.emit(node.openingElement),
+                    (0, doc_1.indent)((0, doc_1.concat)(node.children.map((c) => (0, doc_1.concat)([doc_1.softline, this.emit(c)])))),
+                    doc_1.softline,
+                    this.emit(node.closingElement),
+                ]));
+            case "JsxSelfClosingElement":
+                return (0, doc_1.concat)([
+                    "<",
+                    this.emit(node.tagName),
+                    this.typeArguments(node.typeArguments),
+                    this.emit(node.attributes),
+                    " />",
+                ]);
+            case "JsxOpeningElement":
+                return (0, doc_1.concat)([
+                    "<",
+                    this.emit(node.tagName),
+                    this.typeArguments(node.typeArguments),
+                    this.emit(node.attributes),
+                    ">",
+                ]);
+            case "JsxClosingElement":
+                return (0, doc_1.concat)(["</", this.emit(node.tagName), ">"]);
+            case "JsxFragment":
+                return (0, doc_1.group)((0, doc_1.concat)([
+                    this.emit(node.openingFragment),
+                    (0, doc_1.indent)((0, doc_1.concat)(node.children.map((c) => (0, doc_1.concat)([doc_1.softline, this.emit(c)])))),
+                    doc_1.softline,
+                    this.emit(node.closingFragment),
+                ]));
+            case "JsxOpeningFragment":
+                return "<>";
+            case "JsxClosingFragment":
+                return "</>";
+            case "JsxText":
+                return node.text;
+            case "JsxAttribute":
+                return node.initializer === undefined
+                    ? this.emit(node.name)
+                    : (0, doc_1.concat)([this.emit(node.name), "=", this.emit(node.initializer)]);
+            case "JsxAttributes":
+                return node.properties.length === 0
+                    ? ""
+                    : (0, doc_1.concat)(node.properties.map((p) => (0, doc_1.concat)([" ", this.emit(p)])));
+            case "JsxSpreadAttribute":
+                return (0, doc_1.concat)(["{...", this.emit(node.expression), "}"]);
+            case "JsxExpression":
+                return (0, doc_1.concat)([
+                    "{",
+                    node.dotDotDotToken ? "..." : "",
+                    node.expression ? this.emit(node.expression) : "",
+                    "}",
+                ]);
+            case "JsxNamespacedName":
+                return (0, doc_1.concat)([this.emit(node.namespace), ":", this.emit(node.name)]);
+            /* synthetic / emit-internal */
+            case "Bundle":
+                return (0, doc_1.join)(doc_1.hardline, node.sourceFiles.map((s) => this.emit(s)));
+            case "PartiallyEmittedExpression":
+                return this.emit(node.expression);
+            case "ImportAttribute":
+                return (0, doc_1.concat)([this.emit(node.name), ": ", this.emit(node.value)]);
+            case "ImportAttributes":
+                return node.elements.length === 0
+                    ? (0, doc_1.concat)([node.token, " {}"])
+                    : (0, doc_1.concat)([
+                        node.token,
+                        " { ",
+                        (0, doc_1.join)(", ", node.elements.map((e) => this.emit(e))),
+                        " }",
+                    ]);
+            case "NotEmittedStatement":
+            case "NotEmittedTypeElement":
+                return "";
+            /* jsdoc — types */
+            case "JSDocAllType":
+                return "*";
+            case "JSDocUnknownType":
+                return "?";
+            case "JSDocNonNullableType":
+                return node.postfix
+                    ? (0, doc_1.concat)([this.emit(node.type), "!"])
+                    : (0, doc_1.concat)(["!", this.emit(node.type)]);
+            case "JSDocNullableType":
+                return node.postfix
+                    ? (0, doc_1.concat)([this.emit(node.type), "?"])
+                    : (0, doc_1.concat)(["?", this.emit(node.type)]);
+            case "JSDocOptionalType":
+                return (0, doc_1.concat)([this.emit(node.type), "="]);
+            case "JSDocVariadicType":
+                return (0, doc_1.concat)(["...", this.emit(node.type)]);
+            case "JSDocNamepathType":
+                return this.emit(node.type);
+            case "JSDocFunctionType":
+                return (0, doc_1.concat)([
+                    "function(",
+                    (0, doc_1.join)(", ", node.parameters.map((p) => this.emit(p))),
+                    ")",
+                    node.type ? (0, doc_1.concat)([": ", this.emit(node.type)]) : "",
+                ]);
+            case "JSDocTypeExpression":
+                return (0, doc_1.concat)(["{", this.emit(node.type), "}"]);
+            case "JSDocNameReference":
+                return this.emit(node.name);
+            case "JSDocMemberName":
+                return (0, doc_1.concat)([this.emit(node.left), "#", this.emit(node.right)]);
+            case "JSDocLink":
+                return (0, doc_1.concat)([
+                    "{@link ",
+                    node.name ? this.emit(node.name) : "",
+                    node.text,
+                    "}",
+                ]);
+            case "JSDocLinkCode":
+                return (0, doc_1.concat)([
+                    "{@linkcode ",
+                    node.name ? this.emit(node.name) : "",
+                    node.text,
+                    "}",
+                ]);
+            case "JSDocLinkPlain":
+                return (0, doc_1.concat)([
+                    "{@linkplain ",
+                    node.name ? this.emit(node.name) : "",
+                    node.text,
+                    "}",
+                ]);
+            case "JSDocText":
+                return node.text;
+            case "JSDocTypeLiteral":
+                return (0, doc_1.concat)([
+                    (0, doc_1.join)(doc_1.hardline, (node.jsDocPropertyTags ?? []).map((t) => this.emit(t))),
+                    node.isArrayType ? "[]" : "",
+                ]);
+            case "JSDocSignature":
+                return (0, doc_1.join)(doc_1.hardline, [
+                    ...(node.typeParameters ?? []),
+                    ...node.parameters,
+                    ...(node.type ? [node.type] : []),
+                ].map((t) => this.emit(t)));
+            case "JSDoc": {
+                const body = node.comment === undefined
+                    ? ""
+                    : typeof node.comment === "string"
+                        ? node.comment
+                        : (0, doc_1.concat)(node.comment.map((c) => this.emit(c)));
+                const lines = [(0, doc_1.concat)([" * ", body])];
+                for (const tag of node.tags ?? [])
+                    lines.push((0, doc_1.concat)([" * ", this.emit(tag)]));
+                return (0, doc_1.concat)([
+                    "/**",
+                    doc_1.hardline,
+                    (0, doc_1.join)(doc_1.hardline, lines),
+                    doc_1.hardline,
+                    " */",
+                ]);
+            }
+            /* jsdoc — tags */
+            case "JSDocTypeTag":
+            case "JSDocThisTag":
+            case "JSDocEnumTag":
+            case "JSDocSatisfiesTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    " ",
+                    this.emit(node.typeExpression),
+                    this.jsDocComment(node.comment),
+                ]);
+            case "JSDocReturnTag":
+            case "JSDocThrowsTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    node.typeExpression
+                        ? (0, doc_1.concat)([" ", this.emit(node.typeExpression)])
+                        : "",
+                    this.jsDocComment(node.comment),
+                ]);
+            case "JSDocAuthorTag":
+            case "JSDocClassTag":
+            case "JSDocPublicTag":
+            case "JSDocPrivateTag":
+            case "JSDocProtectedTag":
+            case "JSDocReadonlyTag":
+            case "JSDocOverrideTag":
+            case "JSDocDeprecatedTag":
+            case "JSDocUnknownTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    this.jsDocComment(node.comment),
+                ]);
+            case "JSDocAugmentsTag":
+            case "JSDocImplementsTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    " {",
+                    this.emit(node.class),
+                    "}",
+                    this.jsDocComment(node.comment),
+                ]);
+            case "JSDocParameterTag":
+            case "JSDocPropertyTag": {
+                const name = node.isBracketed
+                    ? (0, doc_1.concat)(["[", this.emit(node.name), "]"])
+                    : this.emit(node.name);
+                const type = node.typeExpression
+                    ? this.emit(node.typeExpression)
+                    : undefined;
+                const main = node.isNameFirst
+                    ? (0, doc_1.concat)([name, type ? (0, doc_1.concat)([" ", type]) : ""])
+                    : (0, doc_1.concat)([type ? (0, doc_1.concat)([type, " "]) : "", name]);
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    " ",
+                    main,
+                    this.jsDocComment(node.comment),
+                ]);
+            }
+            case "JSDocSeeTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    node.name ? (0, doc_1.concat)([" ", this.emit(node.name)]) : "",
+                    this.jsDocComment(node.comment),
+                ]);
+            case "JSDocOverloadTag":
+            case "JSDocCallbackTag": {
+                const full = node.kind === "JSDocCallbackTag" && node.fullName
+                    ? (0, doc_1.concat)([" ", this.emit(node.fullName)])
+                    : "";
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    full,
+                    doc_1.hardline,
+                    this.emit(node.typeExpression),
+                    this.jsDocComment(node.comment),
+                ]);
+            }
+            case "JSDocImportTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    " ",
+                    node.importClause
+                        ? (0, doc_1.concat)([this.emit(node.importClause), " from "])
+                        : "",
+                    this.emit(node.moduleSpecifier),
+                    this.jsDocComment(node.comment),
+                ]);
+            case "JSDocTemplateTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    node.constraint ? (0, doc_1.concat)([" ", this.emit(node.constraint)]) : "",
+                    " ",
+                    (0, doc_1.join)(", ", node.typeParameters.map((t) => this.emit(t))),
+                    this.jsDocComment(node.comment),
+                ]);
+            case "JSDocTypedefTag":
+                return (0, doc_1.concat)([
+                    "@",
+                    this.emit(node.tagName),
+                    node.typeExpression
+                        ? (0, doc_1.concat)([" ", this.emit(node.typeExpression)])
+                        : "",
+                    node.fullName ? (0, doc_1.concat)([" ", this.emit(node.fullName)]) : "",
+                    this.jsDocComment(node.comment),
+                ]);
             default:
                 return this.unsupported(node);
         }
     }
+    /**
+     * Emit a type in the operand position of a postfix type (`T[]`, `T[K]`),
+     * parenthesizing the lower-precedence type forms that would otherwise
+     * re-associate — matching the legacy printer's parenthesizer rules.
+     */
+    postfixTypeOperand(type) {
+        const parenthesize = type.kind === "UnionTypeNode" ||
+            type.kind === "IntersectionTypeNode" ||
+            type.kind === "FunctionTypeNode" ||
+            type.kind === "ConstructorTypeNode" ||
+            type.kind === "ConditionalTypeNode" ||
+            type.kind === "InferTypeNode" ||
+            type.kind === "TypeOperatorNode";
+        return parenthesize ? (0, doc_1.concat)(["(", this.emit(type), ")"]) : this.emit(type);
+    }
+    /** Render a JSDoc tag's trailing comment, prefixed with a space when present. */
+    jsDocComment(comment) {
+        if (comment === undefined)
+            return "";
+        if (typeof comment === "string")
+            return comment.length ? (0, doc_1.concat)([" ", comment]) : "";
+        return comment.length
+            ? (0, doc_1.concat)([" ", (0, doc_1.concat)(comment.map((c) => this.emit(c)))])
+            : "";
+    }
     /** Width-aware `|` / `&` type list with leading-operator breaks. */
     binaryType(operator, parts) {
         if (parts.length === 1)