tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/printer/text-writer.d.ts

@@ -0,0 +1,46 @@
+export declare class TextWriter {
+    readonly newLine: string;
+    readonly indentSize: number;
+    /** Current indentation level. */
+    indent: number;
+    /** Track output length for `getColumn`; off unless source maps are written. */
+    trackColumns: boolean;
+    private parts;
+    /** Output length in UTF-16 code units, when `trackColumns` is on. */
+    private length;
+    /** Number of non-empty writes, to tell whether anything was written. */
+    private writes;
+    private lastWritten;
+    private lineStart;
+    private lineCount;
+    /** Offset of the current line's start in the output, when `trackColumns` is on. */
+    private linePos;
+    private trailingComment;
+    private readonly indentStrings;
+    constructor(newLine: string, indentSize: number);
+    clear(): string;
+    getText(): string;
+    /** Changes whenever something is written. */
+    getWriteCount(): number;
+    getLine(): number;
+    /** Column in UTF-16 code units; needs `trackColumns`. */
+    getColumn(): number;
+    isAtStartOfLine(): boolean;
+    hasTrailingComment(): boolean;
+    hasTrailingWhitespace(): boolean;
+    private indentString;
+    private append;
+    /** Moves the line state past the line terminators in `s`, which ends the output. */
+    private updateLines;
+    private writeIndent;
+    /** Writes text without indentation; it may contain line breaks. */
+    rawWrite(s: string): boolean;
+    /** Writes text that contains no line breaks, such as a token or identifier. */
+    write(s: string): boolean;
+    /** Writes text that may contain line breaks, such as a string or template literal. */
+    writeText(s: string): boolean;
+    /** Writes comment text without line breaks. */
+    writeComment(s: string): boolean;
+    /** Ends the line, unless already at the start of one and not `force`d. */
+    writeLine(force: boolean): boolean;
+}

package/dist/api/compiler/printer/text-writer.js

@@ -0,0 +1,172 @@
+// Builds printer output with indentation and line/column tracking for source maps.
+import { isWhiteSpaceLike } from '../character-codes.js';
+const defaultIndentSize = 4;
+export class TextWriter {
+    newLine;
+    indentSize;
+    /** Current indentation level. */
+    indent;
+    /** Track output length for `getColumn`; off unless source maps are written. */
+    trackColumns;
+    parts;
+    /** Output length in UTF-16 code units, when `trackColumns` is on. */
+    length;
+    /** Number of non-empty writes, to tell whether anything was written. */
+    writes;
+    lastWritten;
+    lineStart;
+    lineCount;
+    /** Offset of the current line's start in the output, when `trackColumns` is on. */
+    linePos;
+    trailingComment;
+    indentStrings;
+    constructor(newLine, indentSize) {
+        this.newLine = newLine;
+        this.indentSize = indentSize > 0 ? indentSize : defaultIndentSize;
+        this.indent = 0;
+        this.trackColumns = false;
+        this.parts = [];
+        this.length = 0;
+        this.writes = 0;
+        this.lastWritten = '';
+        this.lineStart = true;
+        this.lineCount = 0;
+        this.linePos = 0;
+        this.trailingComment = false;
+        this.indentStrings = [''];
+    }
+    clear() {
+        this.indent = 0;
+        this.parts = [];
+        this.length = 0;
+        this.writes = 0;
+        this.lastWritten = '';
+        this.lineStart = true;
+        this.lineCount = 0;
+        this.linePos = 0;
+        this.trailingComment = false;
+        return '';
+    }
+    getText() {
+        const text = this.parts.join('');
+        if (this.parts.length > 1)
+            this.parts = [text];
+        return text;
+    }
+    /** Changes whenever something is written. */
+    getWriteCount() {
+        return this.writes;
+    }
+    getLine() {
+        return this.lineCount;
+    }
+    /** Column in UTF-16 code units; needs `trackColumns`. */
+    getColumn() {
+        return this.lineStart ? this.indent * this.indentSize : this.length - this.linePos;
+    }
+    isAtStartOfLine() {
+        return this.lineStart;
+    }
+    hasTrailingComment() {
+        return this.trailingComment;
+    }
+    hasTrailingWhitespace() {
+        const last = this.lastWritten;
+        return this.writes > 0 && last !== '' && isWhiteSpaceLike(last.charCodeAt(last.length - 1));
+    }
+    indentString(level) {
+        const strings = this.indentStrings;
+        while (strings.length <= level)
+            strings.push(strings[strings.length - 1] + ' '.repeat(this.indentSize));
+        return strings[level];
+    }
+    append(s) {
+        this.parts.push(s);
+        this.writes++;
+        if (this.trackColumns)
+            this.length += s.length;
+        this.lastWritten = s;
+        return true;
+    }
+    /** Moves the line state past the line terminators in `s`, which ends the output. */
+    updateLines(s) {
+        let count = 0;
+        let lastLineStart = 0;
+        for (let i = 0; i < s.length; i++) {
+            const ch = s.charCodeAt(i);
+            if (ch === 13 /* CharacterCodes.carriageReturn */) {
+                if (i + 1 < s.length && s.charCodeAt(i + 1) === 10 /* CharacterCodes.lineFeed */)
+                    i++;
+            }
+            else if (ch !== 10 /* CharacterCodes.lineFeed */ &&
+                ch !== 8232 /* CharacterCodes.lineSeparator */ &&
+                ch !== 8233 /* CharacterCodes.paragraphSeparator */)
+                continue;
+            count++;
+            lastLineStart = i + 1;
+        }
+        if (count > 0) {
+            this.lineCount += count;
+            this.linePos = this.length - s.length + lastLineStart;
+            this.lineStart = this.trackColumns ? this.linePos === this.length : lastLineStart === s.length;
+            return true;
+        }
+        this.lineStart = false;
+        return false;
+    }
+    writeIndent() {
+        if (!this.lineStart)
+            return false;
+        const indent = this.indentString(this.indent);
+        if (indent !== '')
+            this.append(indent);
+        this.lineStart = false;
+        return true;
+    }
+    /** Writes text without indentation; it may contain line breaks. */
+    rawWrite(s) {
+        if (s !== '') {
+            this.append(s);
+            this.trailingComment = false;
+        }
+        return this.updateLines(s);
+    }
+    /** Writes text that contains no line breaks, such as a token or identifier. */
+    write(s) {
+        if (s === '')
+            return false;
+        this.trailingComment = false;
+        this.writeIndent();
+        this.lineStart = false;
+        return this.append(s);
+    }
+    /** Writes text that may contain line breaks, such as a string or template literal. */
+    writeText(s) {
+        if (s === '')
+            return false;
+        this.trailingComment = false;
+        this.writeIndent();
+        this.append(s);
+        return this.updateLines(s);
+    }
+    /** Writes comment text without line breaks. */
+    writeComment(s) {
+        if (s === '')
+            return false;
+        this.trailingComment = true;
+        this.writeIndent();
+        this.lineStart = false;
+        return this.append(s);
+    }
+    /** Ends the line, unless already at the start of one and not `force`d. */
+    writeLine(force) {
+        if (this.lineStart && !force)
+            return false;
+        this.append(this.newLine);
+        this.lineCount++;
+        this.linePos = this.length;
+        this.lineStart = true;
+        this.trailingComment = false;
+        return true;
+    }
+}

package/dist/api/compiler/printer/utilities.d.ts

@@ -0,0 +1,82 @@
+import { type Node, NodeFlags, SourceFile } from '../ast.js';
+import { OperatorPrecedence } from '../ast-utilities.js';
+import { SyntaxKind } from '../syntax-kind.js';
+import { type CommentRange } from '../types.js';
+export declare function positionIsSynthesized(pos: number): boolean;
+export declare function nodeIsSynthesized(node: Node): boolean;
+/** Whether the parser (not a transform) created the node. */
+export declare function isParseTreeNode(node: Node): boolean;
+export declare function getSourceFileOfNode(node: Node | undefined): SourceFile | undefined;
+export declare function isPrologueDirective(node: Node): boolean;
+export declare function isKeywordKind(kind: SyntaxKind): boolean;
+export declare function isPunctuationKind(kind: SyntaxKind): boolean;
+export declare function isLiteralKind(kind: SyntaxKind): boolean;
+export declare function isJSDocKind(kind: SyntaxKind): boolean;
+export declare function isMemberName(node: Node): boolean;
+export declare function isModifier(node: Node): boolean;
+export declare function isOptionalChain(node: Node): boolean;
+export declare function isUnterminatedLiteral(node: Node): boolean;
+export declare function skipPartiallyEmittedExpressions(node: Node): Node;
+/** Whether a variable declaration list declares `let`, `const`, `using` or `await using`, as `NodeFlags.BlockScoped`. */
+export declare function blockScopeFlags(node: Node): NodeFlags;
+export declare function isExpressionKind(kind: SyntaxKind): boolean;
+export declare function isExpression(node: Node): boolean;
+export declare function isTypeNodeKind(kind: SyntaxKind): boolean;
+export declare function isFunctionLikeKind(kind: SyntaxKind): boolean;
+export declare function isStatement(node: Node): boolean;
+export declare function getExpressionPrecedence(expression: Node): OperatorPrecedence;
+export declare const enum TypePrecedence {
+    Conditional = 0,
+    JSDoc = 1,
+    Function = 2,
+    Union = 3,
+    Intersection = 4,
+    TypeOperator = 5,
+    Postfix = 6,
+    NonArray = 7,
+    Lowest = 0,
+    Highest = 7
+}
+export declare function getTypeNodePrecedence(node: Node): TypePrecedence;
+/** The leftmost operand of an expression, e.g. `a` in `a.b + c`. */
+export declare function getLeftmostExpression(node: Node, stopAtCallExpressions: boolean): Node;
+export declare function skipSynthesizedParentheses(node: Node): Node;
+export declare function isNewExpressionWithoutArguments(node: Node): boolean;
+export declare function isBinaryOperation(node: Node, token: SyntaxKind): boolean;
+export declare function mixingBinaryOperatorsRequiresParentheses(a: SyntaxKind, b: SyntaxKind): boolean;
+export declare function isImmediatelyInvokedFunctionExpressionOrArrowFunction(node: Node): boolean;
+export declare function getOperatorOfPrefixOperand(node: Node): SyntaxKind;
+export declare const enum LiteralTextFlags {
+    None = 0,
+    NeverAsciiEscape = 1,
+    JsxAttributeEscape = 2,
+    TerminateUnterminatedLiterals = 4,
+    AllowNumericSeparator = 8
+}
+/**
+ * Escapes `s` for a literal quoted with `quote`, as ECMA-262's QuoteJSONString plus LS, PS
+ * and NEL; non-ASCII characters too unless `NeverAsciiEscape` is set. Doesn't add quotes.
+ */
+export declare function escapeString(s: string, quote: number, flags: LiteralTextFlags): string;
+/** The text of a literal as written, or its canonical (escaped, quoted) form for synthesized literals. */
+export declare function getLiteralText(node: Node, sourceText: string | undefined, flags: LiteralTextFlags): string;
+/** The source text of a node without leading trivia, as tsgo's GetSourceTextOfNodeFromSourceFile. */
+export declare function getSourceTextOfNode(sourceText: string, node: Node): string;
+/** Go's `strings.TrimSpace`: trims Unicode White_Space. */
+export declare function trimUnicodeSpace(text: string, start: number, end: number): string;
+export declare function getLinesBetweenPositions(lineStarts: readonly number[], pos1: number, pos2: number): number;
+export declare function getStartPositionOfRange(text: string, pos: number, includeComments: boolean): number;
+export declare function getPreviousNonWhitespacePosition(text: string, pos: number, stopPos: number): number;
+/** Columns of leading whitespace in `text[pos:end]`, with tabs to the next multiple of 4. */
+export declare function calculateIndent(text: string, pos: number, end: number): number;
+export declare function isLineBreakChar(ch: number): boolean;
+export declare function isJSDocLikeText(text: string, comment: CommentRange): boolean;
+export declare function isPinnedComment(text: string, comment: CommentRange): boolean;
+/** `/// <reference …/>`, `/// <amd-dependency path="…"/>` and `/// <amd-module/>` comments. */
+export declare function isRecognizedTripleSlashComment(sourceText: string, comment: CommentRange): boolean;
+export declare function formatGeneratedName(privateName: boolean, prefix: string, base: string, suffix: string): string;
+export declare function removeLeadingHash(text: string): string;
+export declare function ensureLeadingHash(text: string): string;
+/** An identifier for a module's base name, e.g. `foo_bar` for `./foo-bar`; one `_` per UTF-8 byte of other characters. */
+export declare function makeIdentifierFromModuleName(moduleName: string): string;
+export declare function lineOf(lineStarts: readonly number[], pos: number): number;