@tslite/services 0.0.0-stage → 1.12.0

package/dist/formatting/rulesMap.js

@@ -0,0 +1,127 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/formatting/rulesMap.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, SyntaxKind, every, } from "../_namespaces/edit.js";
+import { anyContext, getAllRules, } from "../_namespaces/ts.formatting.js";
+export function getFormatContext(options, host) {
+    return { options, getRules: getRulesMap(), host };
+}
+let rulesMapCache;
+function getRulesMap() {
+    if (rulesMapCache === undefined) {
+        rulesMapCache = createRulesMap(getAllRules());
+    }
+    return rulesMapCache;
+}
+/**
+ * For a given rule action, gets a mask of other rule actions that
+ * cannot be applied at the same position.
+ */
+function getRuleActionExclusion(ruleAction) {
+    let mask = 0;
+    if (ruleAction & 1 /* RuleAction.StopProcessingSpaceActions */) {
+        mask |= 28 /* RuleAction.ModifySpaceAction */;
+    }
+    if (ruleAction & 2 /* RuleAction.StopProcessingTokenActions */) {
+        mask |= 96 /* RuleAction.ModifyTokenAction */;
+    }
+    if (ruleAction & 28 /* RuleAction.ModifySpaceAction */) {
+        mask |= 28 /* RuleAction.ModifySpaceAction */;
+    }
+    if (ruleAction & 96 /* RuleAction.ModifyTokenAction */) {
+        mask |= 96 /* RuleAction.ModifyTokenAction */;
+    }
+    return mask;
+}
+function createRulesMap(rules) {
+    const map = buildMap(rules);
+    return context => {
+        const bucket = map[getRuleBucketIndex(context.currentTokenSpan.kind, context.nextTokenSpan.kind)];
+        if (bucket) {
+            const rules = [];
+            let ruleActionMask = 0;
+            for (const rule of bucket) {
+                const acceptRuleActions = ~getRuleActionExclusion(ruleActionMask);
+                if (rule.action & acceptRuleActions && every(rule.context, c => c(context))) {
+                    rules.push(rule);
+                    ruleActionMask |= rule.action;
+                }
+            }
+            if (rules.length) {
+                return rules;
+            }
+        }
+    };
+}
+function buildMap(rules) {
+    // Map from bucket index to array of rules
+    const map = new Array(mapRowLength * mapRowLength);
+    // This array is used only during construction of the rulesbucket in the map
+    const rulesBucketConstructionStateList = new Array(map.length);
+    for (const rule of rules) {
+        const specificRule = rule.leftTokenRange.isSpecific && rule.rightTokenRange.isSpecific;
+        for (const left of rule.leftTokenRange.tokens) {
+            for (const right of rule.rightTokenRange.tokens) {
+                const index = getRuleBucketIndex(left, right);
+                let rulesBucket = map[index];
+                if (rulesBucket === undefined) {
+                    rulesBucket = map[index] = [];
+                }
+                addRule(rulesBucket, rule.rule, specificRule, rulesBucketConstructionStateList, index);
+            }
+        }
+    }
+    return map;
+}
+function getRuleBucketIndex(row, column) {
+    Debug.assert(row <= SyntaxKind.LastKeyword && column <= SyntaxKind.LastKeyword, "Must compute formatting context from tokens");
+    return (row * mapRowLength) + column;
+}
+const maskBitSize = 5;
+const mask = 0b11111; // MaskBitSize bits
+const mapRowLength = SyntaxKind.LastToken + 1;
+var RulesPosition;
+(function (RulesPosition) {
+    RulesPosition[RulesPosition["StopRulesSpecific"] = 0] = "StopRulesSpecific";
+    RulesPosition[RulesPosition["StopRulesAny"] = 5] = "StopRulesAny";
+    RulesPosition[RulesPosition["ContextRulesSpecific"] = 10] = "ContextRulesSpecific";
+    RulesPosition[RulesPosition["ContextRulesAny"] = 15] = "ContextRulesAny";
+    RulesPosition[RulesPosition["NoContextRulesSpecific"] = 20] = "NoContextRulesSpecific";
+    RulesPosition[RulesPosition["NoContextRulesAny"] = 25] = "NoContextRulesAny";
+})(RulesPosition || (RulesPosition = {}));
+// The Rules list contains all the inserted rules into a rulebucket in the following order:
+//    1- Ignore rules with specific token combination
+//    2- Ignore rules with any token combination
+//    3- Context rules with specific token combination
+//    4- Context rules with any token combination
+//    5- Non-context rules with specific token combination
+//    6- Non-context rules with any token combination
+//
+// The member rulesInsertionIndexBitmap is used to describe the number of rules
+// in each sub-bucket (above) hence can be used to know the index of where to insert
+// the next rule. It's a bitmap which contains 6 different sections each is given 5 bits.
+//
+// Example:
+// In order to insert a rule to the end of sub-bucket (3), we get the index by adding
+// the values in the bitmap segments 3rd, 2nd, and 1st.
+function addRule(rules, rule, specificTokens, constructionState, rulesBucketIndex) {
+    const position = rule.action & 3 /* RuleAction.StopAction */ ?
+        specificTokens ? RulesPosition.StopRulesSpecific : RulesPosition.StopRulesAny :
+        rule.context !== anyContext ?
+            specificTokens ? RulesPosition.ContextRulesSpecific : RulesPosition.ContextRulesAny :
+            specificTokens ? RulesPosition.NoContextRulesSpecific : RulesPosition.NoContextRulesAny;
+    const state = constructionState[rulesBucketIndex] || 0;
+    rules.splice(getInsertionIndex(state, position), 0, rule);
+    constructionState[rulesBucketIndex] = increaseInsertionIndex(state, position);
+}
+function getInsertionIndex(indexBitmap, maskPosition) {
+    let index = 0;
+    for (let pos = 0; pos <= maskPosition; pos += maskBitSize) {
+        index += indexBitmap & mask;
+        indexBitmap >>= maskBitSize;
+    }
+    return index;
+}
+function increaseInsertionIndex(indexBitmap, maskPosition) {
+    const value = ((indexBitmap >> maskPosition) & mask) + 1;
+    Debug.assert((value & mask) === value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules.");
+    return (indexBitmap & ~(mask << maskPosition)) | (value << maskPosition);
+}

package/dist/formatting/smartIndenter.d.ts

@@ -0,0 +1,44 @@
+import type { EditorSettings, FormatCodeSettings, Node, NodeArray, SourceFile, SourceFileLike, TextRange } from "../_namespaces/edit.js";
+import type { TextRangeWithKind } from "../_namespaces/ts.formatting.js";
+export declare namespace SmartIndenter {
+    /**
+     * @param assumeNewLineBeforeCloseBrace
+     * `false` when called on text from a real source file.
+     * `true` when we need to assume `position` is on a newline.
+     *
+     * This is useful for codefixes. Consider
+     * ```
+     * function f() {
+     * |}
+     * ```
+     * with `position` at `|`.
+     *
+     * When inserting some text after an open brace, we would like to get indentation as if a newline was already there.
+     * By default indentation at `position` will be 0 so 'assumeNewLineBeforeCloseBrace' overrides this behavior.
+     */
+    function getIndentation(position: number, sourceFile: SourceFile, options: EditorSettings, assumeNewLineBeforeCloseBrace?: boolean): number;
+    function getIndentationForNode(n: Node, ignoreActualIndentationRange: TextRange, sourceFile: SourceFile, options: EditorSettings): number;
+    function getBaseIndentation(options: EditorSettings): number;
+    function isArgumentAndStartLineOverlapsExpressionBeingCalled(parent: Node, child: Node, childStartLine: number, sourceFile: SourceFileLike): boolean;
+    function childStartsOnTheSameLineWithElseInIfStatement(parent: Node, child: TextRangeWithKind, childStartLine: number, sourceFile: SourceFileLike): boolean;
+    function argumentStartsOnSameLineAsPreviousArgument(parent: Node, child: TextRangeWithKind, childStartLine: number, sourceFile: SourceFileLike): boolean;
+    function getContainingList(node: Node, sourceFile: SourceFile): NodeArray<Node> | undefined;
+    /**
+     * Character is the actual index of the character since the beginning of the line.
+     * Column - position of the character after expanding tabs to spaces.
+     * "0\t2$"
+     * value of 'character' for '$' is 3
+     * value of 'column' for '$' is 6 (assuming that tab size is 4)
+     */
+    function findFirstNonWhitespaceCharacterAndColumn(startPos: number, endPos: number, sourceFile: SourceFileLike, options: EditorSettings): {
+        column: number;
+        character: number;
+    };
+    function findFirstNonWhitespaceColumn(startPos: number, endPos: number, sourceFile: SourceFileLike, options: EditorSettings): number;
+    function nodeWillIndentChild(settings: FormatCodeSettings, parent: TextRangeWithKind, child: TextRangeWithKind | undefined, sourceFile: SourceFileLike | undefined, indentByDefault: boolean): boolean;
+    /**
+     * True when the parent node should indent the given child by an explicit rule.
+     * @param isNextChild If true, we are judging indent of a hypothetical child *after* this one, not the current child.
+     */
+    function shouldIndentChildNode(settings: FormatCodeSettings, parent: TextRangeWithKind, child?: Node, sourceFile?: SourceFileLike, isNextChild?: boolean): boolean;
+}