@eighty4/dank 0.0.4-0 → 0.0.4-2

package/lib/esbuild.ts

@@ -3,7 +3,8 @@ import esbuild, {
     type BuildContext,
     type BuildOptions,
     type BuildResult,
-    type Message,
+    type Location,
+    type OnLoadArgs,
     type PartialMessage,
     type Plugin,
     type PluginBuild,
@@ -40,14 +41,17 @@ export async function esbuildWebpages(
     entryPoints: Array<EntryPoint>,
     c?: EsbuildConfig,
 ): Promise<void> {
-    const result = await esbuild.build({
-        define,
-        entryNames: '[dir]/[name]-[hash]',
-        entryPoints: mapEntryPointPaths(entryPoints),
-        outdir: b.dirs.buildDist,
-        ...commonBuildOptions(b, r, c),
-    })
-    esbuildResultChecks(result)
+    try {
+        await esbuild.build({
+            define,
+            entryNames: '[dir]/[name]-[hash]',
+            entryPoints: mapEntryPointPaths(entryPoints),
+            outdir: b.dirs.buildDist,
+            ...commonBuildOptions(b, r, c),
+        })
+    } catch (ignore) {
+        process.exit(1)
+    }
 }
 
 export async function esbuildWorkers(
@@ -57,18 +61,21 @@ export async function esbuildWorkers(
     entryPoints: Array<EntryPoint>,
     c?: EsbuildConfig,
 ): Promise<void> {
-    const result = await esbuild.build({
-        define,
-        entryNames: '[dir]/[name]-[hash]',
-        entryPoints: mapEntryPointPaths(entryPoints),
-        outdir: b.dirs.buildDist,
-        ...commonBuildOptions(b, r, c),
-        splitting: false,
-        metafile: true,
-        write: true,
-        assetNames: 'assets/[name]-[hash]',
-    })
-    esbuildResultChecks(result)
+    try {
+        await esbuild.build({
+            define,
+            entryNames: '[dir]/[name]-[hash]',
+            entryPoints: mapEntryPointPaths(entryPoints),
+            outdir: b.dirs.buildDist,
+            ...commonBuildOptions(b, r, c),
+            splitting: false,
+            metafile: true,
+            write: true,
+            assetNames: 'assets/[name]-[hash]',
+        })
+    } catch (ignore) {
+        process.exit(1)
+    }
 }
 
 function commonBuildOptions(
@@ -112,29 +119,8 @@ function mapEntryPointPaths(entryPoints: Array<EntryPoint>) {
     })
 }
 
-function esbuildResultChecks(buildResult: BuildResult) {
-    if (buildResult.errors.length) {
-        buildResult.errors.forEach(msg => esbuildPrintMessage(msg, 'warning'))
-        process.exit(1)
-    }
-    if (buildResult.warnings.length) {
-        buildResult.warnings.forEach(msg => esbuildPrintMessage(msg, 'warning'))
-    }
-}
-
-function esbuildPrintMessage(msg: Message, category: 'error' | 'warning') {
-    const location = msg.location
-        ? ` (${msg.location.file}L${msg.location.line}:${msg.location.column})`
-        : ''
-    console.error(`esbuild ${category}${location}:`, msg.text)
-    msg.notes.forEach(note => {
-        console.error('  ', note.text)
-        if (note.location) console.error('   ', note.location)
-    })
-}
-
 const WORKER_CTOR_REGEX =
-    /new(?:\s|\r?\n)+Worker(?:\s|\r?\n)*\((?:\s|\r?\n)*(?<url>.*)(?:\s|\r?\n)*\)/g
+    /new(?:\s|\r?\n)+(?<ctor>(?:Shared)?Worker)(?:\s|\r?\n)*\((?:\s|\r?\n)*(?<url>.*?)(?:\s|\r?\n)*(?<end>[\),])/g
 const WORKER_URL_REGEX = /^('.*'|".*")$/
 
 export function workersPlugin(r: BuildRegistry): Plugin {
@@ -154,85 +140,68 @@ export function workersPlugin(r: BuildRegistry): Plugin {
                 for (const workerCtorMatch of contents.matchAll(
                     WORKER_CTOR_REGEX,
                 )) {
-                    const workerUrlString = workerCtorMatch.groups!.url
-                    if (WORKER_URL_REGEX.test(workerUrlString)) {
-                        const preamble = contents.substring(
-                            0,
-                            workerCtorMatch.index,
-                        )
-                        const lineIndex = preamble.lastIndexOf('\n') || 0
-                        const lineCommented = /\/\//.test(
-                            preamble.substring(lineIndex),
-                        )
-                        if (lineCommented) continue
-                        const blockCommentIndex = preamble.lastIndexOf('/*')
-                        const blockCommented =
-                            blockCommentIndex !== -1 &&
-                            preamble
-                                .substring(blockCommentIndex)
-                                .indexOf('*/') === -1
-                        if (blockCommented) continue
-                        const clientScript = args.path
-                            .replace(absWorkingDir, '')
-                            .substring(1)
-                        const workerUrl = workerUrlString.substring(
-                            1,
-                            workerUrlString.length - 1,
-                        )
-                        // todo out of bounds error on path resolve
-                        const workerEntryPoint = r.resolve(
-                            clientScript,
-                            workerUrl,
-                        )
-                        const workerUrlPlaceholder = workerEntryPoint
-                            .replace(/^pages/, '')
-                            .replace(/\.(t|m?j)s$/, '.js')
-                        const workerCtorReplacement = `new Worker('${workerUrlPlaceholder}')`
-                        contents =
-                            contents.substring(
-                                0,
-                                workerCtorMatch.index + offset,
-                            ) +
-                            workerCtorReplacement +
-                            contents.substring(
-                                workerCtorMatch.index +
-                                    workerCtorMatch[0].length +
-                                    offset,
-                            )
-                        offset +=
-                            workerCtorReplacement.length -
-                            workerCtorMatch[0].length
-                        r.addWorker({
-                            clientScript,
-                            workerEntryPoint,
-                            workerUrl,
-                            workerUrlPlaceholder,
-                        })
-                    } else {
+                    if (!WORKER_URL_REGEX.test(workerCtorMatch.groups!.url)) {
                         if (!errors) errors = []
-                        const preamble = contents.substring(
-                            0,
-                            workerCtorMatch.index,
+                        errors.push(
+                            invalidWorkerUrlCtorArg(
+                                locationFromMatch(
+                                    args,
+                                    contents,
+                                    workerCtorMatch,
+                                ),
+                                workerCtorMatch,
+                            ),
                         )
-                        const line = preamble.match(/\n/g)?.length || 0
-                        const lineIndex = preamble.lastIndexOf('\n') || 0
-                        const column = preamble.length - lineIndex
-                        const lineText = contents.substring(
-                            lineIndex,
-                            contents.indexOf('\n', lineIndex) ||
-                                contents.length,
+                        continue
+                    }
+                    if (isIndexCommented(contents, workerCtorMatch.index)) {
+                        continue
+                    }
+                    const clientScript = args.path
+                        .replace(absWorkingDir, '')
+                        .substring(1)
+                    const workerUrl = workerCtorMatch.groups!.url.substring(
+                        1,
+                        workerCtorMatch.groups!.url.length - 1,
+                    )
+                    const workerEntryPoint = r.resolver.resolveHrefInPagesDir(
+                        clientScript,
+                        workerUrl,
+                    )
+                    if (workerEntryPoint === 'outofbounds') {
+                        if (!errors) errors = []
+                        errors.push(
+                            outofboundsWorkerUrlCtorArg(
+                                locationFromMatch(
+                                    args,
+                                    contents,
+                                    workerCtorMatch,
+                                ),
+                                workerCtorMatch,
+                            ),
                         )
-                        errors.push({
-                            id: 'worker-url-unresolvable',
-                            location: {
-                                lineText,
-                                line,
-                                column,
-                                file: args.path,
-                                length: workerCtorMatch[0].length,
-                            },
-                        })
+                        continue
                     }
+                    const workerUrlPlaceholder = workerEntryPoint
+                        .replace(/^pages/, '')
+                        .replace(/\.(t|m?j)s$/, '.js')
+                    const workerCtorReplacement = `new ${workerCtorMatch.groups!.ctor}('${workerUrlPlaceholder}'${workerCtorMatch.groups!.end}`
+                    contents =
+                        contents.substring(0, workerCtorMatch.index + offset) +
+                        workerCtorReplacement +
+                        contents.substring(
+                            workerCtorMatch.index +
+                                workerCtorMatch[0].length +
+                                offset,
+                        )
+                    offset +=
+                        workerCtorReplacement.length - workerCtorMatch[0].length
+                    r.addWorker({
+                        clientScript,
+                        workerEntryPoint,
+                        workerUrl,
+                        workerUrlPlaceholder,
+                    })
                 }
                 const loader = args.path.endsWith('ts') ? 'ts' : 'js'
                 return { contents, errors, loader }
@@ -246,3 +215,62 @@ export function workersPlugin(r: BuildRegistry): Plugin {
         },
     }
 }
+
+function isIndexCommented(contents: string, index: number) {
+    const preamble = contents.substring(0, index)
+    const lineIndex = preamble.lastIndexOf('\n') || 0
+    const lineCommented = /\/\//.test(preamble.substring(lineIndex))
+    if (lineCommented) {
+        return true
+    }
+    const blockCommentIndex = preamble.lastIndexOf('/*')
+    const blockCommented =
+        blockCommentIndex !== -1 &&
+        preamble.substring(blockCommentIndex).indexOf('*/') === -1
+    return blockCommented
+}
+
+function locationFromMatch(
+    args: OnLoadArgs,
+    contents: string,
+    match: RegExpExecArray,
+): Partial<Location> {
+    const preamble = contents.substring(0, match.index)
+    const line = preamble.match(/\n/g)?.length || 0
+    let lineIndex = preamble.lastIndexOf('\n')
+    lineIndex = lineIndex === -1 ? 0 : lineIndex + 1
+    const column = preamble.length - lineIndex
+    const lineText = contents.substring(
+        lineIndex,
+        contents.indexOf('\n', lineIndex) || contents.length,
+    )
+    return {
+        lineText,
+        line,
+        column,
+        file: args.path,
+        length: match[0].length,
+    }
+}
+
+function outofboundsWorkerUrlCtorArg(
+    location: Partial<Location>,
+    workerCtorMatch: RegExpExecArray,
+): PartialMessage {
+    return {
+        id: 'worker-url-outofbounds',
+        text: `The ${workerCtorMatch.groups!.ctor} constructor URL arg \`${workerCtorMatch.groups!.url}\` cannot resolve to a path outside of the pages directory`,
+        location,
+    }
+}
+
+function invalidWorkerUrlCtorArg(
+    location: Partial<Location>,
+    workerCtorMatch: RegExpExecArray,
+): PartialMessage {
+    return {
+        id: 'worker-url-unresolvable',
+        text: `The ${workerCtorMatch.groups!.ctor} constructor URL arg \`${workerCtorMatch.groups!.url}\` must be a relative module path`,
+        location,
+    }
+}

package/lib/flags.ts

@@ -8,12 +8,13 @@ export type DankBuild = {
     production: boolean
 }
 
-type ProjectDirs = {
+export type ProjectDirs = {
     buildRoot: string
     buildWatch: string
     buildDist: string
     pages: string
     pagesResolved: string
+    projectResolved: string
     projectRootAbs: string
     public: string
 }
@@ -86,7 +87,7 @@ const isPreviewBuild = () =>
 
 // `dank build` will minify sources and append git release tag to build tag
 // `dank serve` will pre-bundle with service worker and minify
-const isProductionBuild = () =>
+export const isProductionBuild = () =>
     process.env.PRODUCTION === 'true' || process.argv.includes('--production')
 
 // `dank serve` dank port for frontend webserver
@@ -116,12 +117,14 @@ function parsePortEnvVar(name: string): number {
 }
 
 export function defaultProjectDirs(projectRootAbs: string): ProjectDirs {
+    const pages = 'pages'
     const dirs: ProjectDirs = {
         buildRoot: 'build',
         buildDist: join('build', 'dist'),
         buildWatch: join('build', 'watch'),
-        pages: 'pages',
-        pagesResolved: resolve(join(projectRootAbs, 'pages')),
+        pages,
+        pagesResolved: resolve(join(projectRootAbs, pages)),
+        projectResolved: resolve(projectRootAbs),
         projectRootAbs,
         public: 'public',
     }
@@ -141,6 +144,9 @@ export function defaultProjectDirs(projectRootAbs: string): ProjectDirs {
         get pagesResolved(): string {
             return dirs.pagesResolved
         },
+        get projectResolved(): string {
+            return dirs.projectResolved
+        },
         get projectRootAbs(): string {
             return dirs.projectRootAbs
         },

package/lib/html.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'node:events'
 import { readFile } from 'node:fs/promises'
-import { dirname, join, relative, resolve } from 'node:path'
+import { dirname, join, relative } from 'node:path'
 import { extname } from 'node:path/posix'
 import {
     defaultTreeAdapter,
@@ -11,6 +11,7 @@ import {
 } from 'parse5'
 import type { EntryPoint } from './esbuild.ts'
 import type { DankBuild } from './flags.ts'
+import type { Resolver } from './metadata.ts'
 
 type CommentNode = DefaultTreeAdapterTypes.CommentNode
 type Document = DefaultTreeAdapterTypes.Document
@@ -25,6 +26,7 @@ type CollectedImports = {
 
 type PartialReference = {
     commentNode: CommentNode
+    // path within pages dir omitting pages/ segment
     fsPath: string
 }
 
@@ -77,20 +79,24 @@ export class HtmlEntrypoint extends EventEmitter<HtmlEntrypointEvents> {
     #document: Document = defaultTreeAdapter.createDocument()
     // todo cache entrypoints set for quicker diffing
     // #entrypoints: Set<string> = new Set()
+    // path within pages dir omitting pages/ segment
     #fsPath: string
     #partials: Array<PartialContent> = []
+    #resolver: Resolver
     #scripts: Array<ImportedScript> = []
     #update: Object = Object()
     #url: string
 
     constructor(
         build: DankBuild,
+        resolver: Resolver,
         url: string,
         fsPath: string,
         decorations?: Array<HtmlDecoration>,
     ) {
         super({ captureRejections: true })
         this.#build = build
+        this.#resolver = resolver
         this.#decorations = decorations
         this.#url = url
         this.#fsPath = fsPath
@@ -297,7 +303,7 @@ export class HtmlEntrypoint extends EventEmitter<HtmlEntrypointEvents> {
                         dirname(this.#fsPath),
                         partialSpecifier,
                     )
-                    if (!isPagesSubpathInPagesDir(this.#build, partialPath)) {
+                    if (!this.#resolver.isPagesSubpathInPagesDir(partialPath)) {
                         errorExit(
                             `partial ${partialSpecifier} in webpage ${this.#fsPath} cannot be outside of the pages directory`,
                         )
@@ -338,7 +344,7 @@ export class HtmlEntrypoint extends EventEmitter<HtmlEntrypointEvents> {
         elem: Element,
     ): ImportedScript {
         const inPath = join(this.#build.dirs.pages, dirname(this.#fsPath), href)
-        if (!isPathInPagesDir(this.#build, inPath)) {
+        if (!this.#resolver.isProjectSubpathInPagesDir(inPath)) {
             errorExit(
                 `href ${href} in webpage ${this.#fsPath} cannot reference sources outside of the pages directory`,
             )
@@ -362,17 +368,6 @@ export class HtmlEntrypoint extends EventEmitter<HtmlEntrypointEvents> {
     }
 }
 
-// check if relative dir is a subpath of pages dir when joined with pages dir
-// used if the joined pages dir path is only used for the pages dir check
-function isPagesSubpathInPagesDir(build: DankBuild, subpath: string): boolean {
-    return isPathInPagesDir(build, join(build.dirs.pages, subpath))
-}
-
-// check if subpath joined with pages dir is a subpath of pages dir
-function isPathInPagesDir(build: DankBuild, p: string): boolean {
-    return resolve(p).startsWith(build.dirs.pagesResolved)
-}
-
 function getAttr(elem: Element, name: string) {
     return elem.attrs.find(attr => attr.name === name)
 }
@@ -411,6 +406,7 @@ function rewriteHrefs(scripts: Array<ImportedScript>, hrefs?: HtmlHrefs) {
     }
 }
 
+// todo evented error handling so HtmlEntrypoint can be unit tested
 function errorExit(msg: string): never {
     console.log(`\u001b[31merror:\u001b[0m`, msg)
     process.exit(1)

package/lib/metadata.ts

@@ -1,12 +1,51 @@
 import EventEmitter from 'node:events'
 import { writeFile } from 'node:fs/promises'
-import { dirname, join, resolve, sep } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
 import type { BuildResult } from 'esbuild'
 import type { EntryPoint } from './esbuild.ts'
-import type { DankBuild } from './flags.ts'
+import type { DankBuild, ProjectDirs } from './flags.ts'
+
+export type ResolveError = 'outofbounds'
 
 export type Resolver = {
-    resolve(from: string, href: string): string | 'outofbounds'
+    // `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'
+        }
+    }
 }
 
 // summary of a website build
@@ -45,10 +84,7 @@ export type WebsiteRegistryEvents = {
 }
 
 // manages website resources during `dank build` and `dank serve`
-export class WebsiteRegistry
-    extends EventEmitter<WebsiteRegistryEvents>
-    implements Resolver
-{
+export class WebsiteRegistry extends EventEmitter<WebsiteRegistryEvents> {
     #build: DankBuild
     // paths of bundled esbuild outputs
     #bundles: Set<string> = new Set()
@@ -57,11 +93,26 @@ export class WebsiteRegistry
     // map of entrypoints to their output path
     #entrypointHrefs: Record<string, string | null> = {}
     #pageUrls: Array<string> = []
+    #resolver: Resolver
     #workers: Array<WorkerManifest> | null = null
 
     constructor(build: DankBuild) {
         super()
         this.#build = build
+        this.#resolver = new ResolverImpl(build.dirs)
+    }
+
+    set copiedAssets(copiedAssets: Array<string> | null) {
+        this.#copiedAssets =
+            copiedAssets === null ? null : new Set(copiedAssets)
+    }
+
+    set pageUrls(pageUrls: Array<string>) {
+        this.#pageUrls = pageUrls
+    }
+
+    get resolver(): Resolver {
+        return this.#resolver
     }
 
     // bundleOutputs(type?: 'css' | 'js'): Array<string> {
@@ -94,10 +145,6 @@ export class WebsiteRegistry
         }
     }
 
-    resolve(from: string, href: string): string {
-        return resolveImpl(this.#build, from, href)
-    }
-
     workerEntryPoints(): Array<EntryPoint> | null {
         return (
             this.#workers?.map(({ workerEntryPoint }) => ({
@@ -134,15 +181,6 @@ export class WebsiteRegistry
         return manifest
     }
 
-    set copiedAssets(copiedAssets: Array<string> | null) {
-        this.#copiedAssets =
-            copiedAssets === null ? null : new Set(copiedAssets)
-    }
-
-    set pageUrls(pageUrls: Array<string>) {
-        this.#pageUrls = pageUrls
-    }
-
     #manifest(buildTag: string): WebsiteManifest {
         return {
             buildTag,
@@ -211,17 +249,21 @@ export class WebsiteRegistry
 }
 
 // result accumulator of an esbuild `build` or `Context.rebuild`
-export class BuildRegistry implements Resolver {
-    #build: DankBuild
+export class BuildRegistry {
     #onComplete: OnBuildComplete
+    #resolver: Resolver
     #workers: Array<Omit<WorkerManifest, 'dependentEntryPoint'>> | null = null
 
     constructor(
         build: DankBuild,
         onComplete: (manifest: BuildManifest) => void,
     ) {
-        this.#build = build
         this.#onComplete = onComplete
+        this.#resolver = new ResolverImpl(build.dirs)
+    }
+
+    get resolver(): Resolver {
+        return this.#resolver
     }
 
     // resolve web worker imported by a webpage module
@@ -264,21 +306,4 @@ export class BuildRegistry implements Resolver {
             workers,
         })
     }
-
-    resolve(from: string, href: string): string {
-        return resolveImpl(this.#build, from, href)
-    }
-}
-
-function resolveImpl(build: DankBuild, from: string, href: string): string {
-    const { pagesResolved, projectRootAbs } = build.dirs
-    const fromDir = dirname(from)
-    const resolvedFromProjectRoot = join(projectRootAbs, fromDir, href)
-    if (!resolve(resolvedFromProjectRoot).startsWith(pagesResolved)) {
-        throw Error(
-            `href ${href} cannot be resolved from pages${sep}${from} to a path outside of the pages directory`,
-        )
-    } else {
-        return join(fromDir, href)
-    }
 }