@tslite/services 0.0.0-stage → 1.12.0

package/dist/navigationBar.js

@@ -0,0 +1,549 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/navigationBar.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, InternalSymbolName, SyntaxKind, compareStringsCaseSensitiveUI, compareValues, concatenate, contains, createMap, createTextSpanFromNode, createTextSpanFromRange, declarationNameToString, escapeString, filterMutate, forEachChild, getBaseFileName, getNameOfDeclaration, getNodeKind, getNodeModifiers, getPropertyNameForPropertyNameNode, getTextOfIdentifierOrLiteral, getTextOfNode, hasDynamicName, isAmbientModule, isBinaryExpression, isBindingPattern, isCallExpression, isDeclaration, isElementAccessExpression, isExpression, isExternalModule, isIdentifier, isModuleBlock, isModuleDeclaration, isPropertyAccessExpression, isPropertyAssignment, isPropertyName, isStringLiteralLike, isToken, isVariableDeclaration, map, mapDefined, normalizePath, removeFileExtension, unescapeLeadingUnderscores, } from "./_namespaces/ts.js";
+/**
+ * Matches all whitespace characters in a string. Eg:
+ *
+ * "app.
+ *
+ * onactivated"
+ *
+ * matches because of the newline, whereas
+ *
+ * "app.onactivated"
+ *
+ * does not match.
+ */
+const whiteSpaceRegex = /\s+/g;
+/**
+ * Maximum amount of characters to return
+ * The amount was chosen arbitrarily.
+ */
+const maxLength = 150;
+// Keep sourceFile handy so we don't have to search for it every time we need to call `getText`.
+let curCancellationToken;
+let curSourceFile;
+/**
+ * For performance, we keep navigation bar parents on a stack rather than passing them through each recursion.
+ * `parent` is the current parent and is *not* stored in parentsStack.
+ * `startNode` sets a new parent and `endNode` returns to the previous parent.
+ */
+let parentsStack = [];
+let parent;
+// Na tag, também a pilha das classes ES5 que se acompanhavam: a `function` declarada e o `prototype` de JavaScript
+// (CK-02, CK-03).
+// NavigationBarItem requires an array, but will not mutate it, so just give it this for performance.
+let emptyChildItemArray = [];
+export function getNavigationBarItems(sourceFile, cancellationToken) {
+    curCancellationToken = cancellationToken;
+    curSourceFile = sourceFile;
+    try {
+        return map(primaryNavBarMenuItems(rootNavigationBarNode(sourceFile)), convertToPrimaryNavBarMenuItem);
+    }
+    finally {
+        reset();
+    }
+}
+export function getNavigationTree(sourceFile, cancellationToken) {
+    curCancellationToken = cancellationToken;
+    curSourceFile = sourceFile;
+    try {
+        return convertToTree(rootNavigationBarNode(sourceFile));
+    }
+    finally {
+        reset();
+    }
+}
+function reset() {
+    curSourceFile = undefined;
+    curCancellationToken = undefined;
+    parentsStack = [];
+    parent = undefined;
+    emptyChildItemArray = [];
+}
+function nodeText(node) {
+    return cleanText(node.getText(curSourceFile));
+}
+function navigationBarNodeKind(n) {
+    return n.node.kind;
+}
+function pushChild(parent, child) {
+    if (parent.children) {
+        parent.children.push(child);
+    }
+    else {
+        parent.children = [child];
+    }
+}
+function rootNavigationBarNode(sourceFile) {
+    Debug.assert(!parentsStack.length);
+    const root = { node: sourceFile, name: undefined, additionalNodes: undefined, parent: undefined, children: undefined, indent: 0 };
+    parent = root;
+    for (const statement of sourceFile.statements) {
+        addChildrenRecursively(statement);
+    }
+    endNode();
+    Debug.assert(!parent && !parentsStack.length);
+    return root;
+}
+function addLeafNode(node, name) {
+    pushChild(parent, emptyNavigationBarNode(node, name));
+}
+function emptyNavigationBarNode(node, name) {
+    return {
+        node,
+        name: name || (isDeclaration(node) || isExpression(node) ? getNameOfDeclaration(node) : undefined),
+        additionalNodes: undefined,
+        parent,
+        children: undefined,
+        indent: parent.indent + 1
+    };
+}
+/**
+ * Add a new level of NavigationBarNodes.
+ * This pushes to the stack, so you must call `endNode` when you are done adding to this node.
+ */
+function startNode(node, name) {
+    const navNode = emptyNavigationBarNode(node, name);
+    pushChild(parent, navNode);
+    // Save the old parent
+    parentsStack.push(parent);
+    parent = navNode;
+}
+/** Call after calling `startNode` and adding children to it. */
+function endNode() {
+    if (parent.children) {
+        mergeChildren(parent.children, parent);
+        sortChildren(parent.children);
+    }
+    parent = parentsStack.pop();
+}
+function addNodeWithRecursiveChild(node, child, name) {
+    startNode(node, name);
+    addChildrenRecursively(child);
+    endNode();
+}
+/** Look for navigation bar items in node's subtree, adding them to the current `parent`. */
+function addChildrenRecursively(node) {
+    curCancellationToken.throwIfCancellationRequested();
+    if (!node || isToken(node)) {
+        return;
+    }
+    switch (node.kind) {
+        // Na tag, também o construtor, com as parameter properties, o método e o acessor (CK-02), e a method signature
+        // (CK-36).
+        // Na tag, também a propriedade de classe (CK-02).
+        case SyntaxKind.PropertySignature:
+            if (!hasDynamicName(node)) {
+                addLeafNode(node);
+            }
+            break;
+        case SyntaxKind.ImportClause:
+            const importClause = node;
+            // Handle default import case e.g.:
+            //    import d from "mod";
+            if (importClause.name) {
+                addLeafNode(importClause.name);
+            }
+            // Handle named bindings in imports e.g.:
+            //    import * as NS from "mod";
+            //    import {a, b as B} from "mod";
+            const { namedBindings } = importClause;
+            if (namedBindings) {
+                if (namedBindings.kind === SyntaxKind.NamespaceImport) {
+                    addLeafNode(namedBindings);
+                }
+                else {
+                    for (const element of namedBindings.elements) {
+                        addLeafNode(element);
+                    }
+                }
+            }
+            break;
+        case SyntaxKind.ShorthandPropertyAssignment:
+            addNodeWithRecursiveChild(node, node.name);
+            break;
+        case SyntaxKind.SpreadAssignment:
+            const { expression } = node;
+            // Use the expression as the name of the SpreadAssignment, otherwise show as <unknown>.
+            isIdentifier(expression) ? addLeafNode(node, expression) : addLeafNode(node);
+            break;
+        case SyntaxKind.BindingElement:
+        case SyntaxKind.PropertyAssignment:
+        case SyntaxKind.VariableDeclaration:
+            const { name, initializer } = node;
+            if (isBindingPattern(name)) {
+                addChildrenRecursively(name);
+            }
+            else if (initializer && isFunctionOrClassExpression(initializer)) {
+                // Add a node for the VariableDeclaration, but not for the initializer.
+                startNode(node);
+                forEachChild(initializer, addChildrenRecursively);
+                endNode();
+            }
+            else {
+                addNodeWithRecursiveChild(node, initializer);
+            }
+            break;
+        // Na tag, também a `function` declarada, que se acompanhava como possível classe ES5 (CK-02).
+        case SyntaxKind.ArrowFunction:
+            // Na tag, também a function expression (CK-02).
+            addNodeWithRecursiveChild(node, node.body);
+            break;
+        // Na tag, também o enum, a classe, a class expression e a interface (CK-02).
+        case SyntaxKind.ModuleDeclaration:
+            addNodeWithRecursiveChild(node, getInteriorModule(node).body);
+            break;
+        case SyntaxKind.ExportAssignment:
+        case SyntaxKind.ExportSpecifier:
+        // Na tag, também o `import =` (CK-03).
+        case SyntaxKind.IndexSignature:
+        case SyntaxKind.CallSignature:
+        // Na tag, também a construct signature (CK-02).
+        case SyntaxKind.TypeAliasDeclaration:
+            addLeafNode(node);
+            break;
+        // Na tag, também a atribuição que declara em JavaScript (o `exports.x`, o `module.exports`, o `prototype` e o
+        // `Object.defineProperty`) e a que dava um membro a uma classe ES5 acompanhada (CK-03, CK-02).
+        default:
+            // Na tag, também o typedef e o callback do JSDoc do nó (CK-03).
+            forEachChild(node, addChildrenRecursively);
+    }
+}
+/** Merge declarations of the same kind. */
+function mergeChildren(children, node) {
+    const nameToItems = createMap();
+    filterMutate(children, (child, index) => {
+        const declName = child.name || getNameOfDeclaration(child.node);
+        const name = declName && nodeText(declName);
+        if (!name) {
+            // Anonymous items are never merged.
+            return true;
+        }
+        const itemsWithSameName = nameToItems.get(name);
+        if (!itemsWithSameName) {
+            nameToItems.set(name, child);
+            return true;
+        }
+        if (itemsWithSameName instanceof Array) {
+            for (const itemWithSameName of itemsWithSameName) {
+                if (tryMerge(itemWithSameName, child, index, node)) {
+                    return false;
+                }
+            }
+            itemsWithSameName.push(child);
+            return true;
+        }
+        else {
+            const itemWithSameName = itemsWithSameName;
+            if (tryMerge(itemWithSameName, child, index, node)) {
+                return false;
+            }
+            nameToItems.set(name, [itemWithSameName, child]);
+            return true;
+        }
+    });
+}
+function tryMerge(a, b, _bIndex, parent) {
+    // Na tag, antes, a fusão de uma classe ES5 com os membros dela, que só a `function` declarada e a atribuição de
+    // JavaScript davam (CK-02, CK-03).
+    if (shouldReallyMerge(a.node, b.node, parent)) {
+        merge(a, b);
+        return true;
+    }
+    return false;
+}
+/** a and b have the same name, but they may not be mergeable. */
+function shouldReallyMerge(a, b, parent) {
+    if (a.kind !== b.kind || a.parent !== b.parent && !(isOwnChild(a, parent) && isOwnChild(b, parent))) {
+        return false;
+    }
+    switch (a.kind) {
+        // Na tag, também a propriedade de classe, o método e o acessor, que se fundiam só com o mesmo `static` (CK-02).
+        case SyntaxKind.ModuleDeclaration:
+            return areSameModule(a, b);
+        default:
+            return true;
+    }
+}
+// We want to merge own children like `I` in in `module A { interface I {} } module A { interface I {} }`
+// We don't want to merge unrelated children like `m` in `const o = { a: { m() {} }, b: { m() {} } };`
+function isOwnChild(n, parent) {
+    const par = isModuleBlock(n.parent) ? n.parent.parent : n.parent;
+    return par === parent.node || contains(parent.additionalNodes, par);
+}
+// We use 1 NavNode to represent 'A.B.C', but there are multiple source nodes.
+// Only merge module nodes that have the same chain. Don't merge 'A.B.C' with 'A'!
+function areSameModule(a, b) {
+    // TODO: GH#18217
+    return a.body.kind === b.body.kind && (a.body.kind !== SyntaxKind.ModuleDeclaration || areSameModule(a.body, b.body));
+}
+/** Merge source into target. Source should be thrown away after this is called. */
+function merge(target, source) {
+    target.additionalNodes = target.additionalNodes || [];
+    target.additionalNodes.push(source.node);
+    if (source.additionalNodes) {
+        target.additionalNodes.push(...source.additionalNodes);
+    }
+    target.children = concatenate(target.children, source.children);
+    if (target.children) {
+        mergeChildren(target.children, target);
+        sortChildren(target.children);
+    }
+}
+/** Recursively ensure that each NavNode's children are in sorted order. */
+function sortChildren(children) {
+    children.sort(compareChildren);
+}
+function compareChildren(child1, child2) {
+    return compareStringsCaseSensitiveUI(tryGetName(child1.node), tryGetName(child2.node)) // TODO: GH#18217
+        || compareValues(navigationBarNodeKind(child1), navigationBarNodeKind(child2));
+}
+/**
+ * This differs from getItemName because this is just used for sorting.
+ * We only sort nodes by name that have a more-or-less "direct" name, as opposed to `new()` and the like.
+ * So `new()` can still come before an `aardvark` method.
+ */
+function tryGetName(node) {
+    if (node.kind === SyntaxKind.ModuleDeclaration) {
+        return getModuleName(node);
+    }
+    const declName = getNameOfDeclaration(node);
+    if (declName && isPropertyName(declName)) {
+        const propertyName = getPropertyNameForPropertyNameNode(declName);
+        return propertyName && unescapeLeadingUnderscores(propertyName);
+    }
+    switch (node.kind) {
+        // Na tag, também a function expression e a class expression (CK-02).
+        case SyntaxKind.ArrowFunction:
+            return getFunctionOrClassName(node);
+        default:
+            return undefined;
+    }
+}
+function getItemName(node, name) {
+    if (node.kind === SyntaxKind.ModuleDeclaration) {
+        return cleanText(getModuleName(node));
+    }
+    if (name) {
+        const text = isIdentifier(name) ? name.text
+            : isElementAccessExpression(name) ? `[${nodeText(name.argumentExpression)}]`
+                : nodeText(name);
+        if (text.length > 0) {
+            return cleanText(text);
+        }
+    }
+    switch (node.kind) {
+        case SyntaxKind.SourceFile:
+            const sourceFile = node;
+            return isExternalModule(sourceFile)
+                ? `"${escapeString(getBaseFileName(removeFileExtension(normalizePath(sourceFile.fileName))))}"`
+                : "<global>";
+        case SyntaxKind.ExportAssignment:
+            // Na tag, também o `export =` (CK-03).
+            return InternalSymbolName.Default;
+        // Na tag, também a `function` declarada, a function expression, a classe e a class expression, e o nome
+        // `default` delas com o modificador (CK-02).
+        case SyntaxKind.ArrowFunction:
+            // We may get a string with newlines or other whitespace in the case of an object dereference
+            // (eg: "app\n.onactivated"), so we should remove the whitespace for readabiltiy in the
+            // navigation bar.
+            return getFunctionOrClassName(node);
+        // Na tag, também o construtor e a construct signature (CK-02).
+        case SyntaxKind.CallSignature:
+            return "()";
+        case SyntaxKind.IndexSignature:
+            return "[]";
+        default:
+            return "<unknown>";
+    }
+}
+/** Flattens the NavNode tree to a list of items to appear in the primary navbar menu. */
+function primaryNavBarMenuItems(root) {
+    // The primary (middle) navbar menu displays the general code navigation hierarchy, similar to the navtree.
+    // The secondary (right) navbar menu displays the child items of whichever primary item is selected.
+    // Some less interesting items without their own child navigation items (e.g. a local variable declaration) only show up in the secondary menu.
+    const primaryNavBarMenuItems = [];
+    function recur(item) {
+        if (shouldAppearInPrimaryNavBarMenu(item)) {
+            primaryNavBarMenuItems.push(item);
+            if (item.children) {
+                for (const child of item.children) {
+                    recur(child);
+                }
+            }
+        }
+    }
+    recur(root);
+    return primaryNavBarMenuItems;
+    /** Determines if a node should appear in the primary navbar menu. */
+    function shouldAppearInPrimaryNavBarMenu(item) {
+        // Items with children should always appear in the primary navbar menu.
+        if (item.children) {
+            return true;
+        }
+        // Some nodes are otherwise important enough to always include in the primary navigation menu.
+        switch (navigationBarNodeKind(item)) {
+            // Na tag, também a classe, a class expression, o enum e a interface (CK-02), e o typedef e o callback do
+            // JSDoc (CK-03).
+            case SyntaxKind.ModuleDeclaration:
+            case SyntaxKind.SourceFile:
+            case SyntaxKind.TypeAliasDeclaration:
+                return true;
+            // Na tag, também a `function` declarada e a function expression (CK-02).
+            case SyntaxKind.ArrowFunction:
+                return isTopLevelFunctionDeclaration(item);
+            default:
+                return false;
+        }
+        function isTopLevelFunctionDeclaration(item) {
+            if (!item.node.body) {
+                return false;
+            }
+            switch (navigationBarNodeKind(item.parent)) {
+                case SyntaxKind.ModuleBlock:
+                case SyntaxKind.SourceFile:
+                    // Na tag, também o método e o construtor (CK-02).
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+}
+function convertToTree(n) {
+    return {
+        text: getItemName(n.node, n.name),
+        kind: getNodeKind(n.node),
+        kindModifiers: getModifiers(n.node),
+        spans: getSpans(n),
+        nameSpan: n.name && getNodeSpan(n.name),
+        childItems: map(n.children, convertToTree)
+    };
+}
+function convertToPrimaryNavBarMenuItem(n) {
+    return {
+        text: getItemName(n.node, n.name),
+        kind: getNodeKind(n.node),
+        kindModifiers: getModifiers(n.node),
+        spans: getSpans(n),
+        childItems: map(n.children, convertToSecondaryNavBarMenuItem) || emptyChildItemArray,
+        indent: n.indent,
+        bolded: false,
+        grayed: false
+    };
+    function convertToSecondaryNavBarMenuItem(n) {
+        return {
+            text: getItemName(n.node, n.name),
+            kind: getNodeKind(n.node),
+            kindModifiers: getNodeModifiers(n.node),
+            spans: getSpans(n),
+            childItems: emptyChildItemArray,
+            indent: 0,
+            bolded: false,
+            grayed: false
+        };
+    }
+}
+function getSpans(n) {
+    const spans = [getNodeSpan(n.node)];
+    if (n.additionalNodes) {
+        for (const node of n.additionalNodes) {
+            spans.push(getNodeSpan(node));
+        }
+    }
+    return spans;
+}
+function getModuleName(moduleDeclaration) {
+    // We want to maintain quotation marks.
+    if (isAmbientModule(moduleDeclaration)) {
+        return getTextOfNode(moduleDeclaration.name);
+    }
+    // Otherwise, we need to aggregate each identifier to build up the qualified name.
+    const result = [];
+    result.push(getTextOfIdentifierOrLiteral(moduleDeclaration.name));
+    while (moduleDeclaration.body && moduleDeclaration.body.kind === SyntaxKind.ModuleDeclaration) {
+        moduleDeclaration = moduleDeclaration.body;
+        result.push(getTextOfIdentifierOrLiteral(moduleDeclaration.name));
+    }
+    return result.join(".");
+}
+/**
+ * For 'module A.B.C', we want to get the node for 'C'.
+ * We store 'A' as associated with a NavNode, and use getModuleName to traverse down again.
+ */
+function getInteriorModule(decl) {
+    return decl.body && isModuleDeclaration(decl.body) ? getInteriorModule(decl.body) : decl;
+}
+function getNodeSpan(node) {
+    return node.kind === SyntaxKind.SourceFile ? createTextSpanFromRange(node) : createTextSpanFromNode(node, curSourceFile);
+}
+function getModifiers(node) {
+    if (node.parent && node.parent.kind === SyntaxKind.VariableDeclaration) {
+        node = node.parent;
+    }
+    return getNodeModifiers(node);
+}
+/**
+ * O nome de uma arrow. Na tag, também o da `function` declarada, da function expression e da classe: o nome próprio
+ * delas, o `default` do modificador e o `<class>` da classe anônima (CK-02).
+ */
+function getFunctionOrClassName(node) {
+    const { parent } = node;
+    // See if it is a var initializer. If so, use the var name.
+    if (isVariableDeclaration(parent)) {
+        return cleanText(declarationNameToString(parent.name));
+    }
+    // See if it is of the form "<expr> = function(){...}". If so, use the text from the left-hand side.
+    else if (isBinaryExpression(parent) && parent.operatorToken.kind === SyntaxKind.EqualsToken) {
+        return nodeText(parent.left).replace(whiteSpaceRegex, "");
+    }
+    // See if it is a property assignment, and if so use the property name
+    else if (isPropertyAssignment(parent)) {
+        return nodeText(parent.name);
+    }
+    else if (isCallExpression(parent)) {
+        let name = getCalledExpressionName(parent.expression);
+        if (name !== undefined) {
+            name = cleanText(name);
+            if (name.length > maxLength) {
+                return `${name} callback`;
+            }
+            const args = cleanText(mapDefined(parent.arguments, a => isStringLiteralLike(a) ? a.getText(curSourceFile) : undefined).join(", "));
+            return `${name}(${args}) callback`;
+        }
+    }
+    return "<function>";
+}
+// See also 'tryGetPropertyAccessOrIdentifierToString'
+function getCalledExpressionName(expr) {
+    if (isIdentifier(expr)) {
+        return expr.text;
+    }
+    else if (isPropertyAccessExpression(expr)) {
+        const left = getCalledExpressionName(expr.expression);
+        const right = expr.name.text;
+        return left === undefined ? right : `${left}.${right}`;
+    }
+    else {
+        return undefined;
+    }
+}
+/** A arrow. Na tag, também a function expression e a class expression (CK-02). */
+function isFunctionOrClassExpression(node) {
+    switch (node.kind) {
+        case SyntaxKind.ArrowFunction:
+            return true;
+        default:
+            return false;
+    }
+}
+function cleanText(text) {
+    // Truncate to maximum amount of characters as we don't want to do a big replace operation.
+    text = text.length > maxLength ? text.substring(0, maxLength) + "..." : text;
+    // Replaces ECMAScript line terminators and removes the trailing `\` from each line:
+    // \n - Line Feed
+    // \r - Carriage Return
+    // \u2028 - Line separator
+    // \u2029 - Paragraph separator
+    return text.replace(/\\?(\r?\n|\r|\u2028|\u2029)/g, "");
+}

package/dist/organizeImports.d.ts

@@ -0,0 +1,18 @@
+import { formatting } from "./_namespaces/edit.js";
+import type { CheckResult, ExportDeclaration, Expression, ImportDeclaration, LanguageServiceHost, SourceFile, UserPreferences } from "./_namespaces/edit.js";
+/**
+ * Organize imports by:
+ *   1) Removing unused imports
+ *   2) Coalescing imports from the same module
+ *   3) Sorting imports
+ */
+export declare function organizeImports(sourceFile: SourceFile, formatContext: formatting.FormatContext, host: LanguageServiceHost, program: CheckResult, preferences: UserPreferences): import("./types.js").FileTextChanges[];
+/**
+ * @param importGroup a list of ImportDeclarations, all with the same module name.
+ */
+export declare function coalesceImports(importGroup: readonly ImportDeclaration[]): readonly ImportDeclaration[];
+/**
+ * @param exportGroup a list of ExportDeclarations, all with the same module name.
+ */
+export declare function coalesceExports(exportGroup: readonly ExportDeclaration[]): readonly ExportDeclaration[];
+export declare function compareModuleSpecifiers(m1: Expression, m2: Expression): import("@tslite/parser").Comparison;