@eighty4/dank 0.0.4-2 → 0.0.4

package/lib/dirs.ts

@@ -0,0 +1,83 @@
+import { realpath } from 'node:fs/promises'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
+import { cwd } from 'node:process'
+
+export type DankDirectories = {
+    buildRoot: string
+    // output dir of html during `dank serve`
+    buildWatch: string
+    buildDist: string
+    pages: string
+    pagesResolved: string
+    projectResolved: string
+    projectRootAbs: string
+    public: string
+}
+
+export async function defaultProjectDirs(
+    projectRootAbs: string,
+): Promise<Readonly<DankDirectories>> {
+    if (!projectRootAbs) {
+        projectRootAbs = cwd()
+    } else if (!isAbsolute(projectRootAbs)) {
+        throw Error()
+    }
+    const projectResolved = await realpath(projectRootAbs)
+    const pages = 'pages'
+    const pagesResolved = join(projectResolved, pages)
+    return Object.freeze({
+        buildRoot: 'build',
+        buildDist: join('build', 'dist'),
+        buildWatch: join('build', 'watch'),
+        pages,
+        pagesResolved,
+        projectResolved,
+        projectRootAbs,
+        public: 'public',
+    })
+}
+
+export type ResolveError = 'outofbounds'
+
+export class Resolver {
+    #dirs: DankDirectories
+
+    constructor(dirs: DankDirectories) {
+        this.#dirs = dirs
+    }
+
+    // cross platform safe absolute path resolution from pages dir
+    absPagesPath(...p: Array<string>): string {
+        return join(this.#dirs.projectRootAbs, this.#dirs.pages, ...p)
+    }
+
+    // cross platform safe absolute path resolution from project root
+    absProjectPath(...p: Array<string>): string {
+        return join(this.#dirs.projectRootAbs, ...p)
+    }
+
+    // `p` is expected to be a relative path resolvable from the project dir
+    isProjectSubpathInPagesDir(p: string): boolean {
+        return resolve(join(this.#dirs.projectResolved, p)).startsWith(
+            this.#dirs.pagesResolved,
+        )
+    }
+
+    // `p` is expected to be a relative path resolvable from the pages dir
+    isPagesSubpathInPagesDir(p: string): boolean {
+        return this.isProjectSubpathInPagesDir(join(this.#dirs.pages, p))
+    }
+
+    // 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 {
+        const p = join(dirname(from), href)
+        if (this.isProjectSubpathInPagesDir(p)) {
+            return p
+        } else {
+            return 'outofbounds'
+        }
+    }
+}

package/lib/errors.ts

@@ -0,0 +1,6 @@
+export class DankError extends Error {
+    constructor(message: string, cause?: Error) {
+        super(message, { cause })
+        this.name = 'DankError'
+    }
+}

package/lib/esbuild.ts

@@ -9,45 +9,39 @@ import esbuild, {
     type Plugin,
     type PluginBuild,
 } from 'esbuild'
-import type { EsbuildConfig } from './dank.ts'
 import type { DefineDankGlobal } from './define.ts'
-import type { DankBuild } from './flags.ts'
-import type { BuildRegistry, WebsiteRegistry } from './metadata.ts'
+import type { BuildRegistry, WebsiteRegistry } from './registry.ts'
 
 export type EntryPoint = { in: string; out: string }
 
 export async function esbuildDevContext(
-    b: DankBuild,
     r: WebsiteRegistry,
     define: DefineDankGlobal,
     entryPoints: Array<EntryPoint>,
-    c?: EsbuildConfig,
 ): Promise<BuildContext> {
     return await esbuild.context({
         define,
         entryNames: '[dir]/[name]',
         entryPoints: mapEntryPointPaths(entryPoints),
-        outdir: b.dirs.buildWatch,
-        ...commonBuildOptions(b, r, c),
+        outdir: r.config.dirs.buildWatch,
+        ...commonBuildOptions(r),
         splitting: false,
         write: false,
     })
 }
 
 export async function esbuildWebpages(
-    b: DankBuild,
     r: WebsiteRegistry,
     define: DefineDankGlobal,
     entryPoints: Array<EntryPoint>,
-    c?: EsbuildConfig,
 ): Promise<void> {
     try {
         await esbuild.build({
             define,
             entryNames: '[dir]/[name]-[hash]',
             entryPoints: mapEntryPointPaths(entryPoints),
-            outdir: b.dirs.buildDist,
-            ...commonBuildOptions(b, r, c),
+            outdir: r.config.dirs.buildDist,
+            ...commonBuildOptions(r),
         })
     } catch (ignore) {
         process.exit(1)
@@ -55,19 +49,17 @@ export async function esbuildWebpages(
 }
 
 export async function esbuildWorkers(
-    b: DankBuild,
     r: WebsiteRegistry,
     define: DefineDankGlobal,
     entryPoints: Array<EntryPoint>,
-    c?: EsbuildConfig,
 ): Promise<void> {
     try {
         await esbuild.build({
             define,
             entryNames: '[dir]/[name]-[hash]',
             entryPoints: mapEntryPointPaths(entryPoints),
-            outdir: b.dirs.buildDist,
-            ...commonBuildOptions(b, r, c),
+            outdir: r.config.dirs.buildDist,
+            ...commonBuildOptions(r),
             splitting: false,
             metafile: true,
             write: true,
@@ -78,22 +70,19 @@ export async function esbuildWorkers(
     }
 }
 
-function commonBuildOptions(
-    b: DankBuild,
-    r: WebsiteRegistry,
-    c?: EsbuildConfig,
-): BuildOptions {
+function commonBuildOptions(r: WebsiteRegistry): BuildOptions {
     const p = workersPlugin(r.buildRegistry())
     return {
-        absWorkingDir: b.dirs.projectRootAbs,
         assetNames: 'assets/[name]-[hash]',
         bundle: true,
         format: 'esm',
-        loader: c?.loaders || defaultLoaders(),
+        loader: r.config.esbuild?.loaders || defaultLoaders(),
         metafile: true,
-        minify: b.minify,
+        minify: r.config.flags.minify,
         platform: 'browser',
-        plugins: c?.plugins?.length ? [p, ...c.plugins] : [p],
+        plugins: r.config.esbuild?.plugins?.length
+            ? [p, ...r.config.esbuild?.plugins]
+            : [p],
         splitting: true,
         treeShaking: true,
         write: true,
@@ -127,11 +116,8 @@ export function workersPlugin(r: BuildRegistry): Plugin {
     return {
         name: '@eighty4/dank/esbuild/workers',
         setup(build: PluginBuild) {
-            if (!build.initialOptions.absWorkingDir)
-                throw TypeError('plugin requires absWorkingDir')
             if (!build.initialOptions.metafile)
                 throw TypeError('plugin requires metafile')
-            const { absWorkingDir } = build.initialOptions
 
             build.onLoad({ filter: /\.(t|m?j)s$/ }, async args => {
                 let contents = await readFile(args.path, 'utf8')
@@ -158,7 +144,7 @@ export function workersPlugin(r: BuildRegistry): Plugin {
                         continue
                     }
                     const clientScript = args.path
-                        .replace(absWorkingDir, '')
+                        .replace(r.dirs.projectResolved, '')
                         .substring(1)
                     const workerUrl = workerCtorMatch.groups!.url.substring(
                         1,
@@ -182,10 +168,13 @@ export function workersPlugin(r: BuildRegistry): Plugin {
                         )
                         continue
                     }
+                    const workerCtor = workerCtorMatch.groups!.ctor as
+                        | 'Worker'
+                        | 'SharedWorker'
                     const workerUrlPlaceholder = workerEntryPoint
                         .replace(/^pages/, '')
                         .replace(/\.(t|m?j)s$/, '.js')
-                    const workerCtorReplacement = `new ${workerCtorMatch.groups!.ctor}('${workerUrlPlaceholder}'${workerCtorMatch.groups!.end}`
+                    const workerCtorReplacement = `new ${workerCtor}('${workerUrlPlaceholder}'${workerCtorMatch.groups!.end}`
                     contents =
                         contents.substring(0, workerCtorMatch.index + offset) +
                         workerCtorReplacement +
@@ -199,6 +188,7 @@ export function workersPlugin(r: BuildRegistry): Plugin {
                     r.addWorker({
                         clientScript,
                         workerEntryPoint,
+                        workerCtor,
                         workerUrl,
                         workerUrlPlaceholder,
                     })

package/lib/flags.ts

@@ -1,84 +1,21 @@
-import { join, resolve } from 'node:path'
-import { cwd } from 'node:process'
-import type { DankConfig } from './dank.ts'
-
-export type DankBuild = {
-    dirs: ProjectDirs
-    minify: boolean
-    production: boolean
-}
-
-export type ProjectDirs = {
-    buildRoot: string
-    buildWatch: string
-    buildDist: string
-    pages: string
-    pagesResolved: string
-    projectResolved: string
-    projectRootAbs: string
-    public: string
-}
-
-export function resolveBuildFlags(): DankBuild {
-    const flags: DankBuild = {
-        dirs: defaultProjectDirs(cwd()),
-        minify: willMinify(),
-        production: isProductionBuild(),
-    }
-    return {
-        get dirs(): ProjectDirs {
-            return flags.dirs
-        },
-        get minify(): boolean {
-            return flags.minify
-        },
-        get production(): boolean {
-            return flags.production
-        },
-    }
-}
-
-export type DankServe = DankBuild & {
-    dankPort: number
-    esbuildPort: number
+export type DankFlags = {
+    dankPort?: number
+    esbuildPort?: number
     logHttp: boolean
+    minify: boolean
     preview: boolean
+    production: boolean
 }
 
-export function resolveServeFlags(c: DankConfig): DankServe {
-    const preview = isPreviewBuild()
-    const flags: DankServe = {
-        dirs: defaultProjectDirs(cwd()),
-        dankPort: dankPort(c, preview),
-        esbuildPort: esbuildPort(c),
+export function resolveFlags(): Readonly<DankFlags> {
+    return Object.freeze({
+        dankPort: resolveDankPort(),
+        esbuildPort: resolveEsbuildPort(),
         logHttp: willLogHttp(),
         minify: willMinify(),
-        preview,
+        preview: isPreviewBuild(),
         production: isProductionBuild(),
-    }
-    return {
-        get dirs(): ProjectDirs {
-            return flags.dirs
-        },
-        get dankPort(): number {
-            return flags.dankPort
-        },
-        get esbuildPort(): number {
-            return flags.esbuildPort
-        },
-        get logHttp(): boolean {
-            return flags.logHttp
-        },
-        get minify(): boolean {
-            return flags.minify
-        },
-        get preview(): boolean {
-            return flags.preview
-        },
-        get production(): boolean {
-            return flags.production
-        },
-    }
+    })
 }
 
 // `dank serve` will pre-bundle and use service worker
@@ -87,24 +24,21 @@ 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
-export const isProductionBuild = () =>
+const isProductionBuild = () =>
     process.env.PRODUCTION === 'true' || process.argv.includes('--production')
 
-// `dank serve` dank port for frontend webserver
-// alternate --preview port for service worker builds
-function dankPort(c: DankConfig, preview: boolean): number {
+// `dank serve` port for frontend webserver
+function resolveDankPort(): number | undefined {
     if (process.env.DANK_PORT?.length) {
         return parsePortEnvVar('DANK_PORT')
     }
-    return preview ? c.previewPort || c.port || 4000 : c.port || 3000
 }
 
-// `dank serve` esbuild port for bundler integration
-function esbuildPort(c: DankConfig): number {
+// `dank serve` port for esbuild bundler integration
+function resolveEsbuildPort(): number | undefined {
     if (process.env.ESBUILD_PORT?.length) {
         return parsePortEnvVar('ESBUILD_PORT')
     }
-    return c.esbuild?.port || 3995
 }
 
 function parsePortEnvVar(name: string): number {
@@ -116,46 +50,6 @@ 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,
-        pagesResolved: resolve(join(projectRootAbs, pages)),
-        projectResolved: resolve(projectRootAbs),
-        projectRootAbs,
-        public: 'public',
-    }
-    return {
-        get buildRoot(): string {
-            return dirs.buildRoot
-        },
-        get buildDist(): string {
-            return dirs.buildDist
-        },
-        get buildWatch(): string {
-            return dirs.buildWatch
-        },
-        get pages(): string {
-            return dirs.pages
-        },
-        get pagesResolved(): string {
-            return dirs.pagesResolved
-        },
-        get projectResolved(): string {
-            return dirs.projectResolved
-        },
-        get projectRootAbs(): string {
-            return dirs.projectRootAbs
-        },
-        get public(): string {
-            return dirs.public
-        },
-    }
-}
-
 const willMinify = () =>
     isProductionBuild() ||
     process.env.MINIFY === 'true' ||