@eighty4/dank 0.0.2 → 0.0.4-0

package/lib/esbuild.ts

@@ -1,72 +1,109 @@
+import { readFile } from 'node:fs/promises'
 import esbuild, {
     type BuildContext,
     type BuildOptions,
     type BuildResult,
     type Message,
-    type Metafile,
+    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({
+    entryPoints: Array<EntryPoint>,
+    c?: EsbuildConfig,
+): Promise<void> {
+    const result = await esbuild.build({
         define,
         entryNames: '[dir]/[name]-[hash]',
-        entryPoints: removeEntryPointOutExt(entryPoints),
-        outdir,
-        ...webpageBuildOptions,
+        entryPoints: mapEntryPointPaths(entryPoints),
+        outdir: b.dirs.buildDist,
+        ...commonBuildOptions(b, r, c),
     })
-    esbuildResultChecks(buildResult)
-    return buildResult.metafile
+    esbuildResultChecks(result)
+}
+
+export async function esbuildWorkers(
+    b: DankBuild,
+    r: WebsiteRegistry,
+    define: DefineDankGlobal,
+    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)
+}
+
+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,
@@ -95,3 +132,117 @@ function esbuildPrintMessage(msg: Message, category: 'error' | 'warning') {
         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
+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,
+                )) {
+                    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 (!errors) errors = []
+                        const preamble = contents.substring(
+                            0,
+                            workerCtorMatch.index,
+                        )
+                        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,
+                        )
+                        errors.push({
+                            id: 'worker-url-unresolvable',
+                            location: {
+                                lineText,
+                                line,
+                                column,
+                                file: args.path,
+                                length: workerCtorMatch[0].length,
+                            },
+                        })
+                    }
+                }
+                const loader = args.path.endsWith('ts') ? 'ts' : 'js'
+                return { contents, errors, loader }
+            })
+
+            build.onEnd((result: BuildResult<{ metafile: true }>) => {
+                if (result.metafile) {
+                    r.completeBuild(result)
+                }
+            })
+        },
+    }
+}

package/lib/flags.ts

@@ -1,18 +1,160 @@
+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
+}
+
+type ProjectDirs = {
+    buildRoot: string
+    buildWatch: string
+    buildDist: string
+    pages: string
+    pagesResolved: 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 dirs: ProjectDirs = {
+        buildRoot: 'build',
+        buildDist: join('build', 'dist'),
+        buildWatch: join('build', 'watch'),
+        pages: 'pages',
+        pagesResolved: resolve(join(projectRootAbs, 'pages')),
+        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 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')