@eighty4/dank 0.0.4-1 → 0.0.4-3

package/lib/dank.ts

@@ -13,6 +13,8 @@ export type DankConfig = {
     // cdn url rewriting can be simulated with PageMapping
     pages: Record<`/${string}`, `${string}.html` | PageMapping>
 
+    devPages?: Record<`/__${string}`, `${string}.html` | DevPageMapping>
+
     // port of `dank serve` frontend dev server
     // used for `dan serve --preview` if previewPort not specified
     port?: number
@@ -32,6 +34,11 @@ export type PageMapping = {
     webpage: `${string}.html`
 }
 
+export type DevPageMapping = {
+    label: string
+    webpage: `${string}.html`
+}
+
 export type DevService = {
     command: string
     cwd?: string
@@ -66,157 +73,21 @@ export type EsbuildLoader =
     | 'json'
     | 'text'
 
-export async function defineConfig(
-    c: Partial<DankConfig>,
-): Promise<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')
-        }
-    }
-    validatePages(c.pages)
-    validateDevServices(c.services)
-    validateEsbuildConfig(c.esbuild)
-    normalizePagePaths(c.pages!)
-    return c as DankConfig
-}
-
-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')
-        }
-    }
+// DankConfigFunction arg details about a dank process used when building DankConfig
+export type DankDetails = {
+    dev: boolean
+    production: boolean
+    mode: 'build' | 'serve'
 }
 
-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 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`,
-                )
-            }
-        }
-    }
-}
-
-function normalizePagePaths(pages: DankConfig['pages']) {
-    for (const [pageUrl, mapping] of Object.entries(pages)) {
-        if (typeof mapping === 'string') {
-            pages[pageUrl as `/${string}`] = normalizePagePath(mapping)
-        } else {
-            mapping.webpage = normalizePagePath(mapping.webpage)
-        }
-    }
-}
+export type DankConfigFunction = (
+    dank: DankDetails,
+) => Partial<DankConfig> | Promise<Partial<DankConfig>>
 
-function normalizePagePath(p: `${string}.html`): `${string}.html` {
-    return p.replace(/^\.\//, '') as `${string}.html`
+export function defineConfig(config: Partial<DankConfig>): Partial<DankConfig>
+export function defineConfig(config: DankConfigFunction): DankConfigFunction
+export function defineConfig(
+    config: Partial<DankConfig> | DankConfigFunction,
+): Partial<DankConfig> | DankConfigFunction {
+    return config
 }

package/lib/define.ts

@@ -1,4 +1,4 @@
-import type { DankBuild } from './flags.ts'
+import type { ResolvedDankConfig } from './config.ts'
 
 export type DankGlobal = {
     IS_DEV: boolean
@@ -9,9 +9,11 @@ type DefineDankGlobalKey = 'dank.IS_DEV' | 'dank.IS_PROD'
 
 export type DefineDankGlobal = Record<DefineDankGlobalKey, string>
 
-export function createGlobalDefinitions(build: DankBuild): DefineDankGlobal {
+export function createGlobalDefinitions(
+    c: ResolvedDankConfig,
+): DefineDankGlobal {
     return {
-        'dank.IS_DEV': JSON.stringify(!build.production),
-        'dank.IS_PROD': JSON.stringify(build.production),
+        'dank.IS_DEV': JSON.stringify(!c.flags.production),
+        'dank.IS_PROD': JSON.stringify(c.flags.production),
     }
 }

package/lib/developer.ts

@@ -0,0 +1,146 @@
+import { createWriteStream, type WriteStream } from 'node:fs'
+import { mkdir, rm } from 'node:fs/promises'
+import os from 'node:os'
+import { dirname, resolve } from 'node:path'
+import packageJson from '../package.json' with { type: 'json' }
+
+const CONSOLE =
+    process.env.DANK_LOG_CONSOLE === '1' ||
+    process.env.DANK_LOG_CONSOLE === 'true'
+const FILE = process.env.DANK_LOG_FILE
+const ROLLING =
+    process.env.DANK_LOG_ROLLING === '1' ||
+    process.env.DANK_LOG_ROLLING === 'true'
+
+const logs: Array<string> = []
+let initialized = false
+let preparing: Promise<void>
+let stream: WriteStream
+
+export type LogEvent = {
+    realm:
+        | 'build'
+        | 'serve'
+        | 'assets'
+        | 'config'
+        | 'html'
+        | 'registry'
+        | 'services'
+    message: string
+    data?: Record<string, LogEventData>
+}
+
+type LogEventData =
+    | LogEventDatum
+    | Array<LogEventDatum>
+    | Set<LogEventDatum>
+    | Record<string, LogEventDatum>
+
+type LogEventDatum = boolean | number | string | null | undefined
+
+function toStringLogEvent(logEvent: LogEvent): string {
+    const when = new Date().toISOString()
+    const message = `[${logEvent.realm}] ${logEvent.message}\n${when}\n`
+    if (!logEvent.data) {
+        return message
+    }
+    let data = ''
+    for (const k of Object.keys(logEvent.data).sort()) {
+        data += `\n    ${k} = ${toStringData(logEvent.data[k])}`
+    }
+    return `${message}${data}\n`
+}
+
+function toStringData(datum: LogEventData): string {
+    if (datum instanceof Set) {
+        datum = Array.from(datum)
+    }
+    if (
+        datum !== null &&
+        typeof datum === 'object' &&
+        datum.constructor.name === 'Object'
+    ) {
+        datum = Object.entries(datum).map(([k, v]) => `${k} = ${v}`)
+    }
+    if (Array.isArray(datum)) {
+        if (datum.length === 0) {
+            return '[]'
+        } else {
+            return `[\n        ${datum.join('\n        ')}\n    ]`
+        }
+    } else {
+        return `${datum}`
+    }
+}
+
+function logToConsoleAndFile(out: string) {
+    logToConsole(out)
+    logToFile(out)
+}
+
+function logToConsole(out: string) {
+    console.log('\n' + out)
+}
+
+function logToFile(out: string) {
+    logs.push(out)
+    if (!initialized) {
+        initialized = true
+        preparing = prepareLogFile().catch(onPrepareLogFileError)
+    }
+    preparing.then(syncLogs)
+}
+
+async function prepareLogFile() {
+    const path = resolve(FILE!)
+    if (!ROLLING) {
+        await rm(path, { force: true })
+    }
+    await mkdir(dirname(path), { recursive: true })
+    stream = createWriteStream(path, { flags: 'a' })
+    console.log('debug logging to', FILE)
+    logSystemDetails()
+}
+
+function logSystemDetails() {
+    stream.write(`\
+---
+os: ${os.type()}
+build: ${os.version()}
+cpu: ${os.arch()}
+cores: ${os.availableParallelism()}
+${process.versions.bun ? `bun ${process.versions.bun}` : `node ${process.version}`}
+dank: ${packageJson.version}
+\n`)
+}
+
+function syncLogs() {
+    if (!logs.length) return
+    const content = logs.join('\n') + '\n'
+    logs.length = 0
+    stream.write(content)
+}
+
+function onPrepareLogFileError(e: any) {
+    console.error(`init log file \`${FILE}\` error: ${e.message}`)
+    process.exit(1)
+}
+
+function makeLogger(
+    logDelegate: (out: string) => void,
+): (logEvent: LogEvent) => void {
+    return logEvent => logDelegate(toStringLogEvent(logEvent))
+}
+
+export const LOG = (function resolveLogFn() {
+    if (CONSOLE && FILE?.length) {
+        return makeLogger(logToConsoleAndFile)
+    }
+    if (CONSOLE) {
+        return makeLogger(logToConsole)
+    }
+    if (FILE?.length) {
+        return makeLogger(logToFile)
+    }
+    return () => {}
+})()

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,
                     })