@eighty4/dank 0.0.3 → 0.0.4-1

package/lib/esbuild.ts

@@ -1,72 +1,116 @@
+import { readFile } from 'node:fs/promises'
 import esbuild, {
     type BuildContext,
     type BuildOptions,
     type BuildResult,
-    type Message,
-    type Metafile,
+    type Location,
+    type OnLoadArgs,
+    type PartialMessage,
+    type Plugin,
+    type PluginBuild,
 } from 'esbuild'
+import type { EsbuildConfig } from './dank.ts'
 import type { DefineDankGlobal } from './define.ts'
-import { willMinify } from './flags.ts'
+import type { DankBuild } from './flags.ts'
+import type { BuildRegistry, WebsiteRegistry } from './metadata.ts'
 
-const jsBuildOptions: BuildOptions & { metafile: true; write: true } = {
-    bundle: true,
-    metafile: true,
-    minify: willMinify(),
-    platform: 'browser',
-    splitting: false,
-    treeShaking: true,
-    write: true,
-}
-
-const webpageBuildOptions: BuildOptions & { metafile: true; write: true } = {
-    assetNames: 'assets/[name]-[hash]',
-    format: 'esm',
-    loader: {
-        '.tff': 'file',
-        '.woff': 'file',
-        '.woff2': 'file',
-    },
-    ...jsBuildOptions,
-}
+export type EntryPoint = { in: string; out: string }
 
 export async function esbuildDevContext(
+    b: DankBuild,
+    r: WebsiteRegistry,
     define: DefineDankGlobal,
-    entryPoints: Array<{ in: string; out: string }>,
-    outdir: string,
+    entryPoints: Array<EntryPoint>,
+    c?: EsbuildConfig,
 ): Promise<BuildContext> {
     return await esbuild.context({
         define,
         entryNames: '[dir]/[name]',
-        entryPoints: removeEntryPointOutExt(entryPoints),
-        outdir,
-        ...webpageBuildOptions,
-        metafile: false,
+        entryPoints: mapEntryPointPaths(entryPoints),
+        outdir: b.dirs.buildWatch,
+        ...commonBuildOptions(b, r, c),
+        splitting: false,
         write: false,
     })
 }
 
 export async function esbuildWebpages(
+    b: DankBuild,
+    r: WebsiteRegistry,
     define: DefineDankGlobal,
-    entryPoints: Array<{ in: string; out: string }>,
-    outdir: string,
-): Promise<Metafile> {
-    const buildResult = await esbuild.build({
-        define,
-        entryNames: '[dir]/[name]-[hash]',
-        entryPoints: removeEntryPointOutExt(entryPoints),
-        outdir,
-        ...webpageBuildOptions,
-    })
-    esbuildResultChecks(buildResult)
-    return buildResult.metafile
+    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),
+        })
+    } catch (ignore) {
+        process.exit(1)
+    }
+}
+
+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),
+            splitting: false,
+            metafile: true,
+            write: true,
+            assetNames: 'assets/[name]-[hash]',
+        })
+    } catch (ignore) {
+        process.exit(1)
+    }
+}
+
+function commonBuildOptions(
+    b: DankBuild,
+    r: WebsiteRegistry,
+    c?: EsbuildConfig,
+): BuildOptions {
+    const p = workersPlugin(r.buildRegistry())
+    return {
+        absWorkingDir: b.dirs.projectRootAbs,
+        assetNames: 'assets/[name]-[hash]',
+        bundle: true,
+        format: 'esm',
+        loader: c?.loaders || defaultLoaders(),
+        metafile: true,
+        minify: b.minify,
+        platform: 'browser',
+        plugins: c?.plugins?.length ? [p, ...c.plugins] : [p],
+        splitting: true,
+        treeShaking: true,
+        write: true,
+    }
+}
+
+function defaultLoaders(): BuildOptions['loader'] {
+    return {
+        '.woff': 'file',
+        '.woff2': 'file',
+    }
 }
 
 // esbuild will append the .js or .css to output filenames
 // keeping extension on entryPoints data for consistency
-// and removing and mapping entryPoints to pass to esbuild
-function removeEntryPointOutExt(
-    entryPoints: Array<{ in: string; out: string }>,
-) {
+// and only trimming when creating esbuild opts
+function mapEntryPointPaths(entryPoints: Array<EntryPoint>) {
     return entryPoints.map(entryPoint => {
         return {
             in: entryPoint.in,
@@ -75,23 +119,158 @@ function removeEntryPointOutExt(
     })
 }
 
-function esbuildResultChecks(buildResult: BuildResult) {
-    if (buildResult.errors.length) {
-        buildResult.errors.forEach(msg => esbuildPrintMessage(msg, 'warning'))
-        process.exit(1)
+const WORKER_CTOR_REGEX =
+    /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 {
+    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')
+                let offset = 0
+                let errors: Array<PartialMessage> | undefined = undefined
+                for (const workerCtorMatch of contents.matchAll(
+                    WORKER_CTOR_REGEX,
+                )) {
+                    if (!WORKER_URL_REGEX.test(workerCtorMatch.groups!.url)) {
+                        if (!errors) errors = []
+                        errors.push(
+                            invalidWorkerUrlCtorArg(
+                                locationFromMatch(
+                                    args,
+                                    contents,
+                                    workerCtorMatch,
+                                ),
+                                workerCtorMatch,
+                            ),
+                        )
+                        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,
+                            ),
+                        )
+                        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 }
+            })
+
+            build.onEnd((result: BuildResult<{ metafile: true }>) => {
+                if (result.metafile) {
+                    r.completeBuild(result)
+                }
+            })
+        },
+    }
+}
+
+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
     }
-    if (buildResult.warnings.length) {
-        buildResult.warnings.forEach(msg => esbuildPrintMessage(msg, 'warning'))
+    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 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)
-    })
+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

@@ -1,22 +1,166 @@
-// `dank serve` will print http access logs to console
-export const isLogHttp = () =>
-    process.env.LOG_HTTP === 'true' || process.argv.includes('--log-http')
+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
+    logHttp: boolean
+    preview: boolean
+}
+
+export function resolveServeFlags(c: DankConfig): DankServe {
+    const preview = isPreviewBuild()
+    const flags: DankServe = {
+        dirs: defaultProjectDirs(cwd()),
+        dankPort: dankPort(c, preview),
+        esbuildPort: esbuildPort(c),
+        logHttp: willLogHttp(),
+        minify: willMinify(),
+        preview,
+        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
-export const isPreviewBuild = () =>
+const isPreviewBuild = () =>
     process.env.PREVIEW === 'true' || process.argv.includes('--preview')
 
 // `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')
 
-export const willMinify = () =>
+// `dank serve` dank port for frontend webserver
+// alternate --preview port for service worker builds
+function dankPort(c: DankConfig, preview: boolean): number {
+    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 {
+    if (process.env.ESBUILD_PORT?.length) {
+        return parsePortEnvVar('ESBUILD_PORT')
+    }
+    return c.esbuild?.port || 3995
+}
+
+function parsePortEnvVar(name: string): number {
+    const port = parseInt(process.env[name]!, 10)
+    if (isNaN(port)) {
+        throw Error(`env var ${name}=${port} must be a valid port number`)
+    } else {
+        return port
+    }
+}
+
+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' ||
     process.argv.includes('--minify')
 
-export const willTsc = () =>
-    isProductionBuild() ||
-    process.env.TSC === 'true' ||
-    process.argv.includes('--tsc')
+// `dank serve` will print http access logs to console
+const willLogHttp = () =>
+    process.env.LOG_HTTP === 'true' || process.argv.includes('--log-http')