@eighty4/dank 0.0.4-2 → 0.0.4-3

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 {