@staff0rd/assist 0.170.2 → 0.170.3

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.170.2",
+  version: "0.170.3",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -7996,7 +7996,7 @@ function isNameReferencedInSource(sourceFile, name) {
 }
 async function applyExtraction(functionName, sourceFile, destPath, plan2, project) {
   project.createSourceFile(destPath, plan2.destContent, { overwrite: false });
-  for (const fn of [plan2.target, ...plan2.dependencies]) {
+  for (const fn of [plan2.target, ...plan2.functionsToRemove]) {
     fn.remove();
   }
   for (const stmt of plan2.statementsToRemove) {
@@ -8033,7 +8033,7 @@ async function applyExtraction(functionName, sourceFile, destPath, plan2, projec
 
 // src/commands/refactor/extract/collectDependencies.ts
 import {
-  SyntaxKind as SyntaxKind5
+  SyntaxKind as SyntaxKind7
 } from "ts-morph";
 
 // src/commands/refactor/extract/collectPrivateFunctions.ts
@@ -8072,6 +8072,41 @@ function collectPrivateFunctions(target, fnMap) {
   });
 }
 
+// src/commands/refactor/extract/collectPrivateStatements.ts
+import { SyntaxKind as SyntaxKind5 } from "ts-morph";
+function getReferencedIdentifiers(fn) {
+  const names = /* @__PURE__ */ new Set();
+  for (const id of fn.getDescendantsOfKind(SyntaxKind5.Identifier)) {
+    names.add(id.getText());
+  }
+  return names;
+}
+function collectPrivateStatements(functions, stmtMap) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const fn of functions) {
+    for (const name of getReferencedIdentifiers(fn)) {
+      const stmt = stmtMap.get(name);
+      if (stmt) seen.add(stmt);
+    }
+  }
+  return [...seen];
+}
+
+// src/commands/refactor/extract/getFunctionMap.ts
+import {
+  SyntaxKind as SyntaxKind6
+} from "ts-morph";
+function getFunctionMap(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const fn of sourceFile.getDescendantsOfKind(
+    SyntaxKind6.FunctionDeclaration
+  )) {
+    const name = fn.getName();
+    if (name) map.set(name, fn);
+  }
+  return map;
+}
+
 // src/commands/refactor/extract/getPrivateStatementMap.ts
 function getPrivateStatementMap(sourceFile) {
   const map = /* @__PURE__ */ new Map();
@@ -8089,73 +8124,61 @@ function getPrivateStatementMap(sourceFile) {
 }
 
 // src/commands/refactor/extract/collectDependencies.ts
-function getReferencedIdentifiers(fn) {
-  const names = /* @__PURE__ */ new Set();
-  for (const id of fn.getDescendantsOfKind(SyntaxKind5.Identifier)) {
-    names.add(id.getText());
-  }
-  return names;
-}
-function getFunctionMap(sourceFile) {
-  const map = /* @__PURE__ */ new Map();
-  for (const fn of sourceFile.getDescendantsOfKind(
-    SyntaxKind5.FunctionDeclaration
-  )) {
-    const name = fn.getName();
-    if (name) map.set(name, fn);
-  }
-  return map;
+function getRemainingFunctions(sourceFile, extracted) {
+  return sourceFile.getDescendantsOfKind(SyntaxKind7.FunctionDeclaration).filter((fn) => !extracted.has(fn));
 }
-function collectPrivateStatements(functions, stmtMap) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const fn of functions) {
-    for (const name of getReferencedIdentifiers(fn)) {
-      const stmt = stmtMap.get(name);
-      if (stmt) seen.add(stmt);
+function collectFnsUsedByRemaining(remaining, fnMap) {
+  const used = /* @__PURE__ */ new Set();
+  for (const fn of remaining) {
+    for (const dep of collectPrivateFunctions(fn, fnMap)) {
+      used.add(dep);
     }
   }
-  return [...seen];
-}
-function getRemainingFunctions(sourceFile, extracted) {
-  return sourceFile.getDescendantsOfKind(SyntaxKind5.FunctionDeclaration).filter((fn) => !extracted.has(fn));
+  return used;
 }
 function collectDependencies(target, sourceFile) {
   const fnMap = getFunctionMap(sourceFile);
   const depFunctions = collectPrivateFunctions(target, fnMap);
   const allExtracted = [target, ...depFunctions];
   const stmtMap = getPrivateStatementMap(sourceFile);
-  const toCopy = collectPrivateStatements(allExtracted, stmtMap);
-  const extractedSet = new Set(allExtracted);
-  const remaining = getRemainingFunctions(sourceFile, extractedSet);
-  const usedByRemaining = new Set(collectPrivateStatements(remaining, stmtMap));
-  const toRemove = toCopy.filter((s) => !usedByRemaining.has(s));
+  const stmtsToCopy = collectPrivateStatements(allExtracted, stmtMap);
+  const remaining = getRemainingFunctions(sourceFile, new Set(allExtracted));
+  const fnsUsedByRemaining = collectFnsUsedByRemaining(remaining, fnMap);
+  const fnsToRemove = depFunctions.filter((fn) => !fnsUsedByRemaining.has(fn));
+  const staysInSource = [
+    ...remaining,
+    ...depFunctions.filter((fn) => fnsUsedByRemaining.has(fn))
+  ];
+  const stmtsToRemove = stmtsToCopy.filter(
+    (s) => !new Set(collectPrivateStatements(staysInSource, stmtMap)).has(s)
+  );
   return {
-    functions: depFunctions,
-    statements: { toCopy, toRemove }
+    functions: { toCopy: depFunctions, toRemove: fnsToRemove },
+    statements: { toCopy: stmtsToCopy, toRemove: stmtsToRemove }
   };
 }
 
 // src/commands/refactor/extract/findFunction.ts
 import {
-  SyntaxKind as SyntaxKind6
+  SyntaxKind as SyntaxKind8
 } from "ts-morph";
 function findFunction(sourceFile, functionName) {
-  return sourceFile.getDescendantsOfKind(SyntaxKind6.FunctionDeclaration).find((fn) => fn.getName() === functionName);
+  return sourceFile.getDescendantsOfKind(SyntaxKind8.FunctionDeclaration).find((fn) => fn.getName() === functionName);
 }
 
 // src/commands/refactor/extract/getExportedDependencyNames.ts
-import { SyntaxKind as SyntaxKind7 } from "ts-morph";
+import { SyntaxKind as SyntaxKind9 } from "ts-morph";
 function getExportedDependencyNames(target, sourceFile) {
   const calledNames = /* @__PURE__ */ new Set();
-  for (const call of target.getDescendantsOfKind(SyntaxKind7.CallExpression)) {
+  for (const call of target.getDescendantsOfKind(SyntaxKind9.CallExpression)) {
     const expr = call.getExpression();
-    if (expr.getKind() === SyntaxKind7.Identifier) {
+    if (expr.getKind() === SyntaxKind9.Identifier) {
       calledNames.add(expr.getText());
     }
   }
   const exported = [];
   for (const fn of sourceFile.getDescendantsOfKind(
-    SyntaxKind7.FunctionDeclaration
+    SyntaxKind9.FunctionDeclaration
   )) {
     const name = fn.getName();
     if (name && calledNames.has(name) && fn.isExported()) {
@@ -8166,9 +8189,9 @@ function getExportedDependencyNames(target, sourceFile) {
 }
 
 // src/commands/refactor/extract/getStatementNames.ts
-import { SyntaxKind as SyntaxKind8 } from "ts-morph";
+import { SyntaxKind as SyntaxKind10 } from "ts-morph";
 function getStatementNames(node) {
-  if (node.getKind() === SyntaxKind8.VariableStatement) {
+  if (node.getKind() === SyntaxKind10.VariableStatement) {
     const stmt = node;
     return stmt.getDeclarations().map((d) => d.getName());
   }
@@ -8178,7 +8201,7 @@ function getStatementNames(node) {
 
 // src/commands/refactor/extract/resolveImports.ts
 import {
-  SyntaxKind as SyntaxKind9
+  SyntaxKind as SyntaxKind11
 } from "ts-morph";
 
 // src/commands/refactor/extract/matchImport.ts
@@ -8222,7 +8245,7 @@ function matchImport(importDecl, neededNames) {
 function getReferencedNames(nodes) {
   const names = /* @__PURE__ */ new Set();
   for (const node of nodes) {
-    for (const id of node.getDescendantsOfKind(SyntaxKind9.Identifier)) {
+    for (const id of node.getDescendantsOfKind(SyntaxKind11.Identifier)) {
       names.add(id.getText());
     }
   }
@@ -8237,7 +8260,7 @@ function getLocallyDeclaredNames(functions) {
       names.add(param.getName());
     }
     for (const varDecl of fn.getDescendantsOfKind(
-      SyntaxKind9.VariableDeclaration
+      SyntaxKind11.VariableDeclaration
     )) {
       names.add(varDecl.getName());
     }
@@ -8274,26 +8297,24 @@ function extractTexts(target, allFunctions, statements) {
 function analyseTarget(sourceFile, functionName) {
   const target = findFunction(sourceFile, functionName);
   if (!target) throw new Error(`Function "${functionName}" not found`);
-  const { functions: dependencies, statements } = collectDependencies(
-    target,
-    sourceFile
-  );
-  const all = [target, ...dependencies];
+  const { functions, statements } = collectDependencies(target, sourceFile);
+  const all = [target, ...functions.toCopy];
   return {
     target,
-    dependencies,
+    dependencies: functions.toCopy,
+    functionsToRemove: functions.toRemove,
     statementsToCopy: statements.toCopy,
     statementsToRemove: statements.toRemove,
     imports: resolveImports(
       target,
-      dependencies,
+      functions.toCopy,
       sourceFile,
       statements.toCopy
     ),
     exportedDeps: getExportedDependencyNames(target, sourceFile),
     extractedNames: [
       ...statements.toRemove.flatMap(getStatementNames),
-      ...all.map((fn) => fn.getName()).filter(Boolean)
+      ...[target, ...functions.toRemove].map((fn) => fn.getName()).filter(Boolean)
     ],
     functionTexts: extractTexts(target, all, statements.toCopy)
   };
@@ -8394,16 +8415,16 @@ function rewriteImportPaths(imports, sourcePath, destPath) {
 }
 
 // src/commands/refactor/extract/sourceReferencesName.ts
-import { SyntaxKind as SyntaxKind10 } from "ts-morph";
+import { SyntaxKind as SyntaxKind12 } from "ts-morph";
 var DECLARATION_KINDS = /* @__PURE__ */ new Set([
-  SyntaxKind10.FunctionDeclaration,
-  SyntaxKind10.ImportSpecifier,
-  SyntaxKind10.ExportSpecifier
+  SyntaxKind12.FunctionDeclaration,
+  SyntaxKind12.ImportSpecifier,
+  SyntaxKind12.ExportSpecifier
 ]);
 function isInsideExtractedFunction(node, extracted) {
   let current = node;
   while (current) {
-    if (current.getKind() !== SyntaxKind10.FunctionDeclaration) {
+    if (current.getKind() !== SyntaxKind12.FunctionDeclaration) {
       current = current.getParent();
       continue;
     }
@@ -8415,7 +8436,7 @@ function isInsideExtractedFunction(node, extracted) {
 }
 function sourceReferencesName(sourceFile, functionName, extractedNames) {
   const extracted = new Set(extractedNames);
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind10.Identifier)) {
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind12.Identifier)) {
     if (id.getText() !== functionName) continue;
     const parent = id.getParent();
     if (!parent || DECLARATION_KINDS.has(parent.getKind())) continue;
@@ -8620,24 +8641,24 @@ import chalk107 from "chalk";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
-import { SyntaxKind as SyntaxKind11 } from "ts-morph";
+import { SyntaxKind as SyntaxKind13 } from "ts-morph";
 var declarationKinds = [
-  SyntaxKind11.VariableDeclaration,
-  SyntaxKind11.FunctionDeclaration,
-  SyntaxKind11.ClassDeclaration,
-  SyntaxKind11.InterfaceDeclaration,
-  SyntaxKind11.TypeAliasDeclaration,
-  SyntaxKind11.EnumDeclaration,
-  SyntaxKind11.PropertyDeclaration,
-  SyntaxKind11.MethodDeclaration,
-  SyntaxKind11.Parameter
+  SyntaxKind13.VariableDeclaration,
+  SyntaxKind13.FunctionDeclaration,
+  SyntaxKind13.ClassDeclaration,
+  SyntaxKind13.InterfaceDeclaration,
+  SyntaxKind13.TypeAliasDeclaration,
+  SyntaxKind13.EnumDeclaration,
+  SyntaxKind13.PropertyDeclaration,
+  SyntaxKind13.MethodDeclaration,
+  SyntaxKind13.Parameter
 ];
 function isDeclaration(identifier) {
   const parent = identifier.getParent();
   return parent !== void 0 && declarationKinds.includes(parent.getKind());
 }
 function findSymbol(sourceFile, symbolName) {
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind11.Identifier)) {
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind13.Identifier)) {
     if (id.getText() === symbolName && isDeclaration(id)) return id;
   }
   return void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.170.2",
+	"version": "0.170.3",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {