@eighty4/dank 0.0.4-1 → 0.0.4-3

package/client/client.js

@@ -0,0 +1 @@
+new EventSource("http://127.0.0.1:3995/esbuild").addEventListener("change",o=>{let{updated:a}=JSON.parse(o.data),e=new Set;for(let s of a)e.add(s);let d=Array.from(e).filter(s=>s.endsWith(".css"));if(d.length){console.log("esbuild css updates",d);let s={};for(let t of document.getElementsByTagName("link"))if(t.getAttribute("rel")==="stylesheet"){let n=new URL(t.href);(n.host=location.host)&&(s[n.pathname]=t)}let r=!1;for(let t of d){let n=s[t];if(n){let c=n.cloneNode();c.href=`${t}?${Math.random().toString(36).slice(2)}`,c.onload=()=>n.remove(),n.parentNode.insertBefore(c,n.nextSibling),r=!0}}r&&p()}if(d.length<e.size){let s=Array.from(e).filter(t=>!t.endsWith(".css")),r=new Set;for(let t of document.getElementsByTagName("script"))if(t.src.length){let n=new URL(t.src);(n.host=location.host)&&r.add(n.pathname)}s.some(t=>r.has(t))&&(console.log("esbuild js updates require reload"),y())}});function p(){let o=l("green","23995");o.style.opacity="0",o.animate([{opacity:0},{opacity:1},{opacity:1},{opacity:1},{opacity:.75},{opacity:.5},{opacity:.25},{opacity:0}],{duration:400,iterations:1,direction:"normal",easing:"linear"}),document.body.appendChild(o),Promise.all(o.getAnimations().map(a=>a.finished)).then(()=>o.remove())}var i=null;function y(){i||(i=l("orange","33995"),i.style.opacity="0",i.style.pointerEvents="none",i.animate([{opacity:0},{opacity:1}],{duration:400,iterations:1,direction:"normal",easing:"ease-in",fill:"forwards"}),document.body.appendChild(i))}function l(o,a){let e=document.createElement("div");return e.style.border="6px dashed "+o,e.style.zIndex=a,e.style.position="fixed",e.style.top=e.style.left="1px",e.style.height=e.style.width="calc(100% - 2px)",e.style.boxSizing="border-box",e}

package/lib/bin.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { buildWebsite } from './build.ts'
-import { loadConfig } from './config.ts'
+import { DankError } from './errors.ts'
 import { serveWebsite } from './serve.ts'
 
 function printHelp(task?: 'build' | 'serve'): never {
@@ -71,16 +71,14 @@ const task: 'build' | 'serve' = (function resolveTask() {
     return task
 })()
 
-const c = await loadConfig()
-
 try {
     switch (task) {
         case 'build':
-            await buildWebsite(c)
+            await buildWebsite()
             console.log(green('done'))
             process.exit(0)
         case 'serve':
-            await serveWebsite(c)
+            await serveWebsite()
     }
 } catch (e: unknown) {
     errorExit(e)
@@ -88,13 +86,12 @@ try {
 
 function printError(e: unknown) {
     if (e !== null) {
-        if (typeof e === 'string') {
-            console.error(red('error:'), e)
-        } else if (e instanceof Error) {
+        if (e instanceof DankError) {
             console.error(red('error:'), e.message)
-            if (e.stack) {
-                console.error(e.stack)
-            }
+        } else if (e instanceof Error) {
+            console.error(red('error:'), e.stack ?? e.message)
+        } else {
+            console.error(red('error:'), e)
         }
     }
 }

package/lib/build.ts

@@ -1,22 +1,23 @@
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { createBuildTag } from './build_tag.ts'
-import type { DankConfig } from './dank.ts'
+import { loadConfig, type ResolvedDankConfig } from './config.ts'
 import { type DefineDankGlobal, createGlobalDefinitions } from './define.ts'
-import { esbuildWebpages, esbuildWorkers, type EntryPoint } from './esbuild.ts'
-import { resolveBuildFlags, type DankBuild } from './flags.ts'
-import { HtmlEntrypoint } from './html.ts'
-import { type WebsiteManifest, WebsiteRegistry } from './metadata.ts'
+import type { DankDirectories } from './dirs.ts'
+import { esbuildWebpages, esbuildWorkers } from './esbuild.ts'
 import { copyAssets } from './public.ts'
+import { type WebsiteManifest, WebsiteRegistry } from './registry.ts'
 
 export async function buildWebsite(
-    c: DankConfig,
-    build: DankBuild = resolveBuildFlags(),
+    c?: ResolvedDankConfig,
 ): Promise<WebsiteManifest> {
-    const buildTag = await createBuildTag(build)
+    if (!c) {
+        c = await loadConfig('build', process.cwd())
+    }
+    const buildTag = await createBuildTag(c.flags)
     console.log(
-        build.minify
-            ? build.production
+        c.flags.minify
+            ? c.flags.production
                 ? 'minified production'
                 : 'minified'
             : 'unminified',
@@ -24,85 +25,52 @@ export async function buildWebsite(
         buildTag,
         'building in ./build/dist',
     )
-    await rm(build.dirs.buildRoot, { recursive: true, force: true })
-    await mkdir(build.dirs.buildDist, { recursive: true })
+    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 !== '/')) {
-        await mkdir(join(build.dirs.buildDist, subdir), { recursive: true })
+        await mkdir(join(c.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))
+    await mkdir(join(c.dirs.buildRoot, 'metafiles'), { recursive: true })
+    const registry = await buildWebpages(c, createGlobalDefinitions(c))
     return await registry.writeManifest(buildTag)
 }
 
-// builds all webpage entrypoints in one esbuild.build context
-// to support code splitting
+// 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: DankConfig,
-    registry: WebsiteRegistry,
-    build: DankBuild,
+    c: ResolvedDankConfig,
     define: DefineDankGlobal,
-) {
-    // create HtmlEntrypoint for each webpage and collect awaitable esbuild entrypoints
-    const loadingEntryPoints: Array<Promise<Array<EntryPoint>>> = []
-    const htmlEntrypoints: Array<HtmlEntrypoint> = []
-    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)
-    }
-
-    // collect esbuild entrypoints from every HtmlEntrypoint
-    const uniqueEntryPoints: Set<string> = new Set()
-    const buildEntryPoints: Array<EntryPoint> = []
-    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)
+): Promise<WebsiteRegistry> {
+    const registry = new WebsiteRegistry(c)
+    registry.configSync()
+    registry.copiedAssets = await copyAssets(c.dirs)
+    await Promise.all(registry.htmlEntrypoints.map(html => html.process()))
+    await esbuildWebpages(registry, define, registry.webpageEntryPoints)
 
     // todo recursively build workers on building workers that create workers
-    const workerEntryPoints = registry.workerEntryPoints()
+    const workerEntryPoints = registry.workerEntryPoints
     if (workerEntryPoints?.length) {
-        await esbuildWorkers(
-            build,
-            registry,
-            define,
-            workerEntryPoints,
-            c.esbuild,
-        )
+        await esbuildWorkers(registry, define, workerEntryPoints)
     }
-    await rewriteWorkerUrls(build, registry)
+    await rewriteWorkerUrls(c.dirs, registry)
 
     // write out html output with rewritten hrefs
     await Promise.all(
-        htmlEntrypoints.map(async html => {
+        registry.htmlEntrypoints.map(async html => {
             await writeFile(
-                join(build.dirs.buildDist, html.url, 'index.html'),
+                join(c.dirs.buildDist, html.url, 'index.html'),
                 html.output(registry),
             )
         }),
     )
+    return registry
 }
 
 export async function rewriteWorkerUrls(
-    build: DankBuild,
+    dirs: DankDirectories,
     registry: WebsiteRegistry,
 ) {
-    const workers = registry.workers()
+    const workers = registry.workers
     if (!workers) {
         return
     }
@@ -115,7 +83,7 @@ export async function rewriteWorkerUrls(
     const readingFiles = Promise.all(
         dependentBundlePaths.map(async p => {
             bundleOutputs[p] = await readFile(
-                join(build.dirs.projectRootAbs, build.dirs.buildDist, p),
+                join(dirs.projectRootAbs, dirs.buildDist, p),
                 'utf8',
             )
         }),
@@ -127,8 +95,8 @@ export async function rewriteWorkerUrls(
     for (const w of workers) {
         rewriteChains[registry.mappedHref(w.dependentEntryPoint)].push(s =>
             s.replace(
-                createWorkerRegex(w.workerUrlPlaceholder),
-                `new Worker('${registry.mappedHref(w.workerEntryPoint)}')`,
+                createWorkerRegex(w.workerCtor, w.workerUrlPlaceholder),
+                `new ${w.workerCtor}('${registry.mappedHref(w.workerEntryPoint)}')`,
             ),
         )
     }
@@ -144,16 +112,19 @@ export async function rewriteWorkerUrls(
                 result = rewriteFn(result)
             }
             await writeFile(
-                join(build.dirs.projectRootAbs, build.dirs.buildDist, p),
+                join(dirs.projectRootAbs, dirs.buildDist, p),
                 result,
             )
         }),
     )
 }
 
-export function createWorkerRegex(workerUrl: string): RegExp {
+export function createWorkerRegex(
+    workerCtor: 'Worker' | 'SharedWorker',
+    workerUrl: string,
+): RegExp {
     return new RegExp(
-        `new(?:\\s|\\r?\\n)+Worker(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`,
+        `new(?:\\s|\\r?\\n)+${workerCtor}(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`,
         'g',
     )
 }

package/lib/build_tag.ts

@@ -1,7 +1,7 @@
 import { exec } from 'node:child_process'
-import type { DankBuild } from './flags.ts'
+import type { DankFlags } from './flags.ts'
 
-export async function createBuildTag(build: DankBuild): Promise<string> {
+export async function createBuildTag(flags: DankFlags): Promise<string> {
     const now = new Date()
     const ms =
         now.getUTCMilliseconds() +
@@ -11,7 +11,7 @@ export async function createBuildTag(build: DankBuild): Promise<string> {
     const date = now.toISOString().substring(0, 10)
     const time = String(ms).padStart(8, '0')
     const when = `${date}-${time}`
-    if (build.production) {
+    if (flags.production) {
         const gitHash = await new Promise((res, rej) =>
             exec('git rev-parse --short HEAD', (err, stdout) => {
                 if (err) rej(err)

package/lib/config.ts

@@ -1,18 +1,379 @@
 import { isAbsolute, resolve } from 'node:path'
-import type { DankConfig } from './dank.ts'
+import type {
+    DankConfig,
+    DankDetails,
+    EsbuildConfig,
+    PageMapping,
+} from './dank.ts'
+import { LOG } from './developer.ts'
+import { defaultProjectDirs, type DankDirectories } from './dirs.ts'
+import {
+    resolveFlags as lookupDankFlags,
+    type DankFlags as DankFlags,
+} from './flags.ts'
 
-const CFG_P = './dank.config.ts'
+const DEFAULT_DEV_PORT = 3000
+const DEFAULT_PREVIEW_PORT = 4000
+const DEFAULT_ESBUILD_PORT = 3995
 
-export async function loadConfig(path: string = CFG_P): Promise<DankConfig> {
-    const modulePath = `${resolveConfigPath(path)}?${Date.now()}`
-    const module = await import(modulePath)
-    return await module.default
+const DEFAULT_CONFIG_PATH = './dank.config.ts'
+
+export type { DevService } from './dank.ts'
+
+export type ResolvedDankConfig = {
+    // static from process boot
+    get dirs(): Readonly<DankDirectories>
+    get flags(): Readonly<Omit<DankFlags, 'dankPort' | 'esbuildPort'>>
+    get mode(): 'build' | 'serve'
+
+    // reloadable from `dank.config.ts` with `reload()`
+    get dankPort(): number
+    get esbuildPort(): number
+    get esbuild(): Readonly<Omit<EsbuildConfig, 'port'>> | undefined
+    get pages(): Readonly<Record<`/${string}`, PageMapping>>
+    get devPages(): Readonly<DankConfig['devPages']>
+    get services(): Readonly<DankConfig['services']>
+
+    reload(): Promise<void>
+}
+
+export async function loadConfig(
+    mode: 'build' | 'serve',
+    projectRootAbs: string,
+): Promise<ResolvedDankConfig> {
+    if (!isAbsolute(projectRootAbs)) {
+        throw Error()
+    }
+    const modulePath = resolve(projectRootAbs, DEFAULT_CONFIG_PATH)
+    LOG({
+        realm: 'config',
+        message: 'loading config module',
+        data: {
+            modulePath,
+        },
+    })
+    const dirs = await defaultProjectDirs(projectRootAbs)
+    const c = new DankConfigInternal(mode, modulePath, dirs)
+    await c.reload()
+    return c
+}
+
+class DankConfigInternal implements ResolvedDankConfig {
+    #dirs: Readonly<DankDirectories>
+    #flags: Readonly<DankFlags>
+    #mode: 'build' | 'serve'
+    #modulePath: string
+
+    #dankPort: number = DEFAULT_DEV_PORT
+    #esbuildPort: number = DEFAULT_ESBUILD_PORT
+    #esbuild: Readonly<Omit<EsbuildConfig, 'port'>> | undefined
+    #pages: Readonly<Record<`/${string}`, PageMapping>> = {}
+    #devPages: Readonly<DankConfig['devPages']>
+    #services: Readonly<DankConfig['services']>
+
+    constructor(
+        mode: 'build' | 'serve',
+        modulePath: string,
+        dirs: DankDirectories,
+    ) {
+        this.#dirs = dirs
+        this.#flags = lookupDankFlags()
+        this.#mode = mode
+        this.#modulePath = modulePath
+    }
+
+    get dankPort(): number {
+        return this.#dankPort
+    }
+
+    get esbuildPort(): number {
+        return this.#esbuildPort
+    }
+
+    get esbuild(): Omit<EsbuildConfig, 'port'> | undefined {
+        return this.#esbuild
+    }
+
+    get dirs(): Readonly<DankDirectories> {
+        return this.#dirs
+    }
+
+    get flags(): Readonly<Omit<DankFlags, 'dankPort' | 'esbuildPort'>> {
+        return this.#flags
+    }
+
+    get mode(): 'build' | 'serve' {
+        return this.#mode
+    }
+
+    get pages(): Readonly<Record<`/${string}`, PageMapping>> {
+        return this.#pages
+    }
+
+    get devPages(): Readonly<DankConfig['devPages']> {
+        return this.#devPages
+    }
+
+    get services(): Readonly<DankConfig['services']> {
+        return this.#services
+    }
+
+    async reload() {
+        const userConfig = await resolveConfig(
+            this.#modulePath,
+            resolveDankDetails(this.#mode, this.#flags),
+        )
+        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)
+    }
+}
+
+function resolveDankPort(flags: DankFlags, userConfig: DankConfig): number {
+    return (
+        flags.dankPort ||
+        (flags.preview
+            ? userConfig.previewPort || userConfig.port || DEFAULT_PREVIEW_PORT
+            : userConfig.port || DEFAULT_DEV_PORT)
+    )
+}
+
+function resolveEsbuildPort(flags: DankFlags, userConfig: DankConfig): number {
+    return flags.esbuildPort || userConfig.esbuild?.port || DEFAULT_ESBUILD_PORT
+}
+
+async function resolveConfig(
+    modulePath: string,
+    details: DankDetails,
+): Promise<DankConfig> {
+    const module = await import(`${modulePath}?${Date.now()}`)
+    const c: Partial<DankConfig> =
+        typeof module.default === 'function'
+            ? await module.default(details)
+            : module.default
+    validateDankConfig(c)
+    return c as DankConfig
+}
+
+function resolveDankDetails(
+    mode: 'build' | 'serve',
+    flags: DankFlags,
+): DankDetails {
+    return {
+        dev: !flags.production,
+        production: flags.production,
+        mode,
+    }
+}
+
+function validateDankConfig(c: Partial<DankConfig>) {
+    try {
+        validatePorts(c)
+        validatePages(c.pages)
+        validateDevPages(c.devPages)
+        validateDevServices(c.services)
+        validateEsbuildConfig(c.esbuild)
+    } catch (e: any) {
+        LOG({
+            realm: 'config',
+            message: 'validation error',
+            data: {
+                error: e.message,
+            },
+        })
+        throw e
+    }
+}
+
+function validatePorts(c: Partial<DankConfig>) {
+    if (c.port !== null && typeof c.port !== 'undefined') {
+        if (typeof c.port !== 'number') {
+            throw Error('DankConfig.port must be a number')
+        }
+    }
+    if (c.previewPort !== null && typeof c.previewPort !== 'undefined') {
+        if (typeof c.previewPort !== 'number') {
+            throw Error('DankConfig.previewPort must be a number')
+        }
+    }
+}
+
+function validateEsbuildConfig(esbuild?: EsbuildConfig) {
+    if (esbuild?.loaders !== null && typeof esbuild?.loaders !== 'undefined') {
+        if (typeof esbuild.loaders !== 'object') {
+            throw Error(
+                'DankConfig.esbuild.loaders must be a map of extensions to esbuild loaders',
+            )
+        } else {
+            for (const [ext, loader] of Object.entries(esbuild.loaders)) {
+                if (typeof loader !== 'string') {
+                    throw Error(
+                        `DankConfig.esbuild.loaders['${ext}'] must be a string of a loader name`,
+                    )
+                }
+            }
+        }
+    }
+    if (esbuild?.plugins !== null && typeof esbuild?.plugins !== 'undefined') {
+        if (!Array.isArray(esbuild.plugins)) {
+            throw Error(
+                'DankConfig.esbuild.plugins must be an array of esbuild plugins',
+            )
+        }
+    }
+    if (esbuild?.port !== null && typeof esbuild?.port !== 'undefined') {
+        if (typeof esbuild.port !== 'number') {
+            throw Error('DankConfig.esbuild.port must be a number')
+        }
+    }
+}
+
+function validatePages(pages?: DankConfig['pages']) {
+    if (
+        pages === null ||
+        typeof pages === 'undefined' ||
+        Object.keys(pages).length === 0
+    ) {
+        throw Error('DankConfig.pages is required')
+    }
+    for (const [urlPath, mapping] of Object.entries(pages)) {
+        if (typeof mapping === 'string' && mapping.endsWith('.html')) {
+            continue
+        }
+        if (typeof mapping === 'object') {
+            validatePageMapping(urlPath, mapping)
+            continue
+        }
+        throw Error(
+            `DankConfig.pages['${urlPath}'] must configure an html file`,
+        )
+    }
+}
+
+function validateDevPages(devPages?: DankConfig['devPages']) {
+    if (devPages) {
+        for (const [urlPath, mapping] of Object.entries(devPages)) {
+            if (!urlPath.startsWith('/__')) {
+                throw Error(
+                    `DankConfig.devPages['${urlPath}'] must start \`${urlPath}\` with a \`/__\` path prefix`,
+                )
+            }
+            if (typeof mapping === 'string') {
+                if (!mapping.endsWith('.html')) {
+                    throw Error(
+                        `DankConfig.devPages['${urlPath}'] must configure an html file or DevPageMapping config`,
+                    )
+                }
+            } else if (typeof mapping === 'object') {
+                if (
+                    typeof mapping.label !== 'string' ||
+                    !mapping.label.length
+                ) {
+                    throw Error(
+                        `DankConfig.devPages['${urlPath}'].label must declare a label`,
+                    )
+                }
+                if (
+                    typeof mapping.webpage !== 'string' ||
+                    !mapping.webpage.endsWith('.html')
+                ) {
+                    throw Error(
+                        `DankConfig.devPages['${urlPath}'].webpage must configure an html file`,
+                    )
+                }
+            } else {
+                throw Error(
+                    `DankConfig.devPages['${urlPath}'] must be a DevPageMapping config with \`label\` and \`webpage\` values`,
+                )
+            }
+        }
+    }
+}
+
+function validatePageMapping(urlPath: string, mapping: PageMapping) {
+    if (
+        mapping.webpage === null ||
+        typeof mapping.webpage !== 'string' ||
+        !mapping.webpage.endsWith('.html')
+    ) {
+        throw Error(
+            `DankConfig.pages['${urlPath}'].webpage must configure an html file`,
+        )
+    }
+    if (mapping.pattern === null || typeof mapping.pattern === 'undefined') {
+        return
+    }
+    if (
+        typeof mapping.pattern === 'object' &&
+        mapping.pattern.constructor.name === 'RegExp'
+    ) {
+        return
+    }
+    throw Error(`DankConfig.pages['${urlPath}'].pattern must be a RegExp`)
+}
+
+function validateDevServices(services: DankConfig['services']) {
+    if (services === null || typeof services === 'undefined') {
+        return
+    }
+    if (!Array.isArray(services)) {
+        throw Error(`DankConfig.services must be an array`)
+    }
+    for (let i = 0; i < services.length; i++) {
+        const s = services[i]
+        if (s.command === null || typeof s.command === 'undefined') {
+            throw Error(`DankConfig.services[${i}].command is required`)
+        } else if (typeof s.command !== 'string' || s.command.length === 0) {
+            throw Error(
+                `DankConfig.services[${i}].command must be a non-empty string`,
+            )
+        }
+        if (s.cwd !== null && typeof s.cwd !== 'undefined') {
+            if (typeof s.cwd !== 'string' || s.cwd.trim().length === 0) {
+                throw Error(
+                    `DankConfig.services[${i}].cwd must be a non-empty string`,
+                )
+            }
+        }
+        if (s.env !== null && typeof s.env !== 'undefined') {
+            if (typeof s.env !== 'object') {
+                throw Error(
+                    `DankConfig.services[${i}].env must be an env variable map`,
+                )
+            }
+            for (const [k, v] of Object.entries(s.env)) {
+                if (typeof v !== 'string') {
+                    throw Error(
+                        `DankConfig.services[${i}].env[${k}] must be a string`,
+                    )
+                }
+            }
+        }
+        if (s.http !== null && typeof s.http !== 'undefined') {
+            if (typeof s.http.port !== 'number') {
+                throw Error(
+                    `DankConfig.services[${i}].http.port must be a number`,
+                )
+            }
+        }
+    }
 }
 
-export function resolveConfigPath(path: string): string {
-    if (isAbsolute(path)) {
-        return path
-    } else {
-        return resolve(process.cwd(), path)
+function normalizePages(
+    pages: DankConfig['pages'],
+): Record<`/${string}`, PageMapping> {
+    const result: Record<`/${string}`, PageMapping> = {}
+    for (const [pageUrl, mapping] of Object.entries(pages)) {
+        const mappedMapping =
+            typeof mapping === 'string' ? { webpage: mapping } : mapping
+        mappedMapping.webpage = mappedMapping.webpage.replace(
+            /^\.\//,
+            '',
+        ) as `${string}.html`
+        result[pageUrl as `/${string}`] = mappedMapping
     }
+    return result
 }