@eighty4/dank 0.0.4-1 → 0.0.4-2

package/lib_js/serve.js

@@ -1,268 +1,250 @@
-import { mkdir, readFile, rm, watch as _watch, writeFile, } from 'node:fs/promises';
-import { extname, join, resolve } from 'node:path';
+import { mkdir, readFile, rm, watch as _watch, writeFile } from "node:fs/promises";
+import { extname, join, resolve } 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 { createBuiltDistFilesFetcher, createDevServeFilesFetcher, startWebServer } from "./http.js";
 import { WebsiteRegistry } from "./metadata.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(() => { });
+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(() => {
+  });
 }
 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),
-    });
+  const manifest = await buildWebsite(c);
+  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)
+  });
 }
 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);
+  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;
+  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("serve");
+    } 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);
         }
-        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);
+      }
+    }));
+    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);
         }
-        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);
-                }
-            }
+      }
+      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];
+  });
+  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) => {
+      const path = join(serve.dirs.buildWatch, urlPath, "index.html");
+      writeFile(path, html);
+    });
+  }
+  function deletePage(urlPath) {
+    pagesByUrlPath[urlPath].removeAllListeners();
+    delete pagesByUrlPath[urlPath];
+    delete entryPointsByUrlPath[urlPath];
+    resetBuildContext();
+  }
+  async function updatePage(urlPath, partial) {
+    pagesByUrlPath[urlPath].emit("change", partial);
+  }
+  function collectEntrypoints() {
+    const unique = /* @__PURE__ */ 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;
     }
-    async function updatePage(urlPath, partial) {
-        pagesByUrlPath[urlPath].emit('change', partial);
+  }
+  function resetBuildContext() {
+    switch (buildContext) {
+      case "starting":
+        buildContext = "dirty";
+        return;
+      case "dirty":
+      case "disposing":
+        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;
+    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(c, registry, serve, collectEntrypoints()).then(ctx => {
-                if (buildContext === 'dirty') {
-                    buildContext = 'disposing';
-                    ctx.dispose().then(() => {
-                        buildContext = null;
-                        resetBuildContext();
-                    });
-                }
-                else {
-                    buildContext = ctx;
-                }
-            });
-        }
+  }
+  resetBuildContext();
+  const pageRoutes = {
+    get urls() {
+      return Object.keys(c.pages);
+    },
+    get urlRewrites() {
+      return collectUrlRewrites(c);
     }
-    // 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
-    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);
+  };
+  const frontend = createDevServeFilesFetcher(pageRoutes, serve);
+  const devServices = startDevServices(c, signal);
+  startWebServer(serve, frontend, devServices.http, pageRoutes);
 }
 function matchingEntrypoints(a, b) {
-    if (a.size !== b.size) {
-        return false;
-    }
-    for (const v in a) {
-        if (!b.has(v)) {
-            return false;
-        }
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const v in a) {
+    if (!b.has(v)) {
+      return false;
     }
-    return true;
+  }
+  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;
+  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;
 }
 async function loadClientJS(esbuildPort) {
-    const clientJS = await readFile(resolve(import.meta.dirname, join('..', 'client', 'esbuild.js')), 'utf-8');
-    return clientJS.replace('3995', `${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);
-                }
+  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 now2 = Date.now();
+            for (const [filename2, then] of Object.entries(changes)) {
+              if (then <= now2) {
+                fire(filename2);
+                delete changes[filename2];
+              }
             }
+          }, timeout);
         }
+      }
     }
-    catch (e) {
-        if (e.name !== 'AbortError') {
-            throw e;
-        }
+  } catch (e) {
+    if (e.name !== "AbortError") {
+      throw e;
     }
+  }
 }
+export {
+  serveWebsite
+};