@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/core/pub-sub.ts

@@ -0,0 +1,126 @@
+export type Payload = unknown
+
+export type Unsubscribe = () => void
+
+export type FlushCallback = (
+  snapshot: Readonly<Record<string, Payload>>,
+) => void
+
+export interface PubSub {
+  publish<T extends Payload>(channel: string, payload: T): void
+  subscribe<T extends Payload>(
+    channel: string,
+    cb: (payload: T) => void,
+  ): Unsubscribe
+  last<T extends Payload>(channel: string): T | undefined
+  snapshot(): Readonly<Record<string, Payload>>
+  setFlushCallback(cb: FlushCallback | null): void
+  flush(): void
+  dispose(): void
+}
+
+const DEFAULT_DEBOUNCE_MS = 100
+
+export interface CreatePubSubOptions {
+  debounceMs?: number
+}
+
+export const createPubSub = (options: CreatePubSubOptions = {}): PubSub => {
+  const { debounceMs = DEFAULT_DEBOUNCE_MS } = options
+
+  const lastPayloads = new Map<string, Payload>()
+  const subscribers = new Map<string, Set<(payload: Payload) => void>>()
+  let flushCallback: FlushCallback | null = null
+  let timer: NodeJS.Timeout | null = null
+  let disposed = false
+
+  const ensureNotDisposed = (): void => {
+    if (disposed) throw new Error("PubSub: cannot use after dispose()")
+  }
+
+  const scheduleFlush = (): void => {
+    if (timer !== null) return
+    timer = setTimeout(() => {
+      timer = null
+      pubSub.flush()
+    }, debounceMs)
+  }
+
+  const flush = (): void => {
+    if (timer !== null) {
+      clearTimeout(timer)
+      timer = null
+    }
+    const result: Record<string, Payload> = {}
+    for (const [key, value] of lastPayloads) result[key] = value
+    const snapshot = Object.freeze(result)
+    if (flushCallback !== null) flushCallback(snapshot)
+  }
+
+  const publish = <T extends Payload>(channel: string, payload: T): void => {
+    ensureNotDisposed()
+    lastPayloads.set(channel, payload)
+    const set = subscribers.get(channel)
+    if (set !== undefined) {
+      for (const cb of set) cb(payload)
+    }
+    scheduleFlush()
+  }
+
+  const subscribe = <T extends Payload>(
+    channel: string,
+    cb: (payload: T) => void,
+  ): Unsubscribe => {
+    ensureNotDisposed()
+    let set = subscribers.get(channel)
+    if (set === undefined) {
+      set = new Set()
+      subscribers.set(channel, set)
+    }
+    set.add(cb as (payload: Payload) => void)
+    return () => {
+      const current = subscribers.get(channel)
+      if (current === undefined) return
+      current.delete(cb as (payload: Payload) => void)
+      if (current.size === 0) subscribers.delete(channel)
+    }
+  }
+
+  const last = <T extends Payload>(channel: string): T | undefined => {
+    return lastPayloads.get(channel) as T | undefined
+  }
+
+  const snapshot = (): Readonly<Record<string, Payload>> => {
+    const result: Record<string, Payload> = {}
+    for (const [key, value] of lastPayloads) result[key] = value
+    return Object.freeze(result)
+  }
+
+  const setFlushCallback = (cb: FlushCallback | null): void => {
+    flushCallback = cb
+  }
+
+  const dispose = (): void => {
+    if (disposed) return
+    disposed = true
+    if (timer !== null) {
+      clearTimeout(timer)
+      timer = null
+    }
+    subscribers.clear()
+    lastPayloads.clear()
+    flushCallback = null
+  }
+
+  const pubSub: PubSub = {
+    publish,
+    subscribe,
+    last,
+    snapshot,
+    setFlushCallback,
+    flush,
+    dispose,
+  }
+
+  return pubSub
+}

package/src/core/settings.ts

@@ -0,0 +1,153 @@
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  writeSync,
+} from "node:fs"
+import { dirname, join } from "node:path"
+import { homedir } from "node:os"
+import { randomBytes } from "node:crypto"
+
+import { z } from "zod"
+import type pino from "pino"
+
+export const settingsSchema = z
+  .object({
+    brightness: z.number().int().min(10).max(100),
+    activeDeck: z.string().min(1),
+  })
+  .strict()
+
+export type Settings = z.infer<typeof settingsSchema>
+
+export const DEFAULT_SETTINGS: Settings = {
+  brightness: 50,
+  activeDeck: "main",
+}
+
+const SETTINGS_DIR = "sirenodeck"
+const SETTINGS_FILE = "settings.json"
+
+const resolveXdgConfigHome = (): string =>
+  process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config")
+
+export const resolveSettingsPath = (): string => {
+  const dir = join(resolveXdgConfigHome(), SETTINGS_DIR)
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  return join(dir, SETTINGS_FILE)
+}
+
+export const loadSettings = (
+  path: string = resolveSettingsPath(),
+  logger?: pino.Logger,
+): Settings => {
+  if (!existsSync(path)) return DEFAULT_SETTINGS
+  let raw: string
+  try {
+    raw = readFileSync(path, "utf8")
+  } catch (err) {
+    logger?.warn({ err, path }, "settings: read failed; using defaults")
+    return DEFAULT_SETTINGS
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch (err) {
+    logger?.warn({ err, path }, "settings: corrupt JSON; using defaults")
+    return DEFAULT_SETTINGS
+  }
+  const result = settingsSchema.safeParse(parsed)
+  if (!result.success) {
+    logger?.warn(
+      { err: result.error.message, path },
+      "settings: schema mismatch; using defaults",
+    )
+    return DEFAULT_SETTINGS
+  }
+  return result.data
+}
+
+export const atomicWriteJson = (path: string, data: unknown): void => {
+  const tmpPath = `${path}.${randomBytes(6).toString("hex")}.tmp`
+  const fd = openSync(tmpPath, "w", 0o600)
+  try {
+    writeSync(fd, JSON.stringify(data, null, 2))
+  } finally {
+    closeSync(fd)
+  }
+  renameSync(tmpPath, path)
+}
+
+const DEBOUNCE_MS = 500
+
+export interface SettingsStore {
+  get(): Settings
+  update(partial: Partial<Settings>): void
+  flush(): void
+  close(): void
+}
+
+export const createSettingsStore = ({
+  path = resolveSettingsPath(),
+  logger,
+  writeJson = atomicWriteJson,
+}: {
+  path?: string
+  logger?: pino.Logger
+  writeJson?: (path: string, data: unknown) => void
+} = {}): SettingsStore => {
+  let current: Settings = loadSettings(path, logger)
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let pending = false
+
+  const writeNow = (): void => {
+    try {
+      writeJson(path, current)
+    } catch (err) {
+      logger?.warn({ err, path }, "settings: write failed")
+    }
+  }
+
+  const schedule = (): void => {
+    pending = true
+    if (timer !== null) return
+    timer = setTimeout(() => {
+      timer = null
+      if (pending) {
+        pending = false
+        writeNow()
+      }
+    }, DEBOUNCE_MS)
+  }
+
+  return {
+    get: () => ({ ...current }),
+    update: (partial) => {
+      current = { ...current, ...partial }
+      schedule()
+    },
+    flush: () => {
+      if (timer !== null) {
+        clearTimeout(timer)
+        timer = null
+      }
+      pending = false
+      writeNow()
+    },
+    close: () => {
+      if (timer !== null) {
+        clearTimeout(timer)
+        timer = null
+      }
+      if (pending) {
+        pending = false
+        writeNow()
+      }
+    },
+  }
+}
+
+void dirname

package/src/core/store.ts

@@ -0,0 +1,88 @@
+export type ScopeKind = "addon" | "button"
+
+export interface Scope<T = unknown> {
+  get(key: string): T | undefined
+  set(key: string, value: T): void
+  update(key: string, fn: (current: T | undefined) => T): T
+  clear(): void
+  snapshot(): Readonly<Record<string, T>>
+}
+
+export interface Store {
+  addonScope<T = unknown>(addonName: string): Scope<T>
+  buttonScope<T = unknown>(addonName: string, buttonId: string): Scope<T>
+  clearAddon(addonName: string): void
+  clearButton(addonName: string, buttonId: string): void
+  clearAll(): void
+}
+
+const buildScope = <T>(bucket: Map<string, T>): Scope<T> => {
+  const get = (key: string): T | undefined => bucket.get(key)
+  const set = (key: string, value: T): void => {
+    bucket.set(key, value)
+  }
+  const update = (key: string, fn: (current: T | undefined) => T): T => {
+    const next = fn(bucket.get(key))
+    bucket.set(key, next)
+    return next
+  }
+  const clear = (): void => {
+    bucket.clear()
+  }
+  const snapshot = (): Readonly<Record<string, T>> => {
+    const result: Record<string, T> = {}
+    for (const [key, value] of bucket) result[key] = value
+    return Object.freeze(result)
+  }
+  return { get, set, update, clear, snapshot }
+}
+
+export const createStore = (): Store => {
+  const addonScopes = new Map<string, Map<string, unknown>>()
+  const buttonScopes = new Map<string, Map<string, Map<string, unknown>>>()
+
+  const addonBucket = (addonName: string): Map<string, unknown> => {
+    let bucket = addonScopes.get(addonName)
+    if (bucket === undefined) {
+      bucket = new Map()
+      addonScopes.set(addonName, bucket)
+    }
+    return bucket
+  }
+
+  const buttonBucket = (
+    addonName: string,
+    buttonId: string,
+  ): Map<string, unknown> => {
+    let addonMap = buttonScopes.get(addonName)
+    if (addonMap === undefined) {
+      addonMap = new Map()
+      buttonScopes.set(addonName, addonMap)
+    }
+    let bucket = addonMap.get(buttonId)
+    if (bucket === undefined) {
+      bucket = new Map()
+      addonMap.set(buttonId, bucket)
+    }
+    return bucket
+  }
+
+  const store: Store = {
+    addonScope: <T = unknown>(addonName: string): Scope<T> =>
+      buildScope<T>(addonBucket(addonName) as Map<string, T>),
+    buttonScope: <T = unknown>(addonName: string, buttonId: string): Scope<T> =>
+      buildScope<T>(buttonBucket(addonName, buttonId) as Map<string, T>),
+    clearAddon: (addonName: string) => {
+      addonScopes.delete(addonName)
+    },
+    clearButton: (addonName: string, buttonId: string) => {
+      buttonScopes.get(addonName)?.delete(buttonId)
+    },
+    clearAll: () => {
+      addonScopes.clear()
+      buttonScopes.clear()
+    },
+  }
+
+  return store
+}

package/src/core/watcher.ts

@@ -0,0 +1,73 @@
+import chokidar, { type FSWatcher } from "chokidar"
+
+export type WatchEvent = "add" | "change" | "unlink" | "ready" | "error"
+
+export interface WatcherEventHandlers {
+  onChange?: (path: string) => void
+  onUnlink?: (path: string) => void
+  onReady?: () => void
+  onError?: (error: Error) => void
+}
+
+export interface WatchOptions {
+  ignoreInitial?: boolean
+  awaitWriteFinish?:
+    | boolean
+    | { stabilityThreshold?: number; pollInterval?: number }
+  ignored?: ReadonlyArray<string | RegExp>
+}
+
+const defaultIgnored = [/node_modules/, /\.git/, /dist/]
+
+export class ConfigWatcher {
+  private readonly targets: string[]
+  private watcher: FSWatcher | null = null
+  private handlers: WatcherEventHandlers
+
+  constructor(targets: string[], handlers: WatcherEventHandlers = {}) {
+    this.targets = targets
+    this.handlers = handlers
+  }
+
+  async start(options: WatchOptions = {}): Promise<void> {
+    if (this.watcher) return
+    const watcher = chokidar.watch(this.targets, {
+      ignoreInitial: options.ignoreInitial ?? true,
+      awaitWriteFinish: options.awaitWriteFinish ?? {
+        stabilityThreshold: 100,
+        pollInterval: 25,
+      },
+      ignored: options.ignored
+        ? [...options.ignored, ...defaultIgnored]
+        : defaultIgnored,
+      persistent: true,
+    })
+    this.watcher = watcher
+
+    watcher.on("add", (p) => this.handlers.onChange?.(p))
+    watcher.on("change", (p) => this.handlers.onChange?.(p))
+    watcher.on("unlink", (p) => this.handlers.onUnlink?.(p))
+    watcher.on("error", (err: unknown) =>
+      this.handlers.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+      ),
+    )
+    await new Promise<void>((resolve) => {
+      watcher.once("ready", () => {
+        this.handlers.onReady?.()
+        resolve()
+      })
+    })
+  }
+
+  setHandlers(handlers: WatcherEventHandlers): void {
+    this.handlers = handlers
+  }
+
+  async close(): Promise<void> {
+    if (!this.watcher) return
+    const w = this.watcher
+    this.watcher = null
+    await w.close()
+  }
+}