@tslite/services 0.0.0-stage → 1.12.0

package/dist/importTracker.js

@@ -0,0 +1,422 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/importTracker.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, InternalSymbolName, ModifierFlags, SymbolFlags, SyntaxKind, cast, createMap, forEach, getFirstIdentifier, getSourceFileOfNode, getSymbolId, hasModifier, importFromModuleSpecifier, isBindingElement, isCatchClause, isDefaultImport, isExportAssignment, isExportDeclaration, isExportSpecifier, isExternalModuleSymbol, isImportTypeNode, isNamedExports, isSourceFile, isStringLiteral, isVariableDeclaration, isVariableStatement, nodeSeenTracker, symbolEscapedNameNoDefault, symbolName, walkUpBindingElementsAndPatterns, } from "./_namespaces/ts.js";
+/** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily.  */
+export function createImportTracker(sourceFiles, sourceFilesSet, checker, cancellationToken) {
+    const allDirectImports = getDirectImportsMap(sourceFiles, checker, cancellationToken);
+    return (exportSymbol, exportInfo, isForRename) => {
+        const { directImports, indirectUsers } = getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, exportInfo, checker, cancellationToken);
+        return { indirectUsers, ...getSearchesFromDirectImports(directImports, exportSymbol, exportInfo.exportKind, checker, isForRename) };
+    };
+}
+/** Na tag, também o `export =` (CK-03). */
+export var ExportKind;
+(function (ExportKind) {
+    ExportKind[ExportKind["Named"] = 0] = "Named";
+    ExportKind[ExportKind["Default"] = 1] = "Default";
+})(ExportKind || (ExportKind = {}));
+export var ImportExport;
+(function (ImportExport) {
+    ImportExport[ImportExport["Import"] = 0] = "Import";
+    ImportExport[ImportExport["Export"] = 1] = "Export";
+})(ImportExport || (ImportExport = {}));
+/**
+ * Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace.
+ * Na tag, o módulo com `export as namespace` (UMD) era acessível de todo arquivo (CK-03).
+ */
+function getImportersForExport(_sourceFiles, _sourceFilesSet, allDirectImports, { exportingModuleSymbol }, checker, cancellationToken) {
+    const markSeenDirectImport = nodeSeenTracker();
+    const markSeenIndirectUser = nodeSeenTracker();
+    const directImports = [];
+    const indirectUserDeclarations = [];
+    handleDirectImports(exportingModuleSymbol);
+    return { directImports, indirectUsers: getIndirectUsers() };
+    function getIndirectUsers() {
+        // Na tag, o `declare module "x"` que aumentava o módulo usava os exports dele sem importá-lo (CK-02); e o módulo
+        // com `export as namespace` era acessível de todo arquivo (CK-03).
+        // This may return duplicates (if there are multiple module declarations in a single source file, all importing the same thing as a namespace), but `State.markSearchedSymbol` will handle that.
+        return indirectUserDeclarations.map(getSourceFileOfNode);
+    }
+    function handleDirectImports(exportingModuleSymbol) {
+        const theseDirectImports = getDirectImports(exportingModuleSymbol);
+        if (theseDirectImports) {
+            for (const direct of theseDirectImports) {
+                if (!markSeenDirectImport(direct)) {
+                    continue;
+                }
+                if (cancellationToken)
+                    cancellationToken.throwIfCancellationRequested();
+                switch (direct.kind) {
+                    case SyntaxKind.CallExpression:
+                        // Na tag, o `const x = require("y")` de um `export =` era um import direto (CK-03).
+                        // Don't support re-exporting 'require()' calls, so just add a single indirect user.
+                        addIndirectUser(direct.getSourceFile());
+                        break;
+                    case SyntaxKind.Identifier: // o `const x = require("y")`
+                        break;
+                    // Na tag, também o `import x = require("y")` (CK-03).
+                    case SyntaxKind.ImportDeclaration:
+                        directImports.push(direct);
+                        const namedBindings = direct.importClause && direct.importClause.namedBindings;
+                        if (namedBindings && namedBindings.kind === SyntaxKind.NamespaceImport) {
+                            handleNamespaceImport(direct, namedBindings.name, /*isReExport*/ false);
+                        }
+                        else if (isDefaultImport(direct)) {
+                            addIndirectUser(getSourceFileLikeForImportDeclaration(direct)); // Add a check for indirect uses to handle synthetic default imports
+                        }
+                        break;
+                    case SyntaxKind.ExportDeclaration:
+                        if (!direct.exportClause) {
+                            // This is `export * from "foo"`, so imports of this module may import the export too.
+                            handleDirectImports(getContainingModuleSymbol(direct, checker));
+                        }
+                        else {
+                            // This is `export { foo } from "foo"` and creates an alias symbol, so recursive search will get handle re-exports.
+                            directImports.push(direct);
+                        }
+                        break;
+                    case SyntaxKind.ImportType:
+                        directImports.push(direct);
+                        break;
+                    default:
+                        Debug.failBadSyntaxKind(direct, "Unexpected import kind.");
+                }
+            }
+        }
+    }
+    /** Na tag, o import de namespace de um `export =` era um import direto (CK-03). */
+    function handleNamespaceImport(importDeclaration, name, isReExport) {
+        const sourceFileLike = getSourceFileLikeForImportDeclaration(importDeclaration);
+        Debug.assert(sourceFileLike.kind === SyntaxKind.SourceFile);
+        if (isReExport || findNamespaceReExports(sourceFileLike, name, checker)) {
+            addIndirectUsers(sourceFileLike);
+        }
+        else {
+            addIndirectUser(sourceFileLike);
+        }
+    }
+    function addIndirectUser(sourceFileLike) {
+        const isNew = markSeenIndirectUser(sourceFileLike);
+        if (isNew) {
+            indirectUserDeclarations.push(sourceFileLike);
+        }
+        return isNew;
+    }
+    /** Adds a module and all of its transitive dependencies as possible indirect users. */
+    function addIndirectUsers(sourceFileLike) {
+        if (!addIndirectUser(sourceFileLike)) {
+            return;
+        }
+        const moduleSymbol = checker.getMergedSymbol(sourceFileLike.symbol);
+        Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module));
+        const directImports = getDirectImports(moduleSymbol);
+        if (directImports) {
+            for (const directImport of directImports) {
+                if (!isImportTypeNode(directImport)) {
+                    addIndirectUsers(getSourceFileLikeForImportDeclaration(directImport));
+                }
+            }
+        }
+    }
+    function getDirectImports(moduleSymbol) {
+        return allDirectImports.get(getSymbolId(moduleSymbol).toString());
+    }
+}
+/**
+ * Given the set of direct imports of a module, we need to find which ones import the particular exported symbol.
+ * The returned `importSearches` will result in the entire source file being searched.
+ * But re-exports will be placed in 'singleReferences' since they cannot be locally referenced.
+ * Na tag, o import de namespace (e o `import x = require()`) de um `export =` era também uma busca (o
+ * `handleNamespaceImportLike`, CK-03).
+ */
+function getSearchesFromDirectImports(directImports, exportSymbol, exportKind, checker, isForRename) {
+    const importSearches = [];
+    const singleReferences = [];
+    function addSearch(location, symbol) {
+        importSearches.push([location, symbol]);
+    }
+    if (directImports) {
+        for (const decl of directImports) {
+            handleImport(decl);
+        }
+    }
+    return { importSearches, singleReferences };
+    function handleImport(decl) {
+        if (decl.kind === SyntaxKind.Identifier) {
+            return;
+        }
+        if (decl.kind === SyntaxKind.ImportType) {
+            if (decl.qualifier) {
+                const firstIdentifier = getFirstIdentifier(decl.qualifier);
+                if (firstIdentifier.escapedText === symbolName(exportSymbol)) {
+                    singleReferences.push(firstIdentifier);
+                }
+            }
+            return;
+        }
+        // Ignore if there's a grammar error
+        if (decl.moduleSpecifier.kind !== SyntaxKind.StringLiteral) {
+            return;
+        }
+        if (decl.kind === SyntaxKind.ExportDeclaration) {
+            if (decl.exportClause && isNamedExports(decl.exportClause)) {
+                searchForNamedImport(decl.exportClause);
+            }
+            return;
+        }
+        const { name, namedBindings } = decl.importClause || { name: undefined, namedBindings: undefined };
+        if (namedBindings) {
+            switch (namedBindings.kind) {
+                case SyntaxKind.NamespaceImport:
+                    break;
+                case SyntaxKind.NamedImports:
+                    // 'default' might be accessed as a named import `{ default as foo }`.
+                    if (exportKind === 0 /* ExportKind.Named */ || exportKind === 1 /* ExportKind.Default */) {
+                        searchForNamedImport(namedBindings);
+                    }
+                    break;
+                default:
+                    Debug.assertNever(namedBindings);
+            }
+        }
+        // If a default import has the same name as the default export, allow to rename it.
+        // Given `import f` and `export default function f`, we will rename both, but for `import g` we will rename just that.
+        if (name && exportKind === 1 /* ExportKind.Default */ && (!isForRename || name.escapedText === symbolEscapedNameNoDefault(exportSymbol))) {
+            const defaultImportAlias = checker.getSymbolAtLocation(name);
+            addSearch(name, defaultImportAlias);
+        }
+    }
+    function searchForNamedImport(namedBindings) {
+        if (!namedBindings) {
+            return;
+        }
+        for (const element of namedBindings.elements) {
+            const { name, propertyName } = element;
+            if (!isNameMatch((propertyName || name).escapedText)) {
+                continue;
+            }
+            if (propertyName) {
+                // This is `import { foo as bar } from "./a"` or `export { foo as bar } from "./a"`. `foo` isn't a local in the file, so just add it as a single reference.
+                singleReferences.push(propertyName);
+                // If renaming `{ foo as bar }`, don't touch `bar`, just `foo`.
+                // But do rename `foo` in ` { default as foo }` if that's the original export name.
+                if (!isForRename || name.escapedText === exportSymbol.escapedName) {
+                    // Search locally for `bar`.
+                    addSearch(name, checker.getSymbolAtLocation(name));
+                }
+            }
+            else {
+                const localSymbol = element.kind === SyntaxKind.ExportSpecifier && element.propertyName
+                    ? checker.getExportSpecifierLocalTargetSymbol(element) // For re-exporting under a different name, we want to get the re-exported symbol.
+                    : checker.getSymbolAtLocation(name);
+                addSearch(name, localSymbol);
+            }
+        }
+    }
+    function isNameMatch(name) {
+        return name === exportSymbol.escapedName || exportKind !== 0 /* ExportKind.Named */ && name === InternalSymbolName.Default;
+    }
+}
+/** Returns 'true' is the namespace 'name' is re-exported from this module, and 'false' if it is only used locally. */
+function findNamespaceReExports(sourceFileLike, name, checker) {
+    const namespaceImportSymbol = checker.getSymbolAtLocation(name);
+    return !!forEachPossibleImportOrExportStatement(sourceFileLike, statement => {
+        if (!isExportDeclaration(statement))
+            return;
+        const { exportClause, moduleSpecifier } = statement;
+        return !moduleSpecifier && exportClause && isNamedExports(exportClause) &&
+            exportClause.elements.some(element => checker.getExportSpecifierLocalTargetSymbol(element) === namespaceImportSymbol);
+    });
+}
+export function findModuleReferences(program, sourceFiles, searchModuleSymbol) {
+    const refs = [];
+    const checker = program.getTypeChecker();
+    for (const referencingFile of sourceFiles) {
+        forEachImport(referencingFile, (_importDecl, moduleSpecifier) => {
+            const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
+            if (moduleSymbol === searchModuleSymbol) {
+                refs.push({ kind: "import", literal: moduleSpecifier });
+            }
+        });
+    }
+    return refs;
+}
+/** Returns a map from a module symbol Id to all import statements that directly reference the module. */
+function getDirectImportsMap(sourceFiles, checker, cancellationToken) {
+    const map = createMap();
+    for (const sourceFile of sourceFiles) {
+        if (cancellationToken)
+            cancellationToken.throwIfCancellationRequested();
+        forEachImport(sourceFile, (importDecl, moduleSpecifier) => {
+            const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
+            if (moduleSymbol) {
+                const id = getSymbolId(moduleSymbol).toString();
+                let imports = map.get(id);
+                if (!imports) {
+                    map.set(id, imports = []);
+                }
+                imports.push(importDecl);
+            }
+        });
+    }
+    return map;
+}
+/**
+ * Iterates over all statements at the top level. Returns the first truthy result. Na tag, também os de dentro de um
+ * `declare module "x"` (CK-02).
+ */
+function forEachPossibleImportOrExportStatement(sourceFileLike, action) {
+    return forEach(sourceFileLike.statements, action);
+}
+/** Calls `action` for each import, re-export, or require() in a file. Na tag, também o `import x = require()` (CK-03). */
+function forEachImport(sourceFile, action) {
+    if (sourceFile.externalModuleIndicator || sourceFile.imports !== undefined) {
+        for (const i of sourceFile.imports) {
+            action(importFromModuleSpecifier(i), i);
+        }
+    }
+    else {
+        forEachPossibleImportOrExportStatement(sourceFile, statement => {
+            switch (statement.kind) {
+                case SyntaxKind.ExportDeclaration:
+                case SyntaxKind.ImportDeclaration: {
+                    const decl = statement;
+                    if (decl.moduleSpecifier && isStringLiteral(decl.moduleSpecifier)) {
+                        action(decl, decl.moduleSpecifier);
+                    }
+                    break;
+                }
+            }
+        });
+    }
+}
+/**
+ * Given a local reference, we might notice that it's an import/export and recursively search for references of that.
+ * If at an import, look locally for the symbol it imports.
+ * If at an export, look for all imports of it.
+ * This doesn't handle export specifiers; that is done in `getReferencesAtExportSpecifier`.
+ * @param comingFromExport If we are doing a search for all exports, don't bother looking backwards for the imported symbol, since that's the reason we're here.
+ */
+export function getImportOrExportSymbol(node, symbol, checker, comingFromExport) {
+    return comingFromExport ? getExport() : getExport() || getImport();
+    function getExport() {
+        const { parent } = node;
+        const grandParent = parent.parent;
+        if (symbol.exportSymbol) {
+            if (parent.kind === SyntaxKind.PropertyAccessExpression) {
+                // Na tag, o export de um módulo JavaScript, declarado pela atribuição a um acesso (CK-03).
+                return undefined;
+            }
+            else {
+                return exportInfo(symbol.exportSymbol, getExportKindForDeclaration(parent));
+            }
+        }
+        else {
+            const exportNode = getExportNode(parent, node);
+            // Na tag, também o `export import X = Y`, que importava o `Y` (CK-03).
+            if (exportNode && hasModifier(exportNode, ModifierFlags.Export)) {
+                return exportInfo(symbol, getExportKindForDeclaration(exportNode));
+            }
+            // If we are in `export default a;`, `parent` is the export assignment.
+            else if (isExportAssignment(parent)) {
+                return getExportAssignmentExport(parent);
+            }
+            // Também quando o `parent.parent` é o export assignment. Na tag, também o `module.exports =`, o `exports.A =`
+            // e o typedef do JSDoc (CK-03).
+            else if (isExportAssignment(grandParent)) {
+                return getExportAssignmentExport(grandParent);
+            }
+        }
+        /** Na tag, também o `export =` (CK-03). */
+        function getExportAssignmentExport(ex) {
+            const exportingModuleSymbol = Debug.checkDefined(ex.symbol.parent, "Expected export symbol to have a parent");
+            return { kind: 1 /* ImportExport.Export */, symbol, exportInfo: { exportingModuleSymbol, exportKind: 1 /* ExportKind.Default */ } };
+        }
+    }
+    function getImport() {
+        const isImport = isNodeImport(node);
+        if (!isImport)
+            return undefined;
+        // A symbol being imported is always an alias. So get what that aliases to find the local symbol.
+        let importedSymbol = checker.getImmediateAliasedSymbol(symbol);
+        if (!importedSymbol)
+            return undefined;
+        // Search on the local symbol in the exporting module, not the exported symbol. Na tag, também passava do símbolo
+        // do `export =` ao valor dele (CK-03).
+        importedSymbol = skipExportSpecifierSymbol(importedSymbol, checker);
+        // If the import has a different name than the export, do not continue searching.
+        // If `importedName` is undefined, do continue searching as the export is anonymous.
+        // (All imports returned from this function will be ignored anyway if we are in rename and this is a not a named export.)
+        const importedName = symbolEscapedNameNoDefault(importedSymbol);
+        if (importedName === undefined || importedName === InternalSymbolName.Default || importedName === symbol.escapedName) {
+            return { kind: 0 /* ImportExport.Import */, symbol: importedSymbol };
+        }
+    }
+    function exportInfo(symbol, kind) {
+        const exportInfo = getExportInfo(symbol, kind, checker);
+        return exportInfo && { kind: 1 /* ImportExport.Export */, symbol, exportInfo };
+    }
+    /**
+     * O tipo de export de uma declaração, fora o export specifier e o export assignment. Na tag, o modificador `default`
+     * dava o `Default`; ele só existia diante da `function` e da classe (CK-02).
+     */
+    function getExportKindForDeclaration(_node) {
+        return 0 /* ExportKind.Named */;
+    }
+}
+// If a reference is a variable declaration, the exported node would be the variable statement. Na tag, também a class
+// expression, cujo nó exportado era o pai (CK-02).
+function getExportNode(parent, node) {
+    const declaration = isVariableDeclaration(parent) ? parent : isBindingElement(parent) ? walkUpBindingElementsAndPatterns(parent) : undefined;
+    if (declaration) {
+        return parent.name !== node ? undefined :
+            isCatchClause(declaration.parent) ? undefined : isVariableStatement(declaration.parent.parent) ? declaration.parent.parent : undefined;
+    }
+    else {
+        return parent;
+    }
+}
+/** Na tag, também o nome do `import x = require()` (CK-03). */
+function isNodeImport(node) {
+    const { parent } = node;
+    switch (parent.kind) {
+        case SyntaxKind.ImportSpecifier:
+            // For a rename import `{ foo as bar }`, don't search for the imported symbol. Just find local uses of `bar`.
+            return !parent.propertyName;
+        case SyntaxKind.ImportClause:
+        case SyntaxKind.NamespaceImport:
+            Debug.assert(parent.name === node);
+            return true;
+        default:
+            return false;
+    }
+}
+export function getExportInfo(exportSymbol, exportKind, checker) {
+    const moduleSymbol = exportSymbol.parent;
+    if (!moduleSymbol)
+        return undefined; // This can happen if an `export` is not at the top-level (which is a compile error).
+    const exportingModuleSymbol = checker.getMergedSymbol(moduleSymbol); // Need to get merged symbol in case there's an augmentation.
+    // `export` may appear in a namespace. In that case, just rely on global search.
+    return isExternalModuleSymbol(exportingModuleSymbol) ? { exportingModuleSymbol, exportKind } : undefined;
+}
+/** If at an export specifier, go to the symbol it refers to. */
+function skipExportSpecifierSymbol(symbol, checker) {
+    // For `export { foo } from './bar", there's nothing to skip, because it does not create a new alias. But `export { foo } does.
+    if (symbol.declarations) {
+        for (const declaration of symbol.declarations) {
+            if (isExportSpecifier(declaration) && !declaration.propertyName && !declaration.parent.parent.moduleSpecifier) {
+                return checker.getExportSpecifierLocalTargetSymbol(declaration);
+            }
+        }
+    }
+    return symbol;
+}
+function getContainingModuleSymbol(importer, checker) {
+    return checker.getMergedSymbol(getSourceFileLikeForImportDeclaration(importer).symbol);
+}
+/** O arquivo do import. Na tag, também o `declare module "x"` em que o import estava (CK-02). */
+function getSourceFileLikeForImportDeclaration(node) {
+    if (node.kind === SyntaxKind.CallExpression) {
+        return node.getSourceFile();
+    }
+    return cast(node.parent, isSourceFile);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./_namespaces/ts.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+// A entrada dos testes deste pacote: reexporta o barril, que é a entrada do pacote (o `exports` do `package.json`). O
+// barril avalia os arquivos na ordem do outFile da tag, e um import direto de um arquivo avaliaria os outros noutra ordem.
+export * from "./_namespaces/ts.js";

package/dist/navigationBar.d.ts

@@ -0,0 +1,3 @@
+import type { CancellationToken, NavigationBarItem, NavigationTree, SourceFile } from "./_namespaces/ts.js";
+export declare function getNavigationBarItems(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationBarItem[];
+export declare function getNavigationTree(sourceFile: SourceFile, cancellationToken: CancellationToken): NavigationTree;