impact-nova 2.0.8 → 2.1.0-alpha.1

package/dist/components/flows/command-palette/command-palette.js

@@ -0,0 +1,513 @@
+import { jsxs as m, jsx as e, Fragment as se } from "react/jsx-runtime";
+import * as a from "react";
+import * as P from "@radix-ui/react-dialog";
+import { Search as _ } from "impact-nova-icons";
+import { cn as l } from "../../../lib/utils.js";
+import { useCommandPalette as ie } from "./use-command-palette.js";
+import { Kbd as v } from "../../primitives/kbd/kbd.js";
+import { keybindingToSymbols as de } from "../../primitives/kbd/keybinding-display.js";
+import { buildCommandPaletteLayout as le } from "./command-palette-layout.js";
+import { COMMAND_SOURCE_LABELS as me, fuzzyFilter as ce } from "./utils.js";
+const ue = /* @__PURE__ */ new Set(["browser", "system", "ag-grid"]);
+function pe(o) {
+  return !!o && ue.has(o);
+}
+const R = a.createContext({
+  query: "",
+  setQuery: () => {
+  },
+  selectedIndex: 0,
+  setSelectedIndex: () => {
+  },
+  orderedCommands: [],
+  onExecute: () => {
+  }
+});
+function fe({
+  className: o,
+  children: n,
+  commands: r,
+  placeholder: i = "Type a command or search...",
+  emptyTitle: c = "No results found",
+  emptyDescription: p = "Try a different search term",
+  recentGroupLabel: f = "Recently Used",
+  defaultGroupLabel: d = "Commands",
+  navigateLabel: z = "Navigate",
+  runLabel: M = "Run",
+  closeLabel: D = "Close",
+  configureShortcutsLabel: O = "Configure Shortcuts",
+  onCommandExecute: $,
+  onOpenChange: A
+}) {
+  const {
+    open: E,
+    setOpen: F,
+    getPaletteCommands: Z,
+    getEffectiveKeybinding: G,
+    registry: k
+  } = ie(), [y, j] = a.useState(""), [N, g] = a.useState(0), q = a.useRef(null), T = a.useRef(null), K = a.useMemo(() => (r ?? Z()).filter((s) => {
+    const u = s.source ?? "user";
+    return u === "user" || u === "ag-grid";
+  }), [r, E]), Q = a.useMemo(() => {
+    const t = ce(
+      K,
+      y,
+      (s) => `${s.category ? s.category + ": " : ""}${s.label}${s.description ? " " + s.description : ""}`
+    );
+    if (!y.trim()) {
+      const s = k.getRecentCommandIds(), u = new Set(s), x = [], C = [];
+      for (const h of t)
+        u.has(h.item.id) ? x.push(h) : C.push(h);
+      return x.sort(
+        (h, oe) => s.indexOf(h.item.id) - s.indexOf(oe.item.id)
+      ), [...x, ...C];
+    }
+    return t;
+  }, [K, y, k]), U = a.useMemo(
+    () => Q.map((t) => t.item),
+    [Q]
+  ), ee = a.useMemo(
+    () => le({
+      filteredCommands: U,
+      emptyQuery: !y.trim(),
+      recentCommandIds: k.getRecentCommandIds(),
+      recentGroupLabel: f,
+      defaultGroupLabel: d
+    }),
+    [U, y, k, f, d]
+  ), { groups: te, orderedCommands: b } = ee, S = a.useRef({
+    ordered: b,
+    index: N
+  });
+  S.current = { ordered: b, index: N }, a.useEffect(() => {
+    E && (j(""), g(0), requestAnimationFrame(() => {
+      q.current?.focus();
+    }));
+  }, [E]);
+  const I = a.useCallback(
+    (t) => {
+      F(t), A?.(t);
+    },
+    [A, F]
+  ), w = a.useCallback(
+    (t) => {
+      t.handler(), k.addRecentCommand(t.id), $?.(t), I(!1);
+    },
+    [k, $, I]
+  ), ne = a.useCallback(
+    (t) => {
+      const { ordered: s } = S.current, u = Math.max(s.length - 1, 0);
+      switch (t.key) {
+        case "ArrowDown": {
+          t.preventDefault(), g((x) => Math.min(x + 1, u));
+          break;
+        }
+        case "ArrowUp": {
+          t.preventDefault(), g((x) => Math.max(x - 1, 0));
+          break;
+        }
+        case "Enter": {
+          t.preventDefault();
+          const { ordered: x, index: C } = S.current, h = x[C];
+          h && w(h);
+          break;
+        }
+        case "Home": {
+          t.preventDefault(), g(0);
+          break;
+        }
+        case "End": {
+          t.preventDefault(), g(u);
+          break;
+        }
+      }
+    },
+    [w]
+  );
+  a.useEffect(() => {
+    g(0);
+  }, [y]), a.useEffect(() => {
+    const t = b.length;
+    g((s) => t === 0 ? 0 : Math.min(s, t - 1));
+  }, [b.length]), a.useLayoutEffect(() => {
+    const t = T.current;
+    if (!t) return;
+    const s = t.querySelector(
+      '[data-selected="true"]'
+    );
+    s && s.scrollIntoView({
+      block: "nearest",
+      inline: "nearest",
+      behavior: "auto"
+    });
+  }, [N]);
+  const ae = a.useMemo(
+    () => ({
+      query: y,
+      setQuery: j,
+      selectedIndex: N,
+      setSelectedIndex: g,
+      orderedCommands: b,
+      onExecute: w,
+      placeholder: i,
+      emptyTitle: c,
+      emptyDescription: p,
+      recentGroupLabel: f,
+      defaultGroupLabel: d,
+      navigateLabel: z,
+      runLabel: M,
+      closeLabel: D,
+      configureShortcutsLabel: O
+    }),
+    [
+      y,
+      N,
+      b,
+      w,
+      i,
+      c,
+      p,
+      f,
+      d,
+      z,
+      M,
+      D,
+      O
+    ]
+  ), re = a.Children.count(n) > 0;
+  return /* @__PURE__ */ e(P.Root, { open: E, onOpenChange: I, children: /* @__PURE__ */ m(P.Portal, { children: [
+    /* @__PURE__ */ e(P.Overlay, { className: "fixed inset-0 z-50 bg-scrim data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 motion-reduce:animate-none motion-reduce:transition-none" }),
+    /* @__PURE__ */ m(
+      P.Content,
+      {
+        "aria-describedby": void 0,
+        "data-command-palette": !0,
+        "data-component": "command-palette",
+        onKeyDown: ne,
+        className: l(
+          "fixed left-[50%] top-[20%] z-50 w-full max-w-[640px] -translate-x-1/2",
+          "rounded-xl border border-stroke-hairline bg-canvas-elevated shadow-2xl overflow-hidden",
+          "data-[state=open]:animate-in data-[state=closed]:animate-out",
+          "data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+          "data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95",
+          "motion-reduce:animate-none motion-reduce:transition-none",
+          // Pin translate-x at -50% during animation so it stays centered (no horizontal slide)
+          "data-[state=open]:slide-in-from-left-1/2 data-[state=closed]:slide-out-to-left-1/2",
+          "duration-150",
+          o
+        ),
+        style: { transformOrigin: "top center" },
+        children: [
+          /* @__PURE__ */ e(P.Title, { className: "sr-only", children: "Command Palette" }),
+          /* @__PURE__ */ e(R.Provider, { value: ae, children: re ? n : /* @__PURE__ */ m(se, { children: [
+            /* @__PURE__ */ e(B, { ref: q, placeholder: i }),
+            /* @__PURE__ */ e(H, { ref: T, children: b.length === 0 ? /* @__PURE__ */ e(J, {}) : te.map((t, s) => /* @__PURE__ */ m(
+              a.Fragment,
+              {
+                children: [
+                  s > 0 && /* @__PURE__ */ e(W, {}),
+                  /* @__PURE__ */ e(L, { heading: t.heading, children: t.items.map((u, x) => {
+                    const C = t.rowStart + x, h = G(u.id);
+                    return /* @__PURE__ */ e(
+                      V,
+                      {
+                        command: u,
+                        isSelected: C === N,
+                        onSelect: () => w(u),
+                        onMouseEnter: () => g(C),
+                        keybinding: h
+                      },
+                      u.id
+                    );
+                  }) })
+                ]
+              },
+              `${t.heading}-${t.rowStart}`
+            )) }),
+            /* @__PURE__ */ e(Y, {})
+          ] }) })
+        ]
+      }
+    )
+  ] }) });
+}
+fe.displayName = "CommandPalette";
+const B = a.forwardRef(({ className: o, placeholder: n, onValueChange: r, ...i }, c) => {
+  const { query: p, setQuery: f } = a.useContext(R);
+  return /* @__PURE__ */ m(
+    "div",
+    {
+      className: l(
+        "flex items-center gap-3 border-b border-stroke-hairline px-4",
+        o
+      ),
+      "data-command-palette-input": !0,
+      children: [
+        /* @__PURE__ */ e(_, { className: "h-4 w-4 shrink-0 text-content-muted" }),
+        /* @__PURE__ */ e(
+          "input",
+          {
+            ref: c,
+            value: p,
+            onChange: (d) => {
+              f(d.target.value), r?.(d.target.value);
+            },
+            placeholder: n,
+            autoComplete: "off",
+            autoCorrect: "off",
+            spellCheck: !1,
+            className: l(
+              "flex h-12 w-full bg-transparent py-3 text-sm font-medium outline-none",
+              "placeholder:text-content-muted"
+            ),
+            ...i
+          }
+        ),
+        /* @__PURE__ */ e(
+          v,
+          {
+            keybinding: { key: "Escape" },
+            size: "sm",
+            variant: "muted",
+            className: "shrink-0"
+          }
+        )
+      ]
+    }
+  );
+});
+B.displayName = "CommandPaletteInput";
+const H = a.forwardRef(({ className: o, children: n, ...r }, i) => /* @__PURE__ */ e(
+  "div",
+  {
+    ref: i,
+    role: "listbox",
+    "data-command-palette-list": !0,
+    className: l(
+      "max-h-[360px] overflow-y-auto overscroll-contain py-1",
+      o
+    ),
+    ...r,
+    children: n
+  }
+));
+H.displayName = "CommandPaletteList";
+const L = a.forwardRef(({ className: o, heading: n, children: r, ...i }, c) => /* @__PURE__ */ m(
+  "div",
+  {
+    ref: c,
+    role: "group",
+    "aria-label": n,
+    "data-command-palette-group": !0,
+    className: l("py-1", o),
+    ...i,
+    children: [
+      n && /* @__PURE__ */ e("div", { className: "px-4 py-1.5 text-[10px] font-semibold uppercase tracking-wider text-content-muted", children: n }),
+      r
+    ]
+  }
+));
+L.displayName = "CommandPaletteGroup";
+function xe({
+  source: o,
+  isSelected: n
+}) {
+  if (!o || o === "user") return null;
+  const r = me[o];
+  return r ? /* @__PURE__ */ e(
+    "span",
+    {
+      className: l(
+        "shrink-0 rounded px-1.5 py-px text-[9px] font-medium leading-tight tracking-wide",
+        n ? "text-brand-foreground/50" : "text-content-muted border border-stroke-hairline"
+      ),
+      children: r
+    }
+  ) : null;
+}
+const V = a.memo(
+  a.forwardRef(
+    ({ className: o, command: n, isSelected: r, onSelect: i, keybinding: c, ...p }, f) => {
+      const d = pe(n.source);
+      return /* @__PURE__ */ m(
+        "div",
+        {
+          ref: f,
+          role: "option",
+          "aria-selected": r,
+          "data-selected": r,
+          "data-command-palette-item": !0,
+          "data-command-id": n.id,
+          onClick: i,
+          className: l(
+            "flex items-center gap-3 cursor-pointer px-4 py-2 text-sm",
+            // Smooth selection shift; scroll-margin keeps row clear of list edges when scrolling into view
+            "transition-[color,background-color] duration-150 ease-out [scroll-margin-block:6px]",
+            r ? "bg-brand text-brand-foreground" : d ? "text-content-muted hover:bg-canvas-muted" : "text-content-charcoal hover:bg-canvas-muted",
+            o
+          ),
+          ...p,
+          children: [
+            n.icon && /* @__PURE__ */ e(
+              "span",
+              {
+                className: l(
+                  "flex h-4 w-4 shrink-0 items-center justify-center",
+                  r ? "text-brand-foreground" : d ? "text-stroke-hairline" : "text-content-muted"
+                ),
+                children: n.icon
+              }
+            ),
+            /* @__PURE__ */ m("div", { className: "flex flex-1 flex-col min-w-0", children: [
+              /* @__PURE__ */ e(
+                "span",
+                {
+                  className: l(
+                    "truncate",
+                    d && !r ? "font-normal" : "font-medium"
+                  ),
+                  children: n.label
+                }
+              ),
+              n.description && /* @__PURE__ */ e(
+                "span",
+                {
+                  className: l(
+                    "truncate text-xs",
+                    r ? "text-brand-foreground/70" : d ? "text-stroke-hairline" : "text-content-muted"
+                  ),
+                  children: n.description
+                }
+              )
+            ] }),
+            /* @__PURE__ */ e(xe, { source: n.source, isSelected: r }),
+            c && /* @__PURE__ */ e(
+              X,
+              {
+                keybinding: c,
+                isSelected: r,
+                external: d
+              }
+            )
+          ]
+        }
+      );
+    }
+  )
+);
+V.displayName = "CommandPaletteItem";
+function X({
+  keybinding: o,
+  isSelected: n,
+  external: r,
+  className: i,
+  ...c
+}) {
+  const p = de(o);
+  return /* @__PURE__ */ e(
+    "span",
+    {
+      className: l("ms-auto flex items-center gap-0.5 shrink-0", i),
+      "data-command-palette-shortcut": !0,
+      ...c,
+      children: p.map((f, d) => /* @__PURE__ */ e(
+        "kbd",
+        {
+          className: l(
+            "inline-flex min-w-[20px] items-center justify-center rounded px-1 h-[20px] text-[10px] font-mono leading-none",
+            "transition-[color,background-color,border-color] duration-150 ease-out",
+            n ? "bg-canvas-elevated/20 text-brand-foreground border border-brand-foreground/30" : r ? "bg-canvas-muted text-stroke-hairline border border-stroke-hairline" : "bg-canvas-muted text-content-muted border border-stroke-hairline"
+          ),
+          children: f
+        },
+        `${f}-${d}`
+      ))
+    }
+  );
+}
+X.displayName = "CommandPaletteShortcut";
+function J({
+  className: o,
+  ...n
+}) {
+  const { emptyTitle: r, emptyDescription: i } = a.useContext(R);
+  return /* @__PURE__ */ m(
+    "div",
+    {
+      "data-command-palette-empty": !0,
+      className: l(
+        "flex flex-col items-center justify-center py-12 text-center text-sm text-content-muted",
+        o
+      ),
+      ...n,
+      children: [
+        /* @__PURE__ */ e(_, { className: "h-8 w-8 mb-3 text-stroke-hairline" }),
+        /* @__PURE__ */ e("p", { className: "font-medium", children: r }),
+        /* @__PURE__ */ e("p", { className: "text-xs mt-1", children: i })
+      ]
+    }
+  );
+}
+J.displayName = "CommandPaletteEmpty";
+function W({
+  className: o,
+  ...n
+}) {
+  return /* @__PURE__ */ e(
+    "div",
+    {
+      "data-command-palette-separator": !0,
+      className: l("h-px bg-stroke-hairline mx-2", o),
+      ...n
+    }
+  );
+}
+W.displayName = "CommandPaletteSeparator";
+function Y({
+  className: o,
+  ...n
+}) {
+  const { navigateLabel: r, runLabel: i, closeLabel: c, configureShortcutsLabel: p } = a.useContext(R);
+  return /* @__PURE__ */ m(
+    "div",
+    {
+      "data-command-palette-footer": !0,
+      className: l(
+        "flex items-center gap-4 border-t border-stroke-hairline px-4 py-2 text-[11px] text-content-muted",
+        o
+      ),
+      ...n,
+      children: [
+        /* @__PURE__ */ m("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(v, { keys: ["↑"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e(v, { keys: ["↓"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: r })
+        ] }),
+        /* @__PURE__ */ m("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(v, { keys: ["↵"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: i })
+        ] }),
+        /* @__PURE__ */ m("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(v, { keys: ["Escape"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: c })
+        ] }),
+        p && /* @__PURE__ */ m("span", { className: "ms-auto inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(v, { keybinding: { key: "k", alt: !0 }, size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: p })
+        ] })
+      ]
+    }
+  );
+}
+Y.displayName = "CommandPaletteFooter";
+export {
+  fe as CommandPalette,
+  J as CommandPaletteEmpty,
+  Y as CommandPaletteFooter,
+  L as CommandPaletteGroup,
+  B as CommandPaletteInput,
+  V as CommandPaletteItem,
+  H as CommandPaletteList,
+  W as CommandPaletteSeparator,
+  X as CommandPaletteShortcut
+};

package/dist/components/flows/command-palette/command-palette.types.d.ts

@@ -0,0 +1,49 @@
+import { CommandDefinition, KeyBinding } from './utils';
+import type * as React from "react";
+export interface CommandPaletteLabels {
+    /** Placeholder text for the search input */
+    placeholder?: string;
+    /** Title shown when no results are found */
+    emptyTitle?: string;
+    /** Description shown when no results are found */
+    emptyDescription?: string;
+    /** Group heading for recently used commands */
+    recentGroupLabel?: string;
+    /** Group heading for searched commands when no category is present */
+    defaultGroupLabel?: string;
+    /** Label for the navigation hint in the footer */
+    navigateLabel?: string;
+    /** Label for the execution hint in the footer */
+    runLabel?: string;
+    /** Label for the close hint in the footer */
+    closeLabel?: string;
+    /** Label for the configure shortcuts hint in the footer */
+    configureShortcutsLabel?: string;
+}
+export interface CommandPaletteProps extends CommandPaletteLabels {
+    className?: string;
+    children?: React.ReactNode;
+    /** Custom list of commands (overrides automatic registry commands) */
+    commands?: CommandDefinition[];
+    /** Called when a command is executed */
+    onCommandExecute?: (command: CommandDefinition) => void;
+    /** Called when the palette opens/closes */
+    onOpenChange?: (open: boolean) => void;
+}
+export interface CommandPaletteInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange"> {
+    onValueChange?: (value: string) => void;
+}
+export interface CommandPaletteGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    heading?: string;
+}
+export interface CommandPaletteItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    command: CommandDefinition;
+    isSelected?: boolean;
+    onSelect?: () => void;
+    keybinding?: KeyBinding;
+}
+export interface CommandPaletteShortcutProps extends React.HTMLAttributes<HTMLSpanElement> {
+    keybinding: KeyBinding;
+    isSelected?: boolean;
+    external?: boolean;
+}

package/dist/components/flows/command-palette/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Command Palette & Keyboard Shortcuts — Public API
+ */
+export type { ShortcutScope, KeyBinding, CommandDefinition, FuzzyResult, SerializedOverride, BrowserShortcutInfo, ShortcutStorageAdapter, } from './utils';
+export { isMac, getKeySymbol, keybindingToSymbols, keybindingToString, matchesKeybinding, parseKeybinding, keybindingsEqual, keybindingFromEvent, isReservedShortcut, getBrowserShortcutInfo, BROWSER_SHORTCUTS, fuzzyScore, fuzzyFilter, COMMAND_SOURCE_LABELS, scopePriority, serialiseOverrides, deserialiseOverrides, } from './utils';
+export { ShortcutRegistry, LocalStorageAdapter } from './shortcut-registry';
+export type { RegistryChangeEvent, RegistryListener, ConflictInfo } from './shortcut-registry';
+export { CommandPaletteProvider, } from './command-palette-context';
+export { useCommandPalette } from './use-command-palette';
+export type { CommandPaletteContextValue, CommandPaletteProviderProps } from './command-palette-context.types';
+export { useShortcut } from './use-shortcut';
+export type { UseShortcutOptions } from './use-shortcut';
+export { useGlobalShortcut } from './use-global-shortcut';
+export type { UseGlobalShortcutOptions } from './use-global-shortcut';
+export { useBrowserShortcuts } from './use-browser-shortcuts';
+export type { UseBrowserShortcutsOptions } from './use-browser-shortcuts';
+export { ShortcutScopeProvider } from './shortcut-scope-provider';
+export type { ShortcutScopeProviderProps } from './shortcut-scope-provider';
+export { CommandPalette, CommandPaletteInput, CommandPaletteList, CommandPaletteGroup, CommandPaletteItem, CommandPaletteShortcut, CommandPaletteEmpty, CommandPaletteSeparator, CommandPaletteFooter, } from './command-palette';
+export type { CommandPaletteProps, CommandPaletteInputProps, CommandPaletteGroupProps, CommandPaletteItemProps, CommandPaletteShortcutProps, } from './command-palette';
+export { Kbd } from '../../primitives/kbd';
+export type { KbdProps } from '../../primitives/kbd';
+export { ShortcutOverlayProvider, useShortcutOverlay } from './shortcut-overlay-context';
+export type { ShortcutOverlayContextValue, ShortcutOverlayProviderProps } from './shortcut-overlay-context';
+export { ShortcutOverlay } from './shortcut-overlay';

package/dist/components/flows/command-palette/index.js

@@ -0,0 +1,53 @@
+import { BROWSER_SHORTCUTS as r, COMMAND_SOURCE_LABELS as o, deserialiseOverrides as m, fuzzyFilter as a, fuzzyScore as i, getBrowserShortcutInfo as n, isReservedShortcut as d, keybindingFromEvent as s, keybindingsEqual as l, matchesKeybinding as S, parseKeybinding as p, scopePriority as u, serialiseOverrides as c } from "./utils.js";
+import { LocalStorageAdapter as f, ShortcutRegistry as P } from "./shortcut-registry.js";
+import { CommandPaletteProvider as x } from "./command-palette-context.js";
+import { useCommandPalette as g } from "./use-command-palette.js";
+import { useShortcut as v } from "./use-shortcut.js";
+import { useGlobalShortcut as E } from "./use-global-shortcut.js";
+import { useBrowserShortcuts as k } from "./use-browser-shortcuts.js";
+import { ShortcutScopeProvider as B } from "./shortcut-scope-provider.js";
+import { CommandPalette as L, CommandPaletteEmpty as T, CommandPaletteFooter as A, CommandPaletteGroup as F, CommandPaletteInput as I, CommandPaletteItem as M, CommandPaletteList as _, CommandPaletteSeparator as w, CommandPaletteShortcut as G } from "./command-palette.js";
+import { Kbd as q } from "../../primitives/kbd/kbd.js";
+import { getKeySymbol as H, isMac as N, keybindingToString as W, keybindingToSymbols as j } from "../../primitives/kbd/keybinding-display.js";
+import { ShortcutOverlayProvider as Q, useShortcutOverlay as V } from "./shortcut-overlay-context.js";
+import { ShortcutOverlay as Y } from "./shortcut-overlay.js";
+export {
+  r as BROWSER_SHORTCUTS,
+  o as COMMAND_SOURCE_LABELS,
+  L as CommandPalette,
+  T as CommandPaletteEmpty,
+  A as CommandPaletteFooter,
+  F as CommandPaletteGroup,
+  I as CommandPaletteInput,
+  M as CommandPaletteItem,
+  _ as CommandPaletteList,
+  x as CommandPaletteProvider,
+  w as CommandPaletteSeparator,
+  G as CommandPaletteShortcut,
+  q as Kbd,
+  f as LocalStorageAdapter,
+  Y as ShortcutOverlay,
+  Q as ShortcutOverlayProvider,
+  P as ShortcutRegistry,
+  B as ShortcutScopeProvider,
+  m as deserialiseOverrides,
+  a as fuzzyFilter,
+  i as fuzzyScore,
+  n as getBrowserShortcutInfo,
+  H as getKeySymbol,
+  N as isMac,
+  d as isReservedShortcut,
+  s as keybindingFromEvent,
+  W as keybindingToString,
+  j as keybindingToSymbols,
+  l as keybindingsEqual,
+  S as matchesKeybinding,
+  p as parseKeybinding,
+  u as scopePriority,
+  c as serialiseOverrides,
+  k as useBrowserShortcuts,
+  g as useCommandPalette,
+  E as useGlobalShortcut,
+  v as useShortcut,
+  V as useShortcutOverlay
+};

package/dist/components/flows/command-palette/shortcut-instance-context.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export declare const ShortcutInstanceContext: React.Context<{
+    instance?: string;
+    label?: string;
+} | null>;

package/dist/components/flows/command-palette/shortcut-instance-context.js

@@ -0,0 +1,5 @@
+import * as t from "react";
+const e = t.createContext(null);
+export {
+  e as ShortcutInstanceContext
+};

package/dist/components/flows/command-palette/shortcut-overlay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ShortcutOverlay — Excel-like "Key Tips" overlay.
+ *
+ * When visible, scans the DOM for elements with `[data-shortcut-id]`,
+ * resolves their effective keybindings from the command palette registry,
+ * and renders floating Kbd badges positioned next to each element.
+ *
+ * Performance notes:
+ *  - No `elementFromPoint` / forced reflows — uses containment checks only.
+ *  - MutationObserver (childList on body) detects panel open/close cheaply.
+ *  - All rescans are debounced via a single `requestAnimationFrame`.
+ *
+ * Dismiss: click backdrop, press Escape, or re-trigger the shortcut.
+ */
+import * as React from 'react';
+export declare function ShortcutOverlay(): React.ReactPortal | null;
+export declare namespace ShortcutOverlay {
+    var displayName: string;
+}