@eighty4/dank 0.0.4-1 → 0.0.4-3

package/lib/http.ts

@@ -10,8 +10,14 @@ import {
 import { extname, join } from 'node:path'
 import { Readable } from 'node:stream'
 import mime from 'mime'
-import type { DankServe } from './flags.ts'
-import type { WebsiteManifest } from './metadata.ts'
+import type { DankDirectories } from './dirs.ts'
+import type { DankFlags } from './flags.ts'
+import type {
+    UrlRewrite,
+    UrlRewriteProvider,
+    WebsiteManifest,
+    WebsiteRegistry,
+} from './registry.ts'
 import type { HttpServices } from './services.ts'
 
 export type FrontendFetcher = (
@@ -21,25 +27,15 @@ export type FrontendFetcher = (
     notFound: () => void,
 ) => void
 
-// state needed to eval url rewriting after FrontendFetcher and before HttpServices
-export type PageRouteState = {
-    // urls of html entrypoints
-    urls: Array<string>
-    urlRewrites: Array<UrlRewrite>
-}
-
-export type UrlRewrite = {
-    pattern: RegExp
-    url: string
-}
-
 export function startWebServer(
-    serve: DankServe,
+    port: number,
+    flags: DankFlags,
+    dirs: DankDirectories,
+    urlRewriteProvider: UrlRewriteProvider,
     frontendFetcher: FrontendFetcher,
     httpServices: HttpServices,
-    pageRoutes: PageRouteState,
 ) {
-    const serverAddress = 'http://localhost:' + serve.dankPort
+    const serverAddress = 'http://localhost:' + port
     const handler = (req: IncomingMessage, res: ServerResponse) => {
         if (!req.url || !req.method) {
             res.end()
@@ -52,19 +48,20 @@ export function startWebServer(
                     url,
                     headers,
                     httpServices,
-                    pageRoutes,
-                    serve,
+                    flags,
+                    dirs,
+                    urlRewriteProvider,
                     res,
                 ),
             )
         }
     }
-    createServer(serve.logHttp ? createLogWrapper(handler) : handler).listen(
-        serve.dankPort,
+    createServer(flags.logHttp ? createLogWrapper(handler) : handler).listen(
+        port,
     )
     console.log(
-        serve.preview ? 'preview' : 'dev',
-        `server is live at http://127.0.0.1:${serve.dankPort}`,
+        flags.preview ? 'preview' : 'dev',
+        `server is live at http://127.0.0.1:${port}`,
     )
 }
 
@@ -73,12 +70,18 @@ async function onNotFound(
     url: URL,
     headers: Headers,
     httpServices: HttpServices,
-    pageRoutes: PageRouteState,
-    serve: DankServe,
+    flags: DankFlags,
+    dirs: DankDirectories,
+    urlRewriteProvider: UrlRewriteProvider,
     res: ServerResponse,
 ) {
     if (req.method === 'GET' && extname(url.pathname) === '') {
-        const urlRewrite = tryUrlRewrites(url, pageRoutes, serve)
+        const urlRewrite = tryUrlRewrites(
+            flags,
+            dirs,
+            urlRewriteProvider.urlRewrites,
+            url,
+        )
         if (urlRewrite) {
             streamFile(urlRewrite, res)
             return
@@ -107,15 +110,20 @@ async function sendFetchResponse(res: ServerResponse, fetchResponse: Response) {
 }
 
 function tryUrlRewrites(
+    flags: DankFlags,
+    dirs: DankDirectories,
+    urlRewrites: Array<UrlRewrite>,
     url: URL,
-    pageRoutes: PageRouteState,
-    serve: DankServe,
 ): string | null {
-    const urlRewrite = pageRoutes.urlRewrites.find(urlRewrite =>
+    const urlRewrite = urlRewrites.find(urlRewrite =>
         urlRewrite.pattern.test(url.pathname),
     )
     return urlRewrite
-        ? join(serve.dirs.buildWatch, urlRewrite.url, 'index.html')
+        ? join(
+              flags.preview ? dirs.buildDist : dirs.buildWatch,
+              urlRewrite.url,
+              'index.html',
+          )
         : null
 }
 
@@ -178,7 +186,7 @@ function createLogWrapper(handler: RequestListener): RequestListener {
 }
 
 export function createBuiltDistFilesFetcher(
-    dir: string,
+    dirs: DankDirectories,
     manifest: WebsiteManifest,
 ): FrontendFetcher {
     return (
@@ -188,34 +196,42 @@ export function createBuiltDistFilesFetcher(
         notFound: () => void,
     ) => {
         if (manifest.pageUrls.has(url.pathname)) {
-            streamFile(join(dir, url.pathname, 'index.html'), res)
+            streamFile(
+                join(
+                    dirs.projectResolved,
+                    dirs.buildDist,
+                    url.pathname,
+                    'index.html',
+                ),
+                res,
+            )
         } else if (manifest.files.has(url.pathname)) {
-            streamFile(join(dir, url.pathname), res)
+            streamFile(
+                join(dirs.projectResolved, dirs.buildDist, url.pathname),
+                res,
+            )
         } else {
             notFound()
         }
     }
 }
 
-// todo replace PageRouteState with WebsiteRegistry
 export function createDevServeFilesFetcher(
-    pageRoutes: PageRouteState,
-    serve: DankServe,
+    esbuildPort: number,
+    dirs: DankDirectories,
+    registry: WebsiteRegistry,
 ): FrontendFetcher {
-    const proxyAddress = 'http://127.0.0.1:' + serve.esbuildPort
+    const proxyAddress = 'http://127.0.0.1:' + esbuildPort
     return (
         url: URL,
         _headers: Headers,
         res: ServerResponse,
         notFound: () => void,
     ) => {
-        if (pageRoutes.urls.includes(url.pathname)) {
-            streamFile(
-                join(serve.dirs.buildWatch, url.pathname, 'index.html'),
-                res,
-            )
+        if (registry.pageUrls.includes(url.pathname)) {
+            streamFile(join(dirs.buildWatch, url.pathname, 'index.html'), res)
         } else {
-            const maybePublicPath = join(serve.dirs.public, url.pathname)
+            const maybePublicPath = join(dirs.public, url.pathname)
             exists(maybePublicPath).then(fromPublic => {
                 if (fromPublic) {
                     streamFile(maybePublicPath, res)

package/lib/public.ts

@@ -1,16 +1,16 @@
 import { copyFile, mkdir, readdir, stat } from 'node:fs/promises'
 import { platform } from 'node:os'
 import { join } from 'node:path'
-import type { DankBuild } from './flags.ts'
+import type { DankDirectories } from './dirs.ts'
 
 export async function copyAssets(
-    build: DankBuild,
+    dirs: DankDirectories,
 ): Promise<Array<string> | null> {
     try {
-        const stats = await stat(build.dirs.public)
+        const stats = await stat(dirs.public)
         if (stats.isDirectory()) {
-            await mkdir(build.dirs.buildDist, { recursive: true })
-            return await recursiveCopyAssets(build)
+            await mkdir(dirs.buildDist, { recursive: true })
+            return await recursiveCopyAssets(dirs)
         } else {
             throw Error('./public cannot be a file')
         }
@@ -22,13 +22,13 @@ export async function copyAssets(
 const IGNORE = platform() === 'darwin' ? ['.DS_Store'] : []
 
 async function recursiveCopyAssets(
-    build: DankBuild,
+    dirs: DankDirectories,
     dir: string = '',
 ): Promise<Array<string>> {
     const copied: Array<string> = []
-    const to = join(build.dirs.buildDist, dir)
+    const to = join(dirs.buildDist, dir)
     let madeDir = dir === ''
-    const listingDir = join(build.dirs.public, dir)
+    const listingDir = join(dirs.public, dir)
     for (const p of await readdir(listingDir)) {
         if (IGNORE.includes(p)) {
             continue
@@ -36,10 +36,10 @@ async function recursiveCopyAssets(
         try {
             const stats = await stat(join(listingDir, p))
             if (stats.isDirectory()) {
-                copied.push(...(await recursiveCopyAssets(build, join(dir, p))))
+                copied.push(...(await recursiveCopyAssets(dirs, join(dir, p))))
             } else {
                 if (!madeDir) {
-                    await mkdir(join(build.dirs.buildDist, dir), {
+                    await mkdir(join(dirs.buildDist, dir), {
                         recursive: true,
                     })
                     madeDir = true

package/lib/{metadata.ts → registry.ts}

@@ -1,52 +1,13 @@
 import EventEmitter from 'node:events'
 import { writeFile } from 'node:fs/promises'
-import { dirname, join, resolve } from 'node:path'
+import { join } from 'node:path'
 import type { BuildResult } from 'esbuild'
+import type { ResolvedDankConfig } from './config.ts'
+import { LOG } from './developer.ts'
+import { Resolver, type DankDirectories } from './dirs.ts'
 import type { EntryPoint } from './esbuild.ts'
-import type { DankBuild, ProjectDirs } from './flags.ts'
-
-export type ResolveError = 'outofbounds'
-
-export type Resolver = {
-    // `p` is expected to be a relative path resolvable from the project dir
-    isProjectSubpathInPagesDir(p: string): boolean
-
-    // `p` is expected to be a relative path resolvable from the pages dir
-    isPagesSubpathInPagesDir(p: string): boolean
-
-    // resolve a pages subpath from a resource within the pages directory by a relative href
-    // `from` is expected to be a pages resource fs path starting with `pages/` and ending with filename
-    // the result will be a pages subpath and will not have the pages dir prefix
-    // returns 'outofbounds' if the relative path does not resolve to a file within the pages dir
-    resolveHrefInPagesDir(from: string, href: string): string | ResolveError
-}
-
-class ResolverImpl implements Resolver {
-    #dirs: ProjectDirs
-
-    constructor(dirs: ProjectDirs) {
-        this.#dirs = dirs
-    }
-
-    isProjectSubpathInPagesDir(p: string): boolean {
-        return resolve(join(this.#dirs.projectResolved, p)).startsWith(
-            this.#dirs.pagesResolved,
-        )
-    }
-
-    isPagesSubpathInPagesDir(p: string): boolean {
-        return this.isProjectSubpathInPagesDir(join(this.#dirs.pages, p))
-    }
-
-    resolveHrefInPagesDir(from: string, href: string): string | ResolveError {
-        const p = join(dirname(from), href)
-        if (this.isProjectSubpathInPagesDir(p)) {
-            return p
-        } else {
-            return 'outofbounds'
-        }
-    }
-}
+import { HtmlEntrypoint } from './html.ts'
+import type { PageMapping } from './dank.ts'
 
 // summary of a website build
 export type WebsiteManifest = {
@@ -75,31 +36,55 @@ type WorkerManifest = {
     // path to bundled entrypoint dependent on `clientScript`
     dependentEntryPoint: string
     workerEntryPoint: string
+    workerCtor: 'Worker' | 'SharedWorker'
     workerUrl: string
     workerUrlPlaceholder: string
 }
 
 export type WebsiteRegistryEvents = {
+    entrypoints: []
+    webpage: [entrypoint: HtmlEntrypoint]
     workers: []
 }
 
+type WebpageRegistration = {
+    pageUrl: `/${string}`
+    fsPath: string
+    html: HtmlEntrypoint
+    bundles: Array<EntryPoint>
+    urlRewrite?: UrlRewrite
+}
+
+export type UrlRewrite = {
+    pattern: RegExp
+    url: string
+}
+
+export type UrlRewriteProvider = {
+    urlRewrites: Array<UrlRewrite>
+}
+
 // manages website resources during `dank build` and `dank serve`
 export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
-    #build: DankBuild
-    // paths of bundled esbuild outputs
+    // paths of bundled esbuild outputs, as built by esbuild
     #bundles: Set<string> = new Set()
+    #c: ResolvedDankConfig
     // public dir assets
     #copiedAssets: Set<string> | null = null
     // map of entrypoints to their output path
     #entrypointHrefs: Record<string, string | null> = {}
-    #pageUrls: Array<string> = []
-    #resolver: Resolver
+    #pages: Record<`/${string}`, WebpageRegistration> = {}
+    readonly #resolver: Resolver
     #workers: Array<WorkerManifest> | null = null
 
-    constructor(build: DankBuild) {
+    constructor(config: ResolvedDankConfig) {
         super()
-        this.#build = build
-        this.#resolver = new ResolverImpl(build.dirs)
+        this.#c = config
+        this.#resolver = new Resolver(config.dirs)
+    }
+
+    get config(): ResolvedDankConfig {
+        return this.#c
     }
 
     set copiedAssets(copiedAssets: Array<string> | null) {
@@ -107,29 +92,88 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
             copiedAssets === null ? null : new Set(copiedAssets)
     }
 
-    set pageUrls(pageUrls: Array<string>) {
-        this.#pageUrls = pageUrls
+    get htmlEntrypoints(): Array<HtmlEntrypoint> {
+        return Object.values(this.#pages).map(p => p.html)
+    }
+
+    get pageUrls(): Array<string> {
+        return Object.keys(this.#pages)
     }
 
     get resolver(): Resolver {
         return this.#resolver
     }
 
-    // bundleOutputs(type?: 'css' | 'js'): Array<string> {
-    //     if (!type) {
-    //         return Array.from(this.#bundles)
-    //     } else {
-    //         return Array.from(this.#bundles).filter(p => p.endsWith(type))
-    //     }
-    // }
+    get urlRewrites(): Array<UrlRewrite> {
+        return Object.values(this.#pages)
+            .filter(
+                (pr): pr is WebpageRegistration & { urlRewrite: UrlRewrite } =>
+                    typeof pr.urlRewrite !== 'undefined',
+            )
+            .map(pr => pr.urlRewrite)
+    }
+
+    get webpageEntryPoints(): Array<EntryPoint> {
+        const unique: Set<EntryPoint['in']> = 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(): Array<EntryPoint> {
+        const unique: Set<EntryPoint['in']> = 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(): Array<EntryPoint> | null {
+        return (
+            this.#workers?.map(({ workerEntryPoint }) => ({
+                in: workerEntryPoint,
+                out: workerEntryPoint
+                    .replace(/^pages[\//]/, '')
+                    .replace(/\.(mj|t)s$/, '.js'),
+            })) || null
+        )
+    }
+
+    get workers(): Array<WorkerManifest> | null {
+        return this.#workers
+    }
 
     buildRegistry(): BuildRegistry {
-        return new BuildRegistry(this.#build, this.#onBuildManifest)
+        return new BuildRegistry(
+            this.#c.dirs,
+            this.#resolver,
+            this.#onBuildManifest,
+        )
+    }
+
+    configSync() {
+        this.#configDiff()
     }
 
     files(): Set<string> {
         const files = new Set<string>()
-        for (const pageUrl of this.#pageUrls)
+        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)
@@ -145,27 +189,12 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         }
     }
 
-    workerEntryPoints(): Array<EntryPoint> | null {
-        return (
-            this.#workers?.map(({ workerEntryPoint }) => ({
-                in: workerEntryPoint,
-                out: workerEntryPoint
-                    .replace(/^pages[\//]/, '')
-                    .replace(/\.(mj|t)s$/, '.js'),
-            })) || null
-        )
-    }
-
-    workers(): Array<WorkerManifest> | null {
-        return this.#workers
-    }
-
     async writeManifest(buildTag: string): Promise<WebsiteManifest> {
         const manifest = this.#manifest(buildTag)
         await writeFile(
             join(
-                this.#build.dirs.projectRootAbs,
-                this.#build.dirs.buildRoot,
+                this.#c.dirs.projectRootAbs,
+                this.#c.dirs.buildRoot,
                 'website.json',
             ),
             JSON.stringify(
@@ -181,11 +210,103 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
         return manifest
     }
 
+    #configDiff() {
+        const updatePages: ResolvedDankConfig['pages'] = 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 as `/${string}`)
+            if (existingPage) {
+                this.#configPageUpdate(urlPath as `/${string}`, mapping)
+            } else {
+                this.#configPageAdd(urlPath as `/${string}`, mapping)
+            }
+        }
+        for (const prevPage of prevPages) {
+            this.#configPageRemove(prevPage as `/${string}`)
+        }
+    }
+
+    #configPageAdd(urlPath: `/${string}`, mapping: PageMapping) {
+        LOG({
+            realm: 'registry',
+            message: 'added page',
+            data: {
+                urlPath,
+                srcPath: mapping.webpage,
+            },
+        })
+        const html = new HtmlEntrypoint(
+            this.#c,
+            this.#resolver,
+            urlPath as `/${string}`,
+            mapping.webpage,
+        )
+        const urlRewrite = mapping.pattern
+            ? { pattern: mapping.pattern, url: urlPath }
+            : undefined
+        this.#pages[urlPath as `/${string}`] = {
+            pageUrl: urlPath as `/${string}`,
+            fsPath: mapping.webpage,
+            html,
+            urlRewrite,
+            bundles: [],
+        }
+        html.on('entrypoints', entrypoints =>
+            this.#setWebpageBundles(html.url, entrypoints),
+        )
+        this.emit('webpage', html)
+    }
+
+    #configPageUpdate(urlPath: `/${string}`, mapping: PageMapping) {
+        const existingRegistration = this.#pages[urlPath as `/${string}`]
+        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 = undefined
+            }
+        }
+        LOG({
+            realm: 'registry',
+            message: 'updated page src',
+            data: {
+                urlPath,
+                newSrcPath: mapping.webpage,
+                oldSrcPath: this.#pages[urlPath as `/${string}`].fsPath,
+            },
+        })
+    }
+
+    #configPageRemove(urlPath: `/${string}`) {
+        const registration = this.#pages[urlPath]
+        LOG({
+            realm: 'registry',
+            message: 'removed page',
+            data: {
+                urlPath,
+                srcPath: registration.fsPath,
+            },
+        })
+        registration.html.removeAllListeners()
+        delete this.#pages[urlPath]
+    }
+
     #manifest(buildTag: string): WebsiteManifest {
         return {
             buildTag,
             files: this.files(),
-            pageUrls: new Set(this.#pageUrls),
+            pageUrls: new Set(Object.keys(this.#pages)),
         }
     }
 
@@ -246,20 +367,32 @@ export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
             this.emit('workers')
         }
     }
+
+    #setWebpageBundles(url: `/${string}`, bundles: Array<EntryPoint>) {
+        this.#pages[url].bundles = bundles
+        this.emit('entrypoints')
+    }
 }
 
 // result accumulator of an esbuild `build` or `Context.rebuild`
 export class BuildRegistry {
+    #dirs: DankDirectories
     #onComplete: OnBuildComplete
     #resolver: Resolver
     #workers: Array<Omit<WorkerManifest, 'dependentEntryPoint'>> | null = null
 
     constructor(
-        build: DankBuild,
+        dirs: DankDirectories,
+        resolver: Resolver,
         onComplete: (manifest: BuildManifest) => void,
     ) {
+        this.#dirs = dirs
         this.#onComplete = onComplete
-        this.#resolver = new ResolverImpl(build.dirs)
+        this.#resolver = resolver
+    }
+
+    get dirs(): DankDirectories {
+        return this.#dirs
     }
 
     get resolver(): Resolver {