polybundle 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+# PolyBundle
+
+Simple (heavily clanker-made) Lua script bundler for Polytoria.
+
+## Installation
+
+install from this repo:
+
+```
+npm install
+npm link
+```
+
+## Usage
+
+Initialize a project (creates init_scripts.json and a dev sample):
+
+```
+polybundle init
+```
+
+Bundle using the current folder's init_scripts.json:
+
+```
+polybundle
+```
+
+Specify an output file:
+
+```
+polybundle --out dist/bundle.lua
+```
+
+## init_scripts.json format
+
+An array of entry script paths (order matters):
+
+```json
+[
+  "./dev/init1.lua",
+  "./dev/init2.lua"
+]
+```
+
+## Example Output:
+```lua
+local __module_env = {}
+
+-- polybundle: module scripts/lib/library1.module.lua
+__module_env["scripts/lib/library1.module.lua"] = (function()
+local returnedLib = {}
+
+returnedLib.Add = function(a, b)
+    return a + b
+end
+
+return returnedLib
+end)()
+
+-- polybundle: begin scripts\init1.lua
+coroutine.wrap(function()
+local lib = __module_env["scripts/lib/library1.module.lua"]
+
+local addResult = lib.Add(2, 50)
+
+print(addResult)
+print("added successfully in init1")
+end)()
+-- polybundle: end scripts\init1.lua
+
+-- polybundle: begin scripts\init2.lua
+coroutine.wrap(function()
+local addLib = __module_env["scripts/lib/library1.module.lua"]
+
+local addResult = addLib.Add(9, 10)
+
+local res = "add result is "
+
+local final = res .. tostring(addResult)
+
+print(final)
+end)()
+-- polybundle: end scripts\init2.lua
+```

package/bin/polybundle.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { run } = require("../src/cli");
+
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "polybundle",
+  "version": "0.1.0",
+  "description": "Lua script bundler for Polytoria.",
+  "license": "MIT",
+  "bin": {
+    "polybundle": "./bin/polybundle.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bundler.js

@@ -0,0 +1,154 @@
+const fs = require("fs");
+const path = require("path");
+
+const requireRegex = /require\s*\(\s*(['"])(.*?)\1\s*\)/g;
+
+function normalizeLuaSource(source) {
+  return source.endsWith("\n") ? source : source + "\n";
+}
+
+function isModuleFile(filePath) {
+  return filePath.endsWith(".module.lua");
+}
+
+function toLuaKey(filePath, rootDir) {
+  const relative = path.relative(rootDir, filePath);
+  return relative.split(path.sep).join("/");
+}
+
+function resolveModulePath(request, fromDir, rootDir) {
+  const hasExtension = request.endsWith(".lua") || request.endsWith(".module.lua");
+  const withExtension = hasExtension ? request : `${request}.module.lua`;
+
+  let candidate;
+  if (path.isAbsolute(withExtension)) {
+    candidate = withExtension;
+  } else if (withExtension.startsWith("./") || withExtension.startsWith("../")) {
+    candidate = path.resolve(fromDir, withExtension);
+  } else if (withExtension.startsWith("/")) {
+    candidate = path.resolve(rootDir, withExtension.slice(1));
+  } else {
+    candidate = path.resolve(rootDir, withExtension);
+  }
+
+  if (fs.existsSync(candidate)) {
+    return candidate;
+  }
+
+  if (!hasExtension) {
+    const fallback = candidate.replace(/\.module\.lua$/, ".lua");
+    if (fs.existsSync(fallback)) {
+      return fallback;
+    }
+  }
+
+  throw new Error(`Module not found for require("${request}")`);
+}
+
+function collectModulesFromSource(source, filePath, rootDir, moduleList, moduleSet, stack) {
+  return source.replace(requireRegex, (match, quote, request) => {
+    const modulePath = resolveModulePath(request, path.dirname(filePath), rootDir);
+    if (stack.includes(modulePath)) {
+      const cycle = [...stack, modulePath]
+        .map((entry) => path.relative(rootDir, entry))
+        .join(" -> ");
+      throw new Error(`Circular require detected: ${cycle}`);
+    }
+
+    if (!moduleSet.has(modulePath)) {
+      moduleSet.add(modulePath);
+      moduleList.push(modulePath);
+      const moduleSource = fs.readFileSync(modulePath, "utf8");
+      collectModulesFromSource(moduleSource, modulePath, rootDir, moduleList, moduleSet, stack.concat(modulePath));
+    }
+
+    return match;
+  });
+}
+
+function replaceRequiresWithModuleRefs(source, filePath, rootDir, moduleKeyMap) {
+  return source.replace(requireRegex, (match, quote, request) => {
+    const modulePath = resolveModulePath(request, path.dirname(filePath), rootDir);
+    const moduleKey = moduleKeyMap.get(modulePath);
+    if (!moduleKey) {
+      throw new Error(`Missing module entry for require(\"${request}\")`);
+    }
+    return `__module_env[\"${moduleKey}\"]`;
+  });
+}
+
+function bundleModuleSource(source, filePath, rootDir, moduleKeyMap, cache, stack) {
+  if (cache.has(filePath)) {
+    return cache.get(filePath);
+  }
+
+  if (stack.includes(filePath)) {
+    const cycle = [...stack, filePath].map((entry) => path.relative(rootDir, entry)).join(" -> ");
+    throw new Error(`Circular require detected: ${cycle}`);
+  }
+
+  const nextStack = stack.concat(filePath);
+  const replaced = replaceRequiresWithModuleRefs(source, filePath, rootDir, moduleKeyMap);
+  cache.set(filePath, replaced);
+  return replaced;
+}
+
+function bundleEntries(entries, rootDir) {
+  const moduleList = [];
+  const moduleSet = new Set();
+
+  for (const entry of entries) {
+    const entryPath = path.resolve(rootDir, entry);
+    if (isModuleFile(entryPath)) {
+      if (!moduleSet.has(entryPath)) {
+        moduleSet.add(entryPath);
+        moduleList.push(entryPath);
+        const moduleSource = fs.readFileSync(entryPath, "utf8");
+        collectModulesFromSource(moduleSource, entryPath, rootDir, moduleList, moduleSet, [entryPath]);
+      }
+      continue;
+    }
+
+    const source = fs.readFileSync(entryPath, "utf8");
+    collectModulesFromSource(source, entryPath, rootDir, moduleList, moduleSet, [entryPath]);
+  }
+
+  const moduleKeyMap = new Map();
+  for (const modulePath of moduleList) {
+    moduleKeyMap.set(modulePath, toLuaKey(modulePath, rootDir));
+  }
+
+  const moduleCache = new Map();
+  const chunks = [];
+
+  chunks.push("local __module_env = {}\n");
+
+  for (const modulePath of moduleList) {
+    const moduleSource = fs.readFileSync(modulePath, "utf8");
+    const bundledModule = bundleModuleSource(moduleSource, modulePath, rootDir, moduleKeyMap, moduleCache, []);
+    const moduleKey = moduleKeyMap.get(modulePath);
+    const header = `-- polybundle: module ${moduleKey}\n`;
+    const assignment = `__module_env[\"${moduleKey}\"] = (function()\n${normalizeLuaSource(bundledModule)}end)()\n`;
+    chunks.push(header + assignment);
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.resolve(rootDir, entry);
+    if (isModuleFile(entryPath)) {
+      continue;
+    }
+
+    const entrySource = fs.readFileSync(entryPath, "utf8");
+    const replaced = replaceRequiresWithModuleRefs(entrySource, entryPath, rootDir, moduleKeyMap);
+    const wrapped = `coroutine.wrap(function()\n${normalizeLuaSource(replaced)}end)()`;
+    const header = `-- polybundle: begin ${path.relative(rootDir, entryPath)}\n`;
+    const footer = `-- polybundle: end ${path.relative(rootDir, entryPath)}\n`;
+    chunks.push(header + normalizeLuaSource(wrapped) + footer);
+  }
+
+  return chunks.join("\n");
+}
+
+module.exports = {
+  bundleEntries
+};

package/src/cli.js

@@ -0,0 +1,138 @@
+const fs = require("fs");
+const path = require("path");
+const { bundleEntries } = require("./bundler");
+
+function printHelp() {
+  console.log("Usage: polybundle [init] [--out <file>]");
+}
+
+function initScriptTree(scriptTreePath) {
+  const example = [
+    "./dev/init1.lua",
+    "./dev/init2.lua"
+  ];
+
+  if (!fs.existsSync(scriptTreePath)) {
+    fs.writeFileSync(scriptTreePath, JSON.stringify(example, null, 2) + "\n", "utf8");
+    console.log("Created init_scripts.json with example entries.");
+  } else {
+    console.log("init_scripts.json already exists.");
+  }
+
+  const devDir = path.resolve(path.dirname(scriptTreePath), "dev");
+  const libDir = path.join(devDir, "lib");
+
+  fs.mkdirSync(libDir, { recursive: true });
+
+  const init1Path = path.join(devDir, "init1.lua");
+  const init2Path = path.join(devDir, "init2.lua");
+  const libraryPath = path.join(libDir, "library1.module.lua");
+
+  const init1Content = "local lib = require(\"./lib/library1.module.lua\")\n\n" +
+    "local addResult = lib.Add(2, 50)\n\n" +
+    "print(addResult)\n" +
+    "print(\"added successfully in init1\")\n";
+
+  const init2Content = "local addLib = require(\"./lib/library1.module.lua\")\n\n" +
+    "local addResult = addLib.Add(9, 10)\n\n" +
+    "local res = \"add result is \"\n\n" +
+    "local final = res .. tostring(addResult)\n\n" +
+    "print(final)\n";
+
+  const libraryContent = "local returnedLib = {}\n\n" +
+    "returnedLib.Add = function(a, b)\n" +
+    "    return a + b\n" +
+    "end\n\n" +
+    "return returnedLib\n";
+
+  if (!fs.existsSync(init1Path)) {
+    fs.writeFileSync(init1Path, init1Content, "utf8");
+  }
+
+  if (!fs.existsSync(init2Path)) {
+    fs.writeFileSync(init2Path, init2Content, "utf8");
+  }
+
+  if (!fs.existsSync(libraryPath)) {
+    fs.writeFileSync(libraryPath, libraryContent, "utf8");
+  }
+}
+
+function parseArgs(args) {
+  const result = {
+    command: null,
+    outFile: null,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--out") {
+      result.outFile = args[i + 1] || null;
+      i += 1;
+    } else if (!result.command) {
+      result.command = arg;
+    }
+  }
+
+  return result;
+}
+
+function run(args) {
+  const options = parseArgs(args);
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  const cwd = process.cwd();
+  const scriptTreePath = path.resolve(cwd, "init_scripts.json");
+
+  if (options.command === "init") {
+    initScriptTree(scriptTreePath);
+    return;
+  }
+
+  if (!fs.existsSync(scriptTreePath)) {
+    console.log("init_scripts.json not found. Run `polybundle init` first.");
+    process.exitCode = 1;
+    return;
+  }
+
+  let entries;
+  try {
+    const raw = fs.readFileSync(scriptTreePath, "utf8");
+    entries = JSON.parse(raw);
+  } catch (error) {
+    console.error("Failed to read init_scripts.json:", error.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!Array.isArray(entries) || !entries.every((value) => typeof value === "string")) {
+    console.error("init_scripts.json must be an array of string paths.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const outFile = options.outFile
+    ? path.resolve(cwd, options.outFile)
+    : path.resolve(cwd, "dist", "bundle.lua");
+
+  try {
+    const bundled = bundleEntries(entries, cwd);
+    fs.mkdirSync(path.dirname(outFile), { recursive: true });
+    fs.writeFileSync(outFile, bundled, "utf8");
+    console.log(`Bundled ${entries.length} entries into ${outFile}`);
+  } catch (error) {
+    console.error("Bundling failed:", error.message);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  run
+};