jonsoc 1.1.49 → 1.1.50

package/src/util/keybind.ts

@@ -1,103 +0,0 @@
-import { isDeepEqual } from "remeda"
-import type { ParsedKey } from "@opentui/core"
-
-export namespace Keybind {
-  /**
-   * 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,
-      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
-    loaded = true
-    value = fn()
-    return value as T
-  }
-
-  result.reset = () => {
-    loaded = false
-    value = undefined
-  }
-
-  return result
-}

package/src/util/locale.ts

@@ -1,81 +0,0 @@
-export namespace Locale {
-  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,98 +0,0 @@
-export namespace Lock {
-  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,180 +0,0 @@
-import path from "path"
-import fs from "fs/promises"
-import { Global } from "../global"
-import z from "zod"
-
-export namespace Log {
-  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,
-  }
-
-  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
-    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",
-    )
-    const logfile = Bun.file(logpath)
-    await fs.truncate(logpath).catch(() => {})
-    const writer = logfile.writer()
-    write = async (msg: any) => {
-      const num = writer.write(msg)
-      writer.flush()
-      return num
-    }
-  }
-
-  async function cleanup(dir: string) {
-    const glob = new Bun.Glob("????-??-??T??????.log")
-    const files = await Array.fromAsync(
-      glob.scan({
-        cwd: dir,
-        absolute: true,
-      }),
-    )
-    if (files.length <= 5) return
-
-    const filesToDelete = files.slice(0, -10)
-    await Promise.all(filesToDelete.map((file) => fs.unlink(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 Log.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/queue.ts

@@ -1,32 +0,0 @@
-export class AsyncQueue<T> implements AsyncIterable<T> {
-  private queue: T[] = []
-  private resolvers: ((value: T) => void)[] = []
-
-  push(item: T) {
-    const resolve = this.resolvers.shift()
-    if (resolve) resolve(item)
-    else this.queue.push(item)
-  }
-
-  async next(): Promise<T> {
-    if (this.queue.length > 0) return this.queue.shift()!
-    return new Promise((resolve) => this.resolvers.push(resolve))
-  }
-
-  async *[Symbol.asyncIterator]() {
-    while (true) yield await this.next()
-  }
-}
-
-export async function work<T>(concurrency: number, items: T[], fn: (item: T) => Promise<void>) {
-  const pending = [...items]
-  await Promise.all(
-    Array.from({ length: concurrency }, async () => {
-      while (true) {
-        const item = pending.pop()
-        if (item === undefined) return
-        await fn(item)
-      }
-    }),
-  )
-}

package/src/util/rpc.ts

@@ -1,66 +0,0 @@
-export namespace Rpc {
-  type Definition = {
-    [method: string]: (input: any) => any
-  }
-
-  export function listen(rpc: Definition) {
-    onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.request") {
-        const result = await rpc[parsed.method](parsed.input)
-        postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
-      }
-    }
-  }
-
-  export function emit(event: string, data: unknown) {
-    postMessage(JSON.stringify({ type: "rpc.event", event, data }))
-  }
-
-  export function client<T extends Definition>(target: {
-    postMessage: (data: string) => void | null
-    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
-  }) {
-    const pending = new Map<number, (result: any) => void>()
-    const listeners = new Map<string, Set<(data: any) => void>>()
-    let id = 0
-    target.onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.result") {
-        const resolve = pending.get(parsed.id)
-        if (resolve) {
-          resolve(parsed.result)
-          pending.delete(parsed.id)
-        }
-      }
-      if (parsed.type === "rpc.event") {
-        const handlers = listeners.get(parsed.event)
-        if (handlers) {
-          for (const handler of handlers) {
-            handler(parsed.data)
-          }
-        }
-      }
-    }
-    return {
-      call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
-        const requestId = id++
-        return new Promise((resolve) => {
-          pending.set(requestId, resolve)
-          target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
-        })
-      },
-      on<Data>(event: string, handler: (data: Data) => void) {
-        let handlers = listeners.get(event)
-        if (!handlers) {
-          handlers = new Set()
-          listeners.set(event, handlers)
-        }
-        handlers.add(handler)
-        return () => {
-          handlers!.delete(handler)
-        }
-      },
-    }
-  }
-}

package/src/util/scrap.ts

@@ -1,10 +0,0 @@
-export const foo: string = "42"
-export const bar: number = 123
-
-export function dummyFunction(): void {
-  console.log("This is a dummy function")
-}
-
-export function randomHelper(): boolean {
-  return Math.random() > 0.5
-}

package/src/util/signal.ts

@@ -1,12 +0,0 @@
-export function signal() {
-  let resolve: any
-  const promise = new Promise((r) => (resolve = r))
-  return {
-    trigger() {
-      return resolve()
-    },
-    wait() {
-      return promise
-    },
-  }
-}

package/src/util/timeout.ts

@@ -1,14 +0,0 @@
-export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
-  let timeout: NodeJS.Timeout
-  return Promise.race([
-    promise.then((result) => {
-      clearTimeout(timeout)
-      return result
-    }),
-    new Promise<never>((_, reject) => {
-      timeout = setTimeout(() => {
-        reject(new Error(`Operation timed out after ${ms}ms`))
-      }, ms)
-    }),
-  ])
-}

package/src/util/token.ts

@@ -1,7 +0,0 @@
-export namespace Token {
-  const CHARS_PER_TOKEN = 4
-
-  export function estimate(input: string) {
-    return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
-  }
-}

package/src/util/wildcard.ts

@@ -1,56 +0,0 @@
-import { sortBy, pipe } from "remeda"
-
-export namespace Wildcard {
-  export function match(str: string, pattern: string) {
-    let escaped = pattern
-      .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
-      .replace(/\*/g, ".*") // * becomes .*
-      .replace(/\?/g, ".") // ? becomes .
-
-    // If pattern ends with " *" (space + wildcard), make the trailing part optional
-    // This allows "ls *" to match both "ls" and "ls -la"
-    if (escaped.endsWith(" .*")) {
-      escaped = escaped.slice(0, -3) + "( .*)?"
-    }
-
-    return new RegExp("^" + escaped + "$", "s").test(str)
-  }
-
-  export function all(input: string, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
-    for (const [pattern, value] of sorted) {
-      if (match(input, pattern)) {
-        result = value
-        continue
-      }
-    }
-    return result
-  }
-
-  export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
-    for (const [pattern, value] of sorted) {
-      const parts = pattern.split(/\s+/)
-      if (!match(input.head, parts[0])) continue
-      if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
-        result = value
-        continue
-      }
-    }
-    return result
-  }
-
-  function matchSequence(items: string[], patterns: string[]): boolean {
-    if (patterns.length === 0) return true
-    const [pattern, ...rest] = patterns
-    if (pattern === "*") return matchSequence(items, rest)
-    for (let i = 0; i < items.length; i++) {
-      if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
-        return true
-      }
-    }
-    return false
-  }
-}