@eighty4/dank 0.0.5-2 → 0.0.5-4

package/lib/registry.ts

@@ -3,19 +3,12 @@ import { writeFile } from 'node:fs/promises'
 import { join } from 'node:path/posix'
 import type { BuildResult } from 'esbuild'
 import type { ResolvedDankConfig } from './config.ts'
-import type { PageMapping } from './dank.ts'
+import type { PageMapping, WebsiteManifest } from './dank.ts'
 import { LOG } from './developer.ts'
 import { Resolver, type DankDirectories } from './dirs.ts'
 import type { EntryPoint } from './esbuild.ts'
 import { HtmlEntrypoint } from './html.ts'
 
-// summary of a website build
-export type WebsiteManifest = {
-    buildTag: string
-    files: Set<string>
-    pageUrls: Set<string>
-}
-
 // result of an esbuild build from the context of the config's entrypoints
 // path of entrypoint is the reference point to lookup from a dependent page
 export type BuildManifest = {
@@ -67,12 +60,13 @@ export type UrlRewriteProvider = {
 // manages website resources during `dank build` and `dank serve`
 export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
     // paths of bundled esbuild outputs, as built by esbuild
-    #bundles: Set<string> = new Set()
+    #bundles: Set<`/${string}`> = new Set()
     #c: ResolvedDankConfig
     // public dir assets
-    #copiedAssets: Set<string> | null = null
+    #copiedAssets: Set<`/${string}`> | null = null
     // map of entrypoints to their output path
     #entrypointHrefs: Record<string, string | null> = {}
+    #otherOutputs: Set<`/${string}`> | null = null
     #pages: Record<`/${string}`, WebpageRegistration> = {}
     readonly #resolver: Resolver
     #workers: Array<WorkerManifest> | null = null
@@ -87,7 +81,7 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         return this.#c
     }
 
-    set copiedAssets(copiedAssets: Array<string> | null) {
+    set copiedAssets(copiedAssets: Array<`/${string}`> | null) {
         this.#copiedAssets =
             copiedAssets === null ? null : new Set(copiedAssets)
     }
@@ -96,6 +90,14 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         return Object.values(this.#pages).map(p => p.html)
     }
 
+    async manifest(): Promise<WebsiteManifest> {
+        return {
+            buildTag: await this.#c.buildTag(),
+            files: this.files(),
+            pageUrls: Object.keys(this.#pages) as Array<`/${string}`>,
+        }
+    }
+
     get pageUrls(): Array<string> {
         return Object.keys(this.#pages)
     }
@@ -159,6 +161,27 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         return this.#workers
     }
 
+    // add a build output that does is manually injected into build output,
+    // not from HTML processing, public directory, or esbuild entrypoints
+    async addBuildOutput(url: `/${string}`, content: string) {
+        if (
+            this.#pages[url] ||
+            this.#bundles.has(url) ||
+            this.#otherOutputs?.has(url) ||
+            this.#copiedAssets?.has(url)
+        ) {
+            throw Error('build already has a ' + url)
+        }
+        if (this.#otherOutputs === null) this.#otherOutputs = new Set()
+        this.#otherOutputs.add(url)
+        const outputPath = join(
+            this.#c.dirs.projectRootAbs,
+            this.#c.dirs.buildDist,
+            url,
+        )
+        await writeFile(outputPath, content)
+    }
+
     buildRegistry(): BuildRegistry {
         return new BuildRegistry(
             this.#c.dirs,
@@ -171,13 +194,18 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         this.#configDiff()
     }
 
-    files(): Set<string> {
-        const files = new Set<string>()
+    files(): Array<`/${string}`> {
+        const files = new Set<`/${string}`>()
         for (const pageUrl of Object.keys(this.#pages))
-            files.add(pageUrl === '/' ? '/index.html' : `${pageUrl}/index.html`)
+            files.add(
+                pageUrl === '/'
+                    ? '/index.html'
+                    : (`${pageUrl}/index.html` as `/${string}`),
+            )
         for (const f of this.#bundles) files.add(f)
         if (this.#copiedAssets) for (const f of this.#copiedAssets) files.add(f)
-        return files
+        if (this.#otherOutputs) for (const f of this.#otherOutputs) files.add(f)
+        return Array.from(files)
     }
 
     mappedHref(lookup: string): string {
@@ -189,23 +217,15 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         }
     }
 
-    async writeManifest(buildTag: string): Promise<WebsiteManifest> {
-        const manifest = this.#manifest(buildTag)
+    async writeManifest(): Promise<WebsiteManifest> {
+        const manifest = await this.#manifest()
         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,
-            ),
+            JSON.stringify(manifest, null, 4),
         )
         return manifest
     }
@@ -303,18 +323,18 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         delete this.#pages[urlPath]
     }
 
-    #manifest(buildTag: string): WebsiteManifest {
+    async #manifest(): Promise<WebsiteManifest> {
         return {
-            buildTag,
+            buildTag: await this.#c.buildTag(),
             files: this.files(),
-            pageUrls: new Set(Object.keys(this.#pages)),
+            pageUrls: Object.keys(this.#pages) as Array<`/${string}`>,
         }
     }
 
     #onBuildManifest: OnBuildComplete = (build: BuildManifest) => {
         // collect built bundle entrypoint hrefs
         for (const [outPath, entrypoint] of Object.entries(build.bundles)) {
-            this.#bundles.add(outPath)
+            this.#bundles.add(ensurePath(outPath))
             if (entrypoint) {
                 this.#entrypointHrefs[entrypoint] = outPath
             }
@@ -413,7 +433,7 @@ export class BuildRegistry {
         for (const [outPath, output] of Object.entries(
             result.metafile.outputs,
         )) {
-            bundles[outPath.replace(/^build[/\\]dist/, '')] =
+            bundles[outPath.replace(/^build[/\\](dist|watch)/, '')] =
                 output.entryPoint || null
         }
         let workers: BuildManifest['workers'] = null
@@ -438,3 +458,11 @@ export class BuildRegistry {
         })
     }
 }
+
+function ensurePath(path: string): `/${string}` {
+    if (path.startsWith('/')) {
+        return path as `/${string}`
+    } else {
+        throw Error(`expect build dist path ${path} to start with /`)
+    }
+}

package/lib/service_worker.ts

@@ -0,0 +1,63 @@
+import { join } from 'node:path'
+import esbuild from 'esbuild'
+import type { ServiceWorkerBuild } from './dank.ts'
+
+export type ServiceWorkerCaching = {
+    cacheKey: string
+    bypassCache?: {
+        hosts?: Array<string>
+        paths?: Array<`/${string}`>
+    }
+    files: Array<`/${string}`>
+}
+
+export async function createServiceWorker(
+    caching: ServiceWorkerCaching,
+): Promise<ServiceWorkerBuild> {
+    return {
+        outputs: [
+            {
+                content: await buildServiceWorkerBackend(caching),
+                url: '/sw.js',
+            },
+        ],
+    }
+}
+
+async function buildServiceWorkerBackend(
+    caching: ServiceWorkerCaching,
+): Promise<string> {
+    const result = await esbuild.build({
+        logLevel: 'silent',
+        absWorkingDir: join(import.meta.dirname, '../client'),
+        entryPoints: ['ServiceWorker.ts'],
+        treeShaking: true,
+        target: 'ES2022',
+        bundle: true,
+        minify: true,
+        format: 'iife',
+        platform: 'browser',
+        write: false,
+        metafile: true,
+        plugins: [
+            {
+                name: 'DANK:sw',
+                setup(build: esbuild.PluginBuild) {
+                    build.onResolve({ filter: /DANK:sw/ }, () => {
+                        return {
+                            path: join(import.meta.dirname, 'DANK.sw.json'),
+                        }
+                    })
+                    build.onLoad(
+                        { filter: /DANK\.sw\.json$/, namespace: 'file' },
+                        async () => ({
+                            contents: JSON.stringify(caching),
+                            loader: 'json',
+                        }),
+                    )
+                },
+            },
+        ],
+    })
+    return new TextDecoder().decode(result.outputFiles[0].contents)
+}

package/lib_js/bin.js

@@ -4,19 +4,20 @@ import { DankError } from "./errors.js";
 import { serveWebsite } from "./serve.js";
 function printHelp(task2) {
   if (!task2 || task2 === "build") {
-    console.log("dank build [--minify] [--production]");
+    console.log("dank build [--minify] [--production] [--service-worker]");
   }
   if (!task2 || task2 === "serve") {
     console.log(
       // 'dank serve [--minify] [--preview] [--production]',
-      "dank serve [--minify] [--production]"
+      "dank serve [--minify] [--production] [--service-worker]"
     );
   }
   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");
+    console.log("  --log-http        print access logs");
+  console.log("  --minify          minify sources");
+  console.log("  --production      build for production release");
+  console.log("  --service-worker  build service worker");
   if (task2) {
     console.log();
     console.log("use `dank -h` for details on all commands");

package/lib_js/build.js

@@ -1,6 +1,5 @@
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { createBuildTag } from "./build_tag.js";
 import { loadConfig } from "./config.js";
 import { createGlobalDefinitions } from "./define.js";
 import { esbuildWebpages, esbuildWorkers } from "./esbuild.js";
@@ -10,8 +9,7 @@ async function buildWebsite(c) {
   if (!c) {
     c = await loadConfig("build", process.cwd());
   }
-  const buildTag = await createBuildTag(c.flags);
-  console.log(c.flags.minify ? c.flags.production ? "minified production" : "minified" : "unminified", "build", buildTag, "building in ./build/dist");
+  console.log(c.flags.minify ? c.flags.production ? "minified production" : "minified" : "unminified", "build", await c.buildTag(), "building in ./build/dist");
   await rm(c.dirs.buildRoot, { recursive: true, force: true });
   await mkdir(c.dirs.buildDist, { recursive: true });
   for (const subdir of Object.keys(c.pages).filter((url) => url !== "/")) {
@@ -19,7 +17,7 @@ async function buildWebsite(c) {
   }
   await mkdir(join(c.dirs.buildRoot, "metafiles"), { recursive: true });
   const registry = await buildWebpages(c, createGlobalDefinitions(c));
-  return await registry.writeManifest(buildTag);
+  return await registry.writeManifest();
 }
 async function buildWebpages(c, define) {
   const registry = new WebsiteRegistry(c);
@@ -35,6 +33,7 @@ async function buildWebpages(c, define) {
   await Promise.all(registry.htmlEntrypoints.map(async (html) => {
     await writeFile(join(c.dirs.buildDist, html.url, "index.html"), html.output(registry));
   }));
+  await buildServiceWorker(registry);
   return registry;
 }
 async function rewriteWorkerUrls(dirs, registry) {
@@ -65,6 +64,43 @@ async function rewriteWorkerUrls(dirs, registry) {
 function createWorkerRegex(workerCtor, workerUrl) {
   return new RegExp(`new(?:\\s|\\r?\\n)+${workerCtor}(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`, "g");
 }
+async function buildServiceWorker(registry) {
+  const serviceWorkerBuilder = registry.config.serviceWorkerBuilder;
+  if (serviceWorkerBuilder) {
+    const website = await registry.manifest();
+    const serviceWorkerBuild = await serviceWorkerBuilder({ website });
+    validateServiceWorkerBuild(serviceWorkerBuild);
+    serviceWorkerBuild.outputs.map(async (output, i) => {
+      try {
+        return await registry.addBuildOutput(output.url, output.content);
+      } catch {
+        console.log(`ServiceWorkerBuild.outputs[${i}].url \`${output.url}\` is already a url in the build output.`);
+        process.exit(1);
+      }
+    });
+  }
+}
+function validateServiceWorkerBuild(serviceWorkerBuild) {
+  if (serviceWorkerBuild === null || typeof serviceWorkerBuild === "undefined") {
+    console.log(`ServiceWorkerBuild is ${serviceWorkerBuild}.`);
+    console.log("\nMake sure the builder function `serviceWorker` in `dank.config.ts` is returning a ServiceWorkerBuild.");
+    process.exit(1);
+  }
+  const testUrlPattern = /^\/.*\.js$/;
+  const valid = true;
+  serviceWorkerBuild.outputs.forEach((output, i) => {
+    if (!output.content?.length) {
+      console.log(`ServiceWorkerBuild.outputs[${i}].content is empty.`);
+    }
+    if (!output.url?.length || !testUrlPattern.test(output.url)) {
+      console.log(`ServiceWorkerBuild.outputs[${i}].url is not a valid \`/*.js\` path.`);
+    }
+  });
+  if (!valid) {
+    console.log("\nCheck your `serviceWorker` config in `dank.config.ts`.");
+    process.exit(1);
+  }
+}
 export {
   buildWebsite,
   createWorkerRegex,

package/lib_js/build_tag.js

@@ -1,21 +1,81 @@
 import { exec } from "node:child_process";
-async function createBuildTag(flags) {
+async function createBuildTag(projectDir, flags, buildTagSource) {
+  if (typeof buildTagSource === "function") {
+    buildTagSource = await buildTagSource({ production: flags.production });
+  }
+  if (typeof buildTagSource === "undefined" || buildTagSource === null) {
+    buildTagSource = await resolveExpressionDefault(projectDir);
+  }
+  if (typeof buildTagSource !== "string") {
+    throw TypeError("DankConfig.buildTag must resolve to a string expession");
+  }
+  const params = {};
   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 (flags.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;
+  const paramPattern = new RegExp(/{{\s*(?<name>[a-z][A-Za-z]+)\s*}}/g);
+  let paramMatch;
+  let buildTag = buildTagSource;
+  let offset = 0;
+  while ((paramMatch = paramPattern.exec(buildTagSource)) != null) {
+    const paramName = paramMatch.groups.name.trim();
+    let paramValue;
+    if (params[paramName]) {
+      paramValue = params[paramName];
+    } else {
+      paramValue = params[paramName] = await getParamValue(projectDir, paramName, now, buildTagSource);
+    }
+    buildTag = buildTag.substring(0, paramMatch.index + offset) + paramValue + buildTag.substring(paramMatch.index + paramMatch[0].length + offset);
+    offset += paramValue.length - paramMatch[0].length;
+  }
+  const validate = /^[A-Za-z\d][A-Za-z\d-_\.]+$/;
+  if (!validate.test(buildTag)) {
+    throw Error(`build tag ${buildTag} does not pass pattern ${validate.source} validation`);
+  }
+  return buildTag;
+}
+async function resolveExpressionDefault(projectDir) {
+  const base = "{{ date }}-{{ timeMS }}";
+  const isGitRepo = await new Promise((res) => exec("git rev-parse --is-inside-work-tree", { cwd: projectDir }, (err) => res(!err)));
+  return isGitRepo ? base + "-{{ gitHash }}" : base;
+}
+async function getParamValue(projectDir, name, now, buildTagSource) {
+  switch (name) {
+    case "date":
+      return getDate(now);
+    case "gitHash":
+      try {
+        return await getGitHash(projectDir);
+      } catch (e) {
+        if (e === "not-repo") {
+          throw Error(`buildTag cannot use \`gitHash\` in \`${buildTagSource}\` outside of a git repository`);
+        } else {
+          throw e;
+        }
+      }
+    case "timeMS":
+      return getTimeMS(now);
+    default:
+      throw Error(name + " is not a supported build tag param");
   }
 }
+function getDate(now) {
+  return now.toISOString().substring(0, 10);
+}
+async function getGitHash(projectDir) {
+  return await new Promise((res, rej) => exec("git rev-parse --short HEAD", { cwd: projectDir }, (err, stdout, stderr) => {
+    if (err) {
+      if (stderr.includes("not a git repository")) {
+        rej("not-repo");
+      } else {
+        rej(err);
+      }
+    }
+    res(stdout.trim());
+  }));
+}
+function getTimeMS(now) {
+  const ms = now.getUTCMilliseconds() + now.getUTCSeconds() * 1e3 + now.getUTCMinutes() * 1e3 * 60 + now.getUTCHours() * 1e3 * 60 * 60;
+  return String(ms).padStart(8, "0");
+}
 export {
   createBuildTag
 };

package/lib_js/config.js

@@ -1,4 +1,5 @@
 import { isAbsolute, resolve } from "node:path";
+import { createBuildTag } from "./build_tag.js";
 import { defaultProjectDirs } from "./dirs.js";
 import { resolveFlags as lookupDankFlags } from "./flags.js";
 var __rewriteRelativeImportExtension = function(path, preserveJsx) {
@@ -24,10 +25,13 @@ async function loadConfig(mode, projectRootAbs) {
   return c;
 }
 class DankConfigInternal {
+  #buildTag = null;
+  #buildTagBuilder;
   #dirs;
   #flags;
   #mode;
   #modulePath;
+  #serviceWorkerBuilder;
   #dankPort = DEFAULT_DEV_PORT;
   #esbuildPort = DEFAULT_ESBUILD_PORT;
   #esbuild;
@@ -67,14 +71,26 @@ class DankConfigInternal {
   get services() {
     return this.#services;
   }
+  get serviceWorkerBuilder() {
+    return this.#serviceWorkerBuilder;
+  }
+  buildTag() {
+    if (this.#buildTag === null) {
+      this.#buildTag = createBuildTag(this.#dirs.projectRootAbs, this.#flags, this.#buildTagBuilder);
+    }
+    return this.#buildTag;
+  }
   async reload() {
     const userConfig = await resolveConfig(this.#modulePath, resolveDankDetails(this.#mode, this.#flags));
+    this.#buildTag = null;
+    this.#buildTagBuilder = userConfig.buildTag;
     this.#dankPort = resolveDankPort(this.#flags, userConfig);
     this.#esbuildPort = resolveEsbuildPort(this.#flags, userConfig);
     this.#esbuild = Object.freeze(userConfig.esbuild);
     this.#pages = Object.freeze(normalizePages(userConfig.pages));
     this.#devPages = Object.freeze(userConfig.devPages);
     this.#services = Object.freeze(userConfig.services);
+    this.#serviceWorkerBuilder = userConfig.serviceWorker;
   }
 }
 function resolveDankPort(flags, userConfig) {
@@ -99,10 +115,12 @@ function resolveDankDetails(mode, flags) {
 function validateDankConfig(c) {
   try {
     validatePorts(c);
+    validateBuildTag(c.buildTag);
     validatePages(c.pages);
     validateDevPages(c.devPages);
     validateDevServices(c.services);
     validateEsbuildConfig(c.esbuild);
+    validateServiceWorker(c.serviceWorker);
   } catch (e) {
     throw e;
   }
@@ -119,6 +137,31 @@ function validatePorts(c) {
     }
   }
 }
+function validateBuildTag(buildTag) {
+  if (buildTag === null) {
+    return;
+  }
+  switch (typeof buildTag) {
+    case "undefined":
+    case "string":
+    case "function":
+      return;
+    default:
+      throw Error("DankConfig.buildTag must be a string or function");
+  }
+}
+function validateServiceWorker(serviceWorker) {
+  if (serviceWorker === null) {
+    return;
+  }
+  switch (typeof serviceWorker) {
+    case "undefined":
+    case "function":
+      return;
+    default:
+      throw Error("DankConfig.serviceWorker must be a function");
+  }
+}
 function validateEsbuildConfig(esbuild) {
   if (esbuild?.loaders !== null && typeof esbuild?.loaders !== "undefined") {
     if (typeof esbuild.loaders !== "object") {

package/lib_js/dank.js

@@ -1,6 +1,8 @@
+import { createServiceWorker } from "./service_worker.js";
 function defineConfig(config) {
   return config;
 }
 export {
+  createServiceWorker,
   defineConfig
 };

package/lib_js/esbuild.js

@@ -44,6 +44,7 @@ async function esbuildWorkers(r, define, entryPoints) {
 function commonBuildOptions(r) {
   const p = workersPlugin(r.buildRegistry());
   return {
+    absWorkingDir: r.config.dirs.projectRootAbs,
     assetNames: "assets/[name]-[hash]",
     bundle: true,
     format: "esm",

package/lib_js/http.js

@@ -92,9 +92,9 @@ function createLogWrapper(handler) {
 }
 function createBuiltDistFilesFetcher(dirs, manifest) {
   return (url, _headers, res, notFound) => {
-    if (manifest.pageUrls.has(url.pathname)) {
+    if (manifest.pageUrls.includes(url.pathname)) {
       streamFile(join(dirs.projectRootAbs, dirs.buildDist, url.pathname, "index.html"), res);
-    } else if (manifest.files.has(url.pathname)) {
+    } else if (manifest.files.includes(url.pathname)) {
       streamFile(join(dirs.projectRootAbs, dirs.buildDist, url.pathname), res);
     } else {
       notFound();

package/lib_js/public.js

@@ -36,7 +36,7 @@ async function recursiveCopyAssets(dirs, dir = "") {
           madeDir = true;
         }
         await copyFile(join(listingDir, p), join(to, p));
-        copied.push("/" + join(dir, p).replaceAll("\\", "/"));
+        copied.push(`/${join(dir, p).replaceAll("\\", "/")}`);
       }
     } catch (e) {
       console.error("stat error", e);