@tslite/services 0.0.0-stage → 1.13.0

package/dist/rename.js

@@ -0,0 +1,100 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/rename.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, SymbolDisplay, SymbolFlags, SyntaxKind, createTextSpan, endsWith, find, getAdjustedRenameLocation, getLocaleSpecificMessage, getTextOfIdentifierOrLiteral, getTouchingPropertyName, isExternalModuleNameRelative, isIdentifier, isImportOrExportSpecifierName, isLiteralNameOfPropertyDeclarationOrIndexAccess, isSourceFile, isStringLiteralLike, isStringOrNumericLiteralLike, removeFileExtension, stripQuotes, tryGetImportFromModuleSpecifier, tryRemoveSuffix, } from "./_namespaces/ts.js";
+export function getRenameInfo(program, sourceFile, position, options) {
+    const node = getAdjustedRenameLocation(getTouchingPropertyName(sourceFile, position));
+    if (nodeIsEligibleForRename(node)) {
+        const renameInfo = getRenameInfoForNode(node, program.getTypeChecker(), sourceFile, declaration => program.isSourceFileDefaultLibrary(declaration.getSourceFile()), options);
+        if (renameInfo) {
+            return renameInfo;
+        }
+    }
+    return getRenameInfoError(Diagnostics.You_cannot_rename_this_element);
+}
+function getRenameInfoForNode(node, typeChecker, sourceFile, isDefinedInLibraryFile, options) {
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (!symbol)
+        return;
+    // Only allow a symbol to be renamed if it actually has at least one declaration.
+    const { declarations } = symbol;
+    if (!declarations || declarations.length === 0)
+        return;
+    // O que a lib declara não se renomeia. A mensagem é a do que não se renomeia, como a do embutido, que não tem
+    // declaração (CK-48); na tag, ela falava da lib do TypeScript (CK-68).
+    if (declarations.some(isDefinedInLibraryFile)) {
+        return getRenameInfoError(Diagnostics.You_cannot_rename_this_element);
+    }
+    // Cannot rename `default` as in `import { default as foo } from "./someModule";
+    if (isIdentifier(node) && node.originalKeywordKind === SyntaxKind.DefaultKeyword && symbol.parent && symbol.parent.flags & SymbolFlags.Module) {
+        return undefined;
+    }
+    if (isStringLiteralLike(node) && tryGetImportFromModuleSpecifier(node)) {
+        return options && options.allowRenameOfImportPath ? getRenameInfoForModule(node, sourceFile, symbol) : undefined;
+    }
+    const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, node);
+    const specifierName = (isImportOrExportSpecifierName(node) || isStringOrNumericLiteralLike(node) && node.parent.kind === SyntaxKind.ComputedPropertyName)
+        ? stripQuotes(getTextOfIdentifierOrLiteral(node))
+        : undefined;
+    const displayName = specifierName || typeChecker.symbolToString(symbol);
+    const fullDisplayName = specifierName || typeChecker.getFullyQualifiedName(symbol);
+    return getRenameInfoSuccess(displayName, fullDisplayName, kind, SymbolDisplay.getSymbolModifiers(symbol), node, sourceFile);
+}
+function getRenameInfoForModule(node, sourceFile, moduleSymbol) {
+    if (!isExternalModuleNameRelative(node.text)) {
+        return getRenameInfoError(Diagnostics.You_cannot_rename_a_module_via_a_global_import);
+    }
+    const moduleSourceFile = find(moduleSymbol.declarations, isSourceFile);
+    if (!moduleSourceFile)
+        return undefined;
+    const withoutIndex = endsWith(node.text, "/index") || endsWith(node.text, "/index.js") ? undefined : tryRemoveSuffix(removeFileExtension(moduleSourceFile.fileName), "/index");
+    const name = withoutIndex === undefined ? moduleSourceFile.fileName : withoutIndex;
+    const kind = withoutIndex === undefined ? "module" /* ScriptElementKind.moduleElement */ : "directory" /* ScriptElementKind.directory */;
+    const indexAfterLastSlash = node.text.lastIndexOf("/") + 1;
+    // Span should only be the last component of the path. + 1 to account for the quote character.
+    const triggerSpan = createTextSpan(node.getStart(sourceFile) + 1 + indexAfterLastSlash, node.text.length - indexAfterLastSlash);
+    return {
+        canRename: true,
+        fileToRename: name,
+        kind,
+        displayName: name,
+        fullDisplayName: name,
+        kindModifiers: "" /* ScriptElementKindModifier.none */,
+        triggerSpan,
+    };
+}
+function getRenameInfoSuccess(displayName, fullDisplayName, kind, kindModifiers, node, sourceFile) {
+    return {
+        canRename: true,
+        fileToRename: undefined,
+        kind,
+        displayName,
+        fullDisplayName,
+        kindModifiers,
+        triggerSpan: createTriggerSpanForNode(node, sourceFile)
+    };
+}
+function getRenameInfoError(diagnostic) {
+    return { canRename: false, localizedErrorMessage: getLocaleSpecificMessage(diagnostic) };
+}
+function createTriggerSpanForNode(node, sourceFile) {
+    let start = node.getStart(sourceFile);
+    let width = node.getWidth(sourceFile);
+    if (isStringLiteralLike(node)) {
+        // Exclude the quotes
+        start += 1;
+        width -= 2;
+    }
+    return createTextSpan(start, width);
+}
+/** Na tag, também o nome `#private` e o `this` (CK-02). */
+function nodeIsEligibleForRename(node) {
+    switch (node.kind) {
+        case SyntaxKind.Identifier:
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+            return true;
+        case SyntaxKind.NumericLiteral:
+            return isLiteralNameOfPropertyDeclarationOrIndexAccess(node);
+        default:
+            return false;
+    }
+}

package/dist/services.d.ts

@@ -0,0 +1,48 @@
+import { ScriptKind, ScriptTarget } from "./_namespaces/ts.js";
+import type { CancellationToken, DocumentRegistry, EditorOptions, EditorSettings, EmitTextWriter, FormatCodeOptions, FormatCodeSettings, HostCancellationToken, IScriptSnapshot, JsxAttributes, LanguageService, LanguageServiceHost, Node, ObjectLiteralElement, ObjectLiteralExpression, PropertyName, SourceFile, Symbol, SymbolDisplayPart, TextChangeRange, Type, TypeChecker, UnderscoreEscapedMap } from "./_namespaces/ts.js";
+/** A versão da API do language service. */
+export declare const servicesVersion = "0.8";
+export interface DisplayPartsSymbolWriter extends EmitTextWriter {
+    displayParts(): SymbolDisplayPart[];
+}
+export declare function toEditorSettings(options: FormatCodeOptions | FormatCodeSettings): FormatCodeSettings;
+export declare function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings;
+export declare function displayPartsToString(displayParts: SymbolDisplayPart[] | undefined): string;
+export declare function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean, scriptKind?: ScriptKind): SourceFile;
+export declare function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange | undefined, aggressiveChecks?: boolean): SourceFile;
+/** O cancelamento que pergunta ao host no máximo a cada `throttleWaitMilliseconds`: perguntar custa. */
+export declare class ThrottledCancellationToken implements CancellationToken {
+    private hostCancellationToken;
+    private readonly throttleWaitMilliseconds;
+    private lastCancellationCheckTime;
+    constructor(hostCancellationToken: HostCancellationToken, throttleWaitMilliseconds?: number);
+    isCancellationRequested(): boolean;
+    throwIfCancellationRequested(): void;
+}
+/**
+ * A edição que a casca alcança: os namespaces da tag que os métodos de edição do `LanguageService` chamam. Na tag, a casca
+ * os chama direto; aqui ela os alcança por este registro, que o `@tslite/services/edit` faz ao carregar, para quem só lê
+ * não baixar a edição (CK-67), como o completion alcança o auto-import.
+ */
+export interface EditingServices {
+    formatting: typeof import("./_namespaces/ts.formatting.js");
+    codefix: typeof import("./_namespaces/ts.codefix.js");
+    refactor: typeof import("./_namespaces/ts.refactor.js");
+    OrganizeImports: typeof import("./_namespaces/ts.OrganizeImports.js");
+    getEditsForFileRename: typeof import("./getEditsForFileRename.js").getEditsForFileRename;
+}
+/** Registra a edição na casca. O `@tslite/services/edit` o chama ao carregar; o registro vale para o processo. */
+export declare function registerEditingServices(services: EditingServices): void;
+export declare function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry, syntaxOnly?: boolean): LanguageService;
+/** Names in the name table are escaped, so an identifier `__foo` will have a name table entry `___foo`. */
+export declare function getNameTable(sourceFile: SourceFile): UnderscoreEscapedMap<number>;
+/**
+ * Returns the containing object literal property declaration given a possible name node, e.g. "a" in x = { "a": 1 }
+ */
+export declare function getContainingObjectLiteralElement(node: Node): ObjectLiteralElementWithName | undefined;
+export type ObjectLiteralElementWithName = ObjectLiteralElement & {
+    name: PropertyName;
+    parent: ObjectLiteralExpression | JsxAttributes;
+};
+/** Gets all symbols for one property. Does not get symbols for every property. */
+export declare function getPropertySymbolsFromContextualType(node: ObjectLiteralElementWithName, checker: TypeChecker, contextualType: Type, unionSymbolOk: boolean): readonly Symbol[];