@tilua/compiler 8.1.0 → 9.0.0

package/dist/cli.js

@@ -1,33 +1,42 @@
 #!/usr/bin/env node
 import {
+  WRITTEN_BY_TILUA,
   bundle,
   resolveConfig
-} from "./chunk-WOBHMGGC.js";
+} from "./chunk-VUIF62OE.js";
 
 // src/cli.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { basename, dirname, join, relative, resolve } from "path";
-var usage = "usage: tilua <entry> [--out <file>] [--output single|chunks|modules] [--config <tilua.config.json>] [--noCheck] [--noLineMap]";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, watch, writeFileSync } from "fs";
+import { basename, dirname, join, relative, resolve, sep } from "path";
+var usage = "usage: tilua [<entry>] [--out <file>] [--output single|chunks|files] [--config <tilua.config.json>] [--noCheck] [--noLineMap] [--minify] [--watch]\n       tilua init";
 var args = process.argv.slice(2);
 var entry;
 var out;
 var config;
 var typeCheck = true;
 var lineMap;
+var minify;
 var output;
+var watching = false;
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
   if (arg === "--out") out = args[++i];
   else if (arg === "--config") config = args[++i];
   else if (arg === "--noCheck") typeCheck = false;
   else if (arg === "--noLineMap") lineMap = false;
+  else if (arg === "--minify") minify = true;
+  else if (arg === "--watch" || arg === "-w") watching = true;
   else if (arg === "--target") {
     console.error(`--target is gone: the output runs on Lua 5.1 to 5.4, LuaJIT and Luau, and a library says what more its Lua has \u2014 add "luau" to the config's 'types'`);
     process.exit(2);
   } else if (arg === "--output") {
     const value = args[++i];
-    if (value !== "single" && value !== "chunks" && value !== "modules") {
-      console.error(`--output must be 'single', 'chunks' or 'modules', not '${value}'`);
+    if (value === "modules") {
+      console.error("--output modules is gone: --output files writes one file per module, each of which returns its exports");
+      process.exit(2);
+    }
+    if (value !== "single" && value !== "chunks" && value !== "files") {
+      console.error(`--output must be 'single', 'chunks' or 'files', not '${value}'`);
       process.exit(2);
     }
     output = value;
@@ -36,39 +45,162 @@ for (let i = 0; i < args.length; i++) {
     process.exit(0);
   } else entry = arg;
 }
-if (!entry) {
-  console.error(usage);
-  process.exit(2);
+var shown = (path) => relative(process.cwd(), path) || ".";
+function init() {
+  const folder = process.cwd();
+  for (const name of ["tilua.config.json", "tilua.config.jsonc"]) {
+    if (existsSync(join(folder, name))) {
+      console.error(`${name} is already here`);
+      process.exit(1);
+    }
+  }
+  let rootDir = "src";
+  const project = join(folder, "default.project.json");
+  if (existsSync(project)) {
+    const paths = [];
+    const walk = (node) => {
+      if (!node || typeof node !== "object") return;
+      const path = node.$path;
+      const named = typeof path === "string" ? path : path?.optional;
+      if (typeof named === "string" && !/\.\w+$/.test(named)) paths.push(named);
+      for (const [key, child] of Object.entries(node)) if (!key.startsWith("$")) walk(child);
+    };
+    try {
+      walk(JSON.parse(readFileSync(project, "utf8")).tree);
+    } catch (error) {
+      console.error(`default.project.json: ${error.message}`);
+      process.exit(1);
+    }
+    const split = paths.map((path) => path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "").split("/"));
+    const shared = [];
+    for (let i = 0; split.length && split.every((parts) => parts.length > i && parts[i] === split[0][i]); i++) shared.push(split[0][i]);
+    if (split.length) rootDir = shared.join("/") || ".";
+  } else {
+    console.error('No default.project.json here: rootDir is "src". Change it if the project reads its files from elsewhere.');
+  }
+  const written = { types: ["roblox"], output: "files", rootDir };
+  writeFileSync(join(folder, "tilua.config.json"), JSON.stringify(written, null, 4) + "\n");
+  console.log("tilua.config.json: a .luau beside each .tilua under " + rootDir);
+  console.log("Next: npm i -D @tilua/compiler @tilua-types/roblox, then run `npx tilua --watch` beside `rojo serve`.");
+  process.exit(0);
+}
+function writtenByTilua(folder) {
+  const found = [];
+  const walk = (at) => {
+    let items;
+    try {
+      items = readdirSync(at, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      if (item.name.startsWith(".") || item.name === "node_modules") continue;
+      const path = join(at, item.name);
+      if (item.isDirectory()) walk(path);
+      else if (/\.luau?$/.test(item.name) && isTilua(path)) found.push(path);
+    }
+  };
+  walk(folder);
+  return found;
+}
+function isTilua(path) {
+  try {
+    const text = readFileSync(path, "utf8").trimEnd();
+    return text.slice(text.lastIndexOf("\n") + 1).startsWith(WRITTEN_BY_TILUA);
+  } catch {
+    return false;
+  }
 }
-async function main(from) {
-  const found = resolveConfig(config, resolve(from)).config;
+async function build(from) {
+  const found = resolveConfig(config, resolve(from ?? "tilua.config.json")).config;
   const mode = output ?? found?.output ?? "single";
-  const entryFile = mode === "modules" ? void 0 : out ?? from.replace(/\.tilua$/, "") + ".luau";
-  const folder = entryFile !== void 0 ? dirname(entryFile) : out ?? found?.directory ?? dirname(from);
+  if (mode !== "files" && from === void 0) {
+    console.error(usage);
+    process.exit(2);
+  }
+  const perFile = mode === "files";
+  const entryFile = perFile || from === void 0 ? void 0 : out ?? from.replace(/\.tilua$/, "") + ".luau";
+  const folder = resolve(entryFile !== void 0 ? dirname(entryFile) : out ?? found?.outDir ?? process.cwd());
   const result = await bundle({
-    entry: from,
+    entry: perFile ? void 0 : from,
     config,
     typeCheck,
     output: mode,
     lineMap,
+    minify,
+    outDir: perFile ? out : void 0,
     outFile: entryFile !== void 0 ? basename(entryFile) : void 0
   });
   for (const d of result.diagnostics) {
-    console.error(`${relative(process.cwd(), d.file)}:${d.line}:${d.column} ${d.severity === "warning" ? "warning: " : ""}${d.message}`);
+    console.error(`${shown(d.file)}:${d.line}:${d.column} ${d.severity === "warning" ? "warning: " : ""}${d.message}`);
   }
   if (result.code === void 0) {
-    console.error("no bundle written");
-    process.exit(1);
+    console.error("no output written");
+    return false;
+  }
+  const targets = result.files.map((file) => ({ ...file, target: join(folder, file.path) }));
+  if (perFile) {
+    const theirs = targets.filter((file) => existsSync(file.target) && !isTilua(file.target));
+    for (const file of theirs) {
+      console.error(`${shown(file.target)}: this file was not written by tilua, and a .tilua would replace it \u2014 rename or remove one of them`);
+    }
+    if (theirs.length) return false;
+  }
+  for (const file of targets) {
+    if (existsSync(file.target) && readFileSync(file.target, "utf8") === file.code) continue;
+    mkdirSync(dirname(file.target), { recursive: true });
+    writeFileSync(file.target, file.code);
+    console.log(`${shown(file.target)}: ${file.modules.length} module${file.modules.length === 1 ? "" : "s"}`);
   }
-  for (const file of result.files) {
-    const target = join(folder, file.path);
-    mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(target, file.code);
-    console.log(`${target}: ${file.modules.length} module${file.modules.length === 1 ? "" : "s"}`);
+  if (perFile) {
+    const kept = new Set(targets.map((file) => resolve(file.target)));
+    for (const stale of writtenByTilua(folder)) {
+      if (kept.has(resolve(stale))) continue;
+      rmSync(stale);
+      console.log(`${shown(stale)}: removed, its .tilua is gone`);
+    }
   }
-  process.exit(result.diagnostics.some((d) => d.severity !== "warning") ? 1 : 0);
+  return !result.diagnostics.some((d) => d.severity !== "warning");
+}
+async function watchAndBuild(from) {
+  const found = resolveConfig(config, resolve(from ?? "tilua.config.json")).config;
+  const folder = found?.directory ?? (from !== void 0 ? dirname(resolve(from)) : process.cwd());
+  let running = false;
+  let again = false;
+  let timer;
+  const run = async () => {
+    if (running) {
+      again = true;
+      return;
+    }
+    running = true;
+    const ok = await build(from).catch((error) => {
+      console.error(error instanceof Error ? error.message : error);
+      return false;
+    });
+    console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ${ok ? "built" : "built with errors"}; watching ${shown(folder)}`);
+    running = false;
+    if (again) {
+      again = false;
+      await run();
+    }
+  };
+  await run();
+  watch(folder, { recursive: true }, (_event, name) => {
+    if (!name) return;
+    const path = name.toString();
+    if (path.split(sep).includes("node_modules")) return;
+    if (!/\.tilua$|tilua\.config\.jsonc?$|\.project\.json$/.test(path)) return;
+    clearTimeout(timer);
+    timer = setTimeout(() => void run(), 100);
+  });
+}
+async function main() {
+  if (entry === "init") init();
+  if (watching) return watchAndBuild(entry);
+  process.exit(await build(entry) ? 0 : 1);
 }
-main(entry).catch((error) => {
+main().catch((error) => {
   console.error(error instanceof Error ? error.message : error);
   process.exit(1);
 });