woozlit 2.3.0 → 2.3.2

package/src/util/fn.ts

@@ -1,21 +0,0 @@
-import { z } from "zod"
-
-export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
-  const result = (input: z.infer<T>) => {
-    let parsed
-    try {
-      parsed = schema.parse(input)
-    } catch (e) {
-      console.trace("schema validation failure stack trace:")
-      if (e instanceof z.ZodError) {
-        console.error("schema validation issues:", JSON.stringify(e.issues, null, 2))
-      }
-      throw e
-    }
-
-    return cb(parsed)
-  }
-  result.force = (input: z.infer<T>) => cb(input)
-  result.schema = schema
-  return result
-}

package/src/util/format.ts

@@ -1,20 +0,0 @@
-export function formatDuration(secs: number) {
-  if (secs <= 0) return ""
-  if (secs < 60) return `${secs}s`
-  if (secs < 3600) {
-    const mins = Math.floor(secs / 60)
-    const remaining = secs % 60
-    return remaining > 0 ? `${mins}m ${remaining}s` : `${mins}m`
-  }
-  if (secs < 86400) {
-    const hours = Math.floor(secs / 3600)
-    const remaining = Math.floor((secs % 3600) / 60)
-    return remaining > 0 ? `${hours}h ${remaining}m` : `${hours}h`
-  }
-  if (secs < 604800) {
-    const days = Math.floor(secs / 86400)
-    return days === 1 ? "~1 day" : `~${days} days`
-  }
-  const weeks = Math.floor(secs / 604800)
-  return weeks === 1 ? "~1 week" : `~${weeks} weeks`
-}

package/src/util/iife.ts

@@ -1,3 +0,0 @@
-export function iife<T>(fn: () => T) {
-  return fn()
-}

package/src/util/index.ts

@@ -1,12 +0,0 @@
-export * as Archive from "./archive"
-export * as Color from "./color"
-export * as Filesystem from "./filesystem"
-export * as Keybind from "./keybind"
-export * as LocalContext from "./local-context"
-export * as Locale from "./locale"
-export * as Lock from "./lock"
-export * as Log from "./log"
-export * as Process from "./process"
-export * as Rpc from "./rpc"
-export * as Token from "./token"
-export * as Wildcard from "./wildcard"

package/src/util/keybind.ts

@@ -1,101 +0,0 @@
-import { isDeepEqual } from "remeda"
-import type { ParsedKey } from "@opentui/core"
-
-/**
- * Keybind info derived from OpenTUI's ParsedKey with our custom `leader` field.
- * This ensures type compatibility and catches missing fields at compile time.
- */
-export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super"> & {
-  leader: boolean // our custom field
-}
-
-export function match(a: Info | undefined, b: Info): boolean {
-  if (!a) return false
-  const normalizedA = { ...a, super: a.super ?? false }
-  const normalizedB = { ...b, super: b.super ?? false }
-  return isDeepEqual(normalizedA, normalizedB)
-}
-
-/**
- * Convert OpenTUI's ParsedKey to our Keybind.Info format.
- * This helper ensures all required fields are present and avoids manual object creation.
- */
-export function fromParsedKey(key: ParsedKey, leader = false): Info {
-  return {
-    name: key.name === " " ? "space" : key.name,
-    ctrl: key.ctrl,
-    meta: key.meta,
-    shift: key.shift,
-    super: key.super ?? false,
-    leader,
-  }
-}
-
-export function toString(info: Info | undefined): string {
-  if (!info) return ""
-  const parts: string[] = []
-
-  if (info.ctrl) parts.push("ctrl")
-  if (info.meta) parts.push("alt")
-  if (info.super) parts.push("super")
-  if (info.shift) parts.push("shift")
-  if (info.name) {
-    if (info.name === "delete") parts.push("del")
-    else parts.push(info.name)
-  }
-
-  let result = parts.join("+")
-
-  if (info.leader) {
-    result = result ? `<leader> ${result}` : `<leader>`
-  }
-
-  return result
-}
-
-export function parse(key: string): Info[] {
-  if (key === "none") return []
-
-  return key.split(",").map((combo) => {
-    // Handle <leader> syntax by replacing with leader+
-    const normalized = combo.replace(/<leader>/g, "leader+")
-    const parts = normalized.toLowerCase().split("+")
-    const info: Info = {
-      ctrl: false,
-      meta: false,
-      shift: false,
-      leader: false,
-      name: "",
-    }
-
-    for (const part of parts) {
-      switch (part) {
-        case "ctrl":
-          info.ctrl = true
-          break
-        case "alt":
-        case "meta":
-        case "option":
-          info.meta = true
-          break
-        case "super":
-          info.super = true
-          break
-        case "shift":
-          info.shift = true
-          break
-        case "leader":
-          info.leader = true
-          break
-        case "esc":
-          info.name = "escape"
-          break
-        default:
-          info.name = part
-          break
-      }
-    }
-
-    return info
-  })
-}

package/src/util/lazy.ts

@@ -1,18 +0,0 @@
-export function lazy<T>(fn: () => T) {
-  let value: T | undefined
-  let loaded = false
-
-  const result = (): T => {
-    if (loaded) return value as T
-    value = fn()
-    loaded = true
-    return value as T
-  }
-
-  result.reset = () => {
-    loaded = false
-    value = undefined
-  }
-
-  return result
-}

package/src/util/local-context.ts

@@ -1,23 +0,0 @@
-import { AsyncLocalStorage } from "async_hooks"
-
-export class NotFound extends Error {
-  constructor(public override readonly name: string) {
-    super(`No context found for ${name}`)
-  }
-}
-
-export function create<T>(name: string) {
-  const storage = new AsyncLocalStorage<T>()
-  return {
-    use() {
-      const result = storage.getStore()
-      if (!result) {
-        throw new NotFound(name)
-      }
-      return result
-    },
-    provide<R>(value: T, fn: () => R) {
-      return storage.run(value, fn)
-    },
-  }
-}

package/src/util/locale.ts

@@ -1,79 +0,0 @@
-export function titlecase(str: string) {
-  return str.replace(/\b\w/g, (c) => c.toUpperCase())
-}
-
-export function time(input: number): string {
-  const date = new Date(input)
-  return date.toLocaleTimeString(undefined, { timeStyle: "short" })
-}
-
-export function datetime(input: number): string {
-  const date = new Date(input)
-  const localTime = time(input)
-  const localDate = date.toLocaleDateString()
-  return `${localTime} · ${localDate}`
-}
-
-export function todayTimeOrDateTime(input: number): string {
-  const date = new Date(input)
-  const now = new Date()
-  const isToday =
-    date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()
-
-  if (isToday) {
-    return time(input)
-  } else {
-    return datetime(input)
-  }
-}
-
-export function number(num: number): string {
-  if (num >= 1000000) {
-    return (num / 1000000).toFixed(1) + "M"
-  } else if (num >= 1000) {
-    return (num / 1000).toFixed(1) + "K"
-  }
-  return num.toString()
-}
-
-export function duration(input: number) {
-  if (input < 1000) {
-    return `${input}ms`
-  }
-  if (input < 60000) {
-    return `${(input / 1000).toFixed(1)}s`
-  }
-  if (input < 3600000) {
-    const minutes = Math.floor(input / 60000)
-    const seconds = Math.floor((input % 60000) / 1000)
-    return `${minutes}m ${seconds}s`
-  }
-  if (input < 86400000) {
-    const hours = Math.floor(input / 3600000)
-    const minutes = Math.floor((input % 3600000) / 60000)
-    return `${hours}h ${minutes}m`
-  }
-  const hours = Math.floor(input / 3600000)
-  const days = Math.floor((input % 3600000) / 86400000)
-  return `${days}d ${hours}h`
-}
-
-export function truncate(str: string, len: number): string {
-  if (str.length <= len) return str
-  return str.slice(0, len - 1) + "…"
-}
-
-export function truncateMiddle(str: string, maxLength: number = 35): string {
-  if (str.length <= maxLength) return str
-
-  const ellipsis = "…"
-  const keepStart = Math.ceil((maxLength - ellipsis.length) / 2)
-  const keepEnd = Math.floor((maxLength - ellipsis.length) / 2)
-
-  return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
-}
-
-export function pluralize(count: number, singular: string, plural: string): string {
-  const template = count === 1 ? singular : plural
-  return template.replace("{}", count.toString())
-}

package/src/util/lock.ts

@@ -1,96 +0,0 @@
-const locks = new Map<
-  string,
-  {
-    readers: number
-    writer: boolean
-    waitingReaders: (() => void)[]
-    waitingWriters: (() => void)[]
-  }
->()
-
-function get(key: string) {
-  if (!locks.has(key)) {
-    locks.set(key, {
-      readers: 0,
-      writer: false,
-      waitingReaders: [],
-      waitingWriters: [],
-    })
-  }
-  return locks.get(key)!
-}
-
-function process(key: string) {
-  const lock = locks.get(key)
-  if (!lock || lock.writer || lock.readers > 0) return
-
-  // Prioritize writers to prevent starvation
-  if (lock.waitingWriters.length > 0) {
-    const nextWriter = lock.waitingWriters.shift()!
-    nextWriter()
-    return
-  }
-
-  // Wake up all waiting readers
-  while (lock.waitingReaders.length > 0) {
-    const nextReader = lock.waitingReaders.shift()!
-    nextReader()
-  }
-
-  // Clean up empty locks
-  if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
-    locks.delete(key)
-  }
-}
-
-export async function read(key: string): Promise<Disposable> {
-  const lock = get(key)
-
-  return new Promise((resolve) => {
-    if (!lock.writer && lock.waitingWriters.length === 0) {
-      lock.readers++
-      resolve({
-        [Symbol.dispose]: () => {
-          lock.readers--
-          process(key)
-        },
-      })
-    } else {
-      lock.waitingReaders.push(() => {
-        lock.readers++
-        resolve({
-          [Symbol.dispose]: () => {
-            lock.readers--
-            process(key)
-          },
-        })
-      })
-    }
-  })
-}
-
-export async function write(key: string): Promise<Disposable> {
-  const lock = get(key)
-
-  return new Promise((resolve) => {
-    if (!lock.writer && lock.readers === 0) {
-      lock.writer = true
-      resolve({
-        [Symbol.dispose]: () => {
-          lock.writer = false
-          process(key)
-        },
-      })
-    } else {
-      lock.waitingWriters.push(() => {
-        lock.writer = true
-        resolve({
-          [Symbol.dispose]: () => {
-            lock.writer = false
-            process(key)
-          },
-        })
-      })
-    }
-  })
-}

package/src/util/log.ts

@@ -1,197 +0,0 @@
-import path from "path"
-import fs from "fs/promises"
-import { createWriteStream } from "fs"
-import { Global } from "../global"
-import z from "zod"
-import { Glob } from "@woozlit/shared/util/glob"
-
-export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
-export type Level = z.infer<typeof Level>
-
-const levelPriority: Record<Level, number> = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3,
-}
-const keep = 10
-
-let level: Level = "INFO"
-
-function shouldLog(input: Level): boolean {
-  return levelPriority[input] >= levelPriority[level]
-}
-
-export type Logger = {
-  debug(message?: any, extra?: Record<string, any>): void
-  info(message?: any, extra?: Record<string, any>): void
-  error(message?: any, extra?: Record<string, any>): void
-  warn(message?: any, extra?: Record<string, any>): void
-  tag(key: string, value: string): Logger
-  clone(): Logger
-  time(
-    message: string,
-    extra?: Record<string, any>,
-  ): {
-    stop(): void
-    [Symbol.dispose](): void
-  }
-}
-
-const loggers = new Map<string, Logger>()
-
-export const Default = create({ service: "default" })
-
-export interface Options {
-  print: boolean
-  dev?: boolean
-  level?: Level
-}
-
-let logpath = ""
-export function file() {
-  return logpath
-}
-let write = (msg: any) => {
-  process.stderr.write(msg)
-  return msg.length
-}
-
-export async function init(options: Options) {
-  if (options.level) level = options.level
-  void cleanup(Global.Path.log)
-  if (options.print) return
-  logpath = path.join(
-    Global.Path.log,
-    options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
-  )
-  if (options.dev) {
-    // Preserve previous dev.log as dev.log.<timestamp> for hang/incident
-    // forensics. cleanup() above already prunes old timestamped logs.
-    try {
-      const stat = await fs.stat(logpath).catch(() => null)
-      if (stat && stat.size > 0) {
-        const stamp = new Date().toISOString().split(".")[0].replace(/:/g, "")
-        await fs.rename(logpath, `${logpath}.${stamp}`).catch(() => {})
-      }
-    } catch {}
-  } else {
-    await fs.truncate(logpath).catch(() => {})
-  }
-  const stream = createWriteStream(logpath, { flags: "a" })
-  write = async (msg: any) => {
-    return new Promise((resolve, reject) => {
-      stream.write(msg, (err) => {
-        if (err) reject(err)
-        else resolve(msg.length)
-      })
-    })
-  }
-}
-
-async function cleanup(dir: string) {
-  const files = (
-    await Glob.scan("????-??-??T??????.log", {
-      cwd: dir,
-      absolute: false,
-      include: "file",
-    }).catch(() => [])
-  )
-    .filter((file) => path.basename(file) === file)
-    .sort()
-  if (files.length <= keep) return
-
-  const doomed = files.slice(0, -keep)
-  await Promise.all(doomed.map((file) => fs.unlink(path.join(dir, file)).catch(() => {})))
-}
-
-function formatError(error: Error, depth = 0): string {
-  const result = error.message
-  return error.cause instanceof Error && depth < 10
-    ? result + " Caused by: " + formatError(error.cause, depth + 1)
-    : result
-}
-
-let last = Date.now()
-export function create(tags?: Record<string, any>) {
-  tags = tags || {}
-
-  const service = tags["service"]
-  if (service && typeof service === "string") {
-    const cached = loggers.get(service)
-    if (cached) {
-      return cached
-    }
-  }
-
-  function build(message: any, extra?: Record<string, any>) {
-    const prefix = Object.entries({
-      ...tags,
-      ...extra,
-    })
-      .filter(([_, value]) => value !== undefined && value !== null)
-      .map(([key, value]) => {
-        const prefix = `${key}=`
-        if (value instanceof Error) return prefix + formatError(value)
-        if (typeof value === "object") return prefix + JSON.stringify(value)
-        return prefix + value
-      })
-      .join(" ")
-    const next = new Date()
-    const diff = next.getTime() - last
-    last = next.getTime()
-    return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n"
-  }
-  const result: Logger = {
-    debug(message?: any, extra?: Record<string, any>) {
-      if (shouldLog("DEBUG")) {
-        write("DEBUG " + build(message, extra))
-      }
-    },
-    info(message?: any, extra?: Record<string, any>) {
-      if (shouldLog("INFO")) {
-        write("INFO  " + build(message, extra))
-      }
-    },
-    error(message?: any, extra?: Record<string, any>) {
-      if (shouldLog("ERROR")) {
-        write("ERROR " + build(message, extra))
-      }
-    },
-    warn(message?: any, extra?: Record<string, any>) {
-      if (shouldLog("WARN")) {
-        write("WARN  " + build(message, extra))
-      }
-    },
-    tag(key: string, value: string) {
-      if (tags) tags[key] = value
-      return result
-    },
-    clone() {
-      return create({ ...tags })
-    },
-    time(message: string, extra?: Record<string, any>) {
-      const now = Date.now()
-      result.info(message, { status: "started", ...extra })
-      function stop() {
-        result.info(message, {
-          status: "completed",
-          duration: Date.now() - now,
-          ...extra,
-        })
-      }
-      return {
-        stop,
-        [Symbol.dispose]() {
-          stop()
-        },
-      }
-    },
-  }
-
-  if (service && typeof service === "string") {
-    loggers.set(service, result)
-  }
-
-  return result
-}

package/src/util/media.ts

@@ -1,26 +0,0 @@
-const startsWith = (bytes: Uint8Array, prefix: number[]) => prefix.every((value, index) => bytes[index] === value)
-
-export function isPdfAttachment(mime: string) {
-  return mime === "application/pdf"
-}
-
-export function isMedia(mime: string) {
-  return mime.startsWith("image/") || isPdfAttachment(mime)
-}
-
-export function isImageAttachment(mime: string) {
-  return mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet"
-}
-
-export function sniffAttachmentMime(bytes: Uint8Array, fallback: string) {
-  if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return "image/png"
-  if (startsWith(bytes, [0xff, 0xd8, 0xff])) return "image/jpeg"
-  if (startsWith(bytes, [0x47, 0x49, 0x46, 0x38])) return "image/gif"
-  if (startsWith(bytes, [0x42, 0x4d])) return "image/bmp"
-  if (startsWith(bytes, [0x25, 0x50, 0x44, 0x46, 0x2d])) return "application/pdf"
-  if (startsWith(bytes, [0x52, 0x49, 0x46, 0x46]) && startsWith(bytes.subarray(8), [0x57, 0x45, 0x42, 0x50])) {
-    return "image/webp"
-  }
-
-  return fallback
-}

package/src/util/mimo-process.ts

@@ -1,24 +0,0 @@
-export const WOOZLIT_CODE_RUN_ID = "WOOZLIT_CODE_RUN_ID"
-export const WOOZLIT_CODE_PROCESS_ROLE = "WOOZLIT_CODE_PROCESS_ROLE"
-
-export function ensureRunID() {
-  return (process.env[WOOZLIT_CODE_RUN_ID] ??= crypto.randomUUID())
-}
-
-export function ensureProcessRole(fallback: "main" | "worker") {
-  return (process.env[WOOZLIT_CODE_PROCESS_ROLE] ??= fallback)
-}
-
-export function ensureProcessMetadata(fallback: "main" | "worker") {
-  return {
-    runID: ensureRunID(),
-    processRole: ensureProcessRole(fallback),
-  }
-}
-
-export function sanitizedProcessEnv(overrides?: Record<string, string>) {
-  const env = Object.fromEntries(
-    Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined),
-  )
-  return overrides ? Object.assign(env, overrides) : env
-}

package/src/util/network.ts

@@ -1,9 +0,0 @@
-export function online() {
-  const nav = globalThis.navigator
-  if (!nav || typeof nav.onLine !== "boolean") return true
-  return nav.onLine
-}
-
-export function proxied() {
-  return !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)
-}