nextlua 3.0.0 → 3.2.0

package/index.js

@@ -4,12 +4,18 @@ const fs = require("fs");
 const path = require("path");
 const { beautify, minify } = require("./src/main");
 
-const commandId = "nextlua.beautifyDocument";
+const beautifyCommandId = "nextlua.beautifyDocument";
+const minifyCommandId = "nextlua.minifyDocument";
+const menuCommandId = "nextlua.showMenu";
 
 function beautifyText(input) {
     return beautify(input);
 }
 
+function minifyText(input) {
+    return minify(input);
+}
+
 function activate(context) {
     const vscode = require("vscode");
     const selector = [
@@ -32,26 +38,81 @@ function activate(context) {
         }
     });
 
-    const command = vscode.commands.registerCommand(commandId, async () => {
+    function registerTransformCommand(commandId, transform) {
+        return vscode.commands.registerCommand(commandId, async () => {
+            const editor = vscode.window.activeTextEditor;
+            if (!editor) {
+                vscode.window.showInformationMessage("Open a Lua or Luau file first.");
+                return;
+            }
+
+            const document = editor.document;
+            const fullRange = new vscode.Range(
+                document.positionAt(0),
+                document.lineAt(document.lineCount - 1).range.end
+            );
+            const output = transform(document.getText());
+
+            await editor.edit(editBuilder => {
+                editBuilder.replace(fullRange, output);
+            });
+        });
+    }
+
+    const beautifyCommand = registerTransformCommand(beautifyCommandId, beautifyText);
+    const minifyCommand = registerTransformCommand(minifyCommandId, minifyText);
+
+    const transforms = {
+        Beautify: beautifyText,
+        Minify: minifyText
+    };
+
+    const menuCommand = vscode.commands.registerCommand(menuCommandId, async () => {
         const editor = vscode.window.activeTextEditor;
         if (!editor) {
-            vscode.window.showInformationMessage("Open a Lua or Luau file first.");
+            vscode.window.showErrorMessage("No script content in current file");
             return;
         }
 
-        const document = editor.document;
-        const fullRange = new vscode.Range(
-            document.positionAt(0),
-            document.lineAt(document.lineCount - 1).range.end
-        );
-        const output = beautifyText(document.getText());
+        const script = editor.document.getText();
+        if (!script.length) {
+            vscode.window.showErrorMessage("No script content in current file");
+            return;
+        }
 
-        await editor.edit(editBuilder => {
-            editBuilder.replace(fullRange, output);
-        });
+        const type = await vscode.window.showQuickPick(["Beautify", "Minify"]);
+        if (!type) return;
+
+        let output;
+        try {
+            output = transforms[type](script);
+        } catch (error) {
+            console.log(error);
+            vscode.window.showErrorMessage(`Failed to ${type}`);
+            return;
+        }
+
+        const range = new vscode.Range(
+            editor.document.positionAt(0),
+            editor.document.positionAt(script.length)
+        );
+        await editor.edit(editBuilder => editBuilder.replace(range, output));
+        vscode.window.showInformationMessage("Completed!");
     });
 
-    context.subscriptions.push(formatProvider, command);
+    const statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 0);
+    statusBarItem.text = "nextlua";
+    statusBarItem.tooltip = "Lua Formatter";
+    statusBarItem.command = menuCommandId;
+    statusBarItem.show();
+
+    context.subscriptions.push(
+        formatProvider,
+        beautifyCommand,
+        minifyCommand,
+        menuCommand,
+        statusBarItem
+    );
 }
 
 function deactivate() {}
@@ -137,6 +198,7 @@ module.exports = {
     activate,
     deactivate,
     beautifyText,
+    minifyText,
     minify,
     beautify
 };

package/package.json

@@ -1,17 +1,50 @@
 {
   "name": "nextlua",
-  "version": "3.0.0",
+  "displayName": "nextlua",
+  "version": "3.2.0",
   "description": "A luau beautifier and minifier.",
-  "main": "index.js",
+  "publisher": "centurion",
+  "main": "./index.js",
   "bin": {
     "nextlua": "./index.js"
   },
+  "engines": {
+    "vscode": "^1.75.0"
+  },
+  "categories": [
+    "Formatters"
+  ],
+  "activationEvents": [
+    "onLanguage:lua",
+    "onLanguage:luau"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "nextlua.beautifyDocument",
+        "title": "Beautify"
+      },
+      {
+        "command": "nextlua.minifyDocument",
+        "title": "Minify"
+      },
+      {
+        "command": "nextlua.showMenu",
+        "title": "nextlua"
+      }
+    ]
+  },
   "files": [
     "index.js",
     "src"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "package": "vsce package"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.75.0",
+    "@vscode/vsce": "^3.0.0"
   },
   "keywords": [],
   "author": "",

package/src/main.js

@@ -409,10 +409,11 @@ function needsSpace(prev, current) {
     }
 
     if (current === "(") {
-        // Control-flow keywords read better with a space before the paren
-        // (`if (`, `while (`, `elseif (`), but calls like `function(` and
-        // `foo(` stay tight.
-        return keywordsSpacedBeforeParen.has(prev);
+        // Control-flow keywords and binary operators read better with a space
+        // before the paren (`if (`, `while (`, `a * (`, `x = (`), but calls
+        // like `function(` and `foo(` stay tight. A unary sign before `(` is
+        // handled by joinTokens, which suppresses the space (`-(x)`).
+        return keywordsSpacedBeforeParen.has(prev) || binaryOperators.has(prev);
     }
 
     if (current === "[" && isValueEnd(prev)) {
@@ -429,7 +430,9 @@ function needsSpace(prev, current) {
         return false;
     }
 
-    if (prev === "#" || current === "#") {
+    if (prev === "#") {
+        // The length operator binds tightly to its operand: `#h`, never `# h`.
+        // The space *before* `#` still follows the normal rules (`= #h`).
         return false;
     }
 
@@ -454,6 +457,18 @@ function isGenericOpen(tokens, index) {
         !reservedKeywords.has(prev);
 }
 
+function isUnarySign(tokens, index) {
+    // tokens[index] is "-" or "+". It is unary (binding tightly to its operand
+    // with no following space: `-1`, `-x`, `-(y)`, `-#t`) when it does not
+    // follow a complete value. Otherwise it is the binary operator (`a - 1`).
+    const token = tokens[index];
+    if (token !== "-" && token !== "+") {
+        return false;
+    }
+    const before = tokens[index - 1];
+    return before === undefined || !isValueEnd(before);
+}
+
 function joinTokens(tokens) {
     let text = "";
     let prev = null;
@@ -465,7 +480,14 @@ function joinTokens(tokens) {
         const inGeneric = genericDepth > 0;
         const opensGeneric = !inGeneric && token === "<" && isGenericOpen(tokens, idx);
 
-        if (prev !== null && !inGeneric && !opensGeneric && needsSpace(prev, token)) {
+        // A unary +/- binds to its operand, so suppress the space after it.
+        // (Skip the suppression when the next token is itself a +/- so we never
+        // fuse two signs into a `--` comment or a `+-` run.)
+        const prevIsUnarySign = prev !== null &&
+            token !== "-" && token !== "+" &&
+            isUnarySign(tokens, idx - 1);
+
+        if (prev !== null && !inGeneric && !opensGeneric && !prevIsUnarySign && needsSpace(prev, token)) {
             text += " ";
         }
         text += token;
@@ -571,6 +593,17 @@ function layout(input) {
             flushCurrent();
         }
 
+        if (token === "else" && inlineIfStack.length && inlineIfStack[inlineIfStack.length - 1] === "else") {
+            // The `else` of an inline `if ... then ... else ...` expression.
+            // It can appear nested inside parens/brackets (e.g. `x = (if c then
+            // a else b)`), so it must be matched regardless of bracket depth —
+            // otherwise inlineIfStack never empties and statement-splitting
+            // stays disabled for the rest of the block.
+            inlineIfStack.pop();
+            current.push(token);
+            continue;
+        }
+
         if (blockMiddle.has(token) && atStatementLevel()) {
             if (token === "else" && inlineIfStack.length) {
                 inlineIfStack.pop();