saeeol 1.2.5 → 1.2.8

package/test/util/format.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { formatDuration } from "../../src/util/format"
-
-describe("util.format", () => {
-  describe("formatDuration", () => {
-    test("returns empty string for zero or negative values", () => {
-      expect(formatDuration(0)).toBe("")
-      expect(formatDuration(-1)).toBe("")
-      expect(formatDuration(-100)).toBe("")
-    })
-
-    test("formats seconds under a minute", () => {
-      expect(formatDuration(1)).toBe("1s")
-      expect(formatDuration(30)).toBe("30s")
-      expect(formatDuration(59)).toBe("59s")
-    })
-
-    test("formats minutes under an hour", () => {
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(61)).toBe("1m 1s")
-      expect(formatDuration(90)).toBe("1m 30s")
-      expect(formatDuration(120)).toBe("2m")
-      expect(formatDuration(330)).toBe("5m 30s")
-      expect(formatDuration(3599)).toBe("59m 59s")
-    })
-
-    test("formats hours under a day", () => {
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(3660)).toBe("1h 1m")
-      expect(formatDuration(7200)).toBe("2h")
-      expect(formatDuration(8100)).toBe("2h 15m")
-      expect(formatDuration(86399)).toBe("23h 59m")
-    })
-
-    test("formats days under a week", () => {
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(172800)).toBe("~2 days")
-      expect(formatDuration(259200)).toBe("~3 days")
-      expect(formatDuration(604799)).toBe("~6 days")
-    })
-
-    test("formats weeks", () => {
-      expect(formatDuration(604800)).toBe("~1 week")
-      expect(formatDuration(1209600)).toBe("~2 weeks")
-      expect(formatDuration(1609200)).toBe("~2 weeks")
-    })
-
-    test("handles boundary values correctly", () => {
-      expect(formatDuration(59)).toBe("59s")
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(3599)).toBe("59m 59s")
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(86399)).toBe("23h 59m")
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(604799)).toBe("~6 days")
-      expect(formatDuration(604800)).toBe("~1 week")
-    })
-  })
-})

package/test/util/glob.test.ts

@@ -1,164 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import { Glob } from "@saeeol/core/util/glob"
-import { tmpdir } from "../fixture/fixture"
-
-describe("Glob", () => {
-  describe("scan()", () => {
-    test("finds files matching pattern", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, "a.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "b.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "c.md"), "", "utf-8")
-
-      const results = await Glob.scan("*.txt", { cwd: tmp.path })
-
-      expect(results.sort()).toEqual(["a.txt", "b.txt"])
-    })
-
-    test("returns absolute paths when absolute option is true", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*.txt", { cwd: tmp.path, absolute: true })
-
-      expect(results[0]).toBe(path.join(tmp.path, "file.txt"))
-    })
-
-    test("excludes directories by default", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path })
-
-      expect(results).toEqual(["file.txt"])
-    })
-
-    test("excludes directories when include is 'file'", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, include: "file" })
-
-      expect(results).toEqual(["file.txt"])
-    })
-
-    test("includes directories when include is 'all'", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, include: "all" })
-
-      expect(results.sort()).toEqual(["file.txt", "subdir"])
-    })
-
-    test("handles nested patterns", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "nested"), { recursive: true })
-      await fs.writeFile(path.join(tmp.path, "nested", "deep.txt"), "", "utf-8")
-
-      const results = await Glob.scan("**/*.txt", { cwd: tmp.path })
-
-      expect(results).toEqual([path.join("nested", "deep.txt")])
-    })
-
-    test("returns empty array for no matches", async () => {
-      await using tmp = await tmpdir()
-
-      const results = await Glob.scan("*.nonexistent", { cwd: tmp.path })
-
-      expect(results).toEqual([])
-    })
-
-    test("does not follow symlinks by default", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "realdir"))
-      await fs.writeFile(path.join(tmp.path, "realdir", "file.txt"), "", "utf-8")
-      await fs.symlink(path.join(tmp.path, "realdir"), path.join(tmp.path, "linkdir"))
-
-      const results = await Glob.scan("**/*.txt", { cwd: tmp.path })
-
-      expect(results).toEqual([path.join("realdir", "file.txt")])
-    })
-
-    test("follows symlinks when symlink option is true", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "realdir"))
-      await fs.writeFile(path.join(tmp.path, "realdir", "file.txt"), "", "utf-8")
-      await fs.symlink(path.join(tmp.path, "realdir"), path.join(tmp.path, "linkdir"))
-
-      const results = await Glob.scan("**/*.txt", { cwd: tmp.path, symlink: true })
-
-      expect(results.sort()).toEqual([path.join("linkdir", "file.txt"), path.join("realdir", "file.txt")])
-    })
-
-    test("includes dotfiles when dot option is true", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, ".hidden"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "visible"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, dot: true })
-
-      expect(results.sort()).toEqual([".hidden", "visible"])
-    })
-
-    test("excludes dotfiles when dot option is false", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, ".hidden"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "visible"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, dot: false })
-
-      expect(results).toEqual(["visible"])
-    })
-  })
-
-  describe("scanSync()", () => {
-    test("finds files matching pattern synchronously", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, "a.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "b.txt"), "", "utf-8")
-
-      const results = Glob.scanSync("*.txt", { cwd: tmp.path })
-
-      expect(results.sort()).toEqual(["a.txt", "b.txt"])
-    })
-
-    test("respects options", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = Glob.scanSync("*", { cwd: tmp.path, include: "all" })
-
-      expect(results.sort()).toEqual(["file.txt", "subdir"])
-    })
-  })
-
-  describe("match()", () => {
-    test("matches simple patterns", () => {
-      expect(Glob.match("*.txt", "file.txt")).toBe(true)
-      expect(Glob.match("*.txt", "file.js")).toBe(false)
-    })
-
-    test("matches directory patterns", () => {
-      expect(Glob.match("**/*.js", "src/index.js")).toBe(true)
-      expect(Glob.match("**/*.js", "src/index.ts")).toBe(false)
-    })
-
-    test("matches dot files", () => {
-      expect(Glob.match(".*", ".gitignore")).toBe(true)
-      expect(Glob.match("**/*.md", ".github/README.md")).toBe(true)
-    })
-
-    test("matches brace expansion", () => {
-      expect(Glob.match("*.{js,ts}", "file.js")).toBe(true)
-      expect(Glob.match("*.{js,ts}", "file.ts")).toBe(true)
-      expect(Glob.match("*.{js,ts}", "file.py")).toBe(false)
-    })
-  })
-})

package/test/util/iife.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { iife } from "../../src/util/iife"
-
-describe("util.iife", () => {
-  test("should execute function immediately and return result", () => {
-    let called = false
-    const result = iife(() => {
-      called = true
-      return 42
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBe(42)
-  })
-
-  test("should work with async functions", async () => {
-    let called = false
-    const result = await iife(async () => {
-      called = true
-      return "async result"
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBe("async result")
-  })
-
-  test("should handle functions with no return value", () => {
-    let called = false
-    const result = iife(() => {
-      called = true
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBeUndefined()
-  })
-})

package/test/util/lazy.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { lazy } from "../../src/util/lazy"
-
-describe("util.lazy", () => {
-  test("should call function only once", () => {
-    let callCount = 0
-    const getValue = () => {
-      callCount++
-      return "expensive value"
-    }
-
-    const lazyValue = lazy(getValue)
-
-    expect(callCount).toBe(0)
-
-    const result1 = lazyValue()
-    expect(result1).toBe("expensive value")
-    expect(callCount).toBe(1)
-
-    const result2 = lazyValue()
-    expect(result2).toBe("expensive value")
-    expect(callCount).toBe(1)
-  })
-
-  test("should preserve the same reference", () => {
-    const obj = { value: 42 }
-    const lazyObj = lazy(() => obj)
-
-    const result1 = lazyObj()
-    const result2 = lazyObj()
-
-    expect(result1).toBe(obj)
-    expect(result2).toBe(obj)
-    expect(result1).toBe(result2)
-  })
-
-  test("should work with different return types", () => {
-    const lazyString = lazy(() => "string")
-    const lazyNumber = lazy(() => 123)
-    const lazyBoolean = lazy(() => true)
-    const lazyNull = lazy(() => null)
-    const lazyUndefined = lazy(() => undefined)
-
-    expect(lazyString()).toBe("string")
-    expect(lazyNumber()).toBe(123)
-    expect(lazyBoolean()).toBe(true)
-    expect(lazyNull()).toBe(null)
-    expect(lazyUndefined()).toBe(undefined)
-  })
-})

package/test/util/lock.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Lock } from "@/util/lock"
-
-function tick() {
-  return new Promise<void>((r) => queueMicrotask(r))
-}
-
-async function flush(n = 5) {
-  for (let i = 0; i < n; i++) await tick()
-}
-
-describe("util.lock", () => {
-  test("writer exclusivity: blocks reads and other writes while held", async () => {
-    const key = "lock:" + Math.random().toString(36).slice(2)
-
-    const state = {
-      writer2: false,
-      reader: false,
-      writers: 0,
-    }
-
-    // Acquire writer1
-    using writer1 = await Lock.write(key)
-    state.writers++
-    expect(state.writers).toBe(1)
-
-    // Start writer2 candidate (should block)
-    const writer2Task = (async () => {
-      const w = await Lock.write(key)
-      state.writers++
-      expect(state.writers).toBe(1)
-      state.writer2 = true
-      // Hold for a tick so reader cannot slip in
-      await tick()
-      return w
-    })()
-
-    // Start reader candidate (should block)
-    const readerTask = (async () => {
-      const r = await Lock.read(key)
-      state.reader = true
-      return r
-    })()
-
-    // Flush microtasks and assert neither acquired
-    await flush()
-    expect(state.writer2).toBe(false)
-    expect(state.reader).toBe(false)
-
-    // Release writer1
-    writer1[Symbol.dispose]()
-    state.writers--
-
-    // writer2 should acquire next
-    const writer2 = await writer2Task
-    expect(state.writer2).toBe(true)
-
-    // Reader still blocked while writer2 held
-    await flush()
-    expect(state.reader).toBe(false)
-
-    // Release writer2
-    writer2[Symbol.dispose]()
-    state.writers--
-
-    // Reader should now acquire
-    const reader = await readerTask
-    expect(state.reader).toBe(true)
-
-    reader[Symbol.dispose]()
-  })
-})

package/test/util/log.test.ts

@@ -1,86 +0,0 @@
-import { afterEach, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Global } from "@saeeol/core/global"
-import * as Log from "@saeeol/core/util/log"
-import * as Process from "../../src/util/process" 
-import { tmpdir } from "../fixture/fixture"
-
-const log = Global.Path.log
-
-afterEach(() => {
-  Global.Path.log = log
-})
-
-async function files(dir: string) {
-  let last = ""
-  let same = 0
-
-  for (let i = 0; i < 50; i++) {
-    const list = (await fs.readdir(dir)).sort()
-    const next = JSON.stringify(list)
-    same = next === last ? same + 1 : 0
-    if (same >= 2 && list.length === 11) return list
-    last = next
-    await Bun.sleep(10)
-  }
-
-  return (await fs.readdir(dir)).sort()
-}
-
-test("init cleanup keeps the newest timestamped logs", async () => {
-  await using tmp = await tmpdir()
-  Global.Path.log = tmp.path
-
-  const list = Array.from({ length: 12 }, (_, i) => `2000-01-${String(i + 1).padStart(2, "0")}T000000.log`)
-
-  await Promise.all(list.map((file) => fs.writeFile(path.join(tmp.path, file), file)))
-
-  await Log.init({ print: false, dev: false })
-
-  const next = await files(tmp.path)
-
-  expect(next).not.toContain(list[0]!)
-  expect(next).toContain(list.at(-1)!)
-})
-const root = path.join(import.meta.dir, "../..")
-const worker = path.join(import.meta.dir, "../fixture/log-init-worker.ts")
-
-test("uses single log directory for rotation history", async () => {
-  await using tmp = await tmpdir()
-
-  const out = await Process.run([process.execPath, "--conditions=browser", worker, tmp.path], {
-    cwd: root,
-    nothrow: true,
-  })
-
-  const dir = path.join(tmp.path, "share", "saeeol", "log")
-  const history = path.join(dir, ".log-history")
-
-  expect(out.code).toBe(0)
-  expect(out.stderr.toString()).not.toContain("log stream error:")
-  expect(out.stdout.toString()).toBe(path.join(dir, "dev.log"))
-
-  const stat = await fs.stat(history)
-  expect(stat.isFile()).toBe(true)
-})
-
-test("skips rotation rename when active log file is missing", async () => {
-  await using tmp = await tmpdir()
-
-  const out = await Process.run([process.execPath, "--conditions=browser", worker, tmp.path, "missing"], {
-    cwd: root,
-    nothrow: true,
-  })
-
-  const dir = path.join(tmp.path, "share", "saeeol", "log")
-  const list = (await fs.readdir(dir)).sort()
-  const next = list.filter((file) => /^\d{8}-\d{4}-\d{2}-dev\.log$/.test(file))
-  const stat = await fs.stat(path.join(dir, next[0]!))
-
-  expect(out.code).toBe(0)
-  expect(out.stderr.toString()).not.toContain("log stream error:")
-  expect(list).toContain("dev.log")
-  expect(next).toHaveLength(1)
-  expect(stat.size).toBe(0)
-})

package/test/util/module.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Module } from "@saeeol/core/util/module"
-import { Filesystem } from "@/util/filesystem"
-import { tmpdir } from "../fixture/fixture"
-
-describe("util.module", () => {
-  test("resolves package subpaths from the provided dir", async () => {
-    await using tmp = await tmpdir()
-    const root = path.join(tmp.path, "proj")
-    const file = path.join(root, "node_modules/typescript/lib/tsserver.js")
-    await Filesystem.write(file, "export {}\n")
-    await Filesystem.writeJson(path.join(root, "node_modules/typescript/package.json"), { name: "typescript" })
-
-    expect(Module.resolve("typescript/lib/tsserver.js", root)).toBe(file)
-  })
-
-  test("resolves packages through ancestor node_modules", async () => {
-    await using tmp = await tmpdir()
-    const root = path.join(tmp.path, "proj")
-    const cwd = path.join(root, "apps/web")
-    const file = path.join(root, "node_modules/eslint/lib/api.js")
-    await Filesystem.write(file, "export {}\n")
-    await Filesystem.writeJson(path.join(root, "node_modules/eslint/package.json"), {
-      name: "eslint",
-      main: "lib/api.js",
-    })
-    await Filesystem.write(path.join(cwd, ".keep"), "")
-
-    expect(Module.resolve("eslint", cwd)).toBe(file)
-  })
-
-  test("resolves relative to the provided dir", async () => {
-    await using tmp = await tmpdir()
-    const a = path.join(tmp.path, "a")
-    const b = path.join(tmp.path, "b")
-    const left = path.join(a, "node_modules/biome/index.js")
-    const right = path.join(b, "node_modules/biome/index.js")
-    await Filesystem.write(left, "export {}\n")
-    await Filesystem.write(right, "export {}\n")
-    await Filesystem.writeJson(path.join(a, "node_modules/biome/package.json"), {
-      name: "biome",
-      main: "index.js",
-    })
-    await Filesystem.writeJson(path.join(b, "node_modules/biome/package.json"), {
-      name: "biome",
-      main: "index.js",
-    })
-
-    expect(Module.resolve("biome", a)).toBe(left)
-    expect(Module.resolve("biome", b)).toBe(right)
-    expect(Module.resolve("biome", a)).not.toBe(Module.resolve("biome", b))
-  })
-
-  test("returns undefined when resolution fails", async () => {
-    await using tmp = await tmpdir()
-    expect(Module.resolve("missing-package", tmp.path)).toBeUndefined()
-  })
-})

package/test/util/process.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Process } from "@/util/process"
-import { tmpdir } from "../fixture/fixture"
-
-function node(script: string) {
-  return [process.execPath, "-e", script]
-}
-
-describe("util.process", () => {
-  test("captures stdout and stderr", async () => {
-    const out = await Process.run(node('process.stdout.write("out");process.stderr.write("err")'))
-    expect(out.code).toBe(0)
-    expect(out.stdout.toString()).toBe("out")
-    expect(out.stderr.toString()).toBe("err")
-  })
-
-  test("returns code when nothrow is enabled", async () => {
-    const out = await Process.run(node("process.exit(7)"), { nothrow: true })
-    expect(out.code).toBe(7)
-  })
-
-  test("throws RunFailedError on non-zero exit", async () => {
-    const err = await Process.run(node('process.stderr.write("bad");process.exit(3)')).catch((error) => error)
-    expect(err).toBeInstanceOf(Process.RunFailedError)
-    if (!(err instanceof Process.RunFailedError)) throw err
-    expect(err.code).toBe(3)
-    expect(err.stderr.toString()).toBe("bad")
-  })
-
-  test("aborts a running process", async () => {
-    const abort = new AbortController()
-    const started = Date.now()
-    setTimeout(() => abort.abort(), 25)
-
-    const out = await Process.run(node("setInterval(() => {}, 1000)"), {
-      abort: abort.signal,
-      nothrow: true,
-    })
-
-    expect(out.code).not.toBe(0)
-    expect(Date.now() - started).toBeLessThan(1000)
-  }, 3000)
-
-  test("kills after timeout when process ignores terminate signal", async () => {
-    if (process.platform === "win32") return
-
-    const abort = new AbortController()
-    const started = Date.now()
-    setTimeout(() => abort.abort(), 25)
-
-    const out = await Process.run(node('process.on("SIGTERM", () => {}); setInterval(() => {}, 1000)'), {
-      abort: abort.signal,
-      nothrow: true,
-      timeout: 25,
-    })
-
-    expect(out.code).not.toBe(0)
-    expect(Date.now() - started).toBeLessThan(1000)
-  }, 3000)
-
-  test("uses cwd when spawning commands", async () => {
-    await using tmp = await tmpdir()
-    const out = await Process.run(node("process.stdout.write(process.cwd())"), {
-      cwd: tmp.path,
-    })
-    expect(out.stdout.toString()).toBe(tmp.path)
-  })
-
-  test("merges environment overrides", async () => {
-    const out = await Process.run(node('process.stdout.write(process.env.SAEEOL_TEST ?? "")'), {
-      env: {
-        SAEEOL_TEST: "set",
-      },
-    })
-    expect(out.stdout.toString()).toBe("set")
-  })
-
-  test("uses shell in run on Windows", async () => {
-    if (process.platform !== "win32") return
-
-    const out = await Process.run(["set", "SAEEOL_TEST_SHELL"], {
-      shell: true,
-      env: {
-        SAEEOL_TEST_SHELL: "ok",
-      },
-    })
-
-    expect(out.code).toBe(0)
-    expect(out.stdout.toString()).toContain("SAEEOL_TEST_SHELL=ok")
-  })
-
-  test("runs cmd scripts with spaces on Windows without shell", async () => {
-    if (process.platform !== "win32") return
-
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "with space")
-    const file = path.join(dir, "echo cmd.cmd")
-
-    await fs.mkdir(dir, { recursive: true })
-    await Bun.write(file, "@echo off\r\nif %~1==--stdio exit /b 0\r\nexit /b 7\r\n")
-
-    const proc = Process.spawn([file, "--stdio"], {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    expect(await proc.exited).toBe(0)
-  })
-
-  test("rejects missing commands without leaking unhandled errors", async () => {
-    await using tmp = await tmpdir()
-    const cmd = path.join(tmp.path, "missing" + (process.platform === "win32" ? ".cmd" : ""))
-    const err = await Process.spawn([cmd], {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    }).exited.catch((err) => err)
-
-    expect(err).toBeInstanceOf(Error)
-    if (!(err instanceof Error)) throw err
-    expect(err).toMatchObject({
-      code: "ENOENT",
-    })
-  })
-})

package/test/util/timeout.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { withTimeout } from "../../src/util/timeout"
-
-describe("util.timeout", () => {
-  test("should resolve when promise completes before timeout", async () => {
-    const fastPromise = new Promise<string>((resolve) => {
-      setTimeout(() => resolve("fast"), 10)
-    })
-
-    const result = await withTimeout(fastPromise, 100)
-    expect(result).toBe("fast")
-  })
-
-  test("should reject when promise exceeds timeout", async () => {
-    const slowPromise = new Promise<string>((resolve) => {
-      setTimeout(() => resolve("slow"), 200)
-    })
-
-    await expect(withTimeout(slowPromise, 50)).rejects.toThrow("Operation timed out after 50ms")
-  })
-})