@eighty4/dank 0.0.4-0 → 0.0.4-2

package/lib/serve.ts

@@ -11,6 +11,7 @@ import { buildWebsite } from './build.ts'
 import { loadConfig } from './config.ts'
 import type { DankConfig } from './dank.ts'
 import { createGlobalDefinitions } from './define.ts'
+import { LOG } from './developer.ts'
 import { esbuildDevContext, type EntryPoint } from './esbuild.ts'
 import { resolveServeFlags, type DankServe } from './flags.ts'
 import { HtmlEntrypoint } from './html.ts'
@@ -42,7 +43,7 @@ async function startPreviewMode(
     serve: DankServe,
     signal: AbortSignal,
 ) {
-    const manifest = await buildWebsite(c, serve)
+    const manifest = await buildWebsite(c)
     const frontend = createBuiltDistFilesFetcher(serve.dirs.buildDist, manifest)
     const devServices = startDevServices(c, signal)
     startWebServer(serve, frontend, devServices.http, {
@@ -89,12 +90,21 @@ async function startDevMode(
     const entryPointsByUrlPath: Record<string, EntrypointsState> = {}
     let buildContext: BuildContextState = null
 
-    registry.on('workers', resetBuildContext)
+    registry.on('workers', () => {
+        LOG({
+            realm: 'serve',
+            message: 'registry updated worker entrypoints',
+            data: {
+                workers: registry.workerEntryPoints()?.map(ep => ep.in) || null,
+            },
+        })
+        resetBuildContext()
+    })
 
     watch('dank.config.ts', signal, async () => {
         let updated: DankConfig
         try {
-            updated = await loadConfig()
+            updated = await loadConfig('serve')
         } catch (ignore) {
             return
         }
@@ -105,16 +115,41 @@ async function startDevMode(
                 const srcPath =
                     typeof mapping === 'string' ? mapping : mapping.webpage
                 if (!pagesByUrlPath[urlPath]) {
+                    LOG({
+                        realm: 'config',
+                        message: 'added page',
+                        data: {
+                            urlPath,
+                            srcPath,
+                        },
+                    })
                     await addPage(urlPath, srcPath)
                 } else {
                     prevPages.delete(urlPath)
                     if (pagesByUrlPath[urlPath].fsPath !== srcPath) {
+                        LOG({
+                            realm: 'config',
+                            message: 'updated page src',
+                            data: {
+                                urlPath,
+                                newSrcPath: srcPath,
+                                oldSrcPath: pagesByUrlPath[urlPath].fsPath,
+                            },
+                        })
                         await updatePage(urlPath)
                     }
                 }
             }),
         )
         for (const prevPage of Array.from(prevPages)) {
+            LOG({
+                realm: 'config',
+                message: 'removed page',
+                data: {
+                    urlPath: prevPage,
+                    srcPath: c.pages[prevPage as `/${string}`] as string,
+                },
+            })
             delete c.pages[prevPage as `/${string}`]
             deletePage(prevPage)
         }
@@ -122,6 +157,13 @@ async function startDevMode(
     })
 
     watch(serve.dirs.pages, signal, filename => {
+        LOG({
+            realm: 'serve',
+            message: 'pages dir watch event',
+            data: {
+                file: filename,
+            },
+        })
         if (extname(filename) === '.html') {
             for (const [urlPath, srcPath] of Object.entries(c.pages)) {
                 if (srcPath === filename) {
@@ -153,6 +195,7 @@ async function startDevMode(
         await mkdir(join(serve.dirs.buildWatch, urlPath), { recursive: true })
         const htmlEntrypoint = (pagesByUrlPath[urlPath] = new HtmlEntrypoint(
             serve,
+            registry.resolver,
             urlPath,
             srcPath,
             [{ type: 'script', js: clientJS }],
@@ -166,23 +209,56 @@ async function startDevMode(
                     pathsIn,
                 )
             ) {
+                LOG({
+                    realm: 'serve',
+                    message: 'html entrypoints event',
+                    data: {
+                        previous:
+                            entryPointsByUrlPath[urlPath]?.pathsIn || null,
+                        new: pathsIn,
+                    },
+                })
                 entryPointsByUrlPath[urlPath] = { entrypoints, pathsIn }
                 resetBuildContext()
             }
         })
         htmlEntrypoint.on('partial', partial => {
+            LOG({
+                realm: 'serve',
+                message: 'html partial event',
+                data: {
+                    webpage: htmlEntrypoint.fsPath,
+                    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),
-        )
+        htmlEntrypoint.on('partials', partials => {
+            LOG({
+                realm: 'serve',
+                message: 'html partials event',
+                data: {
+                    allPartials: partials.length === 0,
+                    partials,
+                },
+            })
+            partialsByUrlPath[urlPath] = partials
+        })
+        htmlEntrypoint.on('output', html => {
+            const path = join(serve.dirs.buildWatch, urlPath, 'index.html')
+            LOG({
+                realm: 'serve',
+                message: 'html output event',
+                data: {
+                    webpage: htmlEntrypoint.fsPath,
+                    path,
+                },
+            })
+            writeFile(path, html)
+        })
     }
 
     function deletePage(urlPath: string) {
@@ -226,6 +302,7 @@ async function startDevMode(
                 return
         }
         if (buildContext !== null) {
+            LOG({ realm: 'serve', message: 'disposing esbuild context' })
             const disposing = buildContext.dispose()
             buildContext = 'disposing'
             disposing.then(() => {
@@ -296,6 +373,13 @@ async function startEsbuildWatch(
     serve: DankServe,
     entryPoints: Array<EntryPoint>,
 ): Promise<BuildContext> {
+    LOG({
+        realm: 'serve',
+        message: 'starting esbuild watch',
+        data: {
+            entrypoints: entryPoints.map(ep => ep.in),
+        },
+    })
     const ctx = await esbuildDevContext(
         serve,
         registry,

package/lib_js/bin.js

@@ -2,105 +2,101 @@
 import { buildWebsite } from "./build.js";
 import { loadConfig } from "./config.js";
 import { serveWebsite } from "./serve.js";
-function printHelp(task) {
-    if (!task || task === 'build') {
-        console.log('dank build [--minify] [--production]');
-    }
-    if (!task || task === 'serve') {
-        console.log(
-        // 'dank serve [--minify] [--preview] [--production]',
-        'dank serve [--minify] [--production]');
-    }
-    console.log('\nOPTIONS:');
-    if (!task || task === 'serve')
-        console.log('  --log-http     print access logs');
-    console.log('  --minify       minify sources');
-    // if (!task || task === 'serve') console.log('  --preview      pre-bundle and build ServiceWorker')
-    console.log('  --production   build for production release');
-    if (task) {
-        console.log();
-        console.log('use `dank -h` for details on all commands');
-    }
-    process.exit(1);
+function printHelp(task2) {
+  if (!task2 || task2 === "build") {
+    console.log("dank build [--minify] [--production]");
+  }
+  if (!task2 || task2 === "serve") {
+    console.log(
+      // 'dank serve [--minify] [--preview] [--production]',
+      "dank serve [--minify] [--production]"
+    );
+  }
+  console.log("\nOPTIONS:");
+  if (!task2 || task2 === "serve")
+    console.log("  --log-http     print access logs");
+  console.log("  --minify       minify sources");
+  console.log("  --production   build for production release");
+  if (task2) {
+    console.log();
+    console.log("use `dank -h` for details on all commands");
+  }
+  process.exit(1);
 }
 const args = (function collectProgramArgs() {
-    const programNames = ['dank', 'bin.js', 'bin.ts'];
-    let args = [...process.argv];
-    while (true) {
-        const shifted = args.shift();
-        if (!shifted || programNames.some(name => shifted.endsWith(name))) {
-            return args;
-        }
+  const programNames = ["dank", "bin.js", "bin.ts"];
+  let args2 = [...process.argv];
+  while (true) {
+    const shifted = args2.shift();
+    if (!shifted || programNames.some((name) => shifted.endsWith(name))) {
+      return args2;
     }
+  }
 })();
 const task = (function resolveTask() {
-    const showHelp = args.some(arg => arg === '-h' || arg === '--help');
-    const task = (() => {
-        while (true) {
-            const shifted = args.shift();
-            switch (shifted) {
-                case '-h':
-                case '--help':
-                    break;
-                case 'build':
-                    return 'build';
-                case 'dev':
-                case 'serve':
-                    return 'serve';
-                default:
-                    if (showHelp) {
-                        printHelp();
-                    }
-                    else if (typeof shifted === 'undefined') {
-                        printError('missing command');
-                        printHelp();
-                    }
-                    else {
-                        printError(shifted + " isn't a command");
-                        printHelp();
-                    }
-            }
-        }
-    })();
-    if (showHelp) {
-        printHelp(task);
+  const showHelp = args.some((arg) => arg === "-h" || arg === "--help");
+  const task2 = (() => {
+    while (true) {
+      const shifted = args.shift();
+      switch (shifted) {
+        case "-h":
+        case "--help":
+          break;
+        case "build":
+          return "build";
+        case "dev":
+        case "serve":
+          return "serve";
+        default:
+          if (showHelp) {
+            printHelp();
+          } else if (typeof shifted === "undefined") {
+            printError("missing command");
+            printHelp();
+          } else {
+            printError(shifted + " isn't a command");
+            printHelp();
+          }
+      }
     }
-    return task;
+  })();
+  if (showHelp) {
+    printHelp(task2);
+  }
+  return task2;
 })();
-const c = await loadConfig();
+const c = await loadConfig(task);
 try {
-    switch (task) {
-        case 'build':
-            await buildWebsite(c);
-            console.log(green('done'));
-            process.exit(0);
-        case 'serve':
-            await serveWebsite(c);
-    }
-}
-catch (e) {
-    errorExit(e);
+  switch (task) {
+    case "build":
+      await buildWebsite(c);
+      console.log(green("done"));
+      process.exit(0);
+    case "serve":
+      await serveWebsite(c);
+  }
+} catch (e) {
+  errorExit(e);
 }
 function printError(e) {
-    if (e !== null) {
-        if (typeof e === 'string') {
-            console.error(red('error:'), e);
-        }
-        else if (e instanceof Error) {
-            console.error(red('error:'), e.message);
-            if (e.stack) {
-                console.error(e.stack);
-            }
-        }
+  if (e !== null) {
+    if (typeof e === "string") {
+      console.error(red("error:"), e);
+    } else if (e instanceof Error) {
+      console.error(red("error:"), e.message);
+      if (e.stack) {
+        console.error(e.stack);
+      }
     }
+  }
 }
 function green(s) {
-    return `\u001b[32m${s}\u001b[0m`;
+  return `\x1B[32m${s}\x1B[0m`;
 }
 function red(s) {
-    return `\u001b[31m${s}\u001b[0m`;
+  return `\x1B[31m${s}\x1B[0m`;
 }
 function errorExit(e) {
-    printError(e);
-    process.exit(1);
+  printError(e);
+  process.exit(1);
 }

package/lib_js/build.js

@@ -1,5 +1,5 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import { createBuildTag } from "./build_tag.js";
 import { createGlobalDefinitions } from "./define.js";
 import { esbuildWebpages, esbuildWorkers } from "./esbuild.js";
@@ -7,89 +7,80 @@ import { resolveBuildFlags } from "./flags.js";
 import { HtmlEntrypoint } from "./html.js";
 import { WebsiteRegistry } from "./metadata.js";
 import { copyAssets } from "./public.js";
-export async function buildWebsite(c, build = resolveBuildFlags()) {
-    const buildTag = await createBuildTag(build);
-    console.log(build.minify
-        ? build.production
-            ? 'minified production'
-            : 'minified'
-        : 'unminified', 'build', buildTag, 'building in ./build/dist');
-    await rm(build.dirs.buildRoot, { recursive: true, force: true });
-    await mkdir(build.dirs.buildDist, { recursive: true });
-    for (const subdir of Object.keys(c.pages).filter(url => url !== '/')) {
-        await mkdir(join(build.dirs.buildDist, subdir), { recursive: true });
-    }
-    await mkdir(join(build.dirs.buildRoot, 'metafiles'), { recursive: true });
-    const registry = new WebsiteRegistry(build);
-    registry.pageUrls = Object.keys(c.pages);
-    registry.copiedAssets = await copyAssets(build);
-    await buildWebpages(c, registry, build, createGlobalDefinitions(build));
-    return await registry.writeManifest(buildTag);
+async function buildWebsite(c) {
+  const build = resolveBuildFlags();
+  const buildTag = await createBuildTag(build);
+  console.log(build.minify ? build.production ? "minified production" : "minified" : "unminified", "build", buildTag, "building in ./build/dist");
+  await rm(build.dirs.buildRoot, { recursive: true, force: true });
+  await mkdir(build.dirs.buildDist, { recursive: true });
+  for (const subdir of Object.keys(c.pages).filter((url) => url !== "/")) {
+    await mkdir(join(build.dirs.buildDist, subdir), { recursive: true });
+  }
+  await mkdir(join(build.dirs.buildRoot, "metafiles"), { recursive: true });
+  const registry = new WebsiteRegistry(build);
+  registry.pageUrls = Object.keys(c.pages);
+  registry.copiedAssets = await copyAssets(build);
+  await buildWebpages(c, registry, build, createGlobalDefinitions(build));
+  return await registry.writeManifest(buildTag);
 }
-// builds all webpage entrypoints in one esbuild.build context
-// to support code splitting
-// returns all built assets URLs and webpage URLs from DankConfig.pages
 async function buildWebpages(c, registry, build, define) {
-    // create HtmlEntrypoint for each webpage and collect awaitable esbuild entrypoints
-    const loadingEntryPoints = [];
-    const htmlEntrypoints = [];
-    for (const [urlPath, mapping] of Object.entries(c.pages)) {
-        const fsPath = typeof mapping === 'string' ? mapping : mapping.webpage;
-        const html = new HtmlEntrypoint(build, urlPath, fsPath);
-        loadingEntryPoints.push(new Promise(res => html.on('entrypoints', res)));
-        htmlEntrypoints.push(html);
-    }
-    // collect esbuild entrypoints from every HtmlEntrypoint
-    const uniqueEntryPoints = new Set();
-    const buildEntryPoints = [];
-    for (const pageEntryPoints of await Promise.all(loadingEntryPoints)) {
-        for (const entryPoint of pageEntryPoints) {
-            if (!uniqueEntryPoints.has(entryPoint.in)) {
-                buildEntryPoints.push(entryPoint);
-            }
-        }
+  const loadingEntryPoints = [];
+  const htmlEntrypoints = [];
+  for (const [urlPath, mapping] of Object.entries(c.pages)) {
+    const fsPath = typeof mapping === "string" ? mapping : mapping.webpage;
+    const html = new HtmlEntrypoint(build, registry.resolver, urlPath, fsPath);
+    loadingEntryPoints.push(new Promise((res) => html.on("entrypoints", res)));
+    htmlEntrypoints.push(html);
+  }
+  const uniqueEntryPoints = /* @__PURE__ */ new Set();
+  const buildEntryPoints = [];
+  for (const pageEntryPoints of await Promise.all(loadingEntryPoints)) {
+    for (const entryPoint of pageEntryPoints) {
+      if (!uniqueEntryPoints.has(entryPoint.in)) {
+        buildEntryPoints.push(entryPoint);
+      }
     }
-    await esbuildWebpages(build, registry, define, buildEntryPoints, c.esbuild);
-    // todo recursively build workers on building workers that create workers
-    const workerEntryPoints = registry.workerEntryPoints();
-    if (workerEntryPoints?.length) {
-        await esbuildWorkers(build, registry, define, workerEntryPoints, c.esbuild);
-    }
-    await rewriteWorkerUrls(build, registry);
-    // write out html output with rewritten hrefs
-    await Promise.all(htmlEntrypoints.map(async (html) => {
-        await writeFile(join(build.dirs.buildDist, html.url, 'index.html'), html.output(registry));
-    }));
+  }
+  await esbuildWebpages(build, registry, define, buildEntryPoints, c.esbuild);
+  const workerEntryPoints = registry.workerEntryPoints();
+  if (workerEntryPoints?.length) {
+    await esbuildWorkers(build, registry, define, workerEntryPoints, c.esbuild);
+  }
+  await rewriteWorkerUrls(build, registry);
+  await Promise.all(htmlEntrypoints.map(async (html) => {
+    await writeFile(join(build.dirs.buildDist, html.url, "index.html"), html.output(registry));
+  }));
 }
-export async function rewriteWorkerUrls(build, registry) {
-    const workers = registry.workers();
-    if (!workers) {
-        return;
-    }
-    const dependentBundlePaths = workers.map(w => registry.mappedHref(w.dependentEntryPoint));
-    const bundleOutputs = {};
-    // collect all js file contents concurrently
-    const readingFiles = Promise.all(dependentBundlePaths.map(async (p) => {
-        bundleOutputs[p] = await readFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), 'utf8');
-    }));
-    // build regex replacements during file reads
-    const rewriteChains = {};
-    for (const p of dependentBundlePaths)
-        rewriteChains[p] = [];
-    for (const w of workers) {
-        rewriteChains[registry.mappedHref(w.dependentEntryPoint)].push(s => s.replace(createWorkerRegex(w.workerUrlPlaceholder), `new Worker('${registry.mappedHref(w.workerEntryPoint)}')`));
+async function rewriteWorkerUrls(build, registry) {
+  const workers = registry.workers();
+  if (!workers) {
+    return;
+  }
+  const dependentBundlePaths = workers.map((w) => registry.mappedHref(w.dependentEntryPoint));
+  const bundleOutputs = {};
+  const readingFiles = Promise.all(dependentBundlePaths.map(async (p) => {
+    bundleOutputs[p] = await readFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), "utf8");
+  }));
+  const rewriteChains = {};
+  for (const p of dependentBundlePaths)
+    rewriteChains[p] = [];
+  for (const w of workers) {
+    rewriteChains[registry.mappedHref(w.dependentEntryPoint)].push((s) => s.replace(createWorkerRegex(w.workerUrlPlaceholder), `new Worker('${registry.mappedHref(w.workerEntryPoint)}')`));
+  }
+  await readingFiles;
+  await Promise.all(Object.entries(bundleOutputs).map(async ([p, content]) => {
+    let result = content;
+    for (const rewriteFn of rewriteChains[p]) {
+      result = rewriteFn(result);
     }
-    // wait for file reads
-    await readingFiles;
-    // run rewrite regex chain and write back to dist
-    await Promise.all(Object.entries(bundleOutputs).map(async ([p, content]) => {
-        let result = content;
-        for (const rewriteFn of rewriteChains[p]) {
-            result = rewriteFn(result);
-        }
-        await writeFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), result);
-    }));
+    await writeFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), result);
+  }));
 }
-export function createWorkerRegex(workerUrl) {
-    return new RegExp(`new(?:\\s|\\r?\\n)+Worker(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`, 'g');
+function createWorkerRegex(workerUrl) {
+  return new RegExp(`new(?:\\s|\\r?\\n)+Worker(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`, "g");
 }
+export {
+  buildWebsite,
+  createWorkerRegex,
+  rewriteWorkerUrls
+};

package/lib_js/build_tag.js

@@ -1,22 +1,21 @@
-import { exec } from 'node:child_process';
-export async function createBuildTag(build) {
-    const now = new Date();
-    const ms = now.getUTCMilliseconds() +
-        now.getUTCSeconds() * 1000 +
-        now.getUTCMinutes() * 1000 * 60 +
-        now.getUTCHours() * 1000 * 60 * 60;
-    const date = now.toISOString().substring(0, 10);
-    const time = String(ms).padStart(8, '0');
-    const when = `${date}-${time}`;
-    if (build.production) {
-        const gitHash = await new Promise((res, rej) => exec('git rev-parse --short HEAD', (err, stdout) => {
-            if (err)
-                rej(err);
-            res(stdout.trim());
-        }));
-        return `${when}-${gitHash}`;
-    }
-    else {
-        return when;
-    }
+import { exec } from "node:child_process";
+async function createBuildTag(build) {
+  const now = /* @__PURE__ */ new Date();
+  const ms = now.getUTCMilliseconds() + now.getUTCSeconds() * 1e3 + now.getUTCMinutes() * 1e3 * 60 + now.getUTCHours() * 1e3 * 60 * 60;
+  const date = now.toISOString().substring(0, 10);
+  const time = String(ms).padStart(8, "0");
+  const when = `${date}-${time}`;
+  if (build.production) {
+    const gitHash = await new Promise((res, rej) => exec("git rev-parse --short HEAD", (err, stdout) => {
+      if (err)
+        rej(err);
+      res(stdout.trim());
+    }));
+    return `${when}-${gitHash}`;
+  } else {
+    return when;
+  }
 }
+export {
+  createBuildTag
+};