@eighty4/dank 0.0.4-2 → 0.0.4

package/client/client.js

@@ -0,0 +1 @@
+new EventSource("http://127.0.0.1:3995/esbuild").addEventListener("change",o=>{let{updated:a}=JSON.parse(o.data),e=new Set;for(let s of a)e.add(s);let d=Array.from(e).filter(s=>s.endsWith(".css"));if(d.length){console.log("esbuild css updates",d);let s={};for(let t of document.getElementsByTagName("link"))if(t.getAttribute("rel")==="stylesheet"){let n=new URL(t.href);(n.host=location.host)&&(s[n.pathname]=t)}let r=!1;for(let t of d){let n=s[t];if(n){let c=n.cloneNode();c.href=`${t}?${Math.random().toString(36).slice(2)}`,c.onload=()=>n.remove(),n.parentNode.insertBefore(c,n.nextSibling),r=!0}}r&&p()}if(d.length<e.size){let s=Array.from(e).filter(t=>!t.endsWith(".css")),r=new Set;for(let t of document.getElementsByTagName("script"))if(t.src.length){let n=new URL(t.src);(n.host=location.host)&&r.add(n.pathname)}s.some(t=>r.has(t))&&(console.log("esbuild js updates require reload"),y())}});function p(){let o=l("green","23995");o.style.opacity="0",o.animate([{opacity:0},{opacity:1},{opacity:1},{opacity:1},{opacity:.75},{opacity:.5},{opacity:.25},{opacity:0}],{duration:400,iterations:1,direction:"normal",easing:"linear"}),document.body.appendChild(o),Promise.all(o.getAnimations().map(a=>a.finished)).then(()=>o.remove())}var i=null;function y(){i||(i=l("orange","33995"),i.style.opacity="0",i.style.pointerEvents="none",i.animate([{opacity:0},{opacity:1}],{duration:400,iterations:1,direction:"normal",easing:"ease-in",fill:"forwards"}),document.body.appendChild(i))}function l(o,a){let e=document.createElement("div");return e.style.border="6px dashed "+o,e.style.zIndex=a,e.style.position="fixed",e.style.top=e.style.left="1px",e.style.height=e.style.width="calc(100% - 2px)",e.style.boxSizing="border-box",e}

package/lib/bin.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { buildWebsite } from './build.ts'
-import { loadConfig } from './config.ts'
+import { DankError } from './errors.ts'
 import { serveWebsite } from './serve.ts'
 
 function printHelp(task?: 'build' | 'serve'): never {
@@ -71,16 +71,14 @@ const task: 'build' | 'serve' = (function resolveTask() {
     return task
 })()
 
-const c = await loadConfig(task)
-
 try {
     switch (task) {
         case 'build':
-            await buildWebsite(c)
+            await buildWebsite()
             console.log(green('done'))
             process.exit(0)
         case 'serve':
-            await serveWebsite(c)
+            await serveWebsite()
     }
 } catch (e: unknown) {
     errorExit(e)
@@ -88,13 +86,12 @@ try {
 
 function printError(e: unknown) {
     if (e !== null) {
-        if (typeof e === 'string') {
-            console.error(red('error:'), e)
-        } else if (e instanceof Error) {
+        if (e instanceof DankError) {
             console.error(red('error:'), e.message)
-            if (e.stack) {
-                console.error(e.stack)
-            }
+        } else if (e instanceof Error) {
+            console.error(red('error:'), e.stack ?? e.message)
+        } else {
+            console.error(red('error:'), e)
         }
     }
 }

package/lib/build.ts

@@ -1,20 +1,23 @@
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { createBuildTag } from './build_tag.ts'
-import type { DankConfig } from './dank.ts'
+import { loadConfig, type ResolvedDankConfig } from './config.ts'
 import { type DefineDankGlobal, createGlobalDefinitions } from './define.ts'
-import { esbuildWebpages, esbuildWorkers, type EntryPoint } from './esbuild.ts'
-import { resolveBuildFlags, type DankBuild } from './flags.ts'
-import { HtmlEntrypoint } from './html.ts'
-import { type WebsiteManifest, WebsiteRegistry } from './metadata.ts'
+import type { DankDirectories } from './dirs.ts'
+import { esbuildWebpages, esbuildWorkers } from './esbuild.ts'
 import { copyAssets } from './public.ts'
+import { type WebsiteManifest, WebsiteRegistry } from './registry.ts'
 
-export async function buildWebsite(c: DankConfig): Promise<WebsiteManifest> {
-    const build: DankBuild = resolveBuildFlags()
-    const buildTag = await createBuildTag(build)
+export async function buildWebsite(
+    c?: ResolvedDankConfig,
+): Promise<WebsiteManifest> {
+    if (!c) {
+        c = await loadConfig('build', process.cwd())
+    }
+    const buildTag = await createBuildTag(c.flags)
     console.log(
-        build.minify
-            ? build.production
+        c.flags.minify
+            ? c.flags.production
                 ? 'minified production'
                 : 'minified'
             : 'unminified',
@@ -22,85 +25,52 @@ export async function buildWebsite(c: DankConfig): Promise<WebsiteManifest> {
         buildTag,
         'building in ./build/dist',
     )
-    await rm(build.dirs.buildRoot, { recursive: true, force: true })
-    await mkdir(build.dirs.buildDist, { recursive: true })
+    await rm(c.dirs.buildRoot, { recursive: true, force: true })
+    await mkdir(c.dirs.buildDist, { recursive: true })
     for (const subdir of Object.keys(c.pages).filter(url => url !== '/')) {
-        await mkdir(join(build.dirs.buildDist, subdir), { recursive: true })
+        await mkdir(join(c.dirs.buildDist, subdir), { recursive: true })
     }
-    await mkdir(join(build.dirs.buildRoot, 'metafiles'), { recursive: true })
-    const registry = new WebsiteRegistry(build)
-    registry.pageUrls = Object.keys(c.pages)
-    registry.copiedAssets = await copyAssets(build)
-    await buildWebpages(c, registry, build, createGlobalDefinitions(build))
+    await mkdir(join(c.dirs.buildRoot, 'metafiles'), { recursive: true })
+    const registry = await buildWebpages(c, createGlobalDefinitions(c))
     return await registry.writeManifest(buildTag)
 }
 
-// builds all webpage entrypoints in one esbuild.build context
-// to support code splitting
+// builds all webpage entrypoints in one esbuild.build context to support code splitting
 // returns all built assets URLs and webpage URLs from DankConfig.pages
 async function buildWebpages(
-    c: DankConfig,
-    registry: WebsiteRegistry,
-    build: DankBuild,
+    c: ResolvedDankConfig,
     define: DefineDankGlobal,
-) {
-    // create HtmlEntrypoint for each webpage and collect awaitable esbuild entrypoints
-    const loadingEntryPoints: Array<Promise<Array<EntryPoint>>> = []
-    const htmlEntrypoints: Array<HtmlEntrypoint> = []
-    for (const [urlPath, mapping] of Object.entries(c.pages)) {
-        const fsPath = typeof mapping === 'string' ? mapping : mapping.webpage
-        const html = new HtmlEntrypoint(
-            build,
-            registry.resolver,
-            urlPath,
-            fsPath,
-        )
-        loadingEntryPoints.push(new Promise(res => html.on('entrypoints', res)))
-        htmlEntrypoints.push(html)
-    }
-
-    // collect esbuild entrypoints from every HtmlEntrypoint
-    const uniqueEntryPoints: Set<string> = new Set()
-    const buildEntryPoints: Array<EntryPoint> = []
-    for (const pageEntryPoints of await Promise.all(loadingEntryPoints)) {
-        for (const entryPoint of pageEntryPoints) {
-            if (!uniqueEntryPoints.has(entryPoint.in)) {
-                buildEntryPoints.push(entryPoint)
-            }
-        }
-    }
-
-    await esbuildWebpages(build, registry, define, buildEntryPoints, c.esbuild)
+): Promise<WebsiteRegistry> {
+    const registry = new WebsiteRegistry(c)
+    registry.configSync()
+    registry.copiedAssets = await copyAssets(c.dirs)
+    await Promise.all(registry.htmlEntrypoints.map(html => html.process()))
+    await esbuildWebpages(registry, define, registry.webpageEntryPoints)
 
     // todo recursively build workers on building workers that create workers
-    const workerEntryPoints = registry.workerEntryPoints()
+    const workerEntryPoints = registry.workerEntryPoints
     if (workerEntryPoints?.length) {
-        await esbuildWorkers(
-            build,
-            registry,
-            define,
-            workerEntryPoints,
-            c.esbuild,
-        )
+        await esbuildWorkers(registry, define, workerEntryPoints)
     }
-    await rewriteWorkerUrls(build, registry)
+    await rewriteWorkerUrls(c.dirs, registry)
 
     // write out html output with rewritten hrefs
     await Promise.all(
-        htmlEntrypoints.map(async html => {
+        registry.htmlEntrypoints.map(async html => {
             await writeFile(
-                join(build.dirs.buildDist, html.url, 'index.html'),
+                join(c.dirs.buildDist, html.url, 'index.html'),
                 html.output(registry),
             )
         }),
     )
+    return registry
 }
 
 export async function rewriteWorkerUrls(
-    build: DankBuild,
+    dirs: DankDirectories,
     registry: WebsiteRegistry,
 ) {
-    const workers = registry.workers()
+    const workers = registry.workers
     if (!workers) {
         return
     }
@@ -113,7 +83,7 @@ export async function rewriteWorkerUrls(
     const readingFiles = Promise.all(
         dependentBundlePaths.map(async p => {
             bundleOutputs[p] = await readFile(
-                join(build.dirs.projectRootAbs, build.dirs.buildDist, p),
+                join(dirs.projectRootAbs, dirs.buildDist, p),
                 'utf8',
             )
         }),
@@ -125,8 +95,8 @@ export async function rewriteWorkerUrls(
     for (const w of workers) {
         rewriteChains[registry.mappedHref(w.dependentEntryPoint)].push(s =>
             s.replace(
-                createWorkerRegex(w.workerUrlPlaceholder),
-                `new Worker('${registry.mappedHref(w.workerEntryPoint)}')`,
+                createWorkerRegex(w.workerCtor, w.workerUrlPlaceholder),
+                `new ${w.workerCtor}('${registry.mappedHref(w.workerEntryPoint)}')`,
             ),
         )
     }
@@ -142,16 +112,19 @@ export async function rewriteWorkerUrls(
                 result = rewriteFn(result)
             }
             await writeFile(
-                join(build.dirs.projectRootAbs, build.dirs.buildDist, p),
+                join(dirs.projectRootAbs, dirs.buildDist, p),
                 result,
             )
         }),
     )
 }
 
-export function createWorkerRegex(workerUrl: string): RegExp {
+export function createWorkerRegex(
+    workerCtor: 'Worker' | 'SharedWorker',
+    workerUrl: string,
+): RegExp {
     return new RegExp(
-        `new(?:\\s|\\r?\\n)+Worker(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`,
+        `new(?:\\s|\\r?\\n)+${workerCtor}(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`,
         'g',
     )
 }

package/lib/build_tag.ts

@@ -1,7 +1,7 @@
 import { exec } from 'node:child_process'
-import type { DankBuild } from './flags.ts'
+import type { DankFlags } from './flags.ts'
 
-export async function createBuildTag(build: DankBuild): Promise<string> {
+export async function createBuildTag(flags: DankFlags): Promise<string> {
     const now = new Date()
     const ms =
         now.getUTCMilliseconds() +
@@ -11,7 +11,7 @@ export async function createBuildTag(build: DankBuild): Promise<string> {
     const date = now.toISOString().substring(0, 10)
     const time = String(ms).padStart(8, '0')
     const when = `${date}-${time}`
-    if (build.production) {
+    if (flags.production) {
         const gitHash = await new Promise((res, rej) =>
             exec('git rev-parse --short HEAD', (err, stdout) => {
                 if (err) rej(err)

package/lib/config.ts

@@ -6,15 +6,45 @@ import type {
     PageMapping,
 } from './dank.ts'
 import { LOG } from './developer.ts'
-import { isProductionBuild } from './flags.ts'
+import { defaultProjectDirs, type DankDirectories } from './dirs.ts'
+import {
+    resolveFlags as lookupDankFlags,
+    type DankFlags as DankFlags,
+} from './flags.ts'
 
-const CFG_P = './dank.config.ts'
+const DEFAULT_DEV_PORT = 3000
+const DEFAULT_PREVIEW_PORT = 4000
+const DEFAULT_ESBUILD_PORT = 3995
+
+const DEFAULT_CONFIG_PATH = './dank.config.ts'
+
+export type { DevService } from './dank.ts'
+
+export type ResolvedDankConfig = {
+    // static from process boot
+    get dirs(): Readonly<DankDirectories>
+    get flags(): Readonly<Omit<DankFlags, 'dankPort' | 'esbuildPort'>>
+    get mode(): 'build' | 'serve'
+
+    // reloadable from `dank.config.ts` with `reload()`
+    get dankPort(): number
+    get esbuildPort(): number
+    get esbuild(): Readonly<Omit<EsbuildConfig, 'port'>> | undefined
+    get pages(): Readonly<Record<`/${string}`, PageMapping>>
+    get devPages(): Readonly<DankConfig['devPages']>
+    get services(): Readonly<DankConfig['services']>
+
+    reload(): Promise<void>
+}
 
 export async function loadConfig(
     mode: 'build' | 'serve',
-    path: string = CFG_P,
-): Promise<DankConfig> {
-    const modulePath = resolveConfigPath(path)
+    projectRootAbs: string,
+): Promise<ResolvedDankConfig> {
+    if (!isAbsolute(projectRootAbs)) {
+        throw Error()
+    }
+    const modulePath = resolve(projectRootAbs, DEFAULT_CONFIG_PATH)
     LOG({
         realm: 'config',
         message: 'loading config module',
@@ -22,37 +52,119 @@ export async function loadConfig(
             modulePath,
         },
     })
-    const c = await resolveConfig(mode, modulePath)
-    normalizePagePaths(c.pages)
+    const dirs = await defaultProjectDirs(projectRootAbs)
+    const c = new DankConfigInternal(mode, modulePath, dirs)
+    await c.reload()
     return c
 }
 
-export function resolveConfigPath(path: string): string {
-    if (isAbsolute(path)) {
-        return path
-    } else {
-        return resolve(process.cwd(), path)
+class DankConfigInternal implements ResolvedDankConfig {
+    #dirs: Readonly<DankDirectories>
+    #flags: Readonly<DankFlags>
+    #mode: 'build' | 'serve'
+    #modulePath: string
+
+    #dankPort: number = DEFAULT_DEV_PORT
+    #esbuildPort: number = DEFAULT_ESBUILD_PORT
+    #esbuild: Readonly<Omit<EsbuildConfig, 'port'>> | undefined
+    #pages: Readonly<Record<`/${string}`, PageMapping>> = {}
+    #devPages: Readonly<DankConfig['devPages']>
+    #services: Readonly<DankConfig['services']>
+
+    constructor(
+        mode: 'build' | 'serve',
+        modulePath: string,
+        dirs: DankDirectories,
+    ) {
+        this.#dirs = dirs
+        this.#flags = lookupDankFlags()
+        this.#mode = mode
+        this.#modulePath = modulePath
+    }
+
+    get dankPort(): number {
+        return this.#dankPort
+    }
+
+    get esbuildPort(): number {
+        return this.#esbuildPort
+    }
+
+    get esbuild(): Omit<EsbuildConfig, 'port'> | undefined {
+        return this.#esbuild
+    }
+
+    get dirs(): Readonly<DankDirectories> {
+        return this.#dirs
+    }
+
+    get flags(): Readonly<Omit<DankFlags, 'dankPort' | 'esbuildPort'>> {
+        return this.#flags
+    }
+
+    get mode(): 'build' | 'serve' {
+        return this.#mode
+    }
+
+    get pages(): Readonly<Record<`/${string}`, PageMapping>> {
+        return this.#pages
+    }
+
+    get devPages(): Readonly<DankConfig['devPages']> {
+        return this.#devPages
+    }
+
+    get services(): Readonly<DankConfig['services']> {
+        return this.#services
+    }
+
+    async reload() {
+        const userConfig = await resolveConfig(
+            this.#modulePath,
+            resolveDankDetails(this.#mode, this.#flags),
+        )
+        this.#dankPort = resolveDankPort(this.#flags, userConfig)
+        this.#esbuildPort = resolveEsbuildPort(this.#flags, userConfig)
+        this.#esbuild = Object.freeze(userConfig.esbuild)
+        this.#pages = Object.freeze(normalizePages(userConfig.pages))
+        this.#devPages = Object.freeze(userConfig.devPages)
+        this.#services = Object.freeze(userConfig.services)
     }
 }
 
-export async function resolveConfig(
-    mode: 'build' | 'serve',
+function resolveDankPort(flags: DankFlags, userConfig: DankConfig): number {
+    return (
+        flags.dankPort ||
+        (flags.preview
+            ? userConfig.previewPort || userConfig.port || DEFAULT_PREVIEW_PORT
+            : userConfig.port || DEFAULT_DEV_PORT)
+    )
+}
+
+function resolveEsbuildPort(flags: DankFlags, userConfig: DankConfig): number {
+    return flags.esbuildPort || userConfig.esbuild?.port || DEFAULT_ESBUILD_PORT
+}
+
+async function resolveConfig(
     modulePath: string,
+    details: DankDetails,
 ): Promise<DankConfig> {
     const module = await import(`${modulePath}?${Date.now()}`)
     const c: Partial<DankConfig> =
         typeof module.default === 'function'
-            ? await module.default(resolveDankDetails(mode))
+            ? await module.default(details)
             : module.default
     validateDankConfig(c)
     return c as DankConfig
 }
 
-function resolveDankDetails(mode: 'build' | 'serve'): DankDetails {
-    const production = isProductionBuild()
+function resolveDankDetails(
+    mode: 'build' | 'serve',
+    flags: DankFlags,
+): DankDetails {
     return {
-        dev: !production,
-        production,
+        dev: !flags.production,
+        production: flags.production,
         mode,
     }
 }
@@ -61,6 +173,7 @@ function validateDankConfig(c: Partial<DankConfig>) {
     try {
         validatePorts(c)
         validatePages(c.pages)
+        validateDevPages(c.devPages)
         validateDevServices(c.services)
         validateEsbuildConfig(c.esbuild)
     } catch (e: any) {
@@ -140,6 +253,46 @@ function validatePages(pages?: DankConfig['pages']) {
     }
 }
 
+function validateDevPages(devPages?: DankConfig['devPages']) {
+    if (devPages) {
+        for (const [urlPath, mapping] of Object.entries(devPages)) {
+            if (!urlPath.startsWith('/__')) {
+                throw Error(
+                    `DankConfig.devPages['${urlPath}'] must start \`${urlPath}\` with a \`/__\` path prefix`,
+                )
+            }
+            if (typeof mapping === 'string') {
+                if (!mapping.endsWith('.html')) {
+                    throw Error(
+                        `DankConfig.devPages['${urlPath}'] must configure an html file or DevPageMapping config`,
+                    )
+                }
+            } else if (typeof mapping === 'object') {
+                if (
+                    typeof mapping.label !== 'string' ||
+                    !mapping.label.length
+                ) {
+                    throw Error(
+                        `DankConfig.devPages['${urlPath}'].label must declare a label`,
+                    )
+                }
+                if (
+                    typeof mapping.webpage !== 'string' ||
+                    !mapping.webpage.endsWith('.html')
+                ) {
+                    throw Error(
+                        `DankConfig.devPages['${urlPath}'].webpage must configure an html file`,
+                    )
+                }
+            } else {
+                throw Error(
+                    `DankConfig.devPages['${urlPath}'] must be a DevPageMapping config with \`label\` and \`webpage\` values`,
+                )
+            }
+        }
+    }
+}
+
 function validatePageMapping(urlPath: string, mapping: PageMapping) {
     if (
         mapping.webpage === null ||
@@ -209,16 +362,18 @@ function validateDevServices(services: DankConfig['services']) {
     }
 }
 
-function normalizePagePaths(pages: DankConfig['pages']) {
+function normalizePages(
+    pages: DankConfig['pages'],
+): Record<`/${string}`, PageMapping> {
+    const result: Record<`/${string}`, PageMapping> = {}
     for (const [pageUrl, mapping] of Object.entries(pages)) {
-        if (typeof mapping === 'string') {
-            pages[pageUrl as `/${string}`] = normalizePagePath(mapping)
-        } else {
-            mapping.webpage = normalizePagePath(mapping.webpage)
-        }
+        const mappedMapping =
+            typeof mapping === 'string' ? { webpage: mapping } : mapping
+        mappedMapping.webpage = mappedMapping.webpage.replace(
+            /^\.\//,
+            '',
+        ) as `${string}.html`
+        result[pageUrl as `/${string}`] = mappedMapping
     }
-}
-
-function normalizePagePath(p: `${string}.html`): `${string}.html` {
-    return p.replace(/^\.\//, '') as `${string}.html`
+    return result
 }

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

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

@@ -4,6 +4,9 @@ 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' ||
@@ -33,7 +36,7 @@ type LogEventData =
     | Set<LogEventDatum>
     | Record<string, LogEventDatum>
 
-type LogEventDatum = boolean | number | string | null
+type LogEventDatum = boolean | number | string | null | undefined
 
 function toStringLogEvent(logEvent: LogEvent): string {
     const when = new Date().toISOString()
@@ -70,8 +73,17 @@ function toStringData(datum: LogEventData): string {
     }
 }
 
-function logToFile(logEvent: LogEvent) {
-    logs.push(toStringLogEvent(logEvent))
+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)
@@ -114,4 +126,21 @@ function onPrepareLogFileError(e: any) {
     process.exit(1)
 }
 
-export const LOG = FILE?.length ? logToFile : () => {}
+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 () => {}
+})()