@eighty4/dank 0.0.4-1 → 0.0.4-3

package/lib_js/registry.js

@@ -0,0 +1,260 @@
+import EventEmitter from "node:events";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Resolver } from "./dirs.js";
+import { HtmlEntrypoint } from "./html.js";
+class WebsiteRegistry extends EventEmitter {
+  // paths of bundled esbuild outputs, as built by esbuild
+  #bundles = /* @__PURE__ */ new Set();
+  #c;
+  // public dir assets
+  #copiedAssets = null;
+  // map of entrypoints to their output path
+  #entrypointHrefs = {};
+  #pages = {};
+  #resolver;
+  #workers = null;
+  constructor(config) {
+    super();
+    this.#c = config;
+    this.#resolver = new Resolver(config.dirs);
+  }
+  get config() {
+    return this.#c;
+  }
+  set copiedAssets(copiedAssets) {
+    this.#copiedAssets = copiedAssets === null ? null : new Set(copiedAssets);
+  }
+  get htmlEntrypoints() {
+    return Object.values(this.#pages).map((p) => p.html);
+  }
+  get pageUrls() {
+    return Object.keys(this.#pages);
+  }
+  get resolver() {
+    return this.#resolver;
+  }
+  get urlRewrites() {
+    return Object.values(this.#pages).filter((pr) => typeof pr.urlRewrite !== "undefined").map((pr) => pr.urlRewrite);
+  }
+  get webpageEntryPoints() {
+    const unique = /* @__PURE__ */ new Set();
+    return Object.values(this.#pages).flatMap((p) => p.bundles).filter((entryPoint) => {
+      if (unique.has(entryPoint.in)) {
+        return false;
+      } else {
+        unique.add(entryPoint.in);
+        return true;
+      }
+    });
+  }
+  get webpageAndWorkerEntryPoints() {
+    const unique = /* @__PURE__ */ new Set();
+    const pageBundles = Object.values(this.#pages).flatMap((p) => p.bundles);
+    const workerBundles = this.workerEntryPoints;
+    const bundles = workerBundles ? [...pageBundles, ...workerBundles] : pageBundles;
+    return bundles.filter((entryPoint) => {
+      if (unique.has(entryPoint.in)) {
+        return false;
+      } else {
+        unique.add(entryPoint.in);
+        return true;
+      }
+    });
+  }
+  get workerEntryPoints() {
+    return this.#workers?.map(({ workerEntryPoint }) => ({
+      in: workerEntryPoint,
+      out: workerEntryPoint.replace(/^pages[\//]/, "").replace(/\.(mj|t)s$/, ".js")
+    })) || null;
+  }
+  get workers() {
+    return this.#workers;
+  }
+  buildRegistry() {
+    return new BuildRegistry(this.#c.dirs, this.#resolver, this.#onBuildManifest);
+  }
+  configSync() {
+    this.#configDiff();
+  }
+  files() {
+    const files = /* @__PURE__ */ new Set();
+    for (const pageUrl of Object.keys(this.#pages))
+      files.add(pageUrl === "/" ? "/index.html" : `${pageUrl}/index.html`);
+    for (const f of this.#bundles)
+      files.add(f);
+    if (this.#copiedAssets)
+      for (const f of this.#copiedAssets)
+        files.add(f);
+    return files;
+  }
+  mappedHref(lookup) {
+    const found = this.#entrypointHrefs[lookup];
+    if (found) {
+      return found;
+    } else {
+      throw Error(`mapped href for ${lookup} not found`);
+    }
+  }
+  async writeManifest(buildTag) {
+    const manifest = this.#manifest(buildTag);
+    await writeFile(join(this.#c.dirs.projectRootAbs, this.#c.dirs.buildRoot, "website.json"), JSON.stringify({
+      buildTag,
+      files: Array.from(manifest.files),
+      pageUrls: Array.from(manifest.pageUrls)
+    }, null, 4));
+    return manifest;
+  }
+  #configDiff() {
+    const updatePages = this.#c.devPages ? { ...this.#c.pages, ...this.#c.devPages } : { ...this.#c.pages };
+    const prevPages = new Set(Object.keys(this.#pages));
+    for (const [urlPath, mapping] of Object.entries(updatePages)) {
+      const existingPage = prevPages.delete(urlPath);
+      if (existingPage) {
+        this.#configPageUpdate(urlPath, mapping);
+      } else {
+        this.#configPageAdd(urlPath, mapping);
+      }
+    }
+    for (const prevPage of prevPages) {
+      this.#configPageRemove(prevPage);
+    }
+  }
+  #configPageAdd(urlPath, mapping) {
+    const html = new HtmlEntrypoint(this.#c, this.#resolver, urlPath, mapping.webpage);
+    const urlRewrite = mapping.pattern ? { pattern: mapping.pattern, url: urlPath } : void 0;
+    this.#pages[urlPath] = {
+      pageUrl: urlPath,
+      fsPath: mapping.webpage,
+      html,
+      urlRewrite,
+      bundles: []
+    };
+    html.on("entrypoints", (entrypoints) => this.#setWebpageBundles(html.url, entrypoints));
+    this.emit("webpage", html);
+  }
+  #configPageUpdate(urlPath, mapping) {
+    const existingRegistration = this.#pages[urlPath];
+    if (existingRegistration.fsPath !== mapping.webpage) {
+      this.#configPageRemove(urlPath);
+      this.#configPageAdd(urlPath, mapping);
+    } else if (existingRegistration.urlRewrite?.pattern.source !== mapping.pattern?.source) {
+      if (mapping.pattern) {
+        existingRegistration.urlRewrite = {
+          url: urlPath,
+          pattern: mapping.pattern
+        };
+      } else {
+        existingRegistration.urlRewrite = void 0;
+      }
+    }
+  }
+  #configPageRemove(urlPath) {
+    const registration = this.#pages[urlPath];
+    registration.html.removeAllListeners();
+    delete this.#pages[urlPath];
+  }
+  #manifest(buildTag) {
+    return {
+      buildTag,
+      files: this.files(),
+      pageUrls: new Set(Object.keys(this.#pages))
+    };
+  }
+  #onBuildManifest = (build) => {
+    for (const [outPath, entrypoint] of Object.entries(build.bundles)) {
+      this.#bundles.add(outPath);
+      if (entrypoint) {
+        this.#entrypointHrefs[entrypoint] = outPath;
+      }
+    }
+    let updatedWorkerEntrypoints = false;
+    const previousWorkers = this.#workers === null ? null : new Set(this.#workers.map((w) => w.workerEntryPoint));
+    if (build.workers) {
+      if (!previousWorkers || previousWorkers.size !== new Set(build.workers.map((w) => w.workerEntryPoint)).size) {
+        updatedWorkerEntrypoints = true;
+      } else {
+        updatedWorkerEntrypoints = !build.workers.every((w) => previousWorkers.has(w.workerEntryPoint));
+      }
+    } else if (previousWorkers) {
+      updatedWorkerEntrypoints = true;
+    }
+    if (build.workers) {
+      if (!this.#workers) {
+        this.#workers = build.workers;
+      } else {
+        for (const w of build.workers) {
+          const found = this.#workers.find((w2) => {
+            return w.dependentEntryPoint === w2.dependentEntryPoint && w.workerEntryPoint === w2.workerEntryPoint;
+          });
+          if (!found) {
+            this.#workers.push(w);
+          }
+        }
+      }
+    }
+    if (updatedWorkerEntrypoints) {
+      this.emit("workers");
+    }
+  };
+  #setWebpageBundles(url, bundles) {
+    this.#pages[url].bundles = bundles;
+    this.emit("entrypoints");
+  }
+}
+class BuildRegistry {
+  #dirs;
+  #onComplete;
+  #resolver;
+  #workers = null;
+  constructor(dirs, resolver, onComplete) {
+    this.#dirs = dirs;
+    this.#onComplete = onComplete;
+    this.#resolver = resolver;
+  }
+  get dirs() {
+    return this.#dirs;
+  }
+  get resolver() {
+    return this.#resolver;
+  }
+  // resolve web worker imported by a webpage module
+  addWorker(worker) {
+    if (!this.#workers) {
+      this.#workers = [worker];
+    } else {
+      this.#workers.push(worker);
+    }
+  }
+  completeBuild(result) {
+    const bundles = {};
+    for (const [outPath, output] of Object.entries(result.metafile.outputs)) {
+      bundles[outPath.replace(/^build[/\\]dist/, "")] = output.entryPoint || null;
+    }
+    let workers = null;
+    if (this.#workers) {
+      workers = [];
+      for (const output of Object.values(result.metafile.outputs)) {
+        if (!output.entryPoint)
+          continue;
+        const inputs = Object.keys(output.inputs);
+        for (const worker of this.#workers) {
+          if (inputs.includes(worker.clientScript)) {
+            workers.push({
+              ...worker,
+              dependentEntryPoint: output.entryPoint
+            });
+          }
+        }
+      }
+    }
+    this.#onComplete({
+      bundles,
+      workers
+    });
+  }
+}
+export {
+  BuildRegistry,
+  WebsiteRegistry
+};

package/lib_js/serve.js

@@ -1,268 +1,126 @@
-import { mkdir, readFile, rm, watch as _watch, writeFile, } from 'node:fs/promises';
-import { extname, join, resolve } from 'node:path';
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { extname, join } from "node:path";
 import { buildWebsite } from "./build.js";
 import { loadConfig } from "./config.js";
 import { createGlobalDefinitions } from "./define.js";
 import { esbuildDevContext } from "./esbuild.js";
-import { resolveServeFlags } from "./flags.js";
-import { HtmlEntrypoint } from "./html.js";
-import { createBuiltDistFilesFetcher, createDevServeFilesFetcher, startWebServer, } from "./http.js";
-import { WebsiteRegistry } from "./metadata.js";
+import { createBuiltDistFilesFetcher, createDevServeFilesFetcher, startWebServer } from "./http.js";
+import { WebsiteRegistry } from "./registry.js";
 import { startDevServices, updateDevServices } from "./services.js";
-export async function serveWebsite(c) {
-    const serve = resolveServeFlags(c);
-    await rm(serve.dirs.buildRoot, { force: true, recursive: true });
-    const abortController = new AbortController();
-    process.once('exit', () => abortController.abort());
-    if (serve.preview) {
-        await startPreviewMode(c, serve, abortController.signal);
-    }
-    else {
-        await startDevMode(c, serve, abortController.signal);
-    }
-    return new Promise(() => { });
+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);
+  } else {
+    await startDevMode(abortController.signal);
+  }
+  return new Promise(() => {
+  });
 }
-async function startPreviewMode(c, serve, signal) {
-    const manifest = await buildWebsite(c, serve);
-    const frontend = createBuiltDistFilesFetcher(serve.dirs.buildDist, manifest);
-    const devServices = startDevServices(c, signal);
-    startWebServer(serve, frontend, devServices.http, {
-        urls: Object.keys(c.pages),
-        urlRewrites: collectUrlRewrites(c),
-    });
+async function startPreviewMode(signal) {
+  const manifest = await buildWebsite(c);
+  const frontend = createBuiltDistFilesFetcher(c.dirs, manifest);
+  const devServices = startDevServices(c.services, signal);
+  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);
 }
-function collectUrlRewrites(c) {
-    return 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);
-}
-// todo changing partials triggers update on html pages
-async function startDevMode(c, serve, signal) {
-    await mkdir(serve.dirs.buildWatch, { recursive: true });
-    const registry = new WebsiteRegistry(serve);
-    const clientJS = await loadClientJS(serve.esbuildPort);
-    const pagesByUrlPath = {};
-    const partialsByUrlPath = {};
-    const entryPointsByUrlPath = {};
-    let buildContext = null;
-    registry.on('workers', resetBuildContext);
-    watch('dank.config.ts', signal, async () => {
-        let updated;
-        try {
-            updated = await loadConfig();
-        }
-        catch (ignore) {
-            return;
-        }
-        const prevPages = new Set(Object.keys(pagesByUrlPath));
-        await Promise.all(Object.entries(updated.pages).map(async ([urlPath, mapping]) => {
-            c.pages[urlPath] = mapping;
-            const srcPath = typeof mapping === 'string' ? mapping : mapping.webpage;
-            if (!pagesByUrlPath[urlPath]) {
-                await addPage(urlPath, srcPath);
-            }
-            else {
-                prevPages.delete(urlPath);
-                if (pagesByUrlPath[urlPath].fsPath !== srcPath) {
-                    await updatePage(urlPath);
-                }
-            }
-        }));
-        for (const prevPage of Array.from(prevPages)) {
-            delete c.pages[prevPage];
-            deletePage(prevPage);
-        }
-        updateDevServices(updated);
-    });
-    watch(serve.dirs.pages, signal, filename => {
-        if (extname(filename) === '.html') {
-            for (const [urlPath, srcPath] of Object.entries(c.pages)) {
-                if (srcPath === filename) {
-                    updatePage(urlPath);
-                }
-            }
-            for (const [urlPath, partials] of Object.entries(partialsByUrlPath)) {
-                if (partials.includes(filename)) {
-                    updatePage(urlPath, filename);
-                }
-            }
-        }
-    });
-    await Promise.all(Object.entries(c.pages).map(async ([urlPath, mapping]) => {
-        const srcPath = typeof mapping === 'string' ? mapping : mapping.webpage;
-        await addPage(urlPath, srcPath);
-        return new Promise(res => pagesByUrlPath[urlPath].once('entrypoints', res));
-    }));
-    async function addPage(urlPath, srcPath) {
-        await mkdir(join(serve.dirs.buildWatch, urlPath), { recursive: true });
-        const htmlEntrypoint = (pagesByUrlPath[urlPath] = new HtmlEntrypoint(serve, registry.resolver, urlPath, srcPath, [{ type: 'script', js: clientJS }]));
-        htmlEntrypoint.on('entrypoints', entrypoints => {
-            const pathsIn = new Set(entrypoints.map(e => e.in));
-            if (!entryPointsByUrlPath[urlPath] ||
-                !matchingEntrypoints(entryPointsByUrlPath[urlPath].pathsIn, pathsIn)) {
-                entryPointsByUrlPath[urlPath] = { entrypoints, pathsIn };
-                resetBuildContext();
-            }
-        });
-        htmlEntrypoint.on('partial', partial => {
-            if (!partialsByUrlPath[urlPath]) {
-                partialsByUrlPath[urlPath] = [];
-            }
-            partialsByUrlPath[urlPath].push(partial);
-        });
-        htmlEntrypoint.on('partials', partials => (partialsByUrlPath[urlPath] = partials));
-        htmlEntrypoint.on('output', html => writeFile(join(serve.dirs.buildWatch, urlPath, 'index.html'), html));
-    }
-    function deletePage(urlPath) {
-        pagesByUrlPath[urlPath].removeAllListeners();
-        delete pagesByUrlPath[urlPath];
-        delete entryPointsByUrlPath[urlPath];
-        resetBuildContext();
-    }
-    async function updatePage(urlPath, partial) {
-        pagesByUrlPath[urlPath].emit('change', partial);
+async function startDevMode(signal) {
+  const registry = new WebsiteRegistry(c);
+  await mkdir(c.dirs.buildWatch, { recursive: true });
+  let buildContext = null;
+  watch("dank.config.ts", signal, async () => {
+    try {
+      await c.reload();
+    } catch (ignore) {
+      return;
     }
-    function collectEntrypoints() {
-        const unique = new Set();
-        const pageBundles = Object.values(entryPointsByUrlPath)
-            .flatMap(entrypointState => entrypointState.entrypoints)
-            .filter(entryPoint => {
-            if (unique.has(entryPoint.in)) {
-                return false;
-            }
-            else {
-                unique.add(entryPoint.in);
-                return true;
-            }
-        });
-        const workerBundles = registry.workerEntryPoints();
-        if (workerBundles) {
-            return [...pageBundles, ...workerBundles];
-        }
-        else {
-            return pageBundles;
+    registry.configSync();
+    updateDevServices(c.services);
+  });
+  watch(c.dirs.pages, signal, (filename) => {
+    if (extname(filename) === ".html") {
+      registry.htmlEntrypoints.forEach((html) => {
+        if (html.fsPath === filename) {
+          html.emit("change");
+        } else if (html.usesPartial(filename)) {
+          html.emit("change", filename);
         }
+      });
     }
-    function resetBuildContext() {
-        switch (buildContext) {
-            case 'starting':
-                buildContext = 'dirty';
-                return;
-            case 'dirty':
-            case 'disposing':
-                return;
-        }
-        if (buildContext !== null) {
-            const disposing = buildContext.dispose();
-            buildContext = 'disposing';
-            disposing.then(() => {
-                buildContext = null;
-                resetBuildContext();
-            });
-        }
-        else {
-            buildContext = 'starting';
-            startEsbuildWatch(c, registry, serve, collectEntrypoints()).then(ctx => {
-                if (buildContext === 'dirty') {
-                    buildContext = 'disposing';
-                    ctx.dispose().then(() => {
-                        buildContext = null;
-                        resetBuildContext();
-                    });
-                }
-                else {
-                    buildContext = ctx;
-                }
-            });
+  });
+  function resetBuildContext() {
+    switch (buildContext) {
+      case "starting":
+        buildContext = "dirty";
+        return;
+      case "dirty":
+      case "disposing":
+        return;
+    }
+    if (buildContext !== null) {
+      const disposing = buildContext.dispose();
+      buildContext = "disposing";
+      disposing.then(() => {
+        buildContext = null;
+        resetBuildContext();
+      });
+    } else {
+      buildContext = "starting";
+      startEsbuildWatch(registry).then((ctx) => {
+        if (buildContext === "dirty") {
+          buildContext = "disposing";
+          ctx.dispose().then(() => {
+            buildContext = null;
+            resetBuildContext();
+          });
+        } else {
+          buildContext = ctx;
         }
+      });
     }
-    // function removePartialFromPage(partial: string, urlPath: string) {
-    //     const deleteIndex = urlPathsByPartials[partial].indexOf(urlPath)
-    //     if (deleteIndex !== -1) {
-    //         if (urlPathsByPartials[partial].length === 1) {
-    //             delete urlPathsByPartials[partial]
-    //         } else {
-    //             urlPathsByPartials[partial].splice(deleteIndex, 1)
-    //         }
-    //     }
-    // }
-    // inital start of esbuild ctx
+  }
+  registry.on("webpage", (html) => {
+    html.on("error", (e) => console.log(`\x1B[31merror:\x1B[0m`, e.message));
+    html.on("output", (output) => writeHtml(html, output));
+  });
+  registry.on("workers", () => {
     resetBuildContext();
-    // todo this page route state could be built on change and reused
-    const pageRoutes = {
-        get urls() {
-            return Object.keys(c.pages);
-        },
-        get urlRewrites() {
-            return collectUrlRewrites(c);
-        },
-    };
-    const frontend = createDevServeFilesFetcher(pageRoutes, serve);
-    const devServices = startDevServices(c, signal);
-    startWebServer(serve, frontend, devServices.http, pageRoutes);
+  });
+  registry.configSync();
+  await Promise.all(registry.htmlEntrypoints.map((html) => html.process()));
+  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);
 }
-function matchingEntrypoints(a, b) {
-    if (a.size !== b.size) {
-        return false;
+async function startEsbuildWatch(registry) {
+  const entryPoints = registry.webpageAndWorkerEntryPoints;
+  const ctx = await esbuildDevContext(registry, createGlobalDefinitions(c), entryPoints);
+  await ctx.watch();
+  await ctx.serve({
+    host: "127.0.0.1",
+    port: c.esbuildPort,
+    cors: {
+      origin: ["127.0.0.1", "localhost"].map((hostname) => `http://${hostname}:${c.dankPort}`)
     }
-    for (const v in a) {
-        if (!b.has(v)) {
-            return false;
-        }
-    }
-    return true;
-}
-async function startEsbuildWatch(c, registry, serve, entryPoints) {
-    const ctx = await esbuildDevContext(serve, registry, createGlobalDefinitions(serve), entryPoints, c.esbuild);
-    await ctx.watch();
-    await ctx.serve({
-        host: '127.0.0.1',
-        port: serve.esbuildPort,
-        cors: {
-            origin: ['127.0.0.1', 'localhost'].map(hostname => `http://${hostname}:${serve.dankPort}`),
-        },
-    });
-    return ctx;
+  });
+  return ctx;
 }
-async function loadClientJS(esbuildPort) {
-    const clientJS = await readFile(resolve(import.meta.dirname, join('..', 'client', 'esbuild.js')), 'utf-8');
-    return clientJS.replace('3995', `${esbuildPort}`);
-}
-async function watch(p, signal, fire) {
-    const delayFire = 90;
-    const timeout = 100;
-    let changes = {};
-    try {
-        for await (const { filename } of _watch(p, {
-            recursive: true,
-            signal,
-        })) {
-            if (filename) {
-                if (!changes[filename]) {
-                    const now = Date.now();
-                    changes[filename] = now + delayFire;
-                    setTimeout(() => {
-                        const now = Date.now();
-                        for (const [filename, then] of Object.entries(changes)) {
-                            if (then <= now) {
-                                fire(filename);
-                                delete changes[filename];
-                            }
-                        }
-                    }, timeout);
-                }
-            }
-        }
-    }
-    catch (e) {
-        if (e.name !== 'AbortError') {
-            throw e;
-        }
-    }
+async function writeHtml(html, output) {
+  const dir = join(c.dirs.buildWatch, html.url);
+  await mkdir(dir, { recursive: true });
+  const path = join(dir, "index.html");
+  await writeFile(path, output);
 }
+export {
+  serveWebsite
+};