expose-kit 0.6.0 → 0.8.0

package/README.md

@@ -258,6 +258,69 @@ Notes:
 
 ---
 
+### `expose remove-updater`
+
+Replace safe update expressions with += or -=.
+```js
+// before
+a++;
+--b;
+// after
+a += 1;
+b -= 1;
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/remove-updater/mocks).
+
+```bash
+expose remove-updater path/to/file.js --output path/to/file.remove-updater.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Only replaces update expressions whose value is not used.
+- Safe for expression statements and for-loop update clauses.
+
+---
+
+### `expose remove-reassign`
+
+Inline safe alias assignments and wrapper calls.
+```js
+const a = 0;
+const b = a;
+const c = b;
+console.log(c); // => console.log(a);
+```
+```js
+function a(arg) {
+  return b(arg);
+}
+function c(arg) {
+  return d[arg];
+}
+a(0); // => b(0)
+c(0); // => d[0]
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/remove-reassign/mocks).
+
+```bash
+expose remove-reassign path/to/file.js --output path/to/file.remove-reassign.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Only inlines const/immutable alias chains.
+- Skips object shorthand replacements and shadowed bindings.
+- Wrapper inlining is limited to single-return passthroughs.
+
+---
+
 ### `expose remove-unused`
 
 Remove unused variabless.

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // index.ts
 import { Command } from "commander";
-import { dirname as dirname7, join as join7 } from "path";
+import { dirname as dirname9, join as join9 } from "path";
 import { fileURLToPath } from "url";
 import chalk4 from "chalk";
 
@@ -1217,7 +1217,7 @@ var pre_evaluate_default = createCommand((program2) => {
   );
 });
 
-// commands/remove-unused/index.ts
+// commands/remove-updater/index.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import { basename as basename6, dirname as dirname6, extname as extname6, join as join6 } from "path";
 import { parse as parse7 } from "@babel/parser";
@@ -1228,19 +1228,353 @@ import loading7 from "loading-cli";
 var createDefaultOutputPath6 = (inputPath) => {
   const ext = extname6(inputPath);
   if (!ext) {
-    return `${inputPath}.remove-unused.js`;
+    return `${inputPath}.remove-updater.js`;
   }
   const base = basename6(inputPath, ext);
-  return join6(dirname6(inputPath), `${base}.remove-unused${ext}`);
+  return join6(dirname6(inputPath), `${base}.remove-updater${ext}`);
 };
-var removeUnusedVariables = (code, filename) => {
+var isSafeStandaloneUpdate = (path) => {
+  const parent = path.parentPath;
+  if (!parent) return false;
+  if (parent.isExpressionStatement()) return true;
+  if (parent.isForStatement() && path.key === "update") return true;
+  return false;
+};
+var removeUpdaters = (code, filename) => {
   const ast = parse7(code, createParseOptions(filename));
-  let changed = false;
+  let replacedCount = 0;
   patchDefault(traverse6)(ast, {
+    UpdateExpression(path) {
+      if (!isSafeStandaloneUpdate(path)) return;
+      const operator = path.node.operator === "++" ? "+=" : "-=";
+      const left = t5.cloneNode(path.node.argument, true);
+      const replacement = t5.assignmentExpression(
+        operator,
+        left,
+        t5.numericLiteral(1)
+      );
+      path.replaceWith(replacement);
+      replacedCount += 1;
+    }
+  });
+  return {
+    code: patchDefault(generate6)(ast).code,
+    replacedCount
+  };
+};
+var remove_updater_default = createCommand((program2) => {
+  program2.command("remove-updater").description("Replace safe update expressions with += or -=").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--o, --output <file>", "Output file path").option("--unlimited", "Unlimited timeout").action(
+    async (fileArgument, options) => {
+      await timeout(
+        async ({ finish }) => {
+          const filename = fileArgument ?? options.file ?? await createPrompt("Enter the file path:");
+          if (!filename) {
+            showError("No file provided");
+            return finish();
+          }
+          try {
+            const fileContent = readFileSync7(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath6(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading7("Removing update expressions...").start();
+            try {
+              const { code: output, replacedCount } = removeUpdaters(
+                fileContent,
+                filename
+              );
+              writeFileSync6(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved remove-updater file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} updates replaced)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply remove-updater transform");
+              showError(
+                `Error transforming file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+              );
+              return finish();
+            }
+          } catch (error) {
+            showError(
+              `Error reading file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+            return finish();
+          }
+        },
+        options.unlimited ? null : 120 * 1e3
+      );
+    }
+  );
+});
+
+// commands/remove-reassign/index.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename7, dirname as dirname7, extname as extname7, join as join7 } from "path";
+import { parse as parse8 } from "@babel/parser";
+import traverse7 from "@babel/traverse";
+import generate7 from "@babel/generator";
+import * as t6 from "@babel/types";
+import loading8 from "loading-cli";
+var createDefaultOutputPath7 = (inputPath) => {
+  const ext = extname7(inputPath);
+  if (!ext) {
+    return `${inputPath}.remove-reassign.js`;
+  }
+  const base = basename7(inputPath, ext);
+  return join7(dirname7(inputPath), `${base}.remove-reassign${ext}`);
+};
+var isShorthandObjectKey = (path) => {
+  const parent = path.parentPath;
+  if (!parent || !parent.isObjectProperty()) return false;
+  return parent.node.shorthand && parent.get("key") === path;
+};
+var resolveFinalAlias = (binding, getBinding) => {
+  const visited = /* @__PURE__ */ new Set();
+  let currentBinding = binding;
+  let currentName = null;
+  while (currentBinding && !visited.has(currentBinding)) {
+    visited.add(currentBinding);
+    if (!t6.isVariableDeclarator(currentBinding.path.node)) break;
+    const init = currentBinding.path.node.init;
+    if (!init || !t6.isIdentifier(init)) break;
+    const nextBinding = getBinding(init.name);
+    if (!nextBinding || !nextBinding.constant) break;
+    currentBinding = nextBinding;
+    currentName = init.name;
+  }
+  if (!currentBinding || !currentName) {
+    return null;
+  }
+  return { targetBinding: currentBinding, targetName: currentName };
+};
+var getReturnExpression = (functionPath) => {
+  const body = functionPath.node.body;
+  if (!t6.isBlockStatement(body)) {
+    return body;
+  }
+  if (body.body.length !== 1) return null;
+  const statement = body.body[0];
+  if (!t6.isReturnStatement(statement) || !statement.argument) return null;
+  return statement.argument;
+};
+var getWrapperInfo = (functionPath, wrapperBinding) => {
+  const params = functionPath.node.params;
+  if (params.length === 0) return null;
+  const paramNames = [];
+  for (const param of params) {
+    if (!t6.isIdentifier(param)) return null;
+    paramNames.push(param.name);
+  }
+  const expression = getReturnExpression(functionPath);
+  if (!expression) return null;
+  if (t6.isCallExpression(expression)) {
+    if (!t6.isIdentifier(expression.callee)) return null;
+    if (expression.arguments.length !== paramNames.length) return null;
+    for (let i = 0; i < expression.arguments.length; i++) {
+      const arg = expression.arguments[i];
+      if (!t6.isIdentifier(arg)) return null;
+      if (arg.name !== paramNames[i]) return null;
+    }
+    const targetBinding = functionPath.scope.getBinding(expression.callee.name);
+    if (!targetBinding) return null;
+    return {
+      kind: "call",
+      wrapperBinding,
+      targetName: expression.callee.name,
+      targetBinding,
+      paramNames
+    };
+  }
+  if (t6.isMemberExpression(expression) && expression.computed && t6.isIdentifier(expression.object) && t6.isIdentifier(expression.property) && paramNames.length === 1 && expression.property.name === paramNames[0]) {
+    const targetBinding = functionPath.scope.getBinding(expression.object.name);
+    if (!targetBinding) return null;
+    return {
+      kind: "member",
+      wrapperBinding,
+      targetName: expression.object.name,
+      targetBinding
+    };
+  }
+  return null;
+};
+var removeReassign = (code, filename) => {
+  const ast = parse8(code, createParseOptions(filename));
+  const aliases = [];
+  const wrappers = [];
+  patchDefault(traverse7)(ast, {
+    VariableDeclarator(path) {
+      if (!t6.isIdentifier(path.node.id)) return;
+      if (!path.node.init || !t6.isIdentifier(path.node.init)) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      const targetBinding = path.scope.getBinding(path.node.init.name);
+      if (!targetBinding || !targetBinding.constant) return;
+      const resolved = resolveFinalAlias(
+        binding,
+        (name) => path.scope.getBinding(name)
+      );
+      if (!resolved) return;
+      aliases.push({
+        aliasBinding: binding,
+        targetBinding: resolved.targetBinding,
+        targetName: resolved.targetName
+      });
+    },
+    FunctionDeclaration(path) {
+      if (!path.node.id) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding) return;
+      const wrapper = getWrapperInfo(path, binding);
+      if (wrapper) wrappers.push(wrapper);
+    }
+  });
+  patchDefault(traverse7)(ast, {
+    VariableDeclarator(path) {
+      if (!t6.isIdentifier(path.node.id)) return;
+      const initPath = path.get("init");
+      if (!initPath || !initPath.isFunctionExpression() && !initPath.isArrowFunctionExpression()) {
+        return;
+      }
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      const wrapper = getWrapperInfo(
+        initPath,
+        binding
+      );
+      if (wrapper) wrappers.push(wrapper);
+    }
+  });
+  let aliasReplacedCount = 0;
+  let wrapperReplacedCount = 0;
+  for (const alias of aliases) {
+    for (const referencePath of alias.aliasBinding.referencePaths) {
+      if (isShorthandObjectKey(referencePath)) continue;
+      const targetBinding = referencePath.scope.getBinding(alias.targetName);
+      if (targetBinding !== alias.targetBinding) continue;
+      referencePath.replaceWith(t6.identifier(alias.targetName));
+      aliasReplacedCount += 1;
+    }
+  }
+  const wrapperMap = /* @__PURE__ */ new Map();
+  for (const wrapper of wrappers) {
+    wrapperMap.set(wrapper.wrapperBinding, wrapper);
+  }
+  patchDefault(traverse7)(ast, {
+    CallExpression(path) {
+      if (!t6.isIdentifier(path.node.callee)) return;
+      const calleeBinding = path.scope.getBinding(path.node.callee.name);
+      if (!calleeBinding) return;
+      const wrapper = wrapperMap.get(calleeBinding);
+      if (!wrapper) return;
+      const targetBinding = path.scope.getBinding(wrapper.targetName);
+      if (targetBinding !== wrapper.targetBinding) return;
+      if (wrapper.kind === "call") {
+        if (path.node.arguments.length !== wrapper.paramNames.length) return;
+        for (const arg2 of path.node.arguments) {
+          if (t6.isSpreadElement(arg2)) return;
+        }
+        const nextArgs = path.node.arguments.map(
+          (arg2) => t6.cloneNode(arg2, true)
+        );
+        path.replaceWith(
+          t6.callExpression(t6.identifier(wrapper.targetName), nextArgs)
+        );
+        wrapperReplacedCount += 1;
+        return;
+      }
+      if (path.node.arguments.length !== 1) return;
+      const arg = path.node.arguments[0];
+      if (!t6.isExpression(arg) || t6.isSpreadElement(arg)) return;
+      path.replaceWith(
+        t6.memberExpression(
+          t6.identifier(wrapper.targetName),
+          t6.cloneNode(arg, true),
+          true
+        )
+      );
+      wrapperReplacedCount += 1;
+    }
+  });
+  return {
+    code: patchDefault(generate7)(ast).code,
+    aliasReplacedCount,
+    wrapperReplacedCount
+  };
+};
+var remove_reassign_default = createCommand((program2) => {
+  program2.command("remove-reassign").description("Inline safe alias assignments and wrapper calls").argument("[file]", "The file to transform").option("--input, --file <file>", "The file to transform").option("--o, --output <file>", "Output file path").option("--unlimited", "Unlimited timeout").action(
+    async (fileArgument, options) => {
+      await timeout(
+        async ({ finish }) => {
+          const filename = fileArgument ?? options.file ?? await createPrompt("Enter the file path:");
+          if (!filename) {
+            showError("No file provided");
+            return finish();
+          }
+          try {
+            const fileContent = readFileSync8(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath7(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading8("Removing reassign aliases...").start();
+            try {
+              const { code: output, aliasReplacedCount, wrapperReplacedCount } = removeReassign(fileContent, filename);
+              writeFileSync7(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved remove-reassign file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${aliasReplacedCount} aliases, ${wrapperReplacedCount} calls inlined)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply remove-reassign transform");
+              showError(
+                `Error transforming file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+              );
+              return finish();
+            }
+          } catch (error) {
+            showError(
+              `Error reading file '${filename}': ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+            return finish();
+          }
+        },
+        options.unlimited ? null : 120 * 1e3
+      );
+    }
+  );
+});
+
+// commands/remove-unused/index.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename8, dirname as dirname8, extname as extname8, join as join8 } from "path";
+import { parse as parse9 } from "@babel/parser";
+import traverse8 from "@babel/traverse";
+import generate8 from "@babel/generator";
+import * as t7 from "@babel/types";
+import loading9 from "loading-cli";
+var createDefaultOutputPath8 = (inputPath) => {
+  const ext = extname8(inputPath);
+  if (!ext) {
+    return `${inputPath}.remove-unused.js`;
+  }
+  const base = basename8(inputPath, ext);
+  return join8(dirname8(inputPath), `${base}.remove-unused${ext}`);
+};
+var removeUnusedVariables = (code, filename) => {
+  const ast = parse9(code, createParseOptions(filename));
+  let changed = false;
+  patchDefault(traverse8)(ast, {
     Scope(path) {
       for (const binding of Object.values(path.scope.bindings)) {
         if (!binding.referenced && binding.constantViolations.length === 0 && binding.path.key !== "handler" && !binding.path.isFunctionExpression()) {
-          if (t5.isProgram(binding.scope.block) && (binding.kind === "var" || binding.kind === "hoisted")) {
+          if (t7.isProgram(binding.scope.block) && (binding.kind === "var" || binding.kind === "hoisted")) {
             continue;
           }
           const targets = binding.path.parentKey === "params" ? [...binding.referencePaths, ...binding.constantViolations] : [
@@ -1249,11 +1583,11 @@ var removeUnusedVariables = (code, filename) => {
             ...binding.constantViolations
           ];
           for (const targetPath of targets) {
-            if (targetPath.isVariableDeclarator() && (t5.isArrayPattern(targetPath.node.id) && targetPath.node.id.elements.length > 1 || t5.isObjectPattern(targetPath.node.id) && targetPath.node.id.properties.length > 1)) {
+            if (targetPath.isVariableDeclarator() && (t7.isArrayPattern(targetPath.node.id) && targetPath.node.id.elements.length > 1 || t7.isObjectPattern(targetPath.node.id) && targetPath.node.id.properties.length > 1)) {
               continue;
             }
             if (targetPath.key === "consequent" || targetPath.key === "alternate" || targetPath.key === "body") {
-              targetPath.replaceWith(t5.blockStatement([]));
+              targetPath.replaceWith(t7.blockStatement([]));
             } else {
               const parentPath = targetPath.parentPath;
               if (parentPath?.isVariableDeclaration() && parentPath.node.declarations.length === 1) {
@@ -1269,7 +1603,7 @@ var removeUnusedVariables = (code, filename) => {
     }
   });
   return {
-    code: patchDefault(generate6)(ast).code,
+    code: patchDefault(generate8)(ast).code,
     changed
   };
 };
@@ -1284,20 +1618,20 @@ var remove_unused_default = createCommand((program2) => {
             return finish();
           }
           try {
-            const fileContent = readFileSync7(filename, "utf8");
-            const defaultOutputPath = createDefaultOutputPath6(filename);
+            const fileContent = readFileSync9(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath8(filename);
             let outputPath = options.output;
             if (!outputPath) {
               const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
               outputPath = promptPath || defaultOutputPath;
             }
-            const loader = loading7("Removing unused variables...").start();
+            const loader = loading9("Removing unused variables...").start();
             try {
               const { code: output, changed } = removeUnusedVariables(
                 fileContent,
                 filename
               );
-              writeFileSync6(outputPath, output, "utf8");
+              writeFileSync8(outputPath, output, "utf8");
               const diffLines = diff(fileContent, output).length;
               loader.succeed(
                 `Saved remove-unused file to: ${outputPath} (${diffLines} lines changed${changed ? ", removed unused declarations" : ", no changes"})`
@@ -1347,10 +1681,10 @@ var calmGradienrain = (text) => {
   const endHue = 300;
   const saturation = 0.45;
   const value = 0.8;
-  const ease = (t6) => t6 * t6 * (3 - 2 * t6);
+  const ease = (t8) => t8 * t8 * (3 - 2 * t8);
   return text.split("").map((char, i) => {
-    const t6 = ease(i / Math.max(text.length - 1, 1));
-    const hue = startHue + (endHue - startHue) * t6;
+    const t8 = ease(i / Math.max(text.length - 1, 1));
+    const hue = startHue + (endHue - startHue) * t8;
     const c = value * saturation;
     const h = hue / 60;
     const x = c * (1 - Math.abs(h % 2 - 1));
@@ -1374,10 +1708,10 @@ ${calmGradienrain(`Expose Kit v${VERSION}`)}
 `;
 
 // index.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname7(__filename);
-var pkg = JSON.parse(readFileSync8(join7(__dirname, "package.json"), "utf8"));
+var __dirname = dirname9(__filename);
+var pkg = JSON.parse(readFileSync10(join9(__dirname, "package.json"), "utf8"));
 console.log(showCredit(pkg.version));
 console.log();
 var program = new Command();
@@ -1393,6 +1727,8 @@ var commands = [
   expand_object_default,
   object_packer_default,
   pre_evaluate_default,
+  remove_updater_default,
+  remove_reassign_default,
   remove_unused_default
 ];
 for (const command of commands) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expose-kit",
-	"version": "0.6.0",
+	"version": "0.8.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expose-kit",
-	"version": "0.6.0",
+	"version": "0.8.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",