@eighty4/dank 0.0.5-1 → 0.0.5-2

package/lib_js/serve.js

@@ -6,46 +6,51 @@ import { createGlobalDefinitions } from "./define.js";
 import { esbuildDevContext } from "./esbuild.js";
 import { createBuiltDistFilesFetcher, createDevServeFilesFetcher, startWebServer } from "./http.js";
 import { WebsiteRegistry } from "./registry.js";
-import { startDevServices, updateDevServices } from "./services.js";
+import { DevServices } from "./services.js";
 import { watch } from "./watch.js";
 let c;
 async function serveWebsite() {
   c = await loadConfig("serve", process.cwd());
   await rm(c.dirs.buildRoot, { force: true, recursive: true });
-  const abortController = new AbortController();
-  process.once("exit", () => abortController.abort());
   if (c.flags.preview) {
-    await startPreviewMode(abortController.signal);
+    await startPreviewMode();
   } else {
-    await startDevMode(abortController.signal);
+    await startDevMode();
   }
   return new Promise(() => {
   });
 }
-async function startPreviewMode(signal) {
+async function startPreviewMode() {
   const manifest = await buildWebsite(c);
   const frontend = createBuiltDistFilesFetcher(c.dirs, manifest);
-  const devServices = startDevServices(c.services, signal);
+  const devServices = launchDevServices();
   const urlRewrites = Object.keys(c.pages).sort().map((url) => {
     const mapping = c.pages[url];
     return typeof mapping !== "object" || !mapping.pattern ? null : { url, pattern: mapping.pattern };
   }).filter((mapping) => mapping !== null);
-  startWebServer(c.dankPort, c.flags, c.dirs, { urlRewrites }, frontend, devServices.http);
+  startWebServer(c.dankPort, c.flags, c.dirs, { urlRewrites }, frontend, devServices);
+  const controller = new AbortController();
+  watch("dank.config.ts", controller.signal, async (filename) => {
+    console.log(filename, "was updated!");
+    console.log("config updates are not hot reloaded during `dank serve --preview`");
+    console.log("restart DANK to reload configuration");
+    controller.abort();
+  });
 }
-async function startDevMode(signal) {
+async function startDevMode() {
   const registry = new WebsiteRegistry(c);
   await mkdir(c.dirs.buildWatch, { recursive: true });
   let buildContext = null;
-  watch("dank.config.ts", signal, async (filename) => {
+  watch("dank.config.ts", async (filename) => {
     try {
       await c.reload();
     } catch (ignore) {
       return;
     }
     registry.configSync();
-    updateDevServices(c.services);
+    devServices.update(c.services);
   });
-  watch(c.dirs.pages, signal, (filename) => {
+  watch(c.dirs.pages, { recursive: true }, (filename) => {
     if (extname(filename) === ".html") {
       registry.htmlEntrypoints.forEach((html) => {
         if (html.fsPath === filename) {
@@ -99,8 +104,8 @@ async function startDevMode(signal) {
   registry.on("entrypoints", () => resetBuildContext());
   resetBuildContext();
   const frontend = createDevServeFilesFetcher(c.esbuildPort, c.dirs, registry);
-  const devServices = startDevServices(c.services, signal);
-  startWebServer(c.dankPort, c.flags, c.dirs, registry, frontend, devServices.http);
+  const devServices = launchDevServices();
+  startWebServer(c.dankPort, c.flags, c.dirs, registry, frontend, devServices);
 }
 async function startEsbuildWatch(registry) {
   const entryPoints = registry.webpageAndWorkerEntryPoints;
@@ -121,6 +126,32 @@ async function writeHtml(html, output) {
   const path = join(dir, "index.html");
   await writeFile(path, output);
 }
+function launchDevServices() {
+  const services = new DevServices(c.services);
+  services.on("error", (label, cause) => console.log(formatServiceLabel(label), "errored:", cause));
+  services.on("exit", (label, code) => {
+    if (code) {
+      console.log(formatServiceLabel(label), "exited", code);
+    } else {
+      console.log(formatServiceLabel(label), "exited");
+    }
+  });
+  services.on("launch", (label) => console.log(formatServiceLabel(label), "starting"));
+  services.on("stdout", (label, output) => printServiceOutput(label, 32, output));
+  services.on("stderr", (label, output) => printServiceOutput(label, 31, output));
+  return services;
+}
+function formatServiceLabel(label) {
+  return `| \x1B[2m${label.cwd}\x1B[22m ${label.command} |`;
+}
+function formatServiceOutputLabel(label, color) {
+  return `\x1B[${color}m${formatServiceLabel(label)}\x1B[39m`;
+}
+function printServiceOutput(label, color, output) {
+  const formattedLabel = formatServiceOutputLabel(label, color);
+  for (const line of output)
+    console.log(formattedLabel, line);
+}
 export {
   serveWebsite
 };

package/lib_js/services.js

@@ -1,97 +1,130 @@
 import { execSync, spawn } from "node:child_process";
+import EventEmitter from "node:events";
 import { basename, isAbsolute, resolve } from "node:path";
-const running = [];
-if (process.platform === "win32") {
-  process.once("SIGINT", () => process.exit());
-  process.once("exit", () => {
-    for (const { process: process2 } of running) {
-      if (process2) {
-        execSync(`taskkill /pid ${process2.pid} /T /F`);
-      }
-    }
-  });
+class ManagedServiceLabel {
+  #command;
+  #cwd;
+  constructor(spec) {
+    this.#command = spec.command;
+    this.#cwd = !spec.cwd ? "./" : spec.cwd.startsWith("/") ? `/.../${basename(spec.cwd)}` : spec.cwd.startsWith(".") ? spec.cwd : `./${spec.cwd}`;
+  }
+  get command() {
+    return this.#command;
+  }
+  get cwd() {
+    return this.#cwd;
+  }
 }
-let signal;
-let updating = null;
-function startDevServices(services, _signal) {
-  signal = _signal;
-  if (services?.length) {
-    for (const s of services) {
-      running.push({ s, process: startService(s) });
-    }
+class ManagedService extends EventEmitter {
+  #label;
+  #process;
+  #spec;
+  // #status: ManagedServiceStatus = 'starting'
+  constructor(spec) {
+    super();
+    this.#label = new ManagedServiceLabel(spec);
+    this.#spec = spec;
+    this.#process = this.#start();
+  }
+  get spec() {
+    return this.#spec;
+  }
+  get httpSpec() {
+    return this.#spec.http;
   }
-  return {
-    http: {
-      get running() {
-        return running.map(({ s }) => s.http).filter((http) => !!http);
+  matches(other) {
+    return matchingConfig(this.#spec, other);
+  }
+  kill() {
+    if (this.#process)
+      killProcess(this.#process);
+  }
+  #start() {
+    const { path, args } = parseCommand(this.#spec.command);
+    const env = this.#spec.env ? { ...process.env, ...this.#spec.env } : void 0;
+    const cwd = !this.#spec.cwd || isAbsolute(this.#spec.cwd) ? this.#spec.cwd : resolve(process.cwd(), this.#spec.cwd);
+    const spawned = spawnProcess(path, args, env, cwd);
+    this.emit("launch", this.#label);
+    spawned.stdout.on("data", (chunk) => this.emit("stdout", this.#label, parseChunk(chunk)));
+    spawned.stderr.on("data", (chunk) => this.emit("stderr", this.#label, parseChunk(chunk)));
+    spawned.on("error", (e) => {
+      if (e.name === "AbortError") {
+        return;
       }
-    }
-  };
+      const cause = "code" in e && e.code === "ENOENT" ? "program not found" : e.message;
+      this.emit("error", this.#label, cause);
+    });
+    spawned.on("exit", (code, signal) => this.emit("exit", this.#label, code || signal));
+    return spawned;
+  }
 }
-function updateDevServices(services) {
-  if (!services?.length) {
-    if (running.length) {
-      if (updating === null) {
-        updating = { stopping: [], starting: [] };
-      }
-      running.forEach(({ s, process: process2 }) => {
-        if (process2) {
-          stopService(s, process2);
-        } else {
-          removeFromUpdating(s);
-        }
-      });
-      running.length = 0;
+const killProcess = process.platform === "win32" ? (p) => execSync(`taskkill /pid ${p.pid} /T /F`) : (p) => p.kill();
+const spawnProcess = process.platform === "win32" ? (path, args, env, cwd) => spawn("cmd", ["/c", path, ...args], {
+  cwd,
+  env,
+  detached: false,
+  shell: false,
+  windowsHide: true
+}) : (path, args, env, cwd) => spawn(path, args, {
+  cwd,
+  env,
+  detached: false,
+  shell: false
+});
+class DevServices extends EventEmitter {
+  #running;
+  constructor(services) {
+    super();
+    this.#running = services ? this.#start(services) : [];
+    if (process.platform === "win32") {
+      process.once("SIGINT", () => process.exit());
     }
-  } else {
-    if (updating === null) {
-      updating = { stopping: [], starting: [] };
-    }
-    const keep = [];
-    const next = [];
-    for (const s of services) {
-      let found = false;
-      for (let i = 0; i < running.length; i++) {
-        const p = running[i].s;
-        if (matchingConfig(s, p)) {
-          found = true;
-          keep.push(i);
-          break;
-        }
-      }
-      if (!found) {
-        next.push(s);
-      }
-    }
-    for (let i = running.length - 1; i >= 0; i--) {
-      if (!keep.includes(i)) {
-        const { s, process: process2 } = running[i];
-        if (process2) {
-          stopService(s, process2);
-        } else {
-          removeFromUpdating(s);
-        }
-        running.splice(i, 1);
-      }
+    process.once("exit", this.shutdown);
+  }
+  get httpServices() {
+    return this.#running.map((s) => s.httpSpec).filter((http) => !!http);
+  }
+  shutdown = () => {
+    this.#running.forEach((s) => {
+      s.kill();
+      s.removeAllListeners();
+    });
+    this.#running.length = 0;
+  };
+  update(services) {
+    if (!services?.length) {
+      this.shutdown();
+    } else if (!matchingConfigs(this.#running.map((s) => s.spec), services)) {
+      this.shutdown();
+      this.#running = this.#start(services);
     }
-    if (updating.stopping.length) {
-      for (const s of next) {
-        if (!updating.starting.find((queued) => matchingConfig(queued, s))) {
-          updating.starting.push(s);
-        }
-      }
+  }
+  #start(services) {
+    return services.map((spec) => {
+      const service = new ManagedService(spec);
+      service.on("error", (label, cause) => this.emit("error", label, cause));
+      service.on("exit", (label, code) => this.emit("exit", label, code));
+      service.on("launch", (label) => this.emit("launch", label));
+      service.on("stdout", (label, output) => this.emit("stdout", label, output));
+      service.on("stderr", (label, output) => this.emit("stderr", label, output));
+      return service;
+    });
+  }
+}
+function matchingConfigs(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  const crossRef = [...a];
+  for (const toFind of b) {
+    const found = crossRef.findIndex((spec) => matchingConfig(spec, toFind));
+    if (found === -1) {
+      return false;
     } else {
-      updating = null;
-      for (const s of next) {
-        running.push({ s, process: startService(s) });
-      }
+      crossRef.splice(found, 1);
     }
   }
-}
-function stopService(s, process2) {
-  opPrint(s, "stopping");
-  updating.stopping.push(s);
-  process2.kill();
+  return true;
 }
 function matchingConfig(a, b) {
   if (a.command !== b.command) {
@@ -119,99 +152,55 @@ function matchingConfig(a, b) {
   }
   return true;
 }
-function startService(s) {
-  opPrint(s, "starting");
-  const spawned = spawnService(s);
-  const stdoutLabel = logLabel(s, 32);
-  spawned.stdout.on("data", (chunk) => printChunk(stdoutLabel, chunk));
-  const stderrLabel = logLabel(s, 31);
-  spawned.stderr.on("data", (chunk) => printChunk(stderrLabel, chunk));
-  spawned.on("error", (e) => {
-    removeFromRunning(s);
-    if (e.name === "AbortError") {
-      return;
-    }
-    const cause = "code" in e && e.code === "ENOENT" ? "program not found" : e.message;
-    opPrint(s, "error: " + cause);
-  });
-  spawned.on("exit", () => {
-    opPrint(s, "exited");
-    removeFromRunning(s);
-    removeFromUpdating(s);
-  });
-  return spawned;
+function parseChunk(c) {
+  return c.toString().replace(/\r?\n$/, "").split(/\r?\n/);
 }
-function spawnService(s) {
-  const splitCmdAndArgs = s.command.split(/\s+/);
-  const program = splitCmdAndArgs[0];
-  const args = splitCmdAndArgs.length === 1 ? [] : splitCmdAndArgs.slice(1);
-  const env = s.env ? { ...process.env, ...s.env } : void 0;
-  const cwd = resolveCwd(s.cwd);
-  if (process.platform === "win32") {
-    return spawn("cmd", ["/c", program, ...args], {
-      cwd,
-      env,
-      detached: false,
-      shell: false,
-      windowsHide: true
-    });
-  } else {
-    return spawn(program, args, {
-      cwd,
-      env,
-      signal,
-      detached: false,
-      shell: false
-    });
+function parseCommand(command) {
+  command = command.trimStart();
+  const programSplitIndex = command.indexOf(" ");
+  if (programSplitIndex === -1) {
+    return { path: command.trim(), args: [] };
   }
-}
-function removeFromRunning(s) {
-  for (let i = 0; i < running.length; i++) {
-    if (matchingConfig(running[i].s, s)) {
-      running.splice(i, 1);
-      return;
+  const path = command.substring(0, programSplitIndex);
+  const args = [];
+  let argStart = programSplitIndex + 1;
+  let withinLiteral = false;
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i];
+    if (!withinLiteral) {
+      if (c === "'" || c === '"') {
+        withinLiteral = c;
+        continue;
+      }
+      if (c === "\\") {
+        i++;
+        continue;
+      }
     }
-  }
-}
-function removeFromUpdating(s) {
-  if (updating !== null) {
-    for (let i = 0; i < updating.stopping.length; i++) {
-      if (matchingConfig(updating.stopping[i], s)) {
-        updating.stopping.splice(i, 1);
-        if (!updating.stopping.length) {
-          updating.starting.forEach(startService);
-          updating = null;
-          return;
-        }
+    if (withinLiteral) {
+      if (c === withinLiteral) {
+        withinLiteral = false;
+        args.push(command.substring(argStart + 1, i));
+        argStart = i + 1;
       }
+      continue;
+    }
+    if (c === " " && i > argStart) {
+      const maybeArg2 = command.substring(argStart, i).trim();
+      if (maybeArg2.length) {
+        args.push(maybeArg2);
+      }
+      argStart = i + 1;
     }
   }
-}
-function printChunk(label, c) {
-  for (const l of parseChunk(c))
-    console.log(label, l);
-}
-function parseChunk(c) {
-  return c.toString().replace(/\r?\n$/, "").split(/\r?\n/);
-}
-function resolveCwd(p) {
-  if (!p || isAbsolute(p)) {
-    return p;
-  } else {
-    return resolve(process.cwd(), p);
+  const maybeArg = command.substring(argStart, command.length).trim();
+  if (maybeArg.length) {
+    args.push(maybeArg);
   }
-}
-function opPrint(s, msg) {
-  console.log(opLabel(s), msg);
-}
-function opLabel(s) {
-  return `\`${s.cwd ? s.cwd + " " : ""}${s.command}\``;
-}
-function logLabel(s, ansiColor) {
-  s.cwd = !s.cwd ? "./" : s.cwd.startsWith("/") ? `/.../${basename(s.cwd)}` : s.cwd.startsWith(".") ? s.cwd : `./${s.cwd}`;
-  return `\x1B[${ansiColor}m[\x1B[1m${s.command}\x1B[22m \x1B[2;3m${s.cwd}\x1B[22;23m]\x1B[0m`;
+  return { path, args };
 }
 export {
-  startDevServices,
-  updateDevServices
+  DevServices,
+  ManagedServiceLabel,
+  parseCommand
 };

package/lib_js/watch.js

@@ -1,13 +1,22 @@
 import { watch as createWatch } from "node:fs/promises";
-async function watch(p, signal, fire) {
+async function watch(p, signalFireOrOpts, fireOrUndefined) {
+  let opts;
+  let fire;
+  if (signalFireOrOpts instanceof AbortSignal) {
+    opts = { signal: signalFireOrOpts };
+  } else if (typeof signalFireOrOpts === "object") {
+    opts = signalFireOrOpts;
+  } else {
+    fire = signalFireOrOpts;
+  }
+  if (opts && typeof fireOrUndefined === "function") {
+    fire = fireOrUndefined;
+  }
   const delayFire = 90;
   const timeout = 100;
   let changes = {};
   try {
-    for await (const { filename } of createWatch(p, {
-      recursive: true,
-      signal
-    })) {
+    for await (const { filename } of createWatch(p, opts)) {
       if (filename) {
         if (!changes[filename]) {
           const now = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eighty4/dank",
-  "version": "0.0.5-1",
+  "version": "0.0.5-2",
   "type": "module",
   "license": "MIT",
   "author": "Adam McKee Bennett <adam.be.g84d@gmail.com>",