@tilua/compiler 8.1.0 → 9.0.1

package/dist/cli.js

@@ -1,33 +1,43 @@
 #!/usr/bin/env node
 import {
+  WRITTEN_BY_TILUA,
   bundle,
   resolveConfig
-} from "./chunk-WOBHMGGC.js";
+} from "./chunk-3RJVN4KC.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 { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmdirSync, rmSync, watch, writeFileSync } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+import { stripJsonComments } from "@tilua/parser";
+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 +46,284 @@ 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) || ".";
+var OUT = "out";
+function init() {
+  const folder = process.cwd();
+  let existing;
+  for (const name of ["tilua.config.json", "tilua.config.jsonc"]) {
+    const path = join(folder, name);
+    if (!existsSync(path)) continue;
+    let options2 = {};
+    try {
+      options2 = JSON.parse(stripJsonComments(readFileSync(path, "utf8")));
+    } catch (error) {
+      console.error(`${name}: ${error.message}`);
+      process.exit(1);
+    }
+    if (options2.output !== "files" || options2.outDir !== void 0 && options2.outDir !== options2.rootDir) {
+      console.error(`${name} is already here`);
+      process.exit(1);
+    }
+    existing = { path, options: options2 };
+  }
+  const project = join(folder, "default.project.json");
+  if (!existsSync(project)) {
+    console.error("No default.project.json here: run `tilua init` in the folder of a Rojo project (`rojo init` makes one)");
+    process.exit(1);
+  }
+  const text = readFileSync(project, "utf8");
+  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") paths.push(named);
+    for (const [key, child] of Object.entries(node)) if (!key.startsWith("$")) walk(child);
+  };
+  try {
+    walk(JSON.parse(text).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 === 1 && /\.\w+$/.test(shared.at(-1) ?? "")) shared.pop();
+  const rootDir = shared.join("/");
+  if (!rootDir) {
+    console.error("The project's $paths share no folder to compile from: put the code under one (src), as `rojo init` does");
+    process.exit(1);
+  }
+  if (rootDir === OUT || rootDir.startsWith(`${OUT}/`)) {
+    console.error(`The project already reads from ${OUT}: set tilua.config.json up by hand`);
+    process.exit(1);
+  }
+  const out2 = join(folder, OUT);
+  if (existsSync(out2) && readdirSync(out2).length) {
+    console.error(`${OUT} is already here and not empty: the build would replace what is in it`);
+    process.exit(1);
+  }
+  const options = existing ? { ...existing.options, rootDir: existing.options.rootDir ?? rootDir, outDir: OUT } : { types: ["roblox"], output: "files", rootDir, outDir: OUT };
+  writeFileSync(existing?.path ?? join(folder, "tilua.config.json"), JSON.stringify(options, null, 4) + "\n");
+  console.log(`${basename(existing?.path ?? "tilua.config.json")}: ${String(options.rootDir)} compiled to ${OUT}`);
+  const escaped = rootDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let changed = 0;
+  const pointed = text.replace(new RegExp(`("\\$path"\\s*:\\s*")(\\./)?${escaped}(?=/|")`, "g"), (_, head) => {
+    changed++;
+    return `${head}${OUT}`;
+  });
+  writeFileSync(project, pointed);
+  console.log(`default.project.json: ${changed} $path${changed === 1 ? "" : "s"} now read from ${OUT}`);
+  const ignore = join(folder, ".gitignore");
+  const ignored = existsSync(ignore) ? readFileSync(ignore, "utf8") : "";
+  if (!ignored.split(/\r?\n/).some((line) => [OUT, `/${OUT}`, `${OUT}/`, `/${OUT}/`].includes(line.trim()))) {
+    writeFileSync(ignore, `${ignored}${ignored && !ignored.endsWith("\n") ? "\n" : ""}
+# What tilua builds from ${rootDir}
+/${OUT}
+`);
+    console.log(`.gitignore: /${OUT}`);
+  }
+  console.log("Next: npm i -D @tilua/compiler @tilua-types/roblox, then run `npx tilua --watch` beside `rojo serve`.");
+  process.exit(0);
+}
+function isInside(folder, path) {
+  const below = relative(folder, path);
+  return below === "" || !below.startsWith("..") && !isAbsolute(below);
+}
+function filesUnder(folder) {
+  return under(folder).files;
+}
+function under(folder) {
+  const files = [];
+  const folders = [];
+  const walk = (at) => {
+    let items;
+    try {
+      items = readdirSync(at, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      if (item.name === "node_modules" || item.name === ".git") continue;
+      const path = join(at, item.name);
+      if (item.isDirectory()) {
+        folders.push(path);
+        walk(path);
+      } else files.push(path);
+    }
+  };
+  walk(folder);
+  return { files, folders };
+}
+function removeEmpty(folder, keep) {
+  for (const item of readdirSync(folder, { withFileTypes: true })) {
+    if (!item.isDirectory()) continue;
+    const path = join(folder, item.name);
+    removeEmpty(path, keep);
+    if (!readdirSync(path).length && !keep.has(resolve(path))) rmdirSync(path);
+  }
+}
+function writtenByTilua(folder) {
+  return filesUnder(folder).filter((path) => /\.luau?$/.test(path) && isTilua(path));
+}
+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 rootDir = resolve(found?.rootDir ?? process.cwd());
+  const mirror = perFile && resolve(folder) !== rootDir;
+  if (mirror && (isInside(folder, rootDir) || isInside(rootDir, folder) || isInside(folder, found?.directory ?? process.cwd()))) {
+    console.error(`outDir (${shown(folder)}) has to be a folder of its own: not ${isInside(rootDir, folder) ? "under" : "around"} rootDir (${shown(rootDir)}), and not around the project`);
+    return false;
+  }
   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;
   }
-  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"}`);
+  const targets = result.files.map((file) => ({ ...file, target: join(folder, file.path) }));
+  if (mirror) {
+    const compiled = new Map(targets.map((file) => [resolve(file.target), file]));
+    const copies = [];
+    let clash = false;
+    const leftovers = [];
+    for (const source of filesUnder(rootDir)) {
+      if (source.endsWith(".tilua")) continue;
+      if (/\.luau?$/.test(source) && isTilua(source)) {
+        leftovers.push(source);
+        continue;
+      }
+      const target = resolve(folder, relative(rootDir, source));
+      if (compiled.has(target)) {
+        console.error(`${shown(source)}: a .tilua compiles to the same file \u2014 rename or remove one of them`);
+        clash = true;
+        continue;
+      }
+      copies.push({ source, target });
+    }
+    if (clash) return false;
+    for (const leftover of leftovers) {
+      rmSync(leftover);
+      console.log(`${shown(leftover)}: removed \u2014 tilua compiled it beside its .tilua, and the output is in ${shown(folder)} now`);
+    }
+    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 { source, target } of copies) {
+      const bytes = readFileSync(source);
+      if (existsSync(target) && readFileSync(target).equals(bytes)) continue;
+      mkdirSync(dirname(target), { recursive: true });
+      copyFileSync(source, target);
+      console.log(`${shown(target)}: copied`);
+    }
+    const kept = /* @__PURE__ */ new Set([...compiled.keys(), ...copies.map((copy) => copy.target)]);
+    for (const stale of filesUnder(folder)) {
+      if (kept.has(resolve(stale))) continue;
+      rmSync(stale);
+      console.log(`${shown(stale)}: removed`);
+    }
+    const folders = /* @__PURE__ */ new Set([folder, ...under(rootDir).folders.map((path) => resolve(folder, relative(rootDir, path)))]);
+    for (const path of folders) mkdirSync(path, { recursive: true });
+    removeEmpty(folder, folders);
+    return !result.diagnostics.some((d) => d.severity !== "warning");
+  }
+  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"}`);
+  }
+  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());
+  const rootDir = found?.rootDir;
+  const outDir = resolve(out ?? found?.outDir ?? folder);
+  const mirrored = (output ?? found?.output) === "files" && rootDir !== void 0 && outDir !== resolve(rootDir);
+  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 = resolve(folder, name.toString());
+    if (relative(folder, path).split(/[\\/]/).includes("node_modules") || isInside(outDir, path) && mirrored) return;
+    const read = /\.tilua$|tilua\.config\.jsonc?$|\.project\.json$/.test(path) || mirrored && isInside(rootDir, path);
+    if (!read) 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);
 });