@tslite/services 0.0.0-stage → 1.13.0

package/dist/refactors/convertExport.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/refactors/convertExport.js

@@ -0,0 +1,126 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/convertExport.ts: o namespace virou módulo ES, com os imports explícitos.
+// Fica a conversão de um export nomeado em default. Sai a conversão de volta, de um default em nomeado: ela atuava no
+// modificador `default` de uma declaração, que só vinha diante da `function` e da classe (CK-02), e o `export default` que
+// fica é de expressão (CK-46). Saem também a `function`, a classe, a interface e o enum exportados (CK-02).
+import { Debug, Diagnostics, FindAllReferences, InternalSymbolName, ModifierFlags, NodeFlags, SyntaxKind, createExportDefault, createExportSpecifier, createIdentifier, emptyArray, findModifier, first, getModifierFlags, getParentNodeInSpan, getRefactorContextSpan, getTokenAtPosition, isAmbientModule, isIdentifier, isModuleBlock, isSourceFile, textChanges, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Convert export";
+const actionNameNamedToDefault = "Convert named export to default export";
+registerRefactor(refactorName, {
+    getAvailableActions(context) {
+        const info = getInfo(context);
+        if (!info)
+            return emptyArray;
+        const description = Diagnostics.Convert_named_export_to_default_export.message;
+        const actionName = actionNameNamedToDefault;
+        return [{ name: refactorName, description, actions: [{ name: actionName, description }] }];
+    },
+    getEditsForAction(context, actionName) {
+        Debug.assert(actionName === actionNameNamedToDefault, "Unexpected action name");
+        const edits = textChanges.ChangeTracker.with(context, t => doChange(context.file, context.program, Debug.checkDefined(getInfo(context), "context must have info"), t, context.cancellationToken));
+        return { edits, renameFilename: undefined, renameLocation: undefined };
+    },
+});
+function getInfo(context) {
+    const { file } = context;
+    const span = getRefactorContextSpan(context);
+    const token = getTokenAtPosition(file, span.start);
+    const exportNode = getParentNodeInSpan(token, file, span);
+    if (!exportNode || (!isSourceFile(exportNode.parent) && !(isModuleBlock(exportNode.parent) && isAmbientModule(exportNode.parent.parent)))) {
+        return undefined;
+    }
+    const exportingModuleSymbol = isSourceFile(exportNode.parent) ? exportNode.parent.symbol : exportNode.parent.parent.symbol;
+    const flags = getModifierFlags(exportNode);
+    // If source file already has a default export, don't offer refactor.
+    if (!(flags & ModifierFlags.Export) || exportingModuleSymbol.exports.has(InternalSymbolName.Default)) {
+        return undefined;
+    }
+    switch (exportNode.kind) {
+        case SyntaxKind.TypeAliasDeclaration:
+        case SyntaxKind.ModuleDeclaration: {
+            const node = exportNode;
+            return node.name && isIdentifier(node.name) ? { exportNode: node, exportName: node.name, exportingModuleSymbol } : undefined;
+        }
+        case SyntaxKind.VariableStatement: {
+            const vs = exportNode;
+            // Must be `export const x = something;`.
+            if (!(vs.declarationList.flags & NodeFlags.Const) || vs.declarationList.declarations.length !== 1) {
+                return undefined;
+            }
+            const decl = first(vs.declarationList.declarations);
+            if (!decl.initializer)
+                return undefined;
+            return isIdentifier(decl.name) ? { exportNode: vs, exportName: decl.name, exportingModuleSymbol } : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function doChange(exportingSourceFile, program, info, changes, cancellationToken) {
+    changeExport(exportingSourceFile, info, changes, program.getTypeChecker());
+    changeImports(program, info, changes, cancellationToken);
+}
+function changeExport(exportingSourceFile, { exportNode, exportName }, changes, checker) {
+    const exportKeyword = Debug.checkDefined(findModifier(exportNode, SyntaxKind.ExportKeyword), "Should find an export keyword in modifier list");
+    switch (exportNode.kind) {
+        case SyntaxKind.VariableStatement:
+            // If 'x' isn't used in this file, `export const x = 0;` --> `export default 0;`
+            if (!FindAllReferences.Core.isSymbolReferencedInFile(exportName, checker, exportingSourceFile)) {
+                // We checked in `getInfo` that an initializer exists.
+                changes.replaceNode(exportingSourceFile, exportNode, createExportDefault(Debug.checkDefined(first(exportNode.declarationList.declarations).initializer, "Initializer was previously known to be present")));
+                break;
+            }
+        // falls through
+        case SyntaxKind.TypeAliasDeclaration:
+        case SyntaxKind.ModuleDeclaration:
+            // `export type T = number;` -> `type T = number; export default T;`
+            changes.deleteModifier(exportingSourceFile, exportKeyword);
+            changes.insertNodeAfter(exportingSourceFile, exportNode, createExportDefault(createIdentifier(exportName.text)));
+            break;
+        default:
+            Debug.assertNever(exportNode, `Unexpected exportNode kind ${exportNode.kind}`);
+    }
+}
+function changeImports(program, { exportName, exportingModuleSymbol }, changes, cancellationToken) {
+    const checker = program.getTypeChecker();
+    const exportSymbol = Debug.checkDefined(checker.getSymbolAtLocation(exportName), "Export name should resolve to a symbol");
+    FindAllReferences.Core.eachExportReference(program.getSourceFiles(), checker, cancellationToken, exportSymbol, exportingModuleSymbol, exportName.text, /*isDefaultExport*/ false, ref => {
+        const importingSourceFile = ref.getSourceFile();
+        changeNamedToDefaultImport(importingSourceFile, ref, changes);
+    });
+}
+function changeNamedToDefaultImport(importingSourceFile, ref, changes) {
+    const parent = ref.parent;
+    switch (parent.kind) {
+        case SyntaxKind.PropertyAccessExpression:
+            // `a.foo` --> `a.default`
+            changes.replaceNode(importingSourceFile, ref, createIdentifier("default"));
+            break;
+        case SyntaxKind.ImportSpecifier: {
+            // `import { foo } from "./a";` --> `import foo from "./a";`
+            // `import { foo as bar } from "./a";` --> `import bar from "./a";`
+            const defaultImport = createIdentifier(parent.name.text);
+            if (parent.parent.elements.length === 1) {
+                changes.replaceNode(importingSourceFile, parent.parent, defaultImport);
+            }
+            else {
+                changes.delete(importingSourceFile, parent);
+                changes.insertNodeBefore(importingSourceFile, parent.parent, defaultImport);
+            }
+            break;
+        }
+        case SyntaxKind.ExportSpecifier: {
+            // `export { foo } from "./a";` --> `export { default as foo } from "./a";`
+            // `export { foo as bar } from "./a";` --> `export { default as bar } from "./a";`
+            // `export { foo as default } from "./a";` --> `export { default } from "./a";`
+            // (Because `export foo from "./a";` isn't valid syntax.)
+            changes.replaceNode(importingSourceFile, parent, makeExportSpecifier("default", parent.name.text));
+            break;
+        }
+        default:
+            Debug.assertNever(parent, `Unexpected parent kind ${parent.kind}`);
+    }
+}
+function makeExportSpecifier(propertyName, name) {
+    return createExportSpecifier(propertyName === name ? undefined : createIdentifier(propertyName), createIdentifier(name));
+}

package/dist/refactors/convertImport.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/refactors/convertImport.js

@@ -0,0 +1,116 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/convertImport.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, FindAllReferences, ScriptTarget, SymbolFlags, SyntaxKind, cast, createIdentifier, createImportClause, createImportDeclaration, createImportSpecifier, createMap, createNamedImports, createNamespaceImport, createPropertyAccess, createPropertyAssignment, emptyArray, getParentNodeInSpan, getRefactorContextSpan, getTokenAtPosition, getUniqueName, isExportSpecifier, isImportDeclaration, isPropertyAccessExpression, isShorthandPropertyAssignment, isStringLiteral, moduleSpecifierToValidIdentifier, textChanges, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Convert import";
+const actionNameNamespaceToNamed = "Convert namespace import to named imports";
+const actionNameNamedToNamespace = "Convert named imports to namespace import";
+registerRefactor(refactorName, {
+    getAvailableActions(context) {
+        const i = getImportToConvert(context);
+        if (!i)
+            return emptyArray;
+        const description = i.kind === SyntaxKind.NamespaceImport ? Diagnostics.Convert_namespace_import_to_named_imports.message : Diagnostics.Convert_named_imports_to_namespace_import.message;
+        const actionName = i.kind === SyntaxKind.NamespaceImport ? actionNameNamespaceToNamed : actionNameNamedToNamespace;
+        return [{ name: refactorName, description, actions: [{ name: actionName, description }] }];
+    },
+    getEditsForAction(context, actionName) {
+        Debug.assert(actionName === actionNameNamespaceToNamed || actionName === actionNameNamedToNamespace, "Unexpected action name");
+        const edits = textChanges.ChangeTracker.with(context, t => doChange(context.file, context.program, t, Debug.checkDefined(getImportToConvert(context), "Context must provide an import to convert")));
+        return { edits, renameFilename: undefined, renameLocation: undefined };
+    }
+});
+// Can convert imports of the form `import * as m from "m";` or `import d, { x, y } from "m";`.
+function getImportToConvert(context) {
+    const { file } = context;
+    const span = getRefactorContextSpan(context);
+    const token = getTokenAtPosition(file, span.start);
+    const importDecl = getParentNodeInSpan(token, file, span);
+    if (!importDecl || !isImportDeclaration(importDecl))
+        return undefined;
+    const { importClause } = importDecl;
+    return importClause && importClause.namedBindings;
+}
+function doChange(sourceFile, program, changes, toConvert) {
+    const checker = program.getTypeChecker();
+    if (toConvert.kind === SyntaxKind.NamespaceImport) {
+        doChangeNamespaceToNamed(sourceFile, checker, changes, toConvert);
+    }
+    else {
+        doChangeNamedToNamespace(sourceFile, checker, changes, toConvert);
+    }
+}
+// Na tag, o `allowSyntheticDefaultImports` das opções decidia se o namespace usado como valor virava um import default; a
+// configuração fixa o deixa desligado (CK-24), e o import de namespace usado como valor fica.
+function doChangeNamespaceToNamed(sourceFile, checker, changes, toConvert) {
+    let usedAsNamespaceOrDefault = false;
+    const nodesToReplace = [];
+    const conflictingNames = createMap();
+    FindAllReferences.Core.eachSymbolReferenceInFile(toConvert.name, checker, sourceFile, id => {
+        if (!isPropertyAccessExpression(id.parent)) {
+            usedAsNamespaceOrDefault = true;
+        }
+        else {
+            const parent = cast(id.parent, isPropertyAccessExpression);
+            const exportName = parent.name.text;
+            if (checker.resolveName(exportName, id, SymbolFlags.All, /*excludeGlobals*/ true)) {
+                conflictingNames.set(exportName, true);
+            }
+            Debug.assert(parent.expression === id, "Parent expression should match id");
+            nodesToReplace.push(parent);
+        }
+    });
+    // We may need to change `mod.x` to `_x` to avoid a name conflict.
+    const exportNameToImportName = createMap();
+    for (const propertyAccess of nodesToReplace) {
+        const exportName = propertyAccess.name.text;
+        let importName = exportNameToImportName.get(exportName);
+        if (importName === undefined) {
+            exportNameToImportName.set(exportName, importName = conflictingNames.has(exportName) ? getUniqueName(exportName, sourceFile) : exportName);
+        }
+        changes.replaceNode(sourceFile, propertyAccess, createIdentifier(importName));
+    }
+    const importSpecifiers = [];
+    exportNameToImportName.forEach((name, propertyName) => {
+        importSpecifiers.push(createImportSpecifier(name === propertyName ? undefined : createIdentifier(propertyName), createIdentifier(name)));
+    });
+    const importDecl = toConvert.parent.parent;
+    if (usedAsNamespaceOrDefault) {
+        // Need to leave the namespace import alone
+        changes.insertNodeAfter(sourceFile, importDecl, updateImport(importDecl, /*defaultImportName*/ undefined, importSpecifiers));
+    }
+    else {
+        changes.replaceNode(sourceFile, importDecl, updateImport(importDecl, /*defaultImportName*/ undefined, importSpecifiers));
+    }
+}
+function doChangeNamedToNamespace(sourceFile, checker, changes, toConvert) {
+    const importDecl = toConvert.parent.parent;
+    const { moduleSpecifier } = importDecl;
+    const preferredName = moduleSpecifier && isStringLiteral(moduleSpecifier) ? moduleSpecifierToValidIdentifier(moduleSpecifier.text, ScriptTarget.ESNext) : "module";
+    const namespaceNameConflicts = toConvert.elements.some(element => FindAllReferences.Core.eachSymbolReferenceInFile(element.name, checker, sourceFile, id => !!checker.resolveName(preferredName, id, SymbolFlags.All, /*excludeGlobals*/ true)) || false);
+    const namespaceImportName = namespaceNameConflicts ? getUniqueName(preferredName, sourceFile) : preferredName;
+    const neededNamedImports = [];
+    for (const element of toConvert.elements) {
+        const propertyName = (element.propertyName || element.name).text;
+        FindAllReferences.Core.eachSymbolReferenceInFile(element.name, checker, sourceFile, id => {
+            const access = createPropertyAccess(createIdentifier(namespaceImportName), propertyName);
+            if (isShorthandPropertyAssignment(id.parent)) {
+                changes.replaceNode(sourceFile, id.parent, createPropertyAssignment(id.text, access));
+            }
+            else if (isExportSpecifier(id.parent) && !id.parent.propertyName) {
+                if (!neededNamedImports.some(n => n.name === element.name)) {
+                    neededNamedImports.push(createImportSpecifier(element.propertyName && createIdentifier(element.propertyName.text), createIdentifier(element.name.text)));
+                }
+            }
+            else {
+                changes.replaceNode(sourceFile, id, access);
+            }
+        });
+    }
+    changes.replaceNode(sourceFile, toConvert, createNamespaceImport(createIdentifier(namespaceImportName)));
+    if (neededNamedImports.length) {
+        changes.insertNodeAfter(sourceFile, toConvert.parent.parent, updateImport(importDecl, /*defaultImportName*/ undefined, neededNamedImports));
+    }
+}
+function updateImport(old, defaultImportName, elements) {
+    return createImportDeclaration(/*modifiers*/ undefined, createImportClause(defaultImportName, elements && elements.length ? createNamedImports(elements) : undefined), old.moduleSpecifier);
+}

package/dist/refactors/convertParamsToDestructuredObject.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/refactors/convertParamsToDestructuredObject.js

@@ -0,0 +1,282 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/convertParamsToDestructuredObject.ts: o namespace virou módulo ES, com os imports explícitos.
+// Fica a arrow guardada num `const`, que é a função da Linguagem com nome. Saem a `function` declarada, o método, o
+// construtor e a function expression, com a sobrecarga, o modificador `default`, a classe e as referências a ela, o `new`
+// e o parâmetro `this` (CK-02); e o arquivo JavaScript e o JSDoc (CK-03).
+import { Debug, Diagnostics, EmitFlags, FindAllReferences, SyntaxKind, addEmitFlags, compareValues, contains, copyComments, createArrayLiteral, createBindingElement, createNodeArray, createObjectBindingPattern, createObjectLiteral, createParameter, createPropertyAssignment, createPropertySignature, createShorthandPropertyAssignment, createToken, createTypeLiteralNode, deduplicate, emptyArray, equateValues, every, first, flatMap, getContainingFunctionDeclaration, getLocaleSpecificMessage, getSourceFileOfNode, getSymbolTarget, getSynthesizedDeepClone, getTextOfIdentifierOrLiteral, getTouchingToken, getTypeNodeIfAccessible, isCallOrNewExpression, isDeclaration, isElementAccessExpression, isExportAssignment, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceImport, isPropertyAccessExpression, isPropertyAssignment, isRestParameter, isVarConst, isVariableDeclaration, last, map, rangeContainsRange, sortAndDeduplicate, suppressLeadingAndTrailingTrivia, textChanges, tryCast, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Convert parameters to destructured object";
+const minimumParameterLength = 2;
+registerRefactor(refactorName, { getEditsForAction, getAvailableActions });
+function getAvailableActions(context) {
+    const { file, startPosition } = context;
+    const functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, context.program.getTypeChecker());
+    if (!functionDeclaration)
+        return emptyArray;
+    const description = getLocaleSpecificMessage(Diagnostics.Convert_parameters_to_destructured_object);
+    return [{
+            name: refactorName,
+            description,
+            actions: [{
+                    name: refactorName,
+                    description
+                }]
+        }];
+}
+function getEditsForAction(context, actionName) {
+    Debug.assert(actionName === refactorName, "Unexpected action name");
+    const { file, startPosition, program, cancellationToken, host } = context;
+    const functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker());
+    if (!functionDeclaration || !cancellationToken)
+        return undefined;
+    const groupedReferences = getGroupedReferences(functionDeclaration, program, cancellationToken);
+    if (groupedReferences.valid) {
+        const edits = textChanges.ChangeTracker.with(context, t => doChange(file, program, host, t, functionDeclaration, groupedReferences));
+        return { renameFilename: undefined, renameLocation: undefined, edits };
+    }
+    return { edits: [] };
+}
+function doChange(sourceFile, program, host, changes, functionDeclaration, groupedReferences) {
+    const newParamDeclaration = map(createNewParameters(functionDeclaration, program, host), param => getSynthesizedDeepClone(param));
+    changes.replaceNodeRangeWithNodes(sourceFile, first(functionDeclaration.parameters), last(functionDeclaration.parameters), newParamDeclaration, { joiner: ", ",
+        // A tag zerava o recuo para o parâmetro de objeto não recuar quando havia um parâmetro `this` (CK-02).
+        indentation: 0,
+        leadingTriviaOption: textChanges.LeadingTriviaOption.IncludeAll,
+        trailingTriviaOption: textChanges.TrailingTriviaOption.Include
+    });
+    const functionCalls = sortAndDeduplicate(groupedReferences.functionCalls, /*comparer*/ (a, b) => compareValues(a.pos, b.pos));
+    for (const call of functionCalls) {
+        if (call.arguments && call.arguments.length) {
+            const newArgument = getSynthesizedDeepClone(createNewArgument(functionDeclaration, call.arguments), /*includeTrivia*/ true);
+            changes.replaceNodeRange(getSourceFileOfNode(call), first(call.arguments), last(call.arguments), newArgument, { leadingTriviaOption: textChanges.LeadingTriviaOption.IncludeAll, trailingTriviaOption: textChanges.TrailingTriviaOption.Include });
+        }
+    }
+}
+function getGroupedReferences(functionDeclaration, program, cancellationToken) {
+    const functionNames = getFunctionNames(functionDeclaration);
+    const names = deduplicate(functionNames, equateValues);
+    const checker = program.getTypeChecker();
+    const references = flatMap(names, /*mapfn*/ /*mapfn*/ name => FindAllReferences.getReferenceEntriesForNode(-1, name, program, program.getSourceFiles(), cancellationToken));
+    const groupedReferences = groupReferences(references);
+    if (!every(groupedReferences.declarations, /*callback*/ /*callback*/ decl => contains(names, decl))) {
+        groupedReferences.valid = false;
+    }
+    return groupedReferences;
+    function groupReferences(referenceEntries) {
+        const groupedReferences = { functionCalls: [], declarations: [], valid: true };
+        const functionSymbols = map(functionNames, getSymbolTargetAtLocation);
+        for (const entry of referenceEntries) {
+            if (entry.kind !== 1 /* FindAllReferences.EntryKind.Node */) {
+                groupedReferences.valid = false;
+                continue;
+            }
+            // A busca das referências pode dar uma que talvez não seja a da função do refactor: a chamada de um membro de
+            // uma união de tipos que têm, cada um, uma função de mesmo nome. Por isso o símbolo se compara. Na tag, também a
+            // chamada de um construtor por uma subclasse, que tem o símbolo da classe (CK-02).
+            if (contains(functionSymbols, getSymbolTargetAtLocation(entry.node))) {
+                const importOrExportReference = entryToImportOrExport(entry);
+                if (importOrExportReference) {
+                    continue;
+                }
+                const decl = entryToDeclaration(entry);
+                if (decl) {
+                    groupedReferences.declarations.push(decl);
+                    continue;
+                }
+                const call = entryToFunctionCall(entry);
+                if (call) {
+                    groupedReferences.functionCalls.push(call);
+                    continue;
+                }
+            }
+            // Na tag, também as referências à classe de um construtor (CK-02).
+            groupedReferences.valid = false;
+        }
+        return groupedReferences;
+    }
+    function getSymbolTargetAtLocation(node) {
+        const symbol = checker.getSymbolAtLocation(node);
+        return symbol && getSymbolTarget(symbol, checker);
+    }
+}
+function entryToImportOrExport(entry) {
+    const node = entry.node;
+    // Na tag, também o `import =` (CK-03).
+    if (isImportSpecifier(node.parent)
+        || isImportClause(node.parent)
+        || isNamespaceImport(node.parent)) {
+        return node;
+    }
+    if (isExportSpecifier(node.parent) || isExportAssignment(node.parent)) {
+        return node;
+    }
+    return undefined;
+}
+function entryToDeclaration(entry) {
+    if (isDeclaration(entry.node.parent)) {
+        return entry.node;
+    }
+    return undefined;
+}
+function entryToFunctionCall(entry) {
+    if (entry.node.parent) {
+        const functionReference = entry.node;
+        const parent = functionReference.parent;
+        switch (parent.kind) {
+            // foo(...); na tag, também o `super(...)` e o `new Foo(...)` (CK-02)
+            case SyntaxKind.CallExpression:
+                const callOrNewExpression = tryCast(parent, isCallOrNewExpression);
+                if (callOrNewExpression && callOrNewExpression.expression === functionReference) {
+                    return callOrNewExpression;
+                }
+                break;
+            // x.foo(...)
+            case SyntaxKind.PropertyAccessExpression:
+                const propertyAccessExpression = tryCast(parent, isPropertyAccessExpression);
+                if (propertyAccessExpression && propertyAccessExpression.parent && propertyAccessExpression.name === functionReference) {
+                    const callOrNewExpression = tryCast(propertyAccessExpression.parent, isCallOrNewExpression);
+                    if (callOrNewExpression && callOrNewExpression.expression === propertyAccessExpression) {
+                        return callOrNewExpression;
+                    }
+                }
+                break;
+            // x["foo"](...)
+            case SyntaxKind.ElementAccessExpression:
+                const elementAccessExpression = tryCast(parent, isElementAccessExpression);
+                if (elementAccessExpression && elementAccessExpression.parent && elementAccessExpression.argumentExpression === functionReference) {
+                    const callOrNewExpression = tryCast(elementAccessExpression.parent, isCallOrNewExpression);
+                    if (callOrNewExpression && callOrNewExpression.expression === elementAccessExpression) {
+                        return callOrNewExpression;
+                    }
+                }
+                break;
+        }
+    }
+    return undefined;
+}
+function getFunctionDeclarationAtPosition(file, startPosition, checker) {
+    const node = getTouchingToken(file, startPosition);
+    const functionDeclaration = getContainingFunctionDeclaration(node);
+    // Na tag, o refactor não se oferecia no JSDoc de topo de uma função (CK-03).
+    if (functionDeclaration
+        && isValidFunctionDeclaration(functionDeclaration, checker)
+        && rangeContainsRange(functionDeclaration, node)
+        && !(functionDeclaration.body && rangeContainsRange(functionDeclaration.body, node)))
+        return functionDeclaration;
+    return undefined;
+}
+function isValidFunctionDeclaration(functionDeclaration, checker) {
+    if (!isValidParameterNodeArray(functionDeclaration.parameters, checker))
+        return false;
+    switch (functionDeclaration.kind) {
+        case SyntaxKind.ArrowFunction:
+            return isValidVariableDeclaration(functionDeclaration.parent);
+    }
+    return false;
+}
+function isValidParameterNodeArray(parameters, checker) {
+    return parameters.length >= minimumParameterLength
+        && every(parameters, /*callback*/ /*callback*/ paramDecl => isValidParameterDeclaration(paramDecl, checker));
+}
+function isValidParameterDeclaration(parameterDeclaration, checker) {
+    if (isRestParameter(parameterDeclaration)) {
+        const type = checker.getTypeAtLocation(parameterDeclaration);
+        if (!checker.isArrayType(type) && !checker.isTupleType(type))
+            return false;
+    }
+    return !parameterDeclaration.modifiers && isIdentifier(parameterDeclaration.name);
+}
+function isValidVariableDeclaration(node) {
+    return isVariableDeclaration(node) && isVarConst(node) && isIdentifier(node.name) && !node.type;
+}
+function createPropertyOrShorthandAssignment(name, initializer) {
+    if (isIdentifier(initializer) && getTextOfIdentifierOrLiteral(initializer) === name) {
+        return createShorthandPropertyAssignment(name);
+    }
+    return createPropertyAssignment(name, initializer);
+}
+function createNewArgument(functionDeclaration, functionArguments) {
+    const parameters = functionDeclaration.parameters;
+    const hasRestParameter = isRestParameter(last(parameters));
+    const nonRestArguments = hasRestParameter ? functionArguments.slice(0, parameters.length - 1) : functionArguments;
+    const properties = map(nonRestArguments, (arg, i) => {
+        const parameterName = getParameterName(parameters[i]);
+        const property = createPropertyOrShorthandAssignment(parameterName, arg);
+        suppressLeadingAndTrailingTrivia(property.name);
+        if (isPropertyAssignment(property))
+            suppressLeadingAndTrailingTrivia(property.initializer);
+        copyComments(arg, property);
+        return property;
+    });
+    if (hasRestParameter && functionArguments.length >= parameters.length) {
+        const restArguments = functionArguments.slice(parameters.length - 1);
+        const restProperty = createPropertyAssignment(getParameterName(last(parameters)), createArrayLiteral(restArguments));
+        properties.push(restProperty);
+    }
+    const objectLiteral = createObjectLiteral(properties, /*multiLine*/ false);
+    return objectLiteral;
+}
+function createNewParameters(functionDeclaration, program, host) {
+    const checker = program.getTypeChecker();
+    const refactorableParameters = functionDeclaration.parameters;
+    const bindingElements = map(refactorableParameters, createBindingElementFromParameterDeclaration);
+    const objectParameterName = createObjectBindingPattern(bindingElements);
+    const objectParameterType = createParameterTypeNode(refactorableParameters);
+    let objectInitializer;
+    // If every parameter in the original function was optional, add an empty object initializer to the new object parameter
+    if (every(refactorableParameters, isOptionalParameter)) {
+        objectInitializer = createObjectLiteral();
+    }
+    const objectParameter = createParameter(
+    /*modifiers*/ undefined, 
+    /*dotDotDotToken*/ undefined, objectParameterName, 
+    /*questionToken*/ undefined, objectParameterType, objectInitializer);
+    return createNodeArray([objectParameter]);
+    function createBindingElementFromParameterDeclaration(parameterDeclaration) {
+        const element = createBindingElement(
+        /*dotDotDotToken*/ undefined, 
+        /*propertyName*/ undefined, getParameterName(parameterDeclaration), isRestParameter(parameterDeclaration) && isOptionalParameter(parameterDeclaration) ? createArrayLiteral() : parameterDeclaration.initializer);
+        suppressLeadingAndTrailingTrivia(element);
+        if (parameterDeclaration.initializer && element.initializer) {
+            copyComments(parameterDeclaration.initializer, element.initializer);
+        }
+        return element;
+    }
+    function createParameterTypeNode(parameters) {
+        const members = map(parameters, createPropertySignatureFromParameterDeclaration);
+        const typeNode = addEmitFlags(createTypeLiteralNode(members), EmitFlags.SingleLine);
+        return typeNode;
+    }
+    function createPropertySignatureFromParameterDeclaration(parameterDeclaration) {
+        let parameterType = parameterDeclaration.type;
+        if (!parameterType && (parameterDeclaration.initializer || isRestParameter(parameterDeclaration))) {
+            parameterType = getTypeNode(parameterDeclaration);
+        }
+        const propertySignature = createPropertySignature(
+        /*modifiers*/ undefined, getParameterName(parameterDeclaration), isOptionalParameter(parameterDeclaration) ? createToken(SyntaxKind.QuestionToken) : parameterDeclaration.questionToken, parameterType, 
+        /*initializer*/ undefined);
+        suppressLeadingAndTrailingTrivia(propertySignature);
+        copyComments(parameterDeclaration.name, propertySignature.name);
+        if (parameterDeclaration.type && propertySignature.type) {
+            copyComments(parameterDeclaration.type, propertySignature.type);
+        }
+        return propertySignature;
+    }
+    function getTypeNode(node) {
+        const type = checker.getTypeAtLocation(node);
+        return getTypeNodeIfAccessible(type, node, program, host);
+    }
+    function isOptionalParameter(parameterDeclaration) {
+        if (isRestParameter(parameterDeclaration)) {
+            const type = checker.getTypeAtLocation(parameterDeclaration);
+            return !checker.isTupleType(type);
+        }
+        return checker.isOptionalParameter(parameterDeclaration);
+    }
+}
+function getParameterName(paramDeclaration) {
+    return getTextOfIdentifierOrLiteral(paramDeclaration.name);
+}
+// Na tag, um `switch` pelo tipo da função; a arrow é o único que fica (CK-02).
+function getFunctionNames(functionDeclaration) {
+    return [functionDeclaration.parent.name];
+}

package/dist/refactors/convertStringOrTemplateLiteral.d.ts

@@ -0,0 +1 @@
+export {};