@nikcli-ai/app 0.0.6

package/src/context/language.tsx

@@ -0,0 +1,226 @@
+import * as i18n from "@solid-primitives/i18n"
+import { createEffect, createMemo } from "solid-js"
+import { createStore } from "solid-js/store"
+import { createSimpleContext } from "@nikcli-ai/ui/context"
+import { Persist, persisted } from "@/utils/persist"
+import { dict as en } from "@/i18n/en"
+import { dict as zh } from "@/i18n/zh"
+import { dict as zht } from "@/i18n/zht"
+import { dict as ko } from "@/i18n/ko"
+import { dict as de } from "@/i18n/de"
+import { dict as es } from "@/i18n/es"
+import { dict as fr } from "@/i18n/fr"
+import { dict as da } from "@/i18n/da"
+import { dict as ja } from "@/i18n/ja"
+import { dict as pl } from "@/i18n/pl"
+import { dict as ru } from "@/i18n/ru"
+import { dict as ar } from "@/i18n/ar"
+import { dict as no } from "@/i18n/no"
+import { dict as br } from "@/i18n/br"
+import { dict as th } from "@/i18n/th"
+import { dict as bs } from "@/i18n/bs"
+import { dict as uiEn } from "@nikcli-ai/ui/i18n/en"
+import { dict as uiZh } from "@nikcli-ai/ui/i18n/zh"
+import { dict as uiZht } from "@nikcli-ai/ui/i18n/zht"
+import { dict as uiKo } from "@nikcli-ai/ui/i18n/ko"
+import { dict as uiDe } from "@nikcli-ai/ui/i18n/de"
+import { dict as uiEs } from "@nikcli-ai/ui/i18n/es"
+import { dict as uiFr } from "@nikcli-ai/ui/i18n/fr"
+import { dict as uiDa } from "@nikcli-ai/ui/i18n/da"
+import { dict as uiJa } from "@nikcli-ai/ui/i18n/ja"
+import { dict as uiPl } from "@nikcli-ai/ui/i18n/pl"
+import { dict as uiRu } from "@nikcli-ai/ui/i18n/ru"
+import { dict as uiAr } from "@nikcli-ai/ui/i18n/ar"
+import { dict as uiNo } from "@nikcli-ai/ui/i18n/no"
+import { dict as uiBr } from "@nikcli-ai/ui/i18n/br"
+import { dict as uiTh } from "@nikcli-ai/ui/i18n/th"
+import { dict as uiBs } from "@nikcli-ai/ui/i18n/bs"
+
+export type Locale =
+  | "en"
+  | "zh"
+  | "zht"
+  | "ko"
+  | "de"
+  | "es"
+  | "fr"
+  | "da"
+  | "ja"
+  | "pl"
+  | "ru"
+  | "ar"
+  | "no"
+  | "br"
+  | "th"
+  | "bs"
+
+type RawDictionary = typeof en & typeof uiEn
+type Dictionary = i18n.Flatten<RawDictionary>
+
+const LOCALES: readonly Locale[] = [
+  "en",
+  "zh",
+  "zht",
+  "ko",
+  "de",
+  "es",
+  "fr",
+  "da",
+  "ja",
+  "pl",
+  "ru",
+  "bs",
+  "ar",
+  "no",
+  "br",
+  "th",
+]
+
+type ParityKey = "command.session.previous.unseen" | "command.session.next.unseen"
+const PARITY_CHECK: Record<Exclude<Locale, "en">, Record<ParityKey, string>> = {
+  zh,
+  zht,
+  ko,
+  de,
+  es,
+  fr,
+  da,
+  ja,
+  pl,
+  ru,
+  ar,
+  no,
+  br,
+  th,
+  bs,
+}
+void PARITY_CHECK
+
+function detectLocale(): Locale {
+  if (typeof navigator !== "object") return "en"
+
+  const languages = navigator.languages?.length ? navigator.languages : [navigator.language]
+  for (const language of languages) {
+    if (!language) continue
+    if (language.toLowerCase().startsWith("zh")) {
+      if (language.toLowerCase().includes("hant")) return "zht"
+      return "zh"
+    }
+    if (language.toLowerCase().startsWith("ko")) return "ko"
+    if (language.toLowerCase().startsWith("de")) return "de"
+    if (language.toLowerCase().startsWith("es")) return "es"
+    if (language.toLowerCase().startsWith("fr")) return "fr"
+    if (language.toLowerCase().startsWith("da")) return "da"
+    if (language.toLowerCase().startsWith("ja")) return "ja"
+    if (language.toLowerCase().startsWith("pl")) return "pl"
+    if (language.toLowerCase().startsWith("ru")) return "ru"
+    if (language.toLowerCase().startsWith("ar")) return "ar"
+    if (
+      language.toLowerCase().startsWith("no") ||
+      language.toLowerCase().startsWith("nb") ||
+      language.toLowerCase().startsWith("nn")
+    )
+      return "no"
+    if (language.toLowerCase().startsWith("pt")) return "br"
+    if (language.toLowerCase().startsWith("th")) return "th"
+    if (language.toLowerCase().startsWith("bs")) return "bs"
+  }
+
+  return "en"
+}
+
+export const { use: useLanguage, provider: LanguageProvider } = createSimpleContext({
+  name: "Language",
+  init: () => {
+    const [store, setStore, _, ready] = persisted(
+      Persist.global("language", ["language.v1"]),
+      createStore({
+        locale: detectLocale() as Locale,
+      }),
+    )
+
+    const locale = createMemo<Locale>(() => {
+      if (store.locale === "zh") return "zh"
+      if (store.locale === "zht") return "zht"
+      if (store.locale === "ko") return "ko"
+      if (store.locale === "de") return "de"
+      if (store.locale === "es") return "es"
+      if (store.locale === "fr") return "fr"
+      if (store.locale === "da") return "da"
+      if (store.locale === "ja") return "ja"
+      if (store.locale === "pl") return "pl"
+      if (store.locale === "ru") return "ru"
+      if (store.locale === "ar") return "ar"
+      if (store.locale === "no") return "no"
+      if (store.locale === "br") return "br"
+      if (store.locale === "th") return "th"
+      if (store.locale === "bs") return "bs"
+      return "en"
+    })
+
+    createEffect(() => {
+      const current = locale()
+      if (store.locale === current) return
+      setStore("locale", current)
+    })
+
+    const base = i18n.flatten({ ...en, ...uiEn })
+    const dict = createMemo<Dictionary>(() => {
+      if (locale() === "en") return base
+      if (locale() === "zh") return { ...base, ...i18n.flatten({ ...zh, ...uiZh }) }
+      if (locale() === "zht") return { ...base, ...i18n.flatten({ ...zht, ...uiZht }) }
+      if (locale() === "de") return { ...base, ...i18n.flatten({ ...de, ...uiDe }) }
+      if (locale() === "es") return { ...base, ...i18n.flatten({ ...es, ...uiEs }) }
+      if (locale() === "fr") return { ...base, ...i18n.flatten({ ...fr, ...uiFr }) }
+      if (locale() === "da") return { ...base, ...i18n.flatten({ ...da, ...uiDa }) }
+      if (locale() === "ja") return { ...base, ...i18n.flatten({ ...ja, ...uiJa }) }
+      if (locale() === "pl") return { ...base, ...i18n.flatten({ ...pl, ...uiPl }) }
+      if (locale() === "ru") return { ...base, ...i18n.flatten({ ...ru, ...uiRu }) }
+      if (locale() === "ar") return { ...base, ...i18n.flatten({ ...ar, ...uiAr }) }
+      if (locale() === "no") return { ...base, ...i18n.flatten({ ...no, ...uiNo }) }
+      if (locale() === "br") return { ...base, ...i18n.flatten({ ...br, ...uiBr }) }
+      if (locale() === "th") return { ...base, ...i18n.flatten({ ...th, ...uiTh }) }
+      if (locale() === "bs") return { ...base, ...i18n.flatten({ ...bs, ...uiBs }) }
+      return { ...base, ...i18n.flatten({ ...ko, ...uiKo }) }
+    })
+
+    const t = i18n.translator(dict, i18n.resolveTemplate)
+
+    const labelKey: Record<Locale, keyof Dictionary> = {
+      en: "language.en",
+      zh: "language.zh",
+      zht: "language.zht",
+      ko: "language.ko",
+      de: "language.de",
+      es: "language.es",
+      fr: "language.fr",
+      da: "language.da",
+      ja: "language.ja",
+      pl: "language.pl",
+      ru: "language.ru",
+      ar: "language.ar",
+      no: "language.no",
+      br: "language.br",
+      th: "language.th",
+      bs: "language.bs",
+    }
+
+    const label = (value: Locale) => t(labelKey[value])
+
+    createEffect(() => {
+      if (typeof document !== "object") return
+      document.documentElement.lang = locale()
+    })
+
+    return {
+      ready,
+      locale,
+      locales: LOCALES,
+      label,
+      t,
+      setLocale(next: Locale) {
+        setStore("locale", next)
+      },
+    }
+  },
+})

package/src/context/layout-scroll.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+import { createScrollPersistence } from "./layout-scroll"
+
+describe("createScrollPersistence", () => {
+  test("debounces persisted scroll writes", async () => {
+    const snapshot = {
+      session: {
+        review: { x: 0, y: 0 },
+      },
+    } as Record<string, Record<string, { x: number; y: number }>>
+    const writes: Array<Record<string, { x: number; y: number }>> = []
+    const scroll = createScrollPersistence({
+      debounceMs: 10,
+      getSnapshot: (sessionKey) => snapshot[sessionKey],
+      onFlush: (sessionKey, next) => {
+        snapshot[sessionKey] = next
+        writes.push(next)
+      },
+    })
+
+    for (const i of Array.from({ length: 30 }, (_, n) => n + 1)) {
+      scroll.setScroll("session", "review", { x: 0, y: i })
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 40))
+
+    expect(writes).toHaveLength(1)
+    expect(writes[0]?.review).toEqual({ x: 0, y: 30 })
+
+    scroll.setScroll("session", "review", { x: 0, y: 30 })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(writes).toHaveLength(1)
+    scroll.dispose()
+  })
+})

package/src/context/layout-scroll.ts

@@ -0,0 +1,118 @@
+import { createStore, produce } from "solid-js/store"
+
+export type SessionScroll = {
+  x: number
+  y: number
+}
+
+type ScrollMap = Record<string, SessionScroll>
+
+type Options = {
+  debounceMs?: number
+  getSnapshot: (sessionKey: string) => ScrollMap | undefined
+  onFlush: (sessionKey: string, scroll: ScrollMap) => void
+}
+
+export function createScrollPersistence(opts: Options) {
+  const wait = opts.debounceMs ?? 200
+  const [cache, setCache] = createStore<Record<string, ScrollMap>>({})
+  const dirty = new Set<string>()
+  const timers = new Map<string, ReturnType<typeof setTimeout>>()
+
+  function clone(input?: ScrollMap) {
+    const out: ScrollMap = {}
+    if (!input) return out
+
+    for (const key of Object.keys(input)) {
+      const pos = input[key]
+      if (!pos) continue
+      out[key] = { x: pos.x, y: pos.y }
+    }
+
+    return out
+  }
+
+  function seed(sessionKey: string) {
+    if (cache[sessionKey]) return
+    setCache(sessionKey, clone(opts.getSnapshot(sessionKey)))
+  }
+
+  function scroll(sessionKey: string, tab: string) {
+    seed(sessionKey)
+    return cache[sessionKey]?.[tab] ?? opts.getSnapshot(sessionKey)?.[tab]
+  }
+
+  function schedule(sessionKey: string) {
+    const prev = timers.get(sessionKey)
+    if (prev) clearTimeout(prev)
+    timers.set(
+      sessionKey,
+      setTimeout(() => flush(sessionKey), wait),
+    )
+  }
+
+  function setScroll(sessionKey: string, tab: string, pos: SessionScroll) {
+    seed(sessionKey)
+
+    const prev = cache[sessionKey]?.[tab]
+    if (prev?.x === pos.x && prev?.y === pos.y) return
+
+    setCache(sessionKey, tab, { x: pos.x, y: pos.y })
+    dirty.add(sessionKey)
+    schedule(sessionKey)
+  }
+
+  function flush(sessionKey: string) {
+    const timer = timers.get(sessionKey)
+    if (timer) clearTimeout(timer)
+    timers.delete(sessionKey)
+
+    if (!dirty.has(sessionKey)) return
+    dirty.delete(sessionKey)
+
+    opts.onFlush(sessionKey, clone(cache[sessionKey]))
+  }
+
+  function flushAll() {
+    const keys = Array.from(dirty)
+    if (keys.length === 0) return
+
+    for (const key of keys) {
+      flush(key)
+    }
+  }
+
+  function drop(keys: string[]) {
+    if (keys.length === 0) return
+
+    for (const key of keys) {
+      const timer = timers.get(key)
+      if (timer) clearTimeout(timer)
+      timers.delete(key)
+      dirty.delete(key)
+    }
+
+    setCache(
+      produce((draft) => {
+        for (const key of keys) {
+          delete draft[key]
+        }
+      }),
+    )
+  }
+
+  function dispose() {
+    drop(Array.from(timers.keys()))
+  }
+
+  return {
+    cache,
+    drop,
+    flush,
+    flushAll,
+    scroll,
+    seed,
+    setScroll,
+    dispose,
+  }
+}

package/src/context/layout.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test"
+import { createRoot, createSignal } from "solid-js"
+import { createSessionKeyReader, ensureSessionKey, pruneSessionKeys } from "./layout"
+
+describe("layout session-key helpers", () => {
+  test("couples touch and scroll seed in order", () => {
+    const calls: string[] = []
+    const result = ensureSessionKey(
+      "dir/a",
+      (key) => calls.push(`touch:${key}`),
+      (key) => calls.push(`seed:${key}`),
+    )
+
+    expect(result).toBe("dir/a")
+    expect(calls).toEqual(["touch:dir/a", "seed:dir/a"])
+  })
+
+  test("reads dynamic accessor keys lazily", () => {
+    const seen: string[] = []
+
+    createRoot((dispose) => {
+      const [key, setKey] = createSignal("dir/one")
+      const read = createSessionKeyReader(key, (value) => seen.push(value))
+
+      expect(read()).toBe("dir/one")
+      setKey("dir/two")
+      expect(read()).toBe("dir/two")
+
+      dispose()
+    })
+
+    expect(seen).toEqual(["dir/one", "dir/two"])
+  })
+})
+
+describe("pruneSessionKeys", () => {
+  test("keeps active key and drops lowest-used keys", () => {
+    const drop = pruneSessionKeys({
+      keep: "k4",
+      max: 3,
+      used: new Map([
+        ["k1", 1],
+        ["k2", 2],
+        ["k3", 3],
+        ["k4", 4],
+      ]),
+      view: ["k1", "k2", "k4"],
+      tabs: ["k1", "k3", "k4"],
+    })
+
+    expect(drop).toEqual(["k1"])
+    expect(drop.includes("k4")).toBe(false)
+  })
+
+  test("does not prune without keep key", () => {
+    const drop = pruneSessionKeys({
+      keep: undefined,
+      max: 1,
+      used: new Map([
+        ["k1", 1],
+        ["k2", 2],
+      ]),
+      view: ["k1"],
+      tabs: ["k2"],
+    })
+
+    expect(drop).toEqual([])
+  })
+})