@tslite/services 0.0.0-stage → 1.12.0

package/dist/refactors/convertStringOrTemplateLiteral.js

@@ -0,0 +1,148 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/convertStringOrTemplateLiteral.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, SyntaxKind, copyTrailingAsLeadingComments, copyTrailingComments, createNoSubstitutionTemplateLiteral, createTemplateExpression, createTemplateHead, createTemplateMiddle, createTemplateSpan, createTemplateTail, emptyArray, getLocaleSpecificMessage, getTokenAtPosition, getTrailingCommentRanges, isBinaryExpression, isParenthesizedExpression, isStringLiteral, textChanges, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Convert to template string";
+const refactorDescription = getLocaleSpecificMessage(Diagnostics.Convert_to_template_string);
+registerRefactor(refactorName, { getEditsForAction, getAvailableActions });
+function getAvailableActions(context) {
+    const { file, startPosition } = context;
+    const node = getNodeOrParentOfParentheses(file, startPosition);
+    const maybeBinary = getParentBinaryExpression(node);
+    const refactorInfo = { name: refactorName, description: refactorDescription, actions: [] };
+    if (isBinaryExpression(maybeBinary) && isStringConcatenationValid(maybeBinary)) {
+        refactorInfo.actions.push({ name: refactorName, description: refactorDescription });
+        return [refactorInfo];
+    }
+    return emptyArray;
+}
+function getNodeOrParentOfParentheses(file, startPosition) {
+    const node = getTokenAtPosition(file, startPosition);
+    const nestedBinary = getParentBinaryExpression(node);
+    const isNonStringBinary = !isStringConcatenationValid(nestedBinary);
+    if (isNonStringBinary &&
+        isParenthesizedExpression(nestedBinary.parent) &&
+        isBinaryExpression(nestedBinary.parent.parent)) {
+        return nestedBinary.parent.parent;
+    }
+    return node;
+}
+function getEditsForAction(context, actionName) {
+    const { file, startPosition } = context;
+    const node = getNodeOrParentOfParentheses(file, startPosition);
+    switch (actionName) {
+        case refactorDescription:
+            return { edits: getEditsForToTemplateLiteral(context, node) };
+        default:
+            return Debug.fail("invalid action");
+    }
+}
+function getEditsForToTemplateLiteral(context, node) {
+    const maybeBinary = getParentBinaryExpression(node);
+    const file = context.file;
+    const templateLiteral = nodesToTemplate(treeToArray(maybeBinary), file);
+    const trailingCommentRanges = getTrailingCommentRanges(file.text, maybeBinary.end);
+    if (trailingCommentRanges) {
+        const lastComment = trailingCommentRanges[trailingCommentRanges.length - 1];
+        const trailingRange = { pos: trailingCommentRanges[0].pos, end: lastComment.end };
+        // since suppressTrailingTrivia(maybeBinary) does not work, the trailing comment is removed manually
+        // otherwise it would have the trailing comment twice
+        return textChanges.ChangeTracker.with(context, t => {
+            t.deleteRange(file, trailingRange);
+            t.replaceNode(file, maybeBinary, templateLiteral);
+        });
+    }
+    else {
+        return textChanges.ChangeTracker.with(context, t => t.replaceNode(file, maybeBinary, templateLiteral));
+    }
+}
+function isNotEqualsOperator(node) {
+    return node.operatorToken.kind !== SyntaxKind.EqualsToken;
+}
+function getParentBinaryExpression(expr) {
+    while (isBinaryExpression(expr.parent) && isNotEqualsOperator(expr.parent)) {
+        expr = expr.parent;
+    }
+    return expr;
+}
+function isStringConcatenationValid(node) {
+    const { containsString, areOperatorsValid } = treeToArray(node);
+    return containsString && areOperatorsValid;
+}
+function treeToArray(current) {
+    if (isBinaryExpression(current)) {
+        const { nodes, operators, containsString: leftHasString, areOperatorsValid: leftOperatorValid } = treeToArray(current.left);
+        if (!leftHasString && !isStringLiteral(current.right)) {
+            return { nodes: [current], operators: [], containsString: false, areOperatorsValid: true };
+        }
+        const currentOperatorValid = current.operatorToken.kind === SyntaxKind.PlusToken;
+        const areOperatorsValid = leftOperatorValid && currentOperatorValid;
+        nodes.push(current.right);
+        operators.push(current.operatorToken);
+        return { nodes, operators, containsString: true, areOperatorsValid };
+    }
+    return { nodes: [current], operators: [], containsString: isStringLiteral(current), areOperatorsValid: true };
+}
+// to copy comments following the operator
+// "foo" + /* comment */ "bar"
+const copyTrailingOperatorComments = (operators, file) => (index, targetNode) => {
+    if (index < operators.length) {
+        copyTrailingComments(operators[index], targetNode, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false);
+    }
+};
+// to copy comments following the string
+// "foo" /* comment */ + "bar" /* comment */ + "bar2"
+const copyCommentFromMultiNode = (nodes, file, copyOperatorComments) => (indexes, targetNode) => {
+    while (indexes.length > 0) {
+        const index = indexes.shift();
+        copyTrailingComments(nodes[index], targetNode, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false);
+        copyOperatorComments(index, targetNode);
+    }
+};
+function concatConsecutiveString(index, nodes) {
+    let text = "";
+    const indexes = [];
+    while (index < nodes.length && isStringLiteral(nodes[index])) {
+        const stringNode = nodes[index];
+        text = text + stringNode.text;
+        indexes.push(index);
+        index++;
+    }
+    return [index, text, indexes];
+}
+function nodesToTemplate({ nodes, operators }, file) {
+    const copyOperatorComments = copyTrailingOperatorComments(operators, file);
+    const copyCommentFromStringLiterals = copyCommentFromMultiNode(nodes, file, copyOperatorComments);
+    const [begin, headText, headIndexes] = concatConsecutiveString(0, nodes);
+    if (begin === nodes.length) {
+        const noSubstitutionTemplateLiteral = createNoSubstitutionTemplateLiteral(headText);
+        copyCommentFromStringLiterals(headIndexes, noSubstitutionTemplateLiteral);
+        return noSubstitutionTemplateLiteral;
+    }
+    const templateSpans = [];
+    const templateHead = createTemplateHead(headText);
+    copyCommentFromStringLiterals(headIndexes, templateHead);
+    for (let i = begin; i < nodes.length; i++) {
+        const currentNode = getExpressionFromParenthesesOrExpression(nodes[i]);
+        copyOperatorComments(i, currentNode);
+        const [newIndex, subsequentText, stringIndexes] = concatConsecutiveString(i + 1, nodes);
+        i = newIndex - 1;
+        const templatePart = i === nodes.length - 1 ? createTemplateTail(subsequentText) : createTemplateMiddle(subsequentText);
+        copyCommentFromStringLiterals(stringIndexes, templatePart);
+        templateSpans.push(createTemplateSpan(currentNode, templatePart));
+    }
+    return createTemplateExpression(templateHead, templateSpans);
+}
+// to copy comments following the opening & closing parentheses
+// "foo" + ( /* comment */ 5 + 5 ) /* comment */ + "bar"
+function copyCommentsWhenParenthesized(node) {
+    const file = node.getSourceFile();
+    copyTrailingComments(node, node.expression, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false);
+    copyTrailingAsLeadingComments(node.expression, node.expression, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false);
+}
+function getExpressionFromParenthesesOrExpression(node) {
+    if (isParenthesizedExpression(node)) {
+        copyCommentsWhenParenthesized(node);
+        node = node.expression;
+    }
+    return node;
+}

package/dist/refactors/extractSymbol.d.ts

@@ -0,0 +1,60 @@
+import type { ApplicableRefactorInfo, Diagnostic, DiagnosticMessage, Expression, RefactorContext, RefactorEditInfo, SourceFile, Statement, Symbol, TextSpan } from "../_namespaces/edit.js";
+/**
+ * Compute the associated code actions
+ * Exported for tests.
+ */
+export declare function getAvailableActions(context: RefactorContext): readonly ApplicableRefactorInfo[];
+export declare function getEditsForAction(context: RefactorContext, actionName: string): RefactorEditInfo | undefined;
+export declare namespace Messages {
+    const cannotExtractRange: DiagnosticMessage;
+    const cannotExtractImport: DiagnosticMessage;
+    const cannotExtractEmpty: DiagnosticMessage;
+    const expressionExpected: DiagnosticMessage;
+    const uselessConstantType: DiagnosticMessage;
+    const statementOrExpressionExpected: DiagnosticMessage;
+    const cannotExtractRangeContainingConditionalBreakOrContinueStatements: DiagnosticMessage;
+    const cannotExtractRangeContainingConditionalReturnStatement: DiagnosticMessage;
+    const typeWillNotBeVisibleInTheNewScope: DiagnosticMessage;
+    const cannotExtractIdentifier: DiagnosticMessage;
+    const cannotExtractExportedEntity: DiagnosticMessage;
+    const cannotWriteInExpression: DiagnosticMessage;
+    const cannotExtractAmbientBlock: DiagnosticMessage;
+    const cannotAccessVariablesFromNestedScopes: DiagnosticMessage;
+    const cannotExtractToOtherFunctionLike: DiagnosticMessage;
+    const cannotExtractToExpressionArrowFunction: DiagnosticMessage;
+}
+declare enum RangeFacts {
+    None = 0,
+    HasReturn = 1,
+    IsAsyncFunction = 4
+}
+/**
+ * Represents an expression or a list of statements that should be extracted with some extra information
+ */
+interface TargetRange {
+    readonly range: Expression | Statement[];
+    readonly facts: RangeFacts;
+    /**
+     * A list of symbols that are declared in the selected range which are visible in the containing lexical scope
+     * Used to ensure we don't turn something used outside the range free (or worse, resolve to a different entity).
+     */
+    readonly declarations: Symbol[];
+}
+/**
+ * Result of 'getRangeToExtract' operation: contains either a range or a list of errors
+ */
+type RangeToExtract = {
+    readonly targetRange?: never;
+    readonly errors: readonly Diagnostic[];
+} | {
+    readonly targetRange: TargetRange;
+    readonly errors?: never;
+};
+/**
+ * getRangeToExtract takes a span inside a text file and returns either an expression or an array
+ * of statements representing the minimum set of nodes needed to extract the entire span. This
+ * process may fail, in which case a set of errors is returned instead (these are currently
+ * not shown to the user, but can be used by us diagnostically)
+ */
+export declare function getRangeToExtract(sourceFile: SourceFile, span: TextSpan): RangeToExtract;
+export {};