@celestia-island/hikari 0.4.4 → 0.4.5

package/src/composables/highlightLanguages.ts

@@ -0,0 +1,109 @@
+// Static map of highlight.js language id → lazy dynamic import.
+//
+// Each entry is a LITERAL `import("highlight.js/lib/languages/<id>")` so Vite
+// emits it as its own chunk, fetched only when a code block actually requests
+// that language. A variable dynamic import (`import(`...languages/${name}`)`)
+// does NOT get bundled by Vite for node_modules, so the map must be explicit.
+//
+// Covers the languages encountered in practice; anything not listed falls
+// back to plaintext (per "没加载就是保持不变色"). Extend freely — each added
+// entry is just one more on-demand chunk.
+
+import type { LanguageFn } from "highlight.js";
+
+type Loader = () => Promise<{ default: LanguageFn }>;
+
+export const LANGUAGE_LOADERS: Record<string, Loader> = {
+  // ── general-purpose programming ──
+  javascript: () => import("highlight.js/lib/languages/javascript"),
+  typescript: () => import("highlight.js/lib/languages/typescript"),
+  python: () => import("highlight.js/lib/languages/python"),
+  pythonRepl: () => import("highlight.js/lib/languages/python-repl"),
+  java: () => import("highlight.js/lib/languages/java"),
+  kotlin: () => import("highlight.js/lib/languages/kotlin"),
+  scala: () => import("highlight.js/lib/languages/scala"),
+  groovy: () => import("highlight.js/lib/languages/groovy"),
+  c: () => import("highlight.js/lib/languages/c"),
+  cpp: () => import("highlight.js/lib/languages/cpp"),
+  csharp: () => import("highlight.js/lib/languages/csharp"),
+  fsharp: () => import("highlight.js/lib/languages/fsharp"),
+  go: () => import("highlight.js/lib/languages/go"),
+  rust: () => import("highlight.js/lib/languages/rust"),
+  ruby: () => import("highlight.js/lib/languages/ruby"),
+  php: () => import("highlight.js/lib/languages/php"),
+  swift: () => import("highlight.js/lib/languages/swift"),
+  objectivec: () => import("highlight.js/lib/languages/objectivec"),
+  dart: () => import("highlight.js/lib/languages/dart"),
+  elixir: () => import("highlight.js/lib/languages/elixir"),
+  erlang: () => import("highlight.js/lib/languages/erlang"),
+  clojure: () => import("highlight.js/lib/languages/clojure"),
+  lisp: () => import("highlight.js/lib/languages/lisp"),
+  scheme: () => import("highlight.js/lib/languages/scheme"),
+  haskell: () => import("highlight.js/lib/languages/haskell"),
+  elm: () => import("highlight.js/lib/languages/elm"),
+  lua: () => import("highlight.js/lib/languages/lua"),
+  perl: () => import("highlight.js/lib/languages/perl"),
+  r: () => import("highlight.js/lib/languages/r"),
+  matlab: () => import("highlight.js/lib/languages/matlab"),
+  julia: () => import("highlight.js/lib/languages/julia"),
+  nim: () => import("highlight.js/lib/languages/nim"),
+  crystal: () => import("highlight.js/lib/languages/crystal"),
+  ocaml: () => import("highlight.js/lib/languages/ocaml"),
+  vbnet: () => import("highlight.js/lib/languages/vbnet"),
+  delphi: () => import("highlight.js/lib/languages/delphi"),
+  basic: () => import("highlight.js/lib/languages/basic"),
+  fortran: () => import("highlight.js/lib/languages/fortran"),
+  coffeescript: () => import("highlight.js/lib/languages/coffeescript"),
+  livescript: () => import("highlight.js/lib/languages/livescript"),
+
+  // ── web / markup / templating ──
+  xml: () => import("highlight.js/lib/languages/xml"),
+  css: () => import("highlight.js/lib/languages/css"),
+  scss: () => import("highlight.js/lib/languages/scss"),
+  less: () => import("highlight.js/lib/languages/less"),
+  json: () => import("highlight.js/lib/languages/json"),
+  yaml: () => import("highlight.js/lib/languages/yaml"),
+  markdown: () => import("highlight.js/lib/languages/markdown"),
+  handlebars: () => import("highlight.js/lib/languages/handlebars"),
+  twig: () => import("highlight.js/lib/languages/twig"),
+  dust: () => import("highlight.js/lib/languages/dust"),
+  haml: () => import("highlight.js/lib/languages/haml"),
+  erb: () => import("highlight.js/lib/languages/erb"),
+  graphql: () => import("highlight.js/lib/languages/graphql"),
+  http: () => import("highlight.js/lib/languages/http"),
+
+  // ── shell / scripting / build ──
+  bash: () => import("highlight.js/lib/languages/bash"),
+  shell: () => import("highlight.js/lib/languages/shell"),
+  powershell: () => import("highlight.js/lib/languages/powershell"),
+  dos: () => import("highlight.js/lib/languages/dos"),
+  makefile: () => import("highlight.js/lib/languages/makefile"),
+  cmake: () => import("highlight.js/lib/languages/cmake"),
+  dockerfile: () => import("highlight.js/lib/languages/dockerfile"),
+  nginx: () => import("highlight.js/lib/languages/nginx"),
+  gradle: () => import("highlight.js/lib/languages/gradle"),
+  awk: () => import("highlight.js/lib/languages/awk"),
+  tcl: () => import("highlight.js/lib/languages/tcl"),
+  vim: () => import("highlight.js/lib/languages/vim"),
+
+  // ── data / config ──
+  ini: () => import("highlight.js/lib/languages/ini"),
+  toml: () => import("highlight.js/lib/languages/ini"),
+  properties: () => import("highlight.js/lib/languages/properties"),
+  protobuf: () => import("highlight.js/lib/languages/protobuf"),
+  thrift: () => import("highlight.js/lib/languages/thrift"),
+  dns: () => import("highlight.js/lib/languages/dns"),
+
+  // ── systems / hardware / other ──
+  sql: () => import("highlight.js/lib/languages/sql"),
+  pgsql: () => import("highlight.js/lib/languages/pgsql"),
+  glsl: () => import("highlight.js/lib/languages/glsl"),
+  wasm: () => import("highlight.js/lib/languages/wasm"),
+  armasm: () => import("highlight.js/lib/languages/armasm"),
+  x86asm: () => import("highlight.js/lib/languages/x86asm"),
+  verilog: () => import("highlight.js/lib/languages/verilog"),
+  vhdl: () => import("highlight.js/lib/languages/vhdl"),
+  latex: () => import("highlight.js/lib/languages/latex"),
+  diff: () => import("highlight.js/lib/languages/diff"),
+  plaintext: () => import("highlight.js/lib/languages/plaintext"),
+};

package/src/composables/iconRegistry.ts

@@ -0,0 +1,127 @@
+// Shared, tree-shakeable lucide icon registry.
+//
+// `import * as LucideIcons` (wildcard) defeats tree-shaking and pulls the
+// ENTIRE lucide library (~1500 icons, 800KB+) into the bundle. This module
+// imports only the icons the app actually uses — plus a small set of common
+// status/indicator icons server-pushed badges may reference — keyed by their
+// PascalCase lucide export name so dynamic `byName(str)` lookups (breadcrumb
+// badges, nav tags) resolve without the wildcard import. Unknown names fall
+// back to `Info`, matching the previous `|| LucideIcons.Info` behavior.
+
+import { Activity, ArrowDown, ArrowLeft, ArrowRight, ArrowUp, Battery, Bell, Bot, Box, Brain, Cable, Calendar, ChartBarBig as BarChart3, Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Circle, CircleAlert as AlertCircle, CircleCheck as CheckCircle, CircleCheckBig as CheckCircle2, CircleDot, Clock, Cpu, Database, Dot, Ellipsis as MoreHorizontal, ExternalLink, Eye, FileArchive, FileCode, FileImage, FileText, Flame, FolderOpen, Gauge, Globe, HardDrive, Info, Kanban, Key, Layers, LayoutDashboard, LoaderCircle as Loader2, Lock, Maximize, Maximize2, MessageSquare, Mic, MicOff, Minimize, Monitor, Network, Package, Pause, Pencil, Play, Plug, Plus, Radio, RefreshCw, Search, Send, Server, Settings, Share2, Shield, Star, Table, Tag, Thermometer, Trash2, TriangleAlert as AlertTriangle, Volume2, VolumeX, Webhook, Wind, Workflow, Wrench, X, Zap, ZoomIn, ZoomOut } from "lucide-vue-next";
+import type { Component } from "vue";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const REGISTRY: Record<string, Component> = {
+  Activity, AlertCircle, AlertTriangle, ArrowDown, ArrowLeft, ArrowRight,
+  ArrowUp, BarChart3, Battery, Bell, Bot, Box, Brain, Cable, Calendar,
+  Check, CheckCircle, CheckCircle2, ChevronDown, ChevronLeft, ChevronRight,
+  ChevronUp, Circle, CircleDot, Clock, Cpu, Database, Dot, ExternalLink, Eye,
+  FileArchive, FileCode, FileImage, FileText, Flame,
+  FolderOpen, Gauge, Globe, HardDrive, Info, Kanban, Key, Layers,
+  LayoutDashboard, Loader2, Lock, Maximize, Maximize2, MessageSquare, Mic,
+  MicOff, Minimize, Monitor, MoreHorizontal, Network, Package, Pause, Pencil,
+  Play, Plug, Plus, Radio, RefreshCw, Search, Send, Server, Settings, Share2,
+  Shield, Star, Table, Tag, Thermometer, Trash2, Volume2, VolumeX, Webhook,
+  Wind, Workflow, Wrench, X, Zap, ZoomIn, ZoomOut,
+};
+
+/**
+ * Resolve a lucide icon by its PascalCase export name (e.g. `"Cpu"`,
+ * `"Activity"`). Returns `Info` for unknown / falsy names so callers can
+ * always render something.
+ */
+export function iconByName(name: string | undefined | null): Component {
+  if (name) {
+    const hit = REGISTRY[name];
+    if (hit) return hit;
+    // Tolerate lowercase / kebab server strings ("cpu", "check-circle").
+    const alt = REGISTRY[name.replace(/(^|[-_])(.)/g, (_m, _s, c: string) => c.toUpperCase())];
+    if (alt) return alt;
+  }
+  return Info;
+}

package/src/composables/messaging/browserTransport.ts

@@ -0,0 +1,96 @@
+import { defaultDurationFor, defaultRequireInteraction, type MessagePayload, type MessageTransport } from "./types";
+import { scheduleCronAfter } from "@celestia-island/hikari";
+
+/**
+ * Browser Notifications API transport.
+ *
+ * Fires a native OS notification via `window.Notification`. Used when the page
+ * is hidden (user is in another tab/app) and the user has granted permission.
+ *
+ * Lifecycle notes:
+ *  - `available()` only returns true when the API is present *and* the user
+ *    has granted permission. Callers should call `requestPermission()` from
+ *    a user-gesture-triggered flow (e.g. a settings toggle) before relying
+ *    on this transport — browsers reject permission prompts that aren't
+ *    initiated by a user gesture.
+ *  - For error/warning severities we mirror the toast policy: the
+ *    notification is auto-closed after the same 30s window so the two
+ *    surfaces feel consistent. Errors additionally request sticky
+ *    interaction (`requireInteraction: true`) so they survive OS auto-hide.
+ *  - `onclick` focuses the originating window so the user lands back on the
+ *    app — this is the bridge back into the SPA from the OS surface.
+ */
+export const browserTransport: MessageTransport = {
+  name: "browser",
+  available: () =>
+    typeof Notification !== "undefined" && Notification.permission === "granted",
+  send(payload: MessagePayload) {
+    if (typeof Notification === "undefined") return;
+    if (Notification.permission !== "granted") return;
+
+    const severity = payload.severity;
+    const requireInteraction =
+      payload.requireInteraction ?? defaultRequireInteraction(severity);
+
+    const headlineSource = payload.title || payload.message;
+    const title = headlineSource.split("\n")[0]?.slice(0, 200) || headlineSource;
+    const body =
+      payload.body ||
+      (payload.message.length > title.length ? payload.message : undefined);
+
+    let notification: Notification;
+    try {
+      notification = new Notification(title, {
+        body,
+        tag: payload.tag,
+        requireInteraction,
+        data: payload.data,
+      });
+    } catch {
+      // Some browsers throw if the document isn't focused or service worker
+      // is unavailable. Swallow — the toast transport still covers the user.
+      return;
+    }
+
+    notification.onclick = () => {
+      try {
+        window.focus();
+      } catch {
+        // Cross-origin or no-op — ignore.
+      }
+      notification.close();
+    };
+
+    // Mirror the toast auto-close window for transient severities. Errors
+    // default to sticky (requireInteraction) and are skipped here.
+    if (!requireInteraction) {
+      const ttl = payload.duration ?? defaultDurationFor(severity);
+      if (ttl > 0) {
+        scheduleCronAfter(() => {
+          try {
+            notification.close();
+          } catch {
+            // Already closed — ignore.
+          }
+        }, ttl);
+      }
+    }
+  },
+};
+
+/**
+ * Request browser notification permission. Must be invoked from a user
+ * gesture (click handler) — browsers otherwise silently deny.
+ *
+ * Returns the resulting permission state. The shared permission ref inside
+ * {@link useMessaging} is updated as a side effect.
+ */
+export async function requestBrowserPermission(): Promise<NotificationPermission> {
+  if (typeof Notification === "undefined") return "denied";
+  if (Notification.permission !== "default") return Notification.permission;
+  try {
+    return await Notification.requestPermission();
+  } catch {
+    return Notification.permission;
+  }
+}

package/src/composables/messaging/index.ts

@@ -0,0 +1,204 @@
+import { computed, readonly, ref } from "vue";
+
+import { browserTransport, requestBrowserPermission } from "./browserTransport";
+import { toastTransport } from "./toastTransport";
+import { defaultCopyable, defaultDurationFor, type MessagePayload, type MessageSeverity, type MessageTransport, type NotifyOptions, type TransportName } from "./types";
+
+// Re-export the messaging types from the public entry point so consumers
+// can `import type { MessageSeverity } from "./messaging"`.
+export type {
+  MessagePayload,
+  MessageSeverity,
+  MessageTransport,
+  NotifyOptions,
+  TransportName,
+} from "./types";
+
+/**
+ * Registry of all known transports, in priority order.
+ *
+ * Built-ins (`toast`, `browser`) are pre-registered. Native client bridges
+ * (Tauri desktop, mobile native, iOS APNs long-poll) push themselves here
+ * via {@link registerTransport} during boot — typically by reading
+ * `window.__nativeBridge` and wrapping it in a {@link MessageTransport}.
+ */
+const transports: MessageTransport[] = [toastTransport, browserTransport];
+
+/** Page visibility — drives the toast-vs-browser routing decision. */
+const _pageHidden = ref(typeof document !== "undefined" && document.hidden);
+if (typeof document !== "undefined") {
+  const onVis = () => { _pageHidden.value = document.hidden; };
+  document.addEventListener("visibilitychange", onVis);
+}
+const pageHidden = computed(() => _pageHidden.value);
+
+/** Live browser notification permission. */
+const browserPermission = ref<NotificationPermission>(
+  typeof Notification !== "undefined" ? Notification.permission : "denied",
+);
+
+function refreshPermission() {
+  if (typeof Notification !== "undefined") {
+    browserPermission.value = Notification.permission;
+  }
+}
+
+let nextId = 0;
+
+/**
+ * Register a new transport (e.g. a native bridge). Idempotent — re-registering
+ * the same name replaces the prior instance and disposes it if supported.
+ *
+ * Returns an unregister handle so ephemeral bridges (e.g. a reconnecting
+ * WebSocket-based push subscription) can tear themselves down cleanly.
+ */
+export function registerTransport(transport: MessageTransport): () => void {
+  const idx = transports.findIndex((t) => t.name === transport.name);
+  if (idx !== -1) {
+    const [prev] = transports.splice(idx, 1);
+    prev.dispose?.();
+  }
+  transports.push(transport);
+  return () => {
+    const i = transports.indexOf(transport);
+    if (i !== -1) {
+      const [removed] = transports.splice(i, 1);
+      removed.dispose?.();
+    }
+  };
+}
+
+/**
+ * Register a native bridge discovered on `window.__nativeBridge`. Safe to call
+ * unconditionally — no-ops if no bridge is present. Future native client
+ * integrations (Tauri `notification` plugin, HarmonyOS `NotificationService`,
+ * iOS long-poll subscriber) should hook in here.
+ */
+export function registerNativeBridge(): () => void {
+  const bridge =
+    typeof window !== "undefined"
+      ? (window as unknown as { __nativeBridge?: MessageTransport }).__nativeBridge
+      : undefined;
+  if (!bridge || typeof bridge.send !== "function") return () => {};
+  if (bridge.name !== "native") {
+    // Coerce the name so routing allow-lists resolve consistently.
+    (bridge as MessageTransport).name = "native";
+  }
+  return registerTransport(bridge);
+}
+
+/**
+ * Decide which transports a given payload should fire on. Returns the
+ * filtered list (in registry order).
+ *
+ * Routing policy:
+ *   - `toast`: ALWAYS (it's the in-app surface; cheap and visible when the
+ *     user returns).
+ *   - `browser`: ONLY when the page is hidden AND permission is granted AND
+ *     the severity is actionable off-page (error/warning/success). Pure info
+ *     pings don't earn an OS-level interruption.
+ *   - `native`: ALWAYS when available (the native shell decides how to render
+ *     based on its own focus state — we don't second-guess it from the web
+ *     layer).
+ */
+function routePayload(
+  payload: MessagePayload,
+  allowList: TransportName[] | "all",
+): MessageTransport[] {
+  const allow = allowList === "all" ? null : new Set(allowList);
+  const out: MessageTransport[] = [];
+  for (const t of transports) {
+    if (allow && !allow.has(t.name)) continue;
+    if (!t.available()) continue;
+    if (t.name === "browser") {
+      const actionable =
+        payload.severity === "error" ||
+        payload.severity === "warning" ||
+        payload.severity === "success";
+      if (!payload.pageHidden || !actionable) continue;
+    }
+    out.push(t);
+  }
+  return out;
+}
+
+/**
+ * Unified messaging context. Drop-in replacement for {@link useToast} at call
+ * sites that want cross-transport routing — the helper signatures
+ * (`error`/`warning`/`success`/`info`) mirror the toast API to make migration
+ * mechanical.
+ *
+ * @example
+ * const msg = useMessaging();
+ * msg.error(t("auth.login.failed"));          // top-right toast + (if hidden) browser push
+ * msg.warning("Disk almost full", { tag: "disk" });
+ * msg.notify("Saved", { severity: "success", transports: ["toast"] }); // in-app only
+ */
+export function useMessaging() {
+  function notify(message: string, options: NotifyOptions = {}): number {
+    const severity: MessageSeverity = options.severity || "info";
+    const payload: MessagePayload = {
+      id: ++nextId,
+      severity,
+      message,
+      title: options.title,
+      body: options.body,
+      tag: options.tag,
+      requireInteraction: options.requireInteraction,
+      copyable: options.copyable ?? defaultCopyable(severity),
+      duration: options.duration ?? defaultDurationFor(severity),
+      data: options.data,
+      timestamp: Date.now(),
+      pageHidden: pageHidden.value,
+    };
+
+    const routed = routePayload(payload, options.transports ?? "all");
+    for (const t of routed) {
+      try {
+        t.send(payload);
+      } catch {
+        // Transport failure must never propagate — the next transport still
+        // gets a chance.
+      }
+    }
+    return payload.id;
+  }
+
+  function error(message: string, options: Omit<NotifyOptions, "severity"> = {}) {
+    return notify(message, { ...options, severity: "error" });
+  }
+  function warning(message: string, options: Omit<NotifyOptions, "severity"> = {}) {
+    return notify(message, { ...options, severity: "warning" });
+  }
+  function success(message: string, options: Omit<NotifyOptions, "severity"> = {}) {
+    return notify(message, { ...options, severity: "success" });
+  }
+  function info(message: string, options: Omit<NotifyOptions, "severity"> = {}) {
+    return notify(message, { ...options, severity: "info" });
+  }
+
+  /**
+   * Request browser notification permission. Must be called from a user
+   * gesture handler (button click) — otherwise browsers silently deny.
+   */
+  async function ensureBrowserPermission(): Promise<NotificationPermission> {
+    const result = await requestBrowserPermission();
+    refreshPermission();
+    return result;
+  }
+
+  return {
+    notify,
+    error,
+    warning,
+    success,
+    info,
+    ensureBrowserPermission,
+    /** Whether the browser tab is currently hidden. Reactive. */
+    pageHidden: readonly(pageHidden),
+    /** Live browser notification permission. Reactive. */
+    browserPermission: readonly(browserPermission),
+    /** Register a transport at runtime (e.g. native bridge). */
+    registerTransport,
+  };
+}