expose-kit 0.8.0 → 0.10.0

package/README.md

@@ -321,9 +321,61 @@ Notes:
 
 ---
 
+### `expose fn-inliner`
+
+Inline proxy function calls into expressions.
+```js
+const add = (a, b) => a + b;
+const sum = add(1, 2);
+// after
+const sum = 1 + 2;
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/fn-inliner/mocks).
+
+```bash
+expose fn-inliner path/to/file.js --output path/to/file.fn-inliner.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Only inlines functions that return a single expression.
+- Skips return expressions with assignments, functions, blocks, or sequences.
+
+---
+
+### `expose sequence-split`
+
+Split sequence expressions into statements.
+```js
+// before
+a, b, c;
+// after
+a;
+b;
+c;
+```
+Example is [here](https://github.com/evex-dev/expose-kit/tree/main/commands/sequence-split/mocks).
+
+```bash
+expose sequence-split path/to/file.js --output path/to/file.sequence-split.js
+```
+
+Args:
+- `--o, --output <file>`  
+  Output file path  
+
+Notes:
+- Splits safe sequence expressions into standalone statements.
+- Also normalizes single-statement control flow blocks.
+
+---
+
 ### `expose remove-unused`
-
-Remove unused variabless.
+
+Remove unused variabless.
 ```js
 // before
 var a = 0, b = 1;

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // index.ts
 import { Command } from "commander";
-import { dirname as dirname9, join as join9 } from "path";
+import { dirname as dirname11, join as join11 } from "path";
 import { fileURLToPath } from "url";
 import chalk4 from "chalk";
 
@@ -746,11 +746,7 @@ var expand_object_default = createCommand((program2) => {
             }
             const loader = loading4("Expanding object access...").start();
             try {
-              const { code: output, replacedCount } = await expandObjectAccess(
-                fileContent,
-                filename,
-                targetName
-              );
+              const { code: output, replacedCount } = await expandObjectAccess(fileContent, filename, targetName);
               writeFileSync3(outputPath, output, "utf8");
               loader.succeed(
                 `Saved expand-object file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
@@ -932,7 +928,11 @@ var object_packer_default = createCommand((program2) => {
             }
             const loader = loading5("Packing object properties...").start();
             try {
-              const { code: output, packedCount, removedStatements } = packObjectProperties(fileContent, filename);
+              const {
+                code: output,
+                packedCount,
+                removedStatements
+              } = packObjectProperties(fileContent, filename);
               writeFileSync4(outputPath, output, "utf8");
               loader.succeed(
                 `Saved object-packer file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${packedCount} properties packed, ${removedStatements} statements removed)`
@@ -1525,7 +1525,11 @@ var remove_reassign_default = createCommand((program2) => {
             }
             const loader = loading8("Removing reassign aliases...").start();
             try {
-              const { code: output, aliasReplacedCount, wrapperReplacedCount } = removeReassign(fileContent, filename);
+              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)`
@@ -1657,6 +1661,371 @@ var remove_unused_default = createCommand((program2) => {
   );
 });
 
+// commands/fn-inliner/index.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename9, dirname as dirname9, extname as extname9, join as join9 } from "path";
+import { parse as parse10 } from "@babel/parser";
+import traverse9 from "@babel/traverse";
+import generate9 from "@babel/generator";
+import * as t8 from "@babel/types";
+import loading10 from "loading-cli";
+var walk = patchDefault(traverse9);
+var createDefaultOutputPath9 = (inputPath) => {
+  const ext = extname9(inputPath);
+  if (!ext) {
+    return `${inputPath}.fn-inliner.js`;
+  }
+  const base = basename9(inputPath, ext);
+  return join9(dirname9(inputPath), `${base}.fn-inliner${ext}`);
+};
+var isProxyFunctionExpression = (node) => {
+  return t8.isFunction(node) && node.params.every((param) => t8.isIdentifier(param)) && (t8.isBlockStatement(node.body) && node.body.body.length === 1 && t8.isReturnStatement(node.body.body[0]) && (node.body.body[0].argument === void 0 || t8.isExpression(node.body.body[0].argument) && isProxyValue(node.body.body[0].argument)) || t8.isArrowFunctionExpression(node) && t8.isExpression(node.body) && isProxyValue(node.body));
+};
+var isProxyValue = (node) => {
+  if (t8.isFunction(node) || t8.isBlockStatement(node) || t8.isSequenceExpression(node)) {
+    return false;
+  }
+  let isValid = true;
+  walk(node, {
+    "SequenceExpression|BlockStatement|Function|AssignmentExpression"(path) {
+      isValid = false;
+      path.stop();
+    },
+    noScope: true
+  });
+  return isValid;
+};
+var copyExpression = (expression) => {
+  return t8.cloneNode(expression, true);
+};
+var ProxyFunction = class {
+  expression;
+  constructor(expression) {
+    this.expression = expression;
+  }
+  getReplacement(args) {
+    const expression = t8.isExpression(this.expression.body) ? copyExpression(this.expression.body) : this.expression.body.body[0].argument ? copyExpression(this.expression.body.body[0].argument) : t8.identifier("undefined");
+    this.replaceParameters(expression, args);
+    return expression;
+  }
+  replaceParameters(expression, args) {
+    const paramMap = new Map(
+      this.expression.params.map((param, index) => [
+        param.name,
+        args[index] ?? t8.identifier("undefined")
+      ])
+    );
+    const pathsToReplace = [];
+    walk(expression, {
+      enter(path) {
+        if (t8.isIdentifier(path.node) && !(path.parentPath?.isMemberExpression() && path.key === "property") && paramMap.has(path.node.name)) {
+          const replacement = paramMap.get(path.node.name);
+          pathsToReplace.push([path, replacement]);
+        }
+      },
+      noScope: true
+    });
+    for (const [path, replacement] of pathsToReplace) {
+      path.replaceWith(t8.cloneNode(replacement, true));
+    }
+  }
+};
+var ProxyFunctionVariable = class extends ProxyFunction {
+  binding;
+  constructor(binding, expression) {
+    super(expression);
+    this.binding = binding;
+  }
+  getCalls() {
+    return this.binding.referencePaths;
+  }
+  replaceCall(path) {
+    if (!path.parentPath || !path.parentPath.isCallExpression() || path.key !== "callee") {
+      return false;
+    }
+    const argumentNodes = path.parentPath.node.arguments;
+    const args = [];
+    for (const argument of argumentNodes) {
+      if (!t8.isExpression(argument)) {
+        return false;
+      }
+      args.push(t8.cloneNode(argument, true));
+    }
+    const expression = this.getReplacement(args);
+    path.parentPath.replaceWith(expression);
+    return true;
+  }
+};
+var collectProxyFunctions = (ast) => {
+  const proxies = [];
+  walk(ast, {
+    FunctionDeclaration(path) {
+      if (!path.node.id) return;
+      if (!isProxyFunctionExpression(path.node)) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      proxies.push(new ProxyFunctionVariable(binding, path.node));
+    },
+    VariableDeclarator(path) {
+      if (!t8.isIdentifier(path.node.id)) return;
+      const init = path.node.init;
+      if (!init || !isProxyFunctionExpression(init)) return;
+      const binding = path.scope.getBinding(path.node.id.name);
+      if (!binding || !binding.constant) return;
+      proxies.push(new ProxyFunctionVariable(binding, init));
+    }
+  });
+  return proxies;
+};
+var inlineProxyFunctions = (code, filename) => {
+  const ast = parse10(code, createParseOptions(filename));
+  const proxies = collectProxyFunctions(ast);
+  let replacedCount = 0;
+  for (const proxy of proxies) {
+    for (const referencePath of proxy.getCalls()) {
+      if (referencePath.removed) continue;
+      if (proxy.replaceCall(referencePath)) {
+        replacedCount += 1;
+      }
+    }
+  }
+  return {
+    code: patchDefault(generate9)(ast).code,
+    replacedCount
+  };
+};
+var fn_inliner_default = createCommand((program2) => {
+  program2.command("fn-inliner").description("Inline proxy function calls into expressions").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 = readFileSync10(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath9(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading10("Inlining proxy functions...").start();
+            try {
+              const { code: output, replacedCount } = inlineProxyFunctions(
+                fileContent,
+                filename
+              );
+              writeFileSync9(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved fn-inliner file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${replacedCount} replacements)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply fn-inliner 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/sequence-split/index.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync10 } from "fs";
+import { basename as basename10, dirname as dirname10, extname as extname10, join as join10 } from "path";
+import { parse as parse11 } from "@babel/parser";
+import traverse10 from "@babel/traverse";
+import generate10 from "@babel/generator";
+import * as t9 from "@babel/types";
+import loading11 from "loading-cli";
+var walk2 = patchDefault(traverse10);
+var createDefaultOutputPath10 = (inputPath) => {
+  const ext = extname10(inputPath);
+  if (!ext) {
+    return `${inputPath}.sequence-split.js`;
+  }
+  const base = basename10(inputPath, ext);
+  return join10(dirname10(inputPath), `${base}.sequence-split${ext}`);
+};
+var isExcluded = (node) => {
+  return t9.isIdentifier(node) && node.name === "eval";
+};
+var sequenceSplit = (code, filename) => {
+  const ast = parse11(code, createParseOptions(filename));
+  let changedCount = 0;
+  const markChanged = () => {
+    changedCount += 1;
+  };
+  walk2(ast, {
+    ConditionalExpression(path) {
+      if (!path.parentPath || !path.parentPath.isExpressionStatement()) return;
+      const replacement = t9.ifStatement(
+        path.node.test,
+        t9.expressionStatement(path.node.consequent),
+        t9.expressionStatement(path.node.alternate)
+      );
+      if (path.parentPath.parentPath && path.parentPath.parentPath.key === "alternate" && path.parentPath.parentPath.isBlockStatement() && path.parentPath.parentPath.node.body.length === 1) {
+        path.parentPath.parentPath.replaceWith(replacement);
+      } else {
+        path.parentPath.replaceWith(replacement);
+      }
+      path.skip();
+      markChanged();
+    },
+    LogicalExpression(path) {
+      if (!path.parentPath || !path.parentPath.isExpressionStatement()) return;
+      if (path.node.operator !== "&&" && path.node.operator !== "||") return;
+      const test = path.node.operator === "&&" ? path.node.left : t9.unaryExpression("!", path.node.left);
+      const replacement = t9.ifStatement(
+        test,
+        t9.expressionStatement(path.node.right)
+      );
+      if (path.parentPath.parentPath && path.parentPath.parentPath.key === "alternate" && path.parentPath.parentPath.isBlockStatement() && path.parentPath.parentPath.node.body.length === 1) {
+        path.parentPath.parentPath.replaceWith(replacement);
+      } else {
+        path.parentPath.replaceWith(replacement);
+      }
+      path.skip();
+      markChanged();
+    },
+    "ForStatement|WhileStatement|DoWhileStatement"(path) {
+      if (!path.isForStatement() && !path.isWhileStatement() && !path.isDoWhileStatement()) return;
+      if (t9.isBlockStatement(path.node.body)) return;
+      path.node.body = t9.blockStatement([path.node.body]);
+      markChanged();
+    },
+    IfStatement(path) {
+      if (!t9.isBlockStatement(path.node.consequent)) {
+        path.node.consequent = t9.blockStatement([path.node.consequent]);
+        markChanged();
+      }
+      if (path.node.alternate && !t9.isBlockStatement(path.node.alternate) && !t9.isIfStatement(path.node.alternate)) {
+        path.node.alternate = t9.blockStatement([path.node.alternate]);
+        markChanged();
+      }
+    },
+    VariableDeclaration(path) {
+      if (path.node.declarations.length <= 1) return;
+      const replacements = path.node.declarations.map(
+        (declaration) => t9.variableDeclaration(path.node.kind, [declaration])
+      );
+      if (path.parentPath?.isForStatement() && path.parentKey === "init") {
+        const lastDeclaration = replacements.pop();
+        if (lastDeclaration) {
+          path.parentPath.insertBefore(replacements);
+          path.parentPath.node.init = lastDeclaration;
+        }
+      } else {
+        path.replaceWithMultiple(replacements);
+      }
+      markChanged();
+    },
+    SequenceExpression(path) {
+      const expressions = path.node.expressions;
+      if (expressions.length === 1 && expressions[0]) {
+        path.replaceWith(expressions[0]);
+        markChanged();
+        return;
+      }
+      let outerPath = path;
+      while (!t9.isStatement(outerPath.node)) {
+        const parent = outerPath.parentPath;
+        if (!parent) return;
+        if (parent.isConditionalExpression() && (outerPath.key === "consequent" || outerPath.key === "alternate") || parent.isLogicalExpression() && outerPath.key === "right" || parent.isForStatement() && (outerPath.key === "test" || outerPath.key === "update") || parent.isDoWhileStatement() && outerPath.key === "test" || parent.isArrowFunctionExpression() && outerPath.key === "body") {
+          return;
+        }
+        outerPath = parent;
+      }
+      const lastExpression = expressions[expressions.length - 1];
+      if (lastExpression && isExcluded(lastExpression)) {
+        const firstExpressions = expressions.splice(0, expressions.length - 2);
+        if (firstExpressions.length > 0) {
+          const expressionStatements = firstExpressions.map(
+            (expression) => t9.expressionStatement(expression)
+          );
+          outerPath.insertBefore(expressionStatements);
+          markChanged();
+        }
+      } else {
+        const finalExpression = expressions.splice(expressions.length - 1, 1)[0];
+        const expressionStatements = expressions.map(
+          (expression) => t9.expressionStatement(expression)
+        );
+        outerPath.insertBefore(expressionStatements);
+        if (finalExpression) {
+          path.replaceWith(finalExpression);
+        }
+        markChanged();
+      }
+    }
+  });
+  return {
+    code: patchDefault(generate10)(ast).code,
+    changedCount
+  };
+};
+var sequence_split_default = createCommand((program2) => {
+  program2.command("sequence-split").description("Split sequence expressions into statements").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 = readFileSync11(filename, "utf8");
+            const defaultOutputPath = createDefaultOutputPath10(filename);
+            let outputPath = options.output;
+            if (!outputPath) {
+              const promptPath = (await createPrompt("Enter the output file path:"))?.trim();
+              outputPath = promptPath || defaultOutputPath;
+            }
+            const loader = loading11("Splitting sequences...").start();
+            try {
+              const { code: output, changedCount } = sequenceSplit(
+                fileContent,
+                filename
+              );
+              writeFileSync10(outputPath, output, "utf8");
+              loader.succeed(
+                `Saved sequence-split file to: ${outputPath} (${diff(fileContent, output).length} lines changed, ${changedCount} transforms)`
+              );
+              return finish();
+            } catch (error) {
+              loader.fail("Failed to apply sequence-split 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
+      );
+    }
+  );
+});
+
 // utils/cli/showCredit.ts
 import chalk3 from "chalk";
 var beautify = (strings, ...values) => {
@@ -1681,10 +2050,10 @@ var calmGradienrain = (text) => {
   const endHue = 300;
   const saturation = 0.45;
   const value = 0.8;
-  const ease = (t8) => t8 * t8 * (3 - 2 * t8);
+  const ease = (t10) => t10 * t10 * (3 - 2 * t10);
   return text.split("").map((char, i) => {
-    const t8 = ease(i / Math.max(text.length - 1, 1));
-    const hue = startHue + (endHue - startHue) * t8;
+    const t10 = ease(i / Math.max(text.length - 1, 1));
+    const hue = startHue + (endHue - startHue) * t10;
     const c = value * saturation;
     const h = hue / 60;
     const x = c * (1 - Math.abs(h % 2 - 1));
@@ -1708,10 +2077,10 @@ ${calmGradienrain(`Expose Kit v${VERSION}`)}
 `;
 
 // index.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname9(__filename);
-var pkg = JSON.parse(readFileSync10(join9(__dirname, "package.json"), "utf8"));
+var __dirname = dirname11(__filename);
+var pkg = JSON.parse(readFileSync12(join11(__dirname, "package.json"), "utf8"));
 console.log(showCredit(pkg.version));
 console.log();
 var program = new Command();
@@ -1729,7 +2098,9 @@ var commands = [
   pre_evaluate_default,
   remove_updater_default,
   remove_reassign_default,
-  remove_unused_default
+  fn_inliner_default,
+  remove_unused_default,
+  sequence_split_default
 ];
 for (const command of commands) {
   command(program);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expose-kit",
-	"version": "0.8.0",
+	"version": "0.10.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.8.0",
+	"version": "0.10.0",
 	"type": "module",
 	"private": false,
 	"author": "EdamAmex <edame8080@gmail.com> (https://github.com/EdamAme-x)",