@eighty4/dank 0.0.5-1 → 0.0.5-3

package/lib/services.ts

@@ -4,128 +4,225 @@ import {
     execSync,
     spawn,
 } from 'node:child_process'
+import EventEmitter from 'node:events'
 import { basename, isAbsolute, resolve } from 'node:path'
 import type { DevService, ResolvedDankConfig } from './config.ts'
 
-export type DevServices = {
-    http: HttpServices
-}
+export class ManagedServiceLabel {
+    #command: string
+    #cwd: string
+
+    constructor(spec: DevService) {
+        this.#command = spec.command
+        this.#cwd = !spec.cwd
+            ? './'
+            : spec.cwd.startsWith('/')
+              ? `/.../${basename(spec.cwd)}`
+              : spec.cwd.startsWith('.')
+                ? spec.cwd
+                : `./${spec.cwd}`
+    }
 
-export type HttpServices = {
-    running: Array<HttpService>
+    get command(): string {
+        return this.#command
+    }
+
+    get cwd(): string {
+        return this.#cwd
+    }
 }
 
 export type HttpService = NonNullable<DevService['http']>
 
-// up to date representation of dank.config.ts services
-const running: Array<{ s: DevService; process: ChildProcess | null }> = []
+export type DevServiceEvents = {
+    error: [label: ManagedServiceLabel, cause: string]
+    exit: [label: ManagedServiceLabel, code: number | string]
+    launch: [label: ManagedServiceLabel]
+    stdout: [label: ManagedServiceLabel, output: Array<string>]
+    stderr: [label: ManagedServiceLabel, output: Array<string>]
+}
+
+class ManagedService extends EventEmitter<DevServiceEvents> {
+    #label: ManagedServiceLabel
+    #process: ChildProcess | null
+    #spec: DevService
+    // #status: ManagedServiceStatus = 'starting'
+
+    constructor(spec: DevService) {
+        super()
+        this.#label = new ManagedServiceLabel(spec)
+        this.#spec = spec
+        this.#process = this.#start()
+    }
+
+    get spec(): DevService {
+        return this.#spec
+    }
 
-// on Windows process.kill() and AbortSignal will not kill the process spawned with cmd.exe
-if (process.platform === 'win32') {
-    process.once('SIGINT', () => process.exit())
-    process.once('exit', () => {
-        for (const { process } of running) {
-            if (process) {
-                execSync(`taskkill /pid ${process.pid} /T /F`)
+    get httpSpec(): HttpService | undefined {
+        return this.#spec.http
+    }
+
+    matches(other: DevService): boolean {
+        return matchingConfig(this.#spec, other)
+    }
+
+    kill() {
+        if (this.#process) killProcess(this.#process)
+    }
+
+    #start(): ChildProcess {
+        const { path, args } = parseCommand(this.#spec.command)
+        const env = this.#spec.env
+            ? { ...process.env, ...this.#spec.env }
+            : undefined
+        const cwd =
+            !this.#spec.cwd || isAbsolute(this.#spec.cwd)
+                ? this.#spec.cwd
+                : resolve(process.cwd(), this.#spec.cwd)
+        const spawned = spawnProcess(path, args, env, cwd)
+        this.emit('launch', this.#label)
+        spawned.stdout.on('data', chunk =>
+            this.emit('stdout', this.#label, parseChunk(chunk)),
+        )
+        spawned.stderr.on('data', chunk =>
+            this.emit('stderr', this.#label, parseChunk(chunk)),
+        )
+        spawned.on('error', e => {
+            if (e.name === 'AbortError') {
+                return
             }
-        }
-    })
+            const cause =
+                'code' in e && e.code === 'ENOENT'
+                    ? 'program not found'
+                    : e.message
+            this.emit('error', this.#label, cause)
+        })
+        spawned.on('exit', (code, signal) =>
+            this.emit('exit', this.#label, code || signal!),
+        )
+        return spawned
+    }
 }
 
-let signal: AbortSignal
+type SpawnProcess = (
+    program: string,
+    args: Array<string>,
+    env: NodeJS.ProcessEnv | undefined,
+    cwd: string | undefined,
+) => ChildProcessWithoutNullStreams
+
+type KillProcess = (p: ChildProcess) => void
+
+const killProcess: KillProcess =
+    process.platform === 'win32'
+        ? p => execSync(`taskkill /pid ${p.pid} /T /F`)
+        : p => p.kill()
 
-// batch of services that must be stopped before starting new services
-let updating: null | {
-    stopping: Array<DevService>
-    starting: Array<DevService>
-} = null
+const spawnProcess: SpawnProcess =
+    process.platform === 'win32'
+        ? (
+              path: string,
+              args: Array<string>,
+              env: NodeJS.ProcessEnv | undefined,
+              cwd: string | undefined,
+          ) =>
+              spawn('cmd', ['/c', path, ...args], {
+                  cwd,
+                  env,
+                  detached: false,
+                  shell: false,
+                  windowsHide: true,
+              })
+        : (
+              path: string,
+              args: Array<string>,
+              env: NodeJS.ProcessEnv | undefined,
+              cwd: string | undefined,
+          ) =>
+              spawn(path, args, {
+                  cwd,
+                  env,
+                  detached: false,
+                  shell: false,
+              })
 
-export function startDevServices(
-    services: ResolvedDankConfig['services'],
-    _signal: AbortSignal,
-): DevServices {
-    signal = _signal
-    if (services?.length) {
-        for (const s of services) {
-            running.push({ s, process: startService(s) })
+export class DevServices extends EventEmitter<DevServiceEvents> {
+    #running: Array<ManagedService>
+
+    constructor(services: ResolvedDankConfig['services']) {
+        super()
+        this.#running = services ? this.#start(services) : []
+        if (process.platform === 'win32') {
+            process.once('SIGINT', () => process.exit())
         }
+        process.once('exit', this.shutdown)
     }
-    return {
-        http: {
-            get running(): Array<HttpService> {
-                return running.map(({ s }) => s.http).filter(http => !!http)
-            },
-        },
+
+    get httpServices(): Array<HttpService> {
+        return this.#running.map(s => s.httpSpec).filter(http => !!http)
     }
-}
 
-export function updateDevServices(services: ResolvedDankConfig['services']) {
-    if (!services?.length) {
-        if (running.length) {
-            if (updating === null) {
-                updating = { stopping: [], starting: [] }
-            }
-            running.forEach(({ s, process }) => {
-                if (process) {
-                    stopService(s, process)
-                } else {
-                    removeFromUpdating(s)
-                }
-            })
-            running.length = 0
-        }
-    } else {
-        if (updating === null) {
-            updating = { stopping: [], starting: [] }
-        }
-        const keep = []
-        const next: Array<DevService> = []
-        for (const s of services) {
-            let found = false
-            for (let i = 0; i < running.length; i++) {
-                const p = running[i].s
-                if (matchingConfig(s, p)) {
-                    found = true
-                    keep.push(i)
-                    break
-                }
-            }
-            if (!found) {
-                next.push(s)
-            }
-        }
-        for (let i = running.length - 1; i >= 0; i--) {
-            if (!keep.includes(i)) {
-                const { s, process } = running[i]
-                if (process) {
-                    stopService(s, process)
-                } else {
-                    removeFromUpdating(s)
-                }
-                running.splice(i, 1)
-            }
-        }
-        if (updating.stopping.length) {
-            for (const s of next) {
-                if (
-                    !updating.starting.find(queued => matchingConfig(queued, s))
-                ) {
-                    updating.starting.push(s)
-                }
-            }
-        } else {
-            updating = null
-            for (const s of next) {
-                running.push({ s, process: startService(s) })
-            }
+    shutdown = () => {
+        this.#running.forEach(s => {
+            s.kill()
+            s.removeAllListeners()
+        })
+        this.#running.length = 0
+    }
+
+    update(services: ResolvedDankConfig['services']) {
+        if (!services?.length) {
+            this.shutdown()
+        } else if (
+            !matchingConfigs(
+                this.#running.map(s => s.spec),
+                services,
+            )
+        ) {
+            this.shutdown()
+            this.#running = this.#start(services)
         }
     }
+
+    #start(
+        services: NonNullable<ResolvedDankConfig['services']>,
+    ): Array<ManagedService> {
+        return services.map(spec => {
+            const service = new ManagedService(spec)
+            service.on('error', (label, cause) =>
+                this.emit('error', label, cause),
+            )
+            service.on('exit', (label, code) => this.emit('exit', label, code))
+            service.on('launch', label => this.emit('launch', label))
+            service.on('stdout', (label, output) =>
+                this.emit('stdout', label, output),
+            )
+            service.on('stderr', (label, output) =>
+                this.emit('stderr', label, output),
+            )
+            return service
+        })
+    }
 }
 
-function stopService(s: DevService, process: ChildProcess) {
-    opPrint(s, 'stopping')
-    updating!.stopping.push(s)
-    process.kill()
+function matchingConfigs(
+    a: Array<DevService>,
+    b: NonNullable<ResolvedDankConfig['services']>,
+): boolean {
+    if (a.length !== b.length) {
+        return false
+    }
+    const crossRef = [...a]
+    for (const toFind of b) {
+        const found = crossRef.findIndex(spec => matchingConfig(spec, toFind))
+        if (found === -1) {
+            return false
+        } else {
+            crossRef.splice(found, 1)
+        }
+    }
+    return true
 }
 
 function matchingConfig(a: DevService, b: DevService): boolean {
@@ -155,86 +252,6 @@ function matchingConfig(a: DevService, b: DevService): boolean {
     return true
 }
 
-function startService(s: DevService): ChildProcess {
-    opPrint(s, 'starting')
-    const spawned = spawnService(s)
-
-    const stdoutLabel = logLabel(s, 32)
-    spawned.stdout.on('data', chunk => printChunk(stdoutLabel, chunk))
-
-    const stderrLabel = logLabel(s, 31)
-    spawned.stderr.on('data', chunk => printChunk(stderrLabel, chunk))
-
-    spawned.on('error', e => {
-        removeFromRunning(s)
-        if (e.name === 'AbortError') {
-            return
-        }
-        const cause =
-            'code' in e && e.code === 'ENOENT' ? 'program not found' : e.message
-        opPrint(s, 'error: ' + cause)
-    })
-    spawned.on('exit', () => {
-        opPrint(s, 'exited')
-        removeFromRunning(s)
-        removeFromUpdating(s)
-    })
-    return spawned
-}
-
-function spawnService(s: DevService): ChildProcessWithoutNullStreams {
-    const splitCmdAndArgs = s.command.split(/\s+/)
-    const program = splitCmdAndArgs[0]
-    const args = splitCmdAndArgs.length === 1 ? [] : splitCmdAndArgs.slice(1)
-    const env = s.env ? { ...process.env, ...s.env } : undefined
-    const cwd = resolveCwd(s.cwd)
-    if (process.platform === 'win32') {
-        return spawn('cmd', ['/c', program, ...args], {
-            cwd,
-            env,
-            detached: false,
-            shell: false,
-            windowsHide: true,
-        })
-    } else {
-        return spawn(program, args, {
-            cwd,
-            env,
-            signal,
-            detached: false,
-            shell: false,
-        })
-    }
-}
-
-function removeFromRunning(s: DevService) {
-    for (let i = 0; i < running.length; i++) {
-        if (matchingConfig(running[i].s, s)) {
-            running.splice(i, 1)
-            return
-        }
-    }
-}
-
-function removeFromUpdating(s: DevService) {
-    if (updating !== null) {
-        for (let i = 0; i < updating.stopping.length; i++) {
-            if (matchingConfig(updating.stopping[i], s)) {
-                updating.stopping.splice(i, 1)
-                if (!updating.stopping.length) {
-                    updating.starting.forEach(startService)
-                    updating = null
-                    return
-                }
-            }
-        }
-    }
-}
-
-function printChunk(label: string, c: Buffer) {
-    for (const l of parseChunk(c)) console.log(label, l)
-}
-
 function parseChunk(c: Buffer): Array<string> {
     return c
         .toString()
@@ -242,29 +259,50 @@ function parseChunk(c: Buffer): Array<string> {
         .split(/\r?\n/)
 }
 
-function resolveCwd(p?: string): string | undefined {
-    if (!p || isAbsolute(p)) {
-        return p
-    } else {
-        return resolve(process.cwd(), p)
+export function parseCommand(command: string): {
+    path: string
+    args: Array<string>
+} {
+    command = command.trimStart()
+    const programSplitIndex = command.indexOf(' ')
+    if (programSplitIndex === -1) {
+        return { path: command.trim(), args: [] }
     }
-}
-
-function opPrint(s: DevService, msg: string) {
-    console.log(opLabel(s), msg)
-}
-
-function opLabel(s: DevService) {
-    return `\`${s.cwd ? s.cwd + ' ' : ''}${s.command}\``
-}
-
-function logLabel(s: DevService, ansiColor: number): string {
-    s.cwd = !s.cwd
-        ? './'
-        : s.cwd.startsWith('/')
-          ? `/.../${basename(s.cwd)}`
-          : s.cwd.startsWith('.')
-            ? s.cwd
-            : `./${s.cwd}`
-    return `\u001b[${ansiColor}m[\u001b[1m${s.command}\u001b[22m \u001b[2;3m${s.cwd}\u001b[22;23m]\u001b[0m`
+    const path = command.substring(0, programSplitIndex)
+    const args: Array<string> = []
+    let argStart = programSplitIndex + 1
+    let withinLiteral: false | "'" | '"' = false
+    for (let i = 0; i < command.length; i++) {
+        const c = command[i]
+        if (!withinLiteral) {
+            if (c === "'" || c === '"') {
+                withinLiteral = c
+                continue
+            }
+            if (c === '\\') {
+                i++
+                continue
+            }
+        }
+        if (withinLiteral) {
+            if (c === withinLiteral) {
+                withinLiteral = false
+                args.push(command.substring(argStart + 1, i))
+                argStart = i + 1
+            }
+            continue
+        }
+        if (c === ' ' && i > argStart) {
+            const maybeArg = command.substring(argStart, i).trim()
+            if (maybeArg.length) {
+                args.push(maybeArg)
+            }
+            argStart = i + 1
+        }
+    }
+    const maybeArg = command.substring(argStart, command.length).trim()
+    if (maybeArg.length) {
+        args.push(maybeArg)
+    }
+    return { path, args }
 }

package/lib/watch.ts

@@ -1,18 +1,49 @@
-import { watch as createWatch } from 'node:fs/promises'
+import {
+    watch as createWatch,
+    type WatchOptionsWithStringEncoding,
+} from 'node:fs/promises'
+
+type WatchCallback = (filename: string) => void
+
+export async function watch(p: string, fire: WatchCallback): Promise<void>
 
 export async function watch(
     p: string,
     signal: AbortSignal,
-    fire: (filename: string) => void,
-) {
+    fire: WatchCallback,
+): Promise<void>
+
+export async function watch(
+    p: string,
+    opts: WatchOptionsWithStringEncoding,
+    fire: WatchCallback,
+): Promise<void>
+
+export async function watch(
+    p: string,
+    signalFireOrOpts:
+        | AbortSignal
+        | WatchCallback
+        | WatchOptionsWithStringEncoding,
+    fireOrUndefined?: WatchCallback,
+): Promise<void> {
+    let opts: WatchOptionsWithStringEncoding | undefined
+    let fire: WatchCallback
+    if (signalFireOrOpts instanceof AbortSignal) {
+        opts = { signal: signalFireOrOpts }
+    } else if (typeof signalFireOrOpts === 'object') {
+        opts = signalFireOrOpts
+    } else {
+        fire = signalFireOrOpts
+    }
+    if (opts && typeof fireOrUndefined === 'function') {
+        fire = fireOrUndefined
+    }
     const delayFire = 90
     const timeout = 100
     let changes: Record<string, number> = {}
     try {
-        for await (const { filename } of createWatch(p, {
-            recursive: true,
-            signal,
-        })) {
+        for await (const { filename } of createWatch(p, opts)) {
             if (filename) {
                 if (!changes[filename]) {
                     const now = Date.now()

package/lib_js/build.js

@@ -1,6 +1,5 @@
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { createBuildTag } from "./build_tag.js";
 import { loadConfig } from "./config.js";
 import { createGlobalDefinitions } from "./define.js";
 import { esbuildWebpages, esbuildWorkers } from "./esbuild.js";
@@ -10,7 +9,7 @@ async function buildWebsite(c) {
   if (!c) {
     c = await loadConfig("build", process.cwd());
   }
-  const buildTag = await createBuildTag(c.flags);
+  const buildTag = await c.buildTag();
   console.log(c.flags.minify ? c.flags.production ? "minified production" : "minified" : "unminified", "build", buildTag, "building in ./build/dist");
   await rm(c.dirs.buildRoot, { recursive: true, force: true });
   await mkdir(c.dirs.buildDist, { recursive: true });

package/lib_js/build_tag.js

@@ -1,21 +1,81 @@
 import { exec } from "node:child_process";
-async function createBuildTag(flags) {
+async function createBuildTag(projectDir, flags, buildTagSource) {
+  if (typeof buildTagSource === "function") {
+    buildTagSource = await buildTagSource({ production: flags.production });
+  }
+  if (typeof buildTagSource === "undefined" || buildTagSource === null) {
+    buildTagSource = await resolveExpressionDefault(projectDir);
+  }
+  if (typeof buildTagSource !== "string") {
+    throw TypeError("DankConfig.buildTag must resolve to a string expession");
+  }
+  const params = {};
   const now = /* @__PURE__ */ new Date();
-  const ms = now.getUTCMilliseconds() + now.getUTCSeconds() * 1e3 + now.getUTCMinutes() * 1e3 * 60 + now.getUTCHours() * 1e3 * 60 * 60;
-  const date = now.toISOString().substring(0, 10);
-  const time = String(ms).padStart(8, "0");
-  const when = `${date}-${time}`;
-  if (flags.production) {
-    const gitHash = await new Promise((res, rej) => exec("git rev-parse --short HEAD", (err, stdout) => {
-      if (err)
-        rej(err);
-      res(stdout.trim());
-    }));
-    return `${when}-${gitHash}`;
-  } else {
-    return when;
+  const paramPattern = new RegExp(/{{\s*(?<name>[a-z][A-Za-z]+)\s*}}/g);
+  let paramMatch;
+  let buildTag = buildTagSource;
+  let offset = 0;
+  while ((paramMatch = paramPattern.exec(buildTagSource)) != null) {
+    const paramName = paramMatch.groups.name.trim();
+    let paramValue;
+    if (params[paramName]) {
+      paramValue = params[paramName];
+    } else {
+      paramValue = params[paramName] = await getParamValue(projectDir, paramName, now, buildTagSource);
+    }
+    buildTag = buildTag.substring(0, paramMatch.index + offset) + paramValue + buildTag.substring(paramMatch.index + paramMatch[0].length + offset);
+    offset += paramValue.length - paramMatch[0].length;
+  }
+  const validate = /^[A-Za-z\d][A-Za-z\d-_\.]+$/;
+  if (!validate.test(buildTag)) {
+    throw Error(`build tag ${buildTag} does not pass pattern ${validate.source} validation`);
+  }
+  return buildTag;
+}
+async function resolveExpressionDefault(projectDir) {
+  const base = "{{ date }}-{{ timeMS }}";
+  const isGitRepo = await new Promise((res) => exec("git rev-parse --is-inside-work-tree", { cwd: projectDir }, (err) => res(!err)));
+  return isGitRepo ? base + "-{{ gitHash }}" : base;
+}
+async function getParamValue(projectDir, name, now, buildTagSource) {
+  switch (name) {
+    case "date":
+      return getDate(now);
+    case "gitHash":
+      try {
+        return await getGitHash(projectDir);
+      } catch (e) {
+        if (e === "not-repo") {
+          throw Error(`buildTag cannot use \`gitHash\` in \`${buildTagSource}\` outside of a git repository`);
+        } else {
+          throw e;
+        }
+      }
+    case "timeMS":
+      return getTimeMS(now);
+    default:
+      throw Error(name + " is not a supported build tag param");
   }
 }
+function getDate(now) {
+  return now.toISOString().substring(0, 10);
+}
+async function getGitHash(projectDir) {
+  return await new Promise((res, rej) => exec("git rev-parse --short HEAD", { cwd: projectDir }, (err, stdout, stderr) => {
+    if (err) {
+      if (stderr.includes("not a git repository")) {
+        rej("not-repo");
+      } else {
+        rej(err);
+      }
+    }
+    res(stdout.trim());
+  }));
+}
+function getTimeMS(now) {
+  const ms = now.getUTCMilliseconds() + now.getUTCSeconds() * 1e3 + now.getUTCMinutes() * 1e3 * 60 + now.getUTCHours() * 1e3 * 60 * 60;
+  return String(ms).padStart(8, "0");
+}
 export {
   createBuildTag
 };