@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/ui/theme-presentation-builder.ts

@@ -0,0 +1,184 @@
+import type { ThemeUiPresentation, ThemeOverrideContext } from "@/ui"
+import { labelBase } from "./primitives/Label"
+import { textBase } from "./primitives/Text"
+import { iconBase } from "./primitives/Icon"
+import { chipBase } from "./primitives/Chip"
+import { tapIndicatorBase } from "./primitives/TapIndicator"
+import { progressBarBase } from "./primitives/ProgressBar"
+import { iconLabelSurfaceBase } from "./surfaces/IconLabelSurface"
+import { iconLabelProgressSurfaceBase } from "./surfaces/IconLabelProgressSurface"
+import { barsSurfaceBase } from "./surfaces/BarsSurface"
+import { splitActionSurfaceBase } from "./surfaces/SplitActionSurface"
+import { labelValueListSurfaceBase } from "./surfaces/LabelValueListSurface"
+import { temporaryErrorSurfaceBase } from "./surfaces/TemporaryErrorSurface"
+import { valueChartBase } from "./surfaces/ValueChart"
+import { paginatedSurfaceBase } from "./surfaces/PaginatedSurface"
+import { buttonFrameBase } from "./ButtonFrame"
+
+interface UiOverridesModule {
+  components?: { ButtonFrame?: ThemeUiPresentation["buttonFrame"] }
+  surfaces?: ThemeUiPresentation["surfaces"]
+  primitives?: ThemeUiPresentation["primitives"]
+}
+
+/**
+ * Build a ThemeUiPresentation from a ui-overrides module. Returns undefined
+ * when the module has no overrides so the provider can stay free of extra
+ * context. Used by both `frontend/src/App.tsx` and `config-ui/src/App.tsx`
+ * so changes to the override contract stay in one place.
+ */
+export const buildPresentation = (
+  uiOverrides: unknown,
+): ThemeUiPresentation | undefined => {
+  if (uiOverrides === null || uiOverrides === undefined) return undefined
+  const overrides = uiOverrides as UiOverridesModule
+  const components = overrides.components
+  const surfaces = overrides.surfaces
+  const primitives = overrides.primitives
+  if (!components?.ButtonFrame && !surfaces && !primitives) return undefined
+
+  const wrappedPrimitives = primitives
+    ? {
+        ...(primitives.chip
+          ? {
+              chip: (
+                props: Parameters<typeof chipBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => primitives.chip!(props, ctx, chipBase),
+            }
+          : {}),
+        ...(primitives.icon
+          ? {
+              icon: (
+                props: Parameters<typeof iconBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => primitives.icon!(props, ctx, iconBase),
+            }
+          : {}),
+        ...(primitives.text
+          ? {
+              text: (
+                props: Parameters<typeof textBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => primitives.text!(props, ctx, textBase),
+            }
+          : {}),
+        ...(primitives.label
+          ? {
+              label: (
+                props: Parameters<typeof labelBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => primitives.label!(props, ctx, labelBase),
+            }
+          : {}),
+        ...(primitives.tapIndicator
+          ? {
+              tapIndicator: (
+                props: Parameters<typeof tapIndicatorBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => primitives.tapIndicator!(props, ctx, tapIndicatorBase),
+            }
+          : {}),
+        ...(primitives.progressBar
+          ? {
+              progressBar: (
+                props: Parameters<typeof progressBarBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => primitives.progressBar!(props, ctx, progressBarBase),
+            }
+          : {}),
+      }
+    : undefined
+
+  const wrappedSurfaces = surfaces
+    ? {
+        ...(surfaces.iconLabel
+          ? {
+              iconLabel: (
+                props: Parameters<typeof iconLabelSurfaceBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => surfaces.iconLabel!(props, ctx, iconLabelSurfaceBase),
+            }
+          : {}),
+        ...(surfaces.iconLabelProgress
+          ? {
+              iconLabelProgress: (
+                props: Parameters<typeof iconLabelProgressSurfaceBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) =>
+                surfaces.iconLabelProgress!(
+                  props,
+                  ctx,
+                  iconLabelProgressSurfaceBase,
+                ),
+            }
+          : {}),
+        ...(surfaces.bars
+          ? {
+              bars: (
+                props: Parameters<typeof barsSurfaceBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => surfaces.bars!(props, ctx, barsSurfaceBase),
+            }
+          : {}),
+        ...(surfaces.splitAction
+          ? {
+              splitAction: (
+                props: Parameters<typeof splitActionSurfaceBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => surfaces.splitAction!(props, ctx, splitActionSurfaceBase),
+            }
+          : {}),
+        ...(surfaces.labelValueList
+          ? {
+              labelValueList: (
+                props: Parameters<typeof labelValueListSurfaceBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) =>
+                surfaces.labelValueList!(props, ctx, labelValueListSurfaceBase),
+            }
+          : {}),
+        ...(surfaces.temporaryError
+          ? {
+              temporaryError: (
+                props: Parameters<typeof temporaryErrorSurfaceBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) =>
+                surfaces.temporaryError!(props, ctx, temporaryErrorSurfaceBase),
+            }
+          : {}),
+        ...(surfaces.valueChart
+          ? {
+              valueChart: (
+                props: Parameters<typeof valueChartBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => surfaces.valueChart!(props, ctx, valueChartBase),
+            }
+          : {}),
+        ...(surfaces.paginated
+          ? {
+              paginated: (
+                props: Parameters<typeof paginatedSurfaceBase>[0],
+                ctx?: ThemeOverrideContext,
+              ) => surfaces.paginated!(props, ctx, paginatedSurfaceBase),
+            }
+          : {}),
+      }
+    : undefined
+
+  const wrappedButtonFrame = components?.ButtonFrame
+    ? (
+        props: Parameters<typeof buttonFrameBase>[0],
+        ctx?: ThemeOverrideContext,
+      ) => components.ButtonFrame!(props, ctx, buttonFrameBase)
+    : undefined
+
+  if (!wrappedButtonFrame && !wrappedSurfaces && !wrappedPrimitives)
+    return undefined
+
+  return {
+    ...(wrappedButtonFrame ? { buttonFrame: wrappedButtonFrame } : {}),
+    ...(wrappedSurfaces ? { surfaces: wrappedSurfaces } : {}),
+    ...(wrappedPrimitives ? { primitives: wrappedPrimitives } : {}),
+  }
+}

package/src/ui/theme-presentation.tsx

@@ -0,0 +1,146 @@
+import {
+  createContext,
+  createElement,
+  useContext,
+  type ReactElement,
+} from "react"
+import { ButtonFrameProps } from "./ButtonFrame"
+import {
+  ChipProps,
+  IconProps,
+  LabelProps,
+  ProgressBarProps,
+  TapIndicatorProps,
+  TextProps,
+} from "./primitives"
+import {
+  BarsProps,
+  IconLabelProgressSurfaceProps,
+  IconLabelSurfaceProps,
+  LabelValueListProps,
+  PaginatedSurfaceProps,
+  SplitActionSurfaceProps,
+  TemporaryErrorSurfaceProps,
+  ValueChartProps,
+} from "./surfaces"
+
+/**
+ * Theme context passed to every override fn as the second argument. Lets
+ * override code read sibling tokens (`ctx.tokens.primary`) without reaching
+ * across the DOM/CSS to parse a CSS variable. Optional — pre-existing
+ * 1-arg overrides keep working.
+ */
+export interface ThemeOverrideContext {
+  name: string
+  colorTokens: Readonly<Record<string, string>> | null
+  typography: Readonly<Record<string, unknown>> | null
+}
+
+export interface ThemeUiPresentation {
+  buttonFrame?: (
+    props: ButtonFrameProps,
+    ctx?: ThemeOverrideContext,
+    base?: (props: ButtonFrameProps) => ReactElement,
+  ) => ReactElement
+  /**
+   * Optional deck-chrome background hook. Themes can paint a full-deck
+   * background (e.g. a perspective grid) behind the tiles without
+   * needing core-deck patches. Receives the default `className` and
+   * returns any extra classes to merge in. Returning undefined is a
+   * no-op (default behavior).
+   */
+  deckBackground?: (props: { className: string }) => string | undefined
+  primitives?: {
+    chip?: (
+      props: ChipProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: ChipProps) => ReactElement,
+    ) => ReactElement
+    icon?: (
+      props: IconProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: IconProps) => ReactElement,
+    ) => ReactElement
+    text?: (
+      props: TextProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: TextProps) => ReactElement,
+    ) => ReactElement
+    label?: (
+      props: LabelProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: LabelProps) => ReactElement,
+    ) => ReactElement
+    tapIndicator?: (
+      props: TapIndicatorProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: TapIndicatorProps) => ReactElement,
+    ) => ReactElement
+    progressBar?: (
+      props: ProgressBarProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: ProgressBarProps) => ReactElement,
+    ) => ReactElement
+  }
+  surfaces?: {
+    iconLabel?: (
+      props: IconLabelSurfaceProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: IconLabelSurfaceProps) => ReactElement,
+    ) => ReactElement
+    iconLabelProgress?: (
+      props: IconLabelProgressSurfaceProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: IconLabelProgressSurfaceProps) => ReactElement,
+    ) => ReactElement
+    bars?: (
+      props: BarsProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: BarsProps) => ReactElement,
+    ) => ReactElement
+    splitAction?: (
+      props: SplitActionSurfaceProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: SplitActionSurfaceProps) => ReactElement,
+    ) => ReactElement
+    labelValueList?: (
+      props: LabelValueListProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: LabelValueListProps) => ReactElement,
+    ) => ReactElement
+    temporaryError?: (
+      props: TemporaryErrorSurfaceProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: TemporaryErrorSurfaceProps) => ReactElement,
+    ) => ReactElement
+    valueChart?: (
+      props: ValueChartProps,
+      ctx?: ThemeOverrideContext,
+      base?: (props: ValueChartProps) => ReactElement,
+    ) => ReactElement
+    paginated?: (
+      props: PaginatedSurfaceProps<unknown>,
+      ctx?: ThemeOverrideContext,
+      base?: (props: PaginatedSurfaceProps<unknown>) => ReactElement,
+    ) => ReactElement
+  }
+}
+
+const ThemeUiPresentationContext = createContext<
+  ThemeUiPresentation | undefined
+>(undefined)
+
+export function ThemeUiPresentationProvider(props: {
+  children: ReactElement
+  presentation?: ThemeUiPresentation
+}): ReactElement {
+  return createElement(
+    ThemeUiPresentationContext.Provider,
+    { value: props.presentation },
+    props.children,
+  )
+}
+
+export function useThemeUiPresentation(): ThemeUiPresentation | undefined {
+  return useContext(ThemeUiPresentationContext)
+}

package/src/ui/utils/cn.ts

@@ -0,0 +1,12 @@
+export const cn = (
+  ...inputs: (
+    | string
+    | boolean
+    | null
+    | undefined
+    | (string | boolean | null | undefined)[]
+  )[]
+): string => {
+  const resolved = Array.isArray(inputs[0]) ? inputs[0] : inputs
+  return resolved.filter(Boolean).join(" ")
+}

package/src/util/cache-paths.ts

@@ -0,0 +1,38 @@
+import { mkdirSync } from "node:fs"
+import { existsSync } from "node:fs"
+import { homedir, tmpdir } from "node:os"
+import { join } from "node:path"
+import { platform } from "node:process"
+
+const CACHE_NAME = "sirenodeck"
+
+const defaultCacheDir = (): string => {
+  const xdgCache = process.env["XDG_CACHE_HOME"]
+  if (xdgCache && xdgCache.length > 0) return join(xdgCache, CACHE_NAME)
+
+  switch (platform) {
+    case "darwin":
+      return join(homedir(), "Library", "Caches", CACHE_NAME)
+    case "win32":
+      return join(process.env["LOCALAPPDATA"] ?? tmpdir(), CACHE_NAME, "Cache")
+    default:
+      return join(homedir(), ".cache", CACHE_NAME)
+  }
+}
+
+export const resolveAddonCacheDir = (): string => {
+  const dir = defaultCacheDir()
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+  return dir
+}
+
+export const addonNpmRoot = (
+  cacheDir: string = resolveAddonCacheDir(),
+): string => join(cacheDir, "node_modules")
+
+export const addonNpmInstallPath = (
+  packageName: string,
+  cacheDir: string = resolveAddonCacheDir(),
+): string => join(addonNpmRoot(cacheDir), packageName)

package/src/util/config-diff.ts

@@ -0,0 +1,16 @@
+import type { RawConfig } from "@/config/schemas"
+import {
+  configChanged as allConfigChanged,
+  decksChanged,
+} from "@/config/config-diff"
+
+export const onlyDecksChanged = (prev: RawConfig, next: RawConfig): boolean => {
+  return (
+    decksChanged(prev, next) &&
+    JSON.stringify({ ...prev, decks: undefined }) ===
+      JSON.stringify({ ...next, decks: undefined })
+  )
+}
+
+export const configChanged = (prev: RawConfig, next: RawConfig): boolean =>
+  allConfigChanged(prev, next)

package/src/util/daemon-control.ts

@@ -0,0 +1,85 @@
+import { connect, createServer, type Server } from "node:net"
+
+import { existsSync, unlinkSync } from "node:fs"
+
+import type pino from "pino"
+
+import type { DaemonPaths } from "./daemon"
+import { isSocketLive } from "./single-instance"
+
+const GET_TOKEN = "get-token\n"
+
+/**
+ * ponytail: the stale-socket clear used to be unconditional, which quietly took
+ * the socket away from a daemon that was still serving it — the second daemon
+ * got a working control socket while the first was left owning a path that no
+ * longer referred to its listener. Whether a path is free is the kernel's to
+ * say, so ask it: only a socket nothing answers on is cleared, and a genuine
+ * EADDRINUSE surfaces as a rejection instead of being worked around.
+ */
+export const startDaemonControl = async (
+  token: string,
+  paths: DaemonPaths,
+  logger: pino.Logger,
+): Promise<Server> => {
+  if (
+    existsSync(paths.controlSocket) &&
+    !(await isSocketLive(paths.controlSocket))
+  ) {
+    unlinkSync(paths.controlSocket)
+  }
+  return new Promise((resolve, reject) => {
+    const server = createServer((socket) => {
+      socket.setEncoding("utf8")
+      socket.on("data", (data) => {
+        if (String(data).trim() === "get-token") socket.end(`${token}\n`)
+        else socket.destroy()
+      })
+    })
+    server.once("error", reject)
+    server.listen(paths.controlSocket, () => {
+      server.off("error", reject)
+      logger.debug("daemon control socket started")
+      resolve(server)
+    })
+  })
+}
+
+export const requestDaemonToken = (
+  paths: DaemonPaths,
+  timeoutMs = 1_000,
+): Promise<string | null> =>
+  new Promise((resolve) => {
+    if (!existsSync(paths.controlSocket)) {
+      resolve(null)
+      return
+    }
+    const socket = connect(paths.controlSocket)
+    let data = ""
+    let settled = false
+    const finish = (token: string | null): void => {
+      if (settled) return
+      settled = true
+      socket.destroy()
+      resolve(token)
+    }
+    const timer = setTimeout(() => finish(null), timeoutMs)
+    socket.setEncoding("utf8")
+    socket.on("data", (chunk) => {
+      data += chunk
+      if (data.includes("\n")) {
+        clearTimeout(timer)
+        const token = data.split("\n", 1)[0]?.trim() ?? ""
+        finish(token.length > 0 ? token : null)
+      }
+    })
+    socket.on("error", () => {
+      clearTimeout(timer)
+      finish(null)
+    })
+    socket.on("connect", () => socket.write(GET_TOKEN))
+  })
+
+export const removeDaemonControl = (paths: DaemonPaths): void => {
+  if (existsSync(paths.controlSocket)) unlinkSync(paths.controlSocket)
+}