@tslite/services 0.0.0-stage → 1.13.0

package/dist/formatting/formattingContext.d.ts

@@ -0,0 +1,34 @@
+import type { FormatCodeSettings, Node, SourceFileLike } from "../_namespaces/edit.js";
+import type { TextRangeWithKind } from "../_namespaces/ts.formatting.js";
+export declare enum FormattingRequestKind {
+    FormatDocument = 0,
+    FormatSelection = 1,
+    FormatOnEnter = 2,
+    FormatOnSemicolon = 3,
+    FormatOnOpeningCurlyBrace = 4,
+    FormatOnClosingCurlyBrace = 5
+}
+export declare class FormattingContext {
+    readonly sourceFile: SourceFileLike;
+    formattingRequestKind: FormattingRequestKind;
+    options: FormatCodeSettings;
+    currentTokenSpan: TextRangeWithKind;
+    nextTokenSpan: TextRangeWithKind;
+    contextNode: Node;
+    currentTokenParent: Node;
+    nextTokenParent: Node;
+    private contextNodeAllOnSameLine;
+    private nextNodeAllOnSameLine;
+    private tokensAreOnSameLine;
+    private contextNodeBlockIsOnOneLine;
+    private nextNodeBlockIsOnOneLine;
+    constructor(sourceFile: SourceFileLike, formattingRequestKind: FormattingRequestKind, options: FormatCodeSettings);
+    updateContext(currentRange: TextRangeWithKind, currentTokenParent: Node, nextRange: TextRangeWithKind, nextTokenParent: Node, commonParent: Node): void;
+    ContextNodeAllOnSameLine(): boolean;
+    NextNodeAllOnSameLine(): boolean;
+    TokensAreOnSameLine(): boolean;
+    ContextNodeBlockIsOnOneLine(): boolean;
+    NextNodeBlockIsOnOneLine(): boolean;
+    private NodeIsOnOneLine;
+    private BlockIsOnOneLine;
+}

package/dist/formatting/formattingContext.js

@@ -0,0 +1,78 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/formatting/formattingContext.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, SyntaxKind, findChildOfKind, } from "../_namespaces/edit.js";
+export var FormattingRequestKind;
+(function (FormattingRequestKind) {
+    FormattingRequestKind[FormattingRequestKind["FormatDocument"] = 0] = "FormatDocument";
+    FormattingRequestKind[FormattingRequestKind["FormatSelection"] = 1] = "FormatSelection";
+    FormattingRequestKind[FormattingRequestKind["FormatOnEnter"] = 2] = "FormatOnEnter";
+    FormattingRequestKind[FormattingRequestKind["FormatOnSemicolon"] = 3] = "FormatOnSemicolon";
+    FormattingRequestKind[FormattingRequestKind["FormatOnOpeningCurlyBrace"] = 4] = "FormatOnOpeningCurlyBrace";
+    FormattingRequestKind[FormattingRequestKind["FormatOnClosingCurlyBrace"] = 5] = "FormatOnClosingCurlyBrace";
+})(FormattingRequestKind || (FormattingRequestKind = {}));
+export class FormattingContext {
+    constructor(sourceFile, formattingRequestKind, options) {
+        this.sourceFile = sourceFile;
+        this.formattingRequestKind = formattingRequestKind;
+        this.options = options;
+    }
+    updateContext(currentRange, currentTokenParent, nextRange, nextTokenParent, commonParent) {
+        this.currentTokenSpan = Debug.checkDefined(currentRange);
+        this.currentTokenParent = Debug.checkDefined(currentTokenParent);
+        this.nextTokenSpan = Debug.checkDefined(nextRange);
+        this.nextTokenParent = Debug.checkDefined(nextTokenParent);
+        this.contextNode = Debug.checkDefined(commonParent);
+        // drop cached results
+        this.contextNodeAllOnSameLine = undefined;
+        this.nextNodeAllOnSameLine = undefined;
+        this.tokensAreOnSameLine = undefined;
+        this.contextNodeBlockIsOnOneLine = undefined;
+        this.nextNodeBlockIsOnOneLine = undefined;
+    }
+    ContextNodeAllOnSameLine() {
+        if (this.contextNodeAllOnSameLine === undefined) {
+            this.contextNodeAllOnSameLine = this.NodeIsOnOneLine(this.contextNode);
+        }
+        return this.contextNodeAllOnSameLine;
+    }
+    NextNodeAllOnSameLine() {
+        if (this.nextNodeAllOnSameLine === undefined) {
+            this.nextNodeAllOnSameLine = this.NodeIsOnOneLine(this.nextTokenParent);
+        }
+        return this.nextNodeAllOnSameLine;
+    }
+    TokensAreOnSameLine() {
+        if (this.tokensAreOnSameLine === undefined) {
+            const startLine = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line;
+            const endLine = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line;
+            this.tokensAreOnSameLine = (startLine === endLine);
+        }
+        return this.tokensAreOnSameLine;
+    }
+    ContextNodeBlockIsOnOneLine() {
+        if (this.contextNodeBlockIsOnOneLine === undefined) {
+            this.contextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.contextNode);
+        }
+        return this.contextNodeBlockIsOnOneLine;
+    }
+    NextNodeBlockIsOnOneLine() {
+        if (this.nextNodeBlockIsOnOneLine === undefined) {
+            this.nextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.nextTokenParent);
+        }
+        return this.nextNodeBlockIsOnOneLine;
+    }
+    NodeIsOnOneLine(node) {
+        const startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile)).line;
+        const endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
+        return startLine === endLine;
+    }
+    BlockIsOnOneLine(node) {
+        const openBrace = findChildOfKind(node, SyntaxKind.OpenBraceToken, this.sourceFile);
+        const closeBrace = findChildOfKind(node, SyntaxKind.CloseBraceToken, this.sourceFile);
+        if (openBrace && closeBrace) {
+            const startLine = this.sourceFile.getLineAndCharacterOfPosition(openBrace.getEnd()).line;
+            const endLine = this.sourceFile.getLineAndCharacterOfPosition(closeBrace.getStart(this.sourceFile)).line;
+            return startLine === endLine;
+        }
+        return false;
+    }
+}

package/dist/formatting/formattingScanner.d.ts

@@ -0,0 +1,14 @@
+import { LanguageVariant } from "../_namespaces/edit.js";
+import type { Node } from "../_namespaces/edit.js";
+import type { TextRangeWithKind, TokenInfo } from "../_namespaces/ts.formatting.js";
+export interface FormattingScanner {
+    advance(): void;
+    isOnToken(): boolean;
+    isOnEOF(): boolean;
+    readTokenInfo(n: Node): TokenInfo;
+    readEOFTokenRange(): TextRangeWithKind;
+    getCurrentLeadingTrivia(): TextRangeWithKind[] | undefined;
+    lastTrailingTriviaWasNewLine(): boolean;
+    skipToEndOf(node: Node): void;
+}
+export declare function getFormattingScanner<T>(text: string, languageVariant: LanguageVariant, startPos: number, endPos: number, cb: (scanner: FormattingScanner) => T): T;

package/dist/formatting/formattingScanner.js

@@ -0,0 +1,228 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/formatting/formattingScanner.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, LanguageVariant, ScriptTarget, SyntaxKind, append, createScanner, findAncestor, isJsxAttribute, isJsxElement, isJsxText, isKeyword, isParenthesizedExpression, isToken, isTrivia, last, } from "../_namespaces/edit.js";
+import { createTextRangeWithKind, } from "../_namespaces/ts.formatting.js";
+const standardScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, LanguageVariant.Standard);
+const jsxScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, LanguageVariant.JSX);
+var ScanAction;
+(function (ScanAction) {
+    ScanAction[ScanAction["Scan"] = 0] = "Scan";
+    ScanAction[ScanAction["RescanGreaterThanToken"] = 1] = "RescanGreaterThanToken";
+    // Na tag, também o reescaneamento da barra como literal de regex (CK-02).
+    ScanAction[ScanAction["RescanTemplateToken"] = 2] = "RescanTemplateToken";
+    ScanAction[ScanAction["RescanJsxIdentifier"] = 3] = "RescanJsxIdentifier";
+    ScanAction[ScanAction["RescanJsxText"] = 4] = "RescanJsxText";
+    ScanAction[ScanAction["RescanJsxAttributeValue"] = 5] = "RescanJsxAttributeValue";
+})(ScanAction || (ScanAction = {}));
+export function getFormattingScanner(text, languageVariant, startPos, endPos, cb) {
+    const scanner = languageVariant === LanguageVariant.JSX ? jsxScanner : standardScanner;
+    scanner.setText(text);
+    scanner.setTextPos(startPos);
+    let wasNewLine = true;
+    let leadingTrivia;
+    let trailingTrivia;
+    let savedPos;
+    let lastScanAction;
+    let lastTokenInfo;
+    const res = cb({
+        advance,
+        readTokenInfo,
+        readEOFTokenRange,
+        isOnToken,
+        isOnEOF,
+        getCurrentLeadingTrivia: () => leadingTrivia,
+        lastTrailingTriviaWasNewLine: () => wasNewLine,
+        skipToEndOf,
+    });
+    lastTokenInfo = undefined;
+    scanner.setText(undefined);
+    return res;
+    function advance() {
+        lastTokenInfo = undefined;
+        const isStarted = scanner.getStartPos() !== startPos;
+        if (isStarted) {
+            wasNewLine = !!trailingTrivia && last(trailingTrivia).kind === SyntaxKind.NewLineTrivia;
+        }
+        else {
+            scanner.scan();
+        }
+        leadingTrivia = undefined;
+        trailingTrivia = undefined;
+        let pos = scanner.getStartPos();
+        // Read leading trivia and token
+        while (pos < endPos) {
+            const t = scanner.getToken();
+            if (!isTrivia(t)) {
+                break;
+            }
+            // consume leading trivia
+            scanner.scan();
+            const item = {
+                pos,
+                end: scanner.getStartPos(),
+                kind: t
+            };
+            pos = scanner.getStartPos();
+            leadingTrivia = append(leadingTrivia, item);
+        }
+        savedPos = scanner.getStartPos();
+    }
+    function shouldRescanGreaterThanToken(node) {
+        switch (node.kind) {
+            case SyntaxKind.GreaterThanEqualsToken:
+            case SyntaxKind.GreaterThanGreaterThanEqualsToken:
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+            case SyntaxKind.GreaterThanGreaterThanToken:
+                return true;
+        }
+        return false;
+    }
+    function shouldRescanJsxIdentifier(node) {
+        if (node.parent) {
+            switch (node.parent.kind) {
+                case SyntaxKind.JsxAttribute:
+                case SyntaxKind.JsxOpeningElement:
+                case SyntaxKind.JsxClosingElement:
+                case SyntaxKind.JsxSelfClosingElement:
+                    // May parse an identifier like `module-layout`; that will be scanned as a keyword at first, but we should parse the whole thing to get an identifier.
+                    return isKeyword(node.kind) || node.kind === SyntaxKind.Identifier;
+            }
+        }
+        return false;
+    }
+    function shouldRescanJsxText(node) {
+        const isJSXText = isJsxText(node);
+        if (isJSXText) {
+            const containingElement = findAncestor(node.parent, p => isJsxElement(p));
+            if (!containingElement)
+                return false; // should never happen
+            return !isParenthesizedExpression(containingElement.parent);
+        }
+        return false;
+    }
+    function shouldRescanTemplateToken(container) {
+        return container.kind === SyntaxKind.TemplateMiddle ||
+            container.kind === SyntaxKind.TemplateTail;
+    }
+    function shouldRescanJsxAttributeValue(node) {
+        return node.parent && isJsxAttribute(node.parent) && node.parent.initializer === node;
+    }
+    // Na tag, também o literal de regex, que se reescaneava a partir da barra (CK-02).
+    function readTokenInfo(n) {
+        Debug.assert(isOnToken());
+        // normally scanner returns the smallest available token
+        // check the kind of context node to determine if scanner should have more greedy behavior and consume more text.
+        const expectedScanAction = shouldRescanGreaterThanToken(n) ? 1 /* ScanAction.RescanGreaterThanToken */ :
+            shouldRescanTemplateToken(n) ? 2 /* ScanAction.RescanTemplateToken */ :
+                shouldRescanJsxIdentifier(n) ? 3 /* ScanAction.RescanJsxIdentifier */ :
+                    shouldRescanJsxText(n) ? 4 /* ScanAction.RescanJsxText */ :
+                        shouldRescanJsxAttributeValue(n) ? 5 /* ScanAction.RescanJsxAttributeValue */ :
+                            0 /* ScanAction.Scan */;
+        if (lastTokenInfo && expectedScanAction === lastScanAction) {
+            // readTokenInfo was called before with the same expected scan action.
+            // No need to re-scan text, return existing 'lastTokenInfo'
+            // it is ok to call fixTokenKind here since it does not affect
+            // what portion of text is consumed. In contrast rescanning can change it,
+            // i.e. for '>=' when originally scanner eats just one character
+            // and rescanning forces it to consume more.
+            return fixTokenKind(lastTokenInfo, n);
+        }
+        if (scanner.getStartPos() !== savedPos) {
+            Debug.assert(lastTokenInfo !== undefined);
+            // readTokenInfo was called before but scan action differs - rescan text
+            scanner.setTextPos(savedPos);
+            scanner.scan();
+        }
+        let currentToken = getNextToken(n, expectedScanAction);
+        const token = createTextRangeWithKind(scanner.getStartPos(), scanner.getTextPos(), currentToken);
+        // consume trailing trivia
+        if (trailingTrivia) {
+            trailingTrivia = undefined;
+        }
+        while (scanner.getStartPos() < endPos) {
+            currentToken = scanner.scan();
+            if (!isTrivia(currentToken)) {
+                break;
+            }
+            const trivia = createTextRangeWithKind(scanner.getStartPos(), scanner.getTextPos(), currentToken);
+            if (!trailingTrivia) {
+                trailingTrivia = [];
+            }
+            trailingTrivia.push(trivia);
+            if (currentToken === SyntaxKind.NewLineTrivia) {
+                // move past new line
+                scanner.scan();
+                break;
+            }
+        }
+        lastTokenInfo = { leadingTrivia, trailingTrivia, token };
+        return fixTokenKind(lastTokenInfo, n);
+    }
+    function getNextToken(n, expectedScanAction) {
+        const token = scanner.getToken();
+        lastScanAction = 0 /* ScanAction.Scan */;
+        switch (expectedScanAction) {
+            case 1 /* ScanAction.RescanGreaterThanToken */:
+                if (token === SyntaxKind.GreaterThanToken) {
+                    lastScanAction = 1 /* ScanAction.RescanGreaterThanToken */;
+                    const newToken = scanner.reScanGreaterToken();
+                    Debug.assert(n.kind === newToken);
+                    return newToken;
+                }
+                break;
+            case 2 /* ScanAction.RescanTemplateToken */:
+                if (token === SyntaxKind.CloseBraceToken) {
+                    lastScanAction = 2 /* ScanAction.RescanTemplateToken */;
+                    // Na tag, com o `isTaggedTemplate` do template marcado (CK-02).
+                    return scanner.reScanTemplateToken();
+                }
+                break;
+            case 3 /* ScanAction.RescanJsxIdentifier */:
+                lastScanAction = 3 /* ScanAction.RescanJsxIdentifier */;
+                return scanner.scanJsxIdentifier();
+            case 4 /* ScanAction.RescanJsxText */:
+                lastScanAction = 4 /* ScanAction.RescanJsxText */;
+                return scanner.reScanJsxToken();
+            case 5 /* ScanAction.RescanJsxAttributeValue */:
+                lastScanAction = 5 /* ScanAction.RescanJsxAttributeValue */;
+                return scanner.reScanJsxAttributeValue();
+            case 0 /* ScanAction.Scan */:
+                break;
+            default:
+                Debug.assertNever(expectedScanAction);
+        }
+        return token;
+    }
+    function readEOFTokenRange() {
+        Debug.assert(isOnEOF());
+        return createTextRangeWithKind(scanner.getStartPos(), scanner.getTextPos(), SyntaxKind.EndOfFileToken);
+    }
+    function isOnToken() {
+        const current = lastTokenInfo ? lastTokenInfo.token.kind : scanner.getToken();
+        const startPos = lastTokenInfo ? lastTokenInfo.token.pos : scanner.getStartPos();
+        return startPos < endPos && current !== SyntaxKind.EndOfFileToken && !isTrivia(current);
+    }
+    function isOnEOF() {
+        const current = lastTokenInfo ? lastTokenInfo.token.kind : scanner.getToken();
+        return current === SyntaxKind.EndOfFileToken;
+    }
+    // when containing node in the tree is token
+    // but its kind differs from the kind that was returned by the scanner,
+    // then kind needs to be fixed. This might happen in cases
+    // when parser interprets token differently, i.e keyword treated as identifier
+    function fixTokenKind(tokenInfo, container) {
+        if (isToken(container) && tokenInfo.token.kind !== container.kind) {
+            tokenInfo.token.kind = container.kind;
+        }
+        return tokenInfo;
+    }
+    function skipToEndOf(node) {
+        scanner.setTextPos(node.end);
+        savedPos = scanner.getStartPos();
+        lastScanAction = undefined;
+        lastTokenInfo = undefined;
+        wasNewLine = false;
+        leadingTrivia = undefined;
+        trailingTrivia = undefined;
+    }
+}

package/dist/formatting/rule.d.ts

@@ -0,0 +1,31 @@
+import { SyntaxKind } from "../_namespaces/edit.js";
+import { FormattingContext } from "../_namespaces/ts.formatting.js";
+export interface Rule {
+    readonly debugName: string;
+    readonly context: readonly ContextPredicate[];
+    readonly action: RuleAction;
+    readonly flags: RuleFlags;
+}
+export type ContextPredicate = (context: FormattingContext) => boolean;
+export declare const anyContext: readonly ContextPredicate[];
+export declare enum RuleAction {
+    None = 0,
+    StopProcessingSpaceActions = 1,
+    StopProcessingTokenActions = 2,
+    InsertSpace = 4,
+    InsertNewLine = 8,
+    DeleteSpace = 16,
+    DeleteToken = 32,
+    InsertTrailingSemicolon = 64,
+    StopAction = 3,
+    ModifySpaceAction = 28,
+    ModifyTokenAction = 96
+}
+export declare enum RuleFlags {
+    None = 0,
+    CanDeleteNewLines = 1
+}
+export interface TokenRange {
+    readonly tokens: readonly SyntaxKind[];
+    readonly isSpecific: boolean;
+}

package/dist/formatting/rule.js

@@ -0,0 +1,22 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/formatting/rule.ts: o namespace virou módulo ES, com os imports explícitos.
+import { emptyArray, } from "../_namespaces/edit.js";
+export const anyContext = emptyArray;
+export var RuleAction;
+(function (RuleAction) {
+    RuleAction[RuleAction["None"] = 0] = "None";
+    RuleAction[RuleAction["StopProcessingSpaceActions"] = 1] = "StopProcessingSpaceActions";
+    RuleAction[RuleAction["StopProcessingTokenActions"] = 2] = "StopProcessingTokenActions";
+    RuleAction[RuleAction["InsertSpace"] = 4] = "InsertSpace";
+    RuleAction[RuleAction["InsertNewLine"] = 8] = "InsertNewLine";
+    RuleAction[RuleAction["DeleteSpace"] = 16] = "DeleteSpace";
+    RuleAction[RuleAction["DeleteToken"] = 32] = "DeleteToken";
+    RuleAction[RuleAction["InsertTrailingSemicolon"] = 64] = "InsertTrailingSemicolon";
+    RuleAction[RuleAction["StopAction"] = 3] = "StopAction";
+    RuleAction[RuleAction["ModifySpaceAction"] = 28] = "ModifySpaceAction";
+    RuleAction[RuleAction["ModifyTokenAction"] = 96] = "ModifyTokenAction";
+})(RuleAction || (RuleAction = {}));
+export var RuleFlags;
+(function (RuleFlags) {
+    RuleFlags[RuleFlags["None"] = 0] = "None";
+    RuleFlags[RuleFlags["CanDeleteNewLines"] = 1] = "CanDeleteNewLines";
+})(RuleFlags || (RuleFlags = {}));

package/dist/formatting/rules.d.ts

@@ -0,0 +1,7 @@
+import type { Rule, TokenRange } from "../_namespaces/ts.formatting.js";
+export interface RuleSpec {
+    readonly leftTokenRange: TokenRange;
+    readonly rightTokenRange: TokenRange;
+    readonly rule: Rule;
+}
+export declare function getAllRules(): RuleSpec[];