@eighty4/dank 0.0.1-0

package/lib_js/http.js

@@ -0,0 +1,93 @@
+import { createReadStream } from 'node:fs';
+import { createServer, } from 'node:http';
+import { extname, join as fsJoin } from 'node:path';
+import { isProductionBuild } from "./flags.js";
+export function createWebServer(port, frontendFetcher) {
+    const serverAddress = 'http://localhost:' + port;
+    return createServer((req, res) => {
+        if (!req.url || !req.method) {
+            res.end();
+        }
+        else {
+            const url = new URL(serverAddress + req.url);
+            if (req.method !== 'GET') {
+                res.writeHead(405);
+                res.end();
+            }
+            else {
+                frontendFetcher(url, convertHeadersToFetch(req.headers), res);
+            }
+        }
+    });
+}
+export function createBuiltDistFilesFetcher(dir, files) {
+    return (url, _headers, res) => {
+        if (!files.has(url.pathname)) {
+            res.writeHead(404);
+            res.end();
+        }
+        else {
+            const mimeType = resolveMimeType(url);
+            res.setHeader('Content-Type', mimeType);
+            const reading = createReadStream(mimeType === 'text/html'
+                ? fsJoin(dir, url.pathname, 'index.html')
+                : fsJoin(dir, url.pathname));
+            reading.pipe(res);
+            reading.on('error', err => {
+                console.error(`${url.pathname} file read ${reading.path} error ${err.message}`);
+                res.statusCode = 500;
+                res.end();
+            });
+        }
+    };
+}
+export function createLocalProxyFilesFetcher(port) {
+    const proxyAddress = 'http://127.0.0.1:' + port;
+    return (url, _headers, res) => {
+        fetch(proxyAddress + url.pathname).then(fetchResponse => {
+            res.writeHead(fetchResponse.status, convertHeadersFromFetch(fetchResponse.headers));
+            fetchResponse.bytes().then(data => res.end(data));
+        });
+    };
+}
+function resolveMimeType(url) {
+    switch (extname(url.pathname)) {
+        case '':
+            return 'text/html';
+        case '.js':
+            return 'text/javascript';
+        case '.json':
+            return 'application/json';
+        case '.css':
+            return 'text/css';
+        case '.svg':
+            return 'image/svg+xml';
+        case '.png':
+            return 'image/png';
+        default:
+            console.warn('? mime type for', url.pathname);
+            if (!isProductionBuild())
+                process.exit(1);
+            return 'application/octet-stream';
+    }
+}
+function convertHeadersFromFetch(from) {
+    const to = {};
+    for (const name of from.keys()) {
+        to[name] = from.get(name);
+    }
+    return to;
+}
+function convertHeadersToFetch(from) {
+    const to = new Headers();
+    for (const [name, values] of Object.entries(from)) {
+        if (Array.isArray(values)) {
+            for (const value of values)
+                to.append(name, value);
+        }
+        else if (values) {
+            to.set(name, values);
+        }
+    }
+    return to;
+}

package/lib_js/manifest.js

@@ -0,0 +1,37 @@
+import { writeFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+export async function writeBuildManifest(buildTag, files) {
+    await writeJsonToBuildDir('manifest.json', {
+        buildTag,
+        files: Array.from(files).map(f => extname(f).length
+            ? f
+            : f === '/'
+                ? '/index.html'
+                : f + '/index.html'),
+    });
+}
+export async function writeJsonToBuildDir(filename, json) {
+    await writeFile(join('./build', filename), JSON.stringify(json, null, 4));
+}
+export async function writeMetafile(filename, json) {
+    await writeJsonToBuildDir(join('metafiles', filename), json);
+}
+export async function writeCacheManifest(buildTag, files) {
+    await writeJsonToBuildDir('cache.json', {
+        apiRoutes: [],
+        buildTag,
+        files: Array.from(files).map(filenameToWebappPath),
+    });
+}
+// drops index.html from path
+function filenameToWebappPath(p) {
+    if (p === '/index.html') {
+        return '/';
+    }
+    else if (p.endsWith('/index.html')) {
+        return p.substring(0, p.length - '/index.html'.length);
+    }
+    else {
+        return p;
+    }
+}

package/lib_js/public.js

@@ -0,0 +1,43 @@
+import { copyFile, mkdir, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function copyAssets(outRoot) {
+    try {
+        const stats = await stat('public');
+        if (stats.isDirectory()) {
+            await mkdir(outRoot, { recursive: true });
+            return await recursiveCopyAssets(outRoot);
+        }
+        else {
+            throw Error('./public cannot be a file');
+        }
+    }
+    catch (e) {
+        return null;
+    }
+}
+async function recursiveCopyAssets(outRoot, dir = '') {
+    const copied = [];
+    const to = join(outRoot, dir);
+    let madeDir = dir === '';
+    for (const p of await readdir(join('public', dir))) {
+        try {
+            const stats = await stat(join('public', dir, p));
+            if (stats.isDirectory()) {
+                copied.push(...(await recursiveCopyAssets(outRoot, join(dir, p))));
+            }
+            else {
+                if (!madeDir) {
+                    await mkdir(join(outRoot, dir));
+                    madeDir = true;
+                }
+                await copyFile(join('public', dir, p), join(to, p));
+                copied.push('/' + join(dir, p).replaceAll('\\', '/'));
+            }
+        }
+        catch (e) {
+            console.error('stat error', e);
+            process.exit(1);
+        }
+    }
+    return copied;
+}

package/lib_js/serve.js

@@ -0,0 +1,67 @@
+import { mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildWebsite } from "./build.js";
+import { createGlobalDefinitions } from "./define.js";
+import { esbuildDevContext } from "./esbuild.js";
+import { isPreviewBuild } from "./flags.js";
+import { HtmlEntrypoint } from "./html.js";
+import { createBuiltDistFilesFetcher, createLocalProxyFilesFetcher, createWebServer, } from "./http.js";
+import { copyAssets } from "./public.js";
+const isPreview = isPreviewBuild();
+// alternate port for --preview bc of service worker
+const PORT = isPreview ? 4000 : 3000;
+// port for esbuild.serve
+const ESBUILD_PORT = 2999;
+export async function serveWebsite(c) {
+    await rm('build', { force: true, recursive: true });
+    let frontend;
+    if (isPreview) {
+        const { dir, files } = await buildWebsite(c);
+        frontend = createBuiltDistFilesFetcher(dir, files);
+    }
+    else {
+        const { port } = await startEsbuildWatch(c);
+        frontend = createLocalProxyFilesFetcher(port);
+    }
+    createWebServer(PORT, frontend).listen(PORT);
+    console.log(isPreview ? 'preview' : 'dev server', `is live at http://127.0.0.1:${PORT}`);
+    return new Promise(() => { });
+}
+async function startEsbuildWatch(c) {
+    const watchDir = join('build', 'watch');
+    await mkdir(watchDir, { recursive: true });
+    await copyAssets(watchDir);
+    const entryPointUrls = new Set();
+    const entryPoints = [];
+    await Promise.all(Object.entries(c.pages).map(async ([url, srcPath]) => {
+        const html = await HtmlEntrypoint.readFrom(url, join('pages', srcPath));
+        await html.injectPartials();
+        if (url !== '/') {
+            await mkdir(join(watchDir, url), { recursive: true });
+        }
+        html.collectScripts()
+            .filter(scriptImport => !entryPointUrls.has(scriptImport.in))
+            .forEach(scriptImport => {
+            entryPointUrls.add(scriptImport.in);
+            entryPoints.push({
+                in: scriptImport.in,
+                out: scriptImport.out,
+            });
+        });
+        html.rewriteHrefs();
+        await html.writeTo(watchDir);
+        return html;
+    }));
+    console.log(entryPoints);
+    const ctx = await esbuildDevContext(createGlobalDefinitions(), entryPoints, watchDir);
+    await ctx.watch();
+    await ctx.serve({
+        host: '127.0.0.1',
+        port: ESBUILD_PORT,
+        servedir: watchDir,
+        cors: {
+            origin: 'http://127.0.0.1:' + PORT,
+        },
+    });
+    return { port: ESBUILD_PORT };
+}

package/lib_js/tag.js

@@ -0,0 +1,23 @@
+import { exec } from 'node:child_process';
+import { isProductionBuild } from "./flags.js";
+export async function createBuildTag() {
+    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 (isProductionBuild()) {
+        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;
+    }
+}

package/lib_types/dank.d.ts

@@ -0,0 +1,4 @@
+export type DankConfig = {
+    pages: Record<`/${string}`, `./${string}.html`>;
+};
+export declare function defineConfig(c: Partial<DankConfig>): Promise<DankConfig>;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@eighty4/dank",
+  "version": "0.0.1-0",
+  "type": "module",
+  "bin": "./lib_js/bin.js",
+  "exports": {
+    ".": {
+      "node": "./lib_js/dank.js",
+      "types": "./lib_types/dank.d.ts",
+      "import": "./lib/dank.ts"
+    }
+  },
+  "dependencies": {
+    "esbuild": "^0.25.10",
+    "parse5": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2"
+  },
+  "files": [
+    "lib/*.ts",
+    "lib_js/*.js",
+    "lib_types/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.exports.json",
+    "fmt": "prettier --write .",
+    "fmtcheck": "prettier --check .",
+    "typecheck": "tsc --noEmit"
+  }
+}