impact-nova 1.3.0 → 1.5.2

package/dist/components/ui/command-palette/shortcut-registry.js

@@ -0,0 +1,183 @@
+import { isReservedShortcut as f, keybindingsEqual as m, matchesKeybinding as u, scopePriority as o, deserialiseOverrides as g, serialiseOverrides as v } from "./utils.js";
+const l = "impact-nova-shortcuts", h = "impact-nova-recent-commands", p = 10;
+class C {
+  commands = /* @__PURE__ */ new Map();
+  overrides = /* @__PURE__ */ new Map();
+  recentCommandIds = [];
+  listeners = /* @__PURE__ */ new Set();
+  activeScopes = /* @__PURE__ */ new Set();
+  activeInstance = null;
+  constructor() {
+    this.activeScopes.add("global"), this.loadOverrides(), this.loadRecentCommands();
+  }
+  // ─── Instance Management ────────────────────────────────────────────────
+  setActiveInstance(e) {
+    this.activeInstance !== e && (this.activeInstance = e, this.emit({ type: "scope-change" }));
+  }
+  getActiveInstance() {
+    return this.activeInstance;
+  }
+  /**
+   * Get all unique instance identifiers currently registered.
+   */
+  getRegisteredInstances() {
+    const e = /* @__PURE__ */ new Set();
+    for (const t of this.commands.values())
+      t.instance && e.add(t.instance);
+    return Array.from(e);
+  }
+  // ─── Registration ───────────────────────────────────────────────────────
+  register(e) {
+    this.commands.set(e.id, e);
+    const t = this.overrides.get(e.id);
+    t && (e.keybinding = t), this.emit({ type: "register", commandId: e.id });
+  }
+  unregister(e) {
+    this.commands.delete(e), this.emit({ type: "unregister", commandId: e });
+  }
+  // ─── Keybinding Management ─────────────────────────────────────────────
+  getEffectiveKeybinding(e) {
+    const t = this.commands.get(e);
+    if (t)
+      return t.keybinding ?? t.defaultKeybinding;
+  }
+  updateKeybinding(e, t) {
+    const s = this.commands.get(e);
+    if (!s) return { success: !1 };
+    if (!s.customisable) return { success: !1 };
+    if (f(t))
+      return { success: !1, reserved: !0 };
+    const n = this.findConflict(e, t, s.scope);
+    return n ? { success: !1, conflict: n } : (s.keybinding = t, this.overrides.set(e, t), this.saveOverrides(), this.emit({ type: "update-keybinding", commandId: e }), { success: !0 });
+  }
+  resetKeybinding(e) {
+    const t = this.commands.get(e);
+    t && (t.keybinding = void 0, this.overrides.delete(e), this.saveOverrides(), this.emit({ type: "reset-keybinding", commandId: e }));
+  }
+  // ─── Conflict Detection ────────────────────────────────────────────────
+  findConflict(e, t, s) {
+    for (const [n, r] of this.commands) {
+      if (n === e || r.scope !== s) continue;
+      const c = this.getEffectiveKeybinding(n);
+      if (c && m(c, t))
+        return {
+          conflictingCommandId: n,
+          conflictingLabel: r.label,
+          scope: r.scope
+        };
+    }
+    return null;
+  }
+  // ─── Scope Management ──────────────────────────────────────────────────
+  pushScope(e) {
+    this.activeScopes.add(e), this.emit({ type: "scope-change" });
+  }
+  popScope(e) {
+    e !== "global" && (this.activeScopes.delete(e), this.emit({ type: "scope-change" }));
+  }
+  getActiveScopes() {
+    return Array.from(this.activeScopes);
+  }
+  getHighestActiveScope() {
+    let e = "global";
+    for (const t of this.activeScopes)
+      o(t) > o(e) && (e = t);
+    return e;
+  }
+  // ─── Command Queries ───────────────────────────────────────────────────
+  getCommand(e) {
+    return this.commands.get(e);
+  }
+  getAllCommands() {
+    return Array.from(this.commands.values());
+  }
+  /**
+   * Get commands visible in the command palette.
+   * Instance-scoped commands are filtered (only active instance shows unless
+   * there's only one instance, in which case it always shows).
+   * When multiple instances exist, labels are auto-prefixed with the instance name.
+   */
+  getPaletteCommands() {
+    const t = this.getRegisteredInstances().length > 1;
+    return this.getAllCommands().filter((s) => !(s.hidden || s.when && !s.when() || s.instance && t && this.activeInstance && s.instance !== this.activeInstance));
+  }
+  /**
+   * Get commands for the settings panel (all registered, including hidden).
+   */
+  getSettingsCommands() {
+    return this.getAllCommands();
+  }
+  // ─── Keyboard Event Handling ───────────────────────────────────────────
+  /**
+   * Handle a keyboard event. Finds the highest-priority matching command
+   * and executes its handler.
+   *
+   * @returns true if a command was executed, false otherwise
+   */
+  handleKeyEvent(e) {
+    const t = this.activeScopes.has("modal"), n = this.getRegisteredInstances().length > 1;
+    let r = null, c = -1;
+    for (const i of this.commands.values()) {
+      if (i.passive) continue;
+      const a = this.getEffectiveKeybinding(i.id);
+      if (a && !(t && i.scope !== "modal") && !(i.instance && n && i.instance !== this.activeInstance) && !(i.when && !i.when()) && u(e, a)) {
+        const d = o(i.scope);
+        d > c && (r = i, c = d);
+      }
+    }
+    return r ? (e.preventDefault(), e.stopPropagation(), r.handler(), this.addRecentCommand(r.id), !0) : !1;
+  }
+  // ─── Recent Commands ───────────────────────────────────────────────────
+  getRecentCommandIds() {
+    return [...this.recentCommandIds];
+  }
+  addRecentCommand(e) {
+    this.recentCommandIds = [
+      e,
+      ...this.recentCommandIds.filter((t) => t !== e)
+    ].slice(0, p), this.saveRecentCommands();
+  }
+  // ─── Event System ─────────────────────────────────────────────────────
+  subscribe(e) {
+    return this.listeners.add(e), () => {
+      this.listeners.delete(e);
+    };
+  }
+  emit(e) {
+    this.listeners.forEach((t) => t(e));
+  }
+  // ─── Persistence ──────────────────────────────────────────────────────
+  loadOverrides() {
+    if (!(typeof localStorage > "u"))
+      try {
+        const e = localStorage.getItem(l);
+        e && (this.overrides = g(e));
+      } catch {
+      }
+  }
+  saveOverrides() {
+    if (!(typeof localStorage > "u"))
+      try {
+        localStorage.setItem(l, v(this.overrides));
+      } catch {
+      }
+  }
+  loadRecentCommands() {
+    if (!(typeof localStorage > "u"))
+      try {
+        const e = localStorage.getItem(h);
+        e && (this.recentCommandIds = JSON.parse(e));
+      } catch {
+      }
+  }
+  saveRecentCommands() {
+    if (!(typeof localStorage > "u"))
+      try {
+        localStorage.setItem(h, JSON.stringify(this.recentCommandIds));
+      } catch {
+      }
+  }
+}
+export {
+  C as ShortcutRegistry
+};

package/dist/components/ui/command-palette/shortcut-scope-provider.d.ts

@@ -0,0 +1,55 @@
+import { ShortcutScope } from './utils';
+/**
+ * ShortcutScopeProvider — Scope boundary component with instance awareness.
+ *
+ * When mounted, it pushes a scope onto the registry. When unmounted,
+ * it pops the scope. This allows sections of the UI to own their shortcuts.
+ *
+ * When `instance` is provided, the provider wraps its children in a
+ * container div that detects focus events. When anything inside the
+ * container receives focus (click or tab), the instance becomes "active"
+ * in the registry, and only that instance's commands are dispatched.
+ *
+ * Usage:
+ *   // Basic scope (no instance — all commands fire)
+ *   <ShortcutScopeProvider scope="module" name="planning">
+ *     <PlanningModule />
+ *   </ShortcutScopeProvider>
+ *
+ *   // Instance-aware (for multi-table pages)
+ *   <ShortcutScopeProvider scope="page" instance="sales-table" label="Sales Table">
+ *     <DataTable ... />
+ *   </ShortcutScopeProvider>
+ *
+ *   <ShortcutScopeProvider scope="page" instance="inventory-table" label="Inventory Table">
+ *     <DataTable ... />
+ *   </ShortcutScopeProvider>
+ */
+import * as React from 'react';
+export interface ShortcutScopeProviderProps {
+    /** The scope level to activate */
+    scope: ShortcutScope;
+    /** Human-readable name for debugging */
+    name?: string;
+    /**
+     * Unique instance identifier. When provided, enables focus-based
+     * dispatch so that only the focused instance's commands fire.
+     */
+    instance?: string;
+    /**
+     * Human-readable label for the instance (shown in command palette
+     * when multiple instances are present, e.g. "Sales Table").
+     */
+    label?: string;
+    /** Optional className for the wrapper div (only used when instance is set) */
+    className?: string;
+    children: React.ReactNode;
+}
+export declare const ShortcutInstanceContext: React.Context<{
+    instance?: string;
+    label?: string;
+}>;
+export declare function ShortcutScopeProvider({ scope, instance, label, className, children, }: ShortcutScopeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ShortcutScopeProvider {
+    var displayName: string;
+}

package/dist/components/ui/command-palette/shortcut-scope-provider.js

@@ -0,0 +1,55 @@
+import { jsx as c, Fragment as m } from "react/jsx-runtime";
+import * as a from "react";
+import { useCommandPalette as f } from "./command-palette-context.js";
+import { cn as l } from "../../../lib/utils.js";
+const d = a.createContext(null);
+function v({
+  scope: t,
+  instance: e,
+  label: o,
+  className: n,
+  children: u
+}) {
+  const { pushScope: r, popScope: p, setActiveInstance: s, getActiveInstance: i } = f();
+  return a.useEffect(() => (r(t), () => {
+    p(t);
+  }), [t, r, p]), e ? /* @__PURE__ */ c(d.Provider, { value: { instance: e, label: o }, children: /* @__PURE__ */ c(
+    C,
+    {
+      instance: e,
+      className: n,
+      setActiveInstance: s,
+      getActiveInstance: i,
+      children: u
+    }
+  ) }) : /* @__PURE__ */ c(m, { children: u });
+}
+v.displayName = "ShortcutScopeProvider";
+function C({
+  instance: t,
+  className: e,
+  setActiveInstance: o,
+  getActiveInstance: n,
+  children: u
+}) {
+  const r = a.useCallback(() => {
+    o(t);
+  }, [t, o]);
+  return a.useEffect(() => () => {
+    queueMicrotask(() => {
+    });
+  }, [t]), /* @__PURE__ */ c(
+    "div",
+    {
+      onFocusCapture: r,
+      onClickCapture: r,
+      className: l("relative", e),
+      "data-shortcut-instance": t,
+      children: u
+    }
+  );
+}
+export {
+  d as ShortcutInstanceContext,
+  v as ShortcutScopeProvider
+};

package/dist/components/ui/command-palette/shortcut-settings.d.ts

@@ -0,0 +1,27 @@
+import { ShortcutScope } from './utils';
+/**
+ * ShortcutSettings — Keyboard shortcut customisation panel built with AG Grid.
+ *
+ * Features:
+ *   - AG Grid with search, sort, and filter on every column
+ *   - Source column with set filter (All / User / Browser / AG Grid / System)
+ *   - Click keybinding cell → "recording mode" (press new keys)
+ *   - Non-customisable rows are read-only
+ *   - Conflict detection with inline warning
+ *   - Reset individual overrides to defaults
+ *   - Persists changes to localStorage immediately
+ */
+import * as React from 'react';
+export interface ShortcutSettingsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Filter to specific scopes */
+    scopes?: ShortcutScope[];
+    /** Filter to specific sources */
+    sources?: Array<'system' | 'user' | 'ag-grid' | 'browser'>;
+    /** Optional render prop to hoist the recording indicator/conflict message up to a parent toolbar */
+    renderStatus?: (node: React.ReactNode | null) => React.ReactNode;
+}
+declare function ShortcutSettings({ className, scopes, sources, renderStatus, ...props }: ShortcutSettingsProps): import("react/jsx-runtime").JSX.Element;
+declare namespace ShortcutSettings {
+    var displayName: string;
+}
+export { ShortcutSettings };

package/dist/components/ui/command-palette/shortcut-settings.js

@@ -0,0 +1,266 @@
+import { jsx as r, jsxs as h, Fragment as N } from "react/jsx-runtime";
+import * as n from "react";
+import { User as L, Monitor as F, AlertTriangle as I, Lock as R, RotateCcw as U } from "lucide-react";
+import { cn as p } from "../../../lib/utils.js";
+import { ModuleRegistry as _, AllCommunityModule as K } from "ag-grid-community";
+import { AllEnterpriseModule as j } from "ag-grid-enterprise";
+import { DataTable as z, DataTableContent as B } from "../data-table/data-table.js";
+import { AG_CELL_NO_PADDING as S } from "../ag-grid-react/cell-renderers/index.js";
+import { Kbd as O } from "./kbd.js";
+import { useCommandPalette as $ } from "./command-palette-context.js";
+import { keybindingToString as H, keybindingFromEvent as V, isReservedShortcut as W } from "./utils.js";
+import { BadgeCellRenderer as q } from "../ag-grid-react/cell-renderers/badge-cell-renderer.js";
+_.registerModules([K, j]);
+const J = {
+  system: "System",
+  user: "User",
+  "ag-grid": "AG Grid",
+  browser: "Browser"
+};
+function Q(l) {
+  const e = l.data;
+  return e ? /* @__PURE__ */ h("div", { className: "flex items-center gap-2 min-w-0 h-full", children: [
+    !e.customisable && /* @__PURE__ */ r(R, { className: "h-3 w-3 text-[#9ca3af] shrink-0" }),
+    /* @__PURE__ */ h("div", { className: "flex flex-col min-w-0 gap-0", children: [
+      /* @__PURE__ */ r("span", { className: "truncate font-medium text-[#374151] text-xs leading-tight", children: e.command }),
+      e.description && /* @__PURE__ */ r("span", { className: "truncate text-[10px] text-[#9ca3af] leading-tight", children: e.description })
+    ] })
+  ] }) : null;
+}
+function X(l) {
+  const e = l.data;
+  if (!e) return null;
+  const c = l.recordingCommandId === e.id;
+  return /* @__PURE__ */ r("div", { className: p(
+    "w-full h-full flex items-center ag-cell-inner-padding",
+    e.customisable ? "in-ag-editable-cell-highlight" : ""
+  ), children: /* @__PURE__ */ r(
+    "div",
+    {
+      className: p(
+        "flex items-center justify-between w-full h-7 rounded-[8px] px-1.5 group/row relative",
+        e.customisable ? "bg-white" : "bg-transparent",
+        c && "ring-1 ring-[#4259ee] border border-[#4259ee]"
+      ),
+      children: c ? /* @__PURE__ */ r("span", { className: "text-xs text-[#4259ee] font-medium animate-pulse", children: "Press desired shortcut..." }) : /* @__PURE__ */ h(N, { children: [
+        e.keybinding ? /* @__PURE__ */ r(
+          "button",
+          {
+            onClick: (a) => {
+              a.stopPropagation(), e.customisable && l.onStartRecording(e.id);
+            },
+            disabled: !e.customisable,
+            className: p(
+              "flex items-center justify-end h-full w-full text-right",
+              e.customisable ? "cursor-pointer" : "cursor-default opacity-70"
+            ),
+            children: /* @__PURE__ */ r(O, { keybinding: e.keybinding, size: "sm" })
+          }
+        ) : e.customisable ? /* @__PURE__ */ r(
+          "button",
+          {
+            onClick: (a) => {
+              a.stopPropagation(), l.onStartRecording(e.id);
+            },
+            className: "flex items-center justify-end h-full w-full text-xs text-[#9ca3af] hover:text-[#4259ee] transition-colors cursor-pointer text-right",
+            children: "Add shortcut"
+          }
+        ) : /* @__PURE__ */ r("span", { className: "text-xs text-transparent", children: "--" }),
+        e.hasOverride && e.customisable && !c && /* @__PURE__ */ r(
+          "button",
+          {
+            onClick: (a) => {
+              a.stopPropagation(), l.onReset(e.id);
+            },
+            className: "absolute right-1 p-0.5 rounded bg-white hover:bg-[#f3f4f6] hover:text-[#ef4444] cursor-pointer opacity-0 group-hover/row:opacity-100 transition-opacity z-10",
+            title: "Reset to default",
+            children: /* @__PURE__ */ r(U, { className: "h-3 w-3" })
+          }
+        )
+      ] })
+    }
+  ) });
+}
+function Y(l) {
+  const e = l.data;
+  return e ? /* @__PURE__ */ r("div", { className: "flex items-center h-full", children: /* @__PURE__ */ r("span", { className: "text-xs text-[#6b7280] capitalize", children: e.scope }) }) : null;
+}
+function Z({
+  className: l,
+  scopes: e,
+  sources: c,
+  renderStatus: a,
+  ...k
+}) {
+  const {
+    getSettingsCommands: E,
+    getEffectiveKeybinding: M,
+    updateKeybinding: g,
+    resetKeybinding: b,
+    version: A
+  } = $(), [o, f] = n.useState(null), [d, i] = n.useState(null), G = n.useMemo(() => {
+    let s = E();
+    return e && (s = s.filter((t) => e.includes(t.scope))), c && (s = s.filter((t) => t.source && c.includes(t.source))), s.map((t) => {
+      const u = M(t.id), m = t.source ?? "user", C = J[m] ?? t.source ?? "User", v = C.toLowerCase() === "user";
+      return {
+        id: t.id,
+        command: t.label,
+        description: t.description || "",
+        category: t.category || "General",
+        keybinding: u,
+        keybindingDisplay: u ? H(u) : "",
+        scope: t.scope,
+        source: C,
+        sourceColor: v ? "primary" : "neutral",
+        sourceIcon: v ? /* @__PURE__ */ r(L, { className: "h-3 w-3" }) : /* @__PURE__ */ r(F, { className: "h-3 w-3" }),
+        customisable: t.customisable !== !1,
+        passive: t.passive === !0,
+        hasOverride: t.keybinding !== void 0,
+        _def: t
+      };
+    });
+  }, [A, e, c]), x = n.useCallback((s) => {
+    f(s), i(null);
+  }, []), y = n.useCallback((s) => {
+    b(s), i(null);
+  }, [b]);
+  n.useEffect(() => {
+    if (!o) return;
+    const s = (t) => {
+      if (t.preventDefault(), t.stopPropagation(), t.key === "Escape") {
+        f(null), i(null);
+        return;
+      }
+      const u = V(t);
+      if (!u) return;
+      if (W(u)) {
+        i({ type: "reserved", text: "This shortcut is reserved by the browser and cannot be used" }), f(null), setTimeout(() => i(null), 3e3);
+        return;
+      }
+      const m = g(o, u);
+      m.success ? (f(null), i(null)) : m.conflict ? (i({
+        type: "conflict",
+        text: `Conflicts with "${m.conflict.conflictingLabel}" in ${m.conflict.scope} scope`
+      }), f(null), setTimeout(() => i(null), 3e3)) : m.reserved && (i({ type: "reserved", text: "This shortcut is reserved by the browser" }), f(null), setTimeout(() => i(null), 3e3));
+    };
+    return window.addEventListener("keydown", s, !0), () => window.removeEventListener("keydown", s, !0);
+  }, [o, g]);
+  const P = n.useMemo(() => [
+    {
+      field: "command",
+      headerName: "Command",
+      flex: 1,
+      minWidth: 200,
+      filter: "agTextColumnFilter",
+      cellRenderer: Q,
+      filterValueGetter: (s) => {
+        const t = s.data;
+        return t ? `${t.command} ${t.description}` : "";
+      }
+    },
+    {
+      field: "category",
+      headerName: "Category",
+      width: 140,
+      filter: "agSetColumnFilter"
+    },
+    {
+      field: "keybindingDisplay",
+      headerName: "Shortcut",
+      width: 180,
+      type: "rightAligned",
+      filter: "agTextColumnFilter",
+      cellRenderer: X,
+      cellClass: S,
+      cellRendererParams: {
+        recordingCommandId: o,
+        onStartRecording: x,
+        onReset: y
+      },
+      sortable: !0
+    },
+    {
+      field: "scope",
+      headerName: "Scope",
+      width: 100,
+      filter: "agSetColumnFilter",
+      cellRenderer: Y
+    },
+    {
+      field: "source",
+      headerName: "Source",
+      width: 130,
+      filter: "agSetColumnFilter",
+      cellClass: S,
+      cellRenderer: q,
+      cellRendererParams: {
+        variant: "subtle",
+        colorField: "sourceColor",
+        isIcon: !0,
+        iconField: "sourceIcon",
+        size: "small"
+      },
+      headerComponentParams: {
+        isSearchable: !0,
+        advanceSearchEnabled: !0,
+        selectOptions: [
+          { label: "System", value: "System" },
+          { label: "User", value: "User" },
+          { label: "AG Grid", value: "AG Grid" },
+          { label: "Browser", value: "Browser" }
+        ],
+        isMultiSelect: !0
+      }
+    }
+  ], [o, x, y]), T = n.useMemo(() => ({
+    filter: {
+      filterModel: {
+        source: {
+          filterType: "set",
+          values: ["System", "User", "AG Grid"]
+        }
+      }
+    }
+  }), []), D = n.useMemo(() => ({
+    sortable: !0,
+    resizable: !0,
+    filter: !0,
+    headerComponentParams: {
+      isSearchable: !0,
+      advanceSearchEnabled: !0
+    }
+  }), []), w = d || o ? /* @__PURE__ */ h("div", { className: p(
+    "px-3 py-1.5 text-[10px] md:text-sm font-medium rounded-md whitespace-nowrap flex items-center gap-2",
+    d?.type === "conflict" ? "bg-[#fef3c7] text-[#92400e]" : d?.type === "reserved" ? "bg-[#fee2e2] text-[#991b1b]" : o ? "bg-[#eff6ff] text-[#1e40af] animate-[pulse_1.5s_ease-in-out_infinite]" : ""
+  ), children: [
+    d?.type === "conflict" ? /* @__PURE__ */ r(I, { className: "h-3.5 w-3.5 shrink-0" }) : d?.type === "reserved" ? /* @__PURE__ */ r(R, { className: "h-3.5 w-3.5 shrink-0" }) : o ? /* @__PURE__ */ r("span", { className: "shrink-0 text-base", children: "⌨️" }) : null,
+    /* @__PURE__ */ r("span", { children: d ? d.text : /* @__PURE__ */ h(N, { children: [
+      /* @__PURE__ */ r("strong", { children: "Recording:" }),
+      " Press shortcut or ",
+      /* @__PURE__ */ r("strong", { children: "Esc" })
+    ] }) })
+  ] }) : null;
+  return /* @__PURE__ */ h(z, { className: p("flex flex-col w-full h-full border-t-0", l), ...k, children: [
+    a ? a(w) : w,
+    /* @__PURE__ */ r(
+      B,
+      {
+        rowData: G,
+        columnDefs: P,
+        defaultColDef: D,
+        initialState: T,
+        rowHeight: 44,
+        animateRows: !1,
+        rowSelection: "single",
+        suppressCellFocus: !0,
+        getRowId: (s) => s.data.id,
+        suppressRowClickSelection: !0,
+        domLayout: "normal"
+      }
+    )
+  ] });
+}
+Z.displayName = "ShortcutSettings";
+export {
+  Z as ShortcutSettings
+};

package/dist/components/ui/command-palette/use-browser-shortcuts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * useBrowserShortcuts — Registers all browser-reserved shortcuts as passive,
+ * non-customisable commands so they appear in the command palette and settings
+ * panel. This lets users discover what shortcuts are browser-reserved and why
+ * they can't be overridden.
+ *
+ * Usage:
+ *   // Show all browser shortcuts
+ *   useBrowserShortcuts();
+ *
+ *   // Hide DevTools shortcuts from the palette
+ *   useBrowserShortcuts({ exclude: ['devtools'] });
+ *
+ *   // Hide entire categories
+ *   useBrowserShortcuts({ exclude: ['System', 'Address Bar'] });
+ *
+ *   // Hide specific shortcuts by their label (partial match, case-insensitive)
+ *   useBrowserShortcuts({ exclude: ['devtools', 'caret browsing'] });
+ */
+export interface UseBrowserShortcutsOptions {
+    /**
+     * Patterns to exclude from the palette. Each pattern is matched against
+     * the shortcut's label AND category (case-insensitive, partial match).
+     *
+     * Examples:
+     * - `['devtools']` hides all DevTools-related shortcuts
+     * - `['System']` hides entire System category
+     * - `['devtools', 'caret browsing', 'page source']` hides specific items
+     */
+    exclude?: string[];
+}
+export declare function useBrowserShortcuts(options?: UseBrowserShortcutsOptions): void;

package/dist/components/ui/command-palette/use-browser-shortcuts.js

@@ -0,0 +1,48 @@
+import * as u from "react";
+import { useCommandPalette as f } from "./command-palette-context.js";
+import { BROWSER_SHORTCUTS as d } from "./utils.js";
+function m(r) {
+  const s = r.split("+"), e = { key: "" };
+  for (const t of s)
+    t === "meta" ? e.meta = !0 : t === "ctrl" ? e.ctrl = !0 : t === "alt" ? e.alt = !0 : t === "shift" ? e.shift = !0 : e.key = t;
+  return e;
+}
+function b(r) {
+  const { registerCommand: s, unregisterCommand: e } = f(), t = r?.exclude;
+  u.useEffect(() => {
+    const c = [];
+    for (const o of d) {
+      if (t?.length) {
+        const a = `${o.label} ${o.category}`.toLowerCase();
+        if (t.some(
+          (l) => a.includes(l.toLowerCase())
+        )) continue;
+      }
+      const n = `browser.${o.shortcut.replace(/\+/g, "-")}`;
+      c.push(n);
+      const i = {
+        id: n,
+        label: o.label,
+        description: `Browser shortcut (${o.category})`,
+        category: o.category,
+        scope: "global",
+        defaultKeybinding: m(o.shortcut),
+        customisable: !1,
+        hidden: !1,
+        handler: () => {
+        },
+        // no-op — browser handles these
+        source: "browser",
+        passive: !0
+      };
+      s(i);
+    }
+    return () => {
+      for (const o of c)
+        e(o);
+    };
+  }, [s, e, JSON.stringify(t)]);
+}
+export {
+  b as useBrowserShortcuts
+};

package/dist/components/ui/command-palette/use-global-shortcut.d.ts

@@ -0,0 +1,3 @@
+import { UseShortcutOptions } from './use-shortcut';
+export type UseGlobalShortcutOptions = Omit<UseShortcutOptions, 'scope'>;
+export declare function useGlobalShortcut(options: UseGlobalShortcutOptions): void;

package/dist/components/ui/command-palette/use-global-shortcut.js

@@ -0,0 +1,7 @@
+import { useShortcut as t } from "./use-shortcut.js";
+function u(o) {
+  t({ ...o, scope: "global" });
+}
+export {
+  u as useGlobalShortcut
+};