@ai-matrx/rich-content 0.2.10 → 0.2.16

package/dist/rich-document/variants/RegistryActionMenu.js

@@ -0,0 +1,74 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { AdvancedMenu } from "../../host/app-bindings.js";
+import { useActionSurfaceProvider } from "../runtime/useActionSurfaceProvider.js";
+import { resumePendingAuthAction } from "../actions/resumePendingAuthAction.js";
+import { buildMenuTree, registryMenuActions } from "./shared/menuStructure.js";
+import { resolveActionDisplay, runAction } from "./shared/runAction.js";
+const menuActions = registryMenuActions;
+function toAdvancedMenuItems(actions, ctx, getCtx) {
+  const toItem = (action) => {
+    const display = resolveActionDisplay(action, ctx);
+    return {
+      key: action.id,
+      icon: display.Icon,
+      iconColor: display.iconColor,
+      label: display.label,
+      description: display.disabledReason,
+      disabled: display.isDisabled,
+      // Handlers own their toasts (success, failure, loading) — the menu adds
+      // none of its own, so a toast never doubles.
+      showToast: false,
+      action: () => runAction(action, getCtx)
+    };
+  };
+  const tree = buildMenuTree(menuActions(actions));
+  return [
+    ...tree.topLevel.map(toItem),
+    ...tree.submenus.map((submenu) => ({
+      key: `submenu-${submenu.label}`,
+      icon: submenu.icon ?? submenu.actions[0].icon,
+      label: submenu.label,
+      action: () => {
+      },
+      showToast: false,
+      children: submenu.actions.map(toItem)
+    })),
+    ...tree.extras.map(toItem)
+  ];
+}
+function RegistryActionMenu(props) {
+  const { isOpen, onClose, content, source, actions, anchorElement, title } = props;
+  const { ctx, getCtx, resolvedActions } = useActionSurfaceProvider({
+    content,
+    source,
+    actions,
+    actionsVariant: "none"
+  });
+  const getMenuCtx = () => ({
+    ...getCtx(),
+    onClose
+  });
+  React.useEffect(() => {
+    resumePendingAuthAction(getMenuCtx());
+  });
+  return /* @__PURE__ */ jsx(
+    AdvancedMenu,
+    {
+      isOpen,
+      onClose,
+      items: toAdvancedMenuItems(resolvedActions, ctx, getMenuCtx),
+      title,
+      position: "bottom-left",
+      anchorElement
+    }
+  );
+}
+var RegistryActionMenu_default = RegistryActionMenu;
+export {
+  RegistryActionMenu,
+  RegistryActionMenu_default as default,
+  menuActions,
+  toAdvancedMenuItems
+};

package/dist/rich-document/variants/shared/AlchemyDocumentMenu.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { RichDocumentActionContext } from "../../types.js";
+export declare function AlchemyDocumentMenu({ getCtx, sourceId, size, }: {
+    getCtx: () => RichDocumentActionContext;
+    sourceId: string;
+    size?: "sm" | "xs";
+}): React.JSX.Element;

package/dist/rich-document/variants/shared/AlchemyDocumentMenu.js

@@ -0,0 +1,83 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useAlchemyDisclosure } from "../../../host/app-bindings.js";
+import * as React from "react";
+import { ContentTransferMenu } from "@ai-matrx/alchemy/react/workspace";
+import { directSource } from "@ai-matrx/alchemy/operate";
+import { removeThinkingContent } from "@ai-matrx/print/markdown";
+function AlchemyDocumentMenu({
+  getCtx,
+  sourceId,
+  size = "sm"
+}) {
+  useAlchemyDisclosure();
+  const [hasThinking, setHasThinking] = React.useState(false);
+  const source = {
+    id: sourceId,
+    label: "Document",
+    // getCtx reads refs and is legal only when Alchemy starts capture.
+    capture: async ({ signal }) => {
+      signal.throwIfAborted();
+      const ctx = getCtx();
+      const capturedSourceId = ctx.instanceKey("alchemy");
+      if (capturedSourceId !== sourceId)
+        throw new Error(
+          "The document changed. Reopen Alchemy Menu for the current document."
+        );
+      const text = removeThinkingContent(ctx.content);
+      setHasThinking(text !== ctx.content);
+      return directSource(
+        { kind: "markdown", text },
+        {
+          id: capturedSourceId,
+          sourceId: capturedSourceId,
+          revision: ctx.content,
+          label: "Document"
+        }
+      );
+    }
+  };
+  const includingThinkingSource = {
+    id: `${sourceId}:including-thinking`,
+    label: "Document",
+    capture: async ({ signal }) => {
+      signal.throwIfAborted();
+      const ctx = getCtx();
+      const capturedSourceId = ctx.instanceKey("alchemy");
+      if (capturedSourceId !== sourceId)
+        throw new Error(
+          "The document changed. Reopen Alchemy Menu for the current document."
+        );
+      return directSource(
+        { kind: "markdown", text: ctx.content },
+        {
+          id: `${capturedSourceId}:including-thinking`,
+          sourceId: capturedSourceId,
+          revision: ctx.content,
+          label: "Document"
+        }
+      );
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    ContentTransferMenu,
+    {
+      source,
+      label: "Document",
+      className: size === "xs" ? "matrx-alchemy-xs" : void 0,
+      variants: hasThinking ? [
+        {
+          id: "include-thinking",
+          label: "Including thinking",
+          copyLabel: "Copy including thinking",
+          hint: "Includes the original reasoning content",
+          source: includingThinkingSource
+        }
+      ] : []
+    },
+    sourceId
+  );
+}
+export {
+  AlchemyDocumentMenu
+};

package/dist/rich-document/variants/shared/OpenOneMenuButton.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { ContentSource } from "../../types.js";
+/** True when an ancestor right-click menu already carries this content. */
+export declare function useOneMenuFor(source: ContentSource): boolean;
+export declare function OpenOneMenuButton({ source, className, ariaLabel, }: {
+    source: ContentSource;
+    className?: string;
+    ariaLabel?: string;
+}): React.ReactElement;

package/dist/rich-document/variants/shared/OpenOneMenuButton.js

@@ -0,0 +1,70 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { MoreHorizontal } from "lucide-react";
+import { Button } from "@ai-matrx/design-system";
+import { cn } from "@ai-matrx/design-system";
+import {
+  contentSourceKey,
+  sameContentSource,
+  useRegistryMenuSource
+} from "../../../host/app-bindings.js";
+import { openContextMenuForElement } from "../../../host/app-bindings.js";
+function contentTriggerFor(button, source) {
+  const key = contentSourceKey(source);
+  const carries = (el) => el.getAttribute("data-content-source") === key;
+  const selector = '[data-alchemy-trigger="context"][data-content-source]';
+  for (let node = button; node; node = node.parentElement) {
+    if (node.matches(selector) && carries(node)) return node;
+    const hit = [...node.querySelectorAll(selector)].find(carries);
+    if (hit) return hit;
+  }
+  return button;
+}
+function useOneMenuFor(source) {
+  return sameContentSource(useRegistryMenuSource(), source);
+}
+function OpenOneMenuButton({
+  source,
+  className,
+  ariaLabel = "More actions"
+}) {
+  const buttonRef = React.useRef(null);
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      ref: buttonRef,
+      variant: "ghost",
+      size: "icon",
+      className: cn("h-8 w-8 p-0 pointer-coarse:h-11 pointer-coarse:w-11", className),
+      "aria-label": ariaLabel,
+      "aria-haspopup": "menu",
+      onClick: () => {
+        const button = buttonRef.current;
+        if (!button) return;
+        const trigger = contentTriggerFor(button, source);
+        if (trigger === button) {
+          openContextMenuForElement(button);
+          return;
+        }
+        const rect = button.getBoundingClientRect();
+        trigger.dispatchEvent(
+          new MouseEvent("contextmenu", {
+            bubbles: true,
+            cancelable: true,
+            view: window,
+            button: 2,
+            buttons: 2,
+            clientX: rect.left + rect.width / 2,
+            clientY: rect.bottom
+          })
+        );
+      },
+      children: /* @__PURE__ */ jsx(MoreHorizontal, { className: "h-4 w-4" })
+    }
+  );
+}
+export {
+  OpenOneMenuButton,
+  useOneMenuFor
+};

package/dist/rich-document/variants/shared/StandaloneOneMenu.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { ClickTarget } from "@ai-matrx/alchemy/actions";
+import type { RichDocumentActionContext } from "../../types.js";
+export declare function StandaloneOneMenu({ getCtx, target, className, }: {
+    getCtx: () => RichDocumentActionContext;
+    target: ClickTarget;
+    className?: string;
+}): React.ReactElement;

package/dist/rich-document/variants/shared/StandaloneOneMenu.js

@@ -0,0 +1,32 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { RegistryContextMenu } from "../../RegistryContextMenu.js";
+import { OpenOneMenuButton } from "./OpenOneMenuButton.js";
+function StandaloneOneMenu({
+  getCtx,
+  target,
+  className
+}) {
+  const ctx = getCtx();
+  const host = target.host;
+  return /* @__PURE__ */ jsx(
+    RegistryContextMenu,
+    {
+      content: ctx.content,
+      source: ctx.source,
+      actions: {
+        exclude: [...target.excludedActionIds],
+        extra: [...host?.extra ?? []],
+        ...ctx.callbacks ? { callbacks: ctx.callbacks } : {},
+        ...ctx.extensions ? { extensions: ctx.extensions } : {},
+        metadata: ctx.metadata,
+        isCreator: ctx.isCreator,
+        surfaceKey: ctx.surfaceKey
+      },
+      children: /* @__PURE__ */ jsx("span", { className: "inline-flex", children: /* @__PURE__ */ jsx(OpenOneMenuButton, { source: ctx.source, className }) })
+    }
+  );
+}
+export {
+  StandaloneOneMenu
+};

package/dist/rich-document/variants/shared/categories.d.ts

@@ -0,0 +1,4 @@
+import type { ActionCategory } from "../../types.js";
+export declare function getCategoryLabel(category: ActionCategory): string;
+export declare function getCategoryWeight(category: ActionCategory): number;
+export declare function sortCategoriesInDisplayOrder(categories: ActionCategory[]): ActionCategory[];

package/dist/rich-document/variants/shared/categories.js

@@ -0,0 +1,31 @@
+const CATEGORY_META = {
+  edit: { label: "Edit", weight: 0 },
+  creator: { label: "Creator", weight: 1 },
+  copy: { label: "Copy", weight: 2 },
+  export: { label: "Export", weight: 3 },
+  save: { label: "Actions", weight: 4 },
+  share: { label: "Share", weight: 5 },
+  feedback: { label: "Feedback", weight: 6 },
+  listen: { label: "Listen", weight: 6.2 },
+  study: { label: "Study", weight: 6.4 },
+  ask: { label: "Ask in chat", weight: 6.6 },
+  ai: { label: "AI", weight: -1 },
+  admin: { label: "Server API (test)", weight: 7 },
+  app: { label: "App", weight: 8 }
+};
+function getCategoryLabel(category) {
+  return CATEGORY_META[category]?.label ?? category;
+}
+function getCategoryWeight(category) {
+  return CATEGORY_META[category]?.weight ?? 99;
+}
+function sortCategoriesInDisplayOrder(categories) {
+  return [...categories].sort(
+    (a, b) => getCategoryWeight(a) - getCategoryWeight(b)
+  );
+}
+export {
+  getCategoryLabel,
+  getCategoryWeight,
+  sortCategoriesInDisplayOrder
+};

package/dist/rich-document/variants/shared/iconMap.d.ts

@@ -0,0 +1,2 @@
+import { type LucideIcon } from "lucide-react";
+export declare function resolveIcon(iconName: string): LucideIcon;

package/dist/rich-document/variants/shared/iconMap.js

@@ -0,0 +1,73 @@
+import {
+  Copy,
+  FileText,
+  FileType,
+  Brain,
+  Save,
+  FileCode,
+  CheckSquare,
+  Eye,
+  Globe,
+  Mail,
+  Printer,
+  ScanLine,
+  Edit,
+  History,
+  GitBranch,
+  Trash2,
+  BarChart3,
+  Activity,
+  ThumbsUp,
+  ThumbsDown,
+  Maximize2,
+  Briefcase,
+  BookText,
+  Bug,
+  Megaphone,
+  Settings,
+  GitFork,
+  EyeOff,
+  ListFilter,
+  Scissors,
+  Undo2,
+  Circle
+} from "lucide-react";
+const ICON_MAP = {
+  Copy,
+  FileText,
+  FileType,
+  Brain,
+  Save,
+  FileCode,
+  CheckSquare,
+  Eye,
+  Globe,
+  Mail,
+  Printer,
+  ScanLine,
+  Edit,
+  History,
+  GitBranch,
+  Trash2,
+  BarChart3,
+  Activity,
+  ThumbsUp,
+  ThumbsDown,
+  Maximize2,
+  Briefcase,
+  BookText,
+  Bug,
+  Megaphone,
+  Settings,
+  GitFork,
+  EyeOff,
+  ListFilter,
+  Scissors,
+  Undo2
+};
+function resolveIcon(iconName) {
+  return ICON_MAP[iconName] ?? Circle;
+}
+export {
+  resolveIcon
+};

package/dist/rich-document/variants/shared/menuStructure.d.ts

@@ -0,0 +1,81 @@
+import { type LucideIcon } from "lucide-react";
+import type { RichDocumentAction } from "../../types.js";
+export interface MenuSection {
+    /** Submenu label, or null for the promoted top-level group. */
+    submenu: string | null;
+    /** Icon for the submenu trigger (ignored for the top-level group). */
+    icon?: LucideIcon;
+    /** Action IDs in this section, in intended display order. */
+    actionIds: string[];
+    /**
+     * The category every row of this section takes in the Alchemy layout, which
+     * places a section in a group by its rows' category. Set it on a section
+     * whose rows mix categories, so the section sits in ONE predictable place.
+     */
+    layoutCategory?: RichDocumentAction["category"];
+    /**
+     * In the one menu engine (⋯, right-click, sheet, palette) this section's rows
+     * show INLINE, under no heading — the group has no approved name (ALC-15 chair
+     * ruling: a heading is a name the classic menus used; otherwise inline). The
+     * tree hosts (ProTextarea's "…", the user bubble) still group them under
+     * `submenu`.
+     */
+    inline?: boolean;
+    /**
+     * The heading names the THING these rows act on ("Conversation": the whole
+     * conversation, not the clicked message) — declared to the engine as a target
+     * label (`section.kind: "target"`), never a group heading.
+     */
+    target?: boolean;
+}
+/**
+ * The canonical menu layout. Order here = render order. Action IDs not
+ * listed in any section are treated as `extra` (consumer-supplied) and
+ * rendered in a trailing group.
+ */
+/**
+ * The AI section's label in the tree hosts — the classic context-menu name
+ * "AI Actions" (agent-shortcuts placement label), restored 2026-09-26 over the
+ * coined "Improve with AI" (ALC-15 round 3). Hosts that carry the agent-shortcut
+ * libraries and ProTextarea's bound agents fold them INTO this group, so there
+ * is one AI family in every menu, never a parallel one. In the one menu engine
+ * the group is `inline` (no heading), so it never reads "AI Actions › AI Actions".
+ */
+export declare const AI_SUBMENU_LABEL = "AI Actions";
+/** The whole-conversation section's label (answer menus of chat messages). */
+export declare const CONVERSATION_SUBMENU_LABEL = "Conversation";
+export declare const MENU_STRUCTURE: MenuSection[];
+export interface MenuSubmenuNode {
+    label: string;
+    icon?: LucideIcon;
+    actions: RichDocumentAction[];
+}
+export interface MenuTree {
+    /** Promoted, always-visible top-level items. */
+    topLevel: RichDocumentAction[];
+    /** Named submenus, each with ≥1 visible action. */
+    submenus: MenuSubmenuNode[];
+    /** Consumer-supplied actions not present in MENU_STRUCTURE. */
+    extras: RichDocumentAction[];
+}
+export declare function buildMenuTree(input: RichDocumentAction[], options?: {
+    aiSlot?: boolean;
+}): MenuTree;
+/**
+ * THE ONE selector of which registry actions a MENU shows (every host: ⋯,
+ * right-click, ProTextarea "…", the mobile sheet). A bar's primary buttons
+ * stay on the bar; a menu carries the overflow set. One selector is what
+ * keeps every host's tree identical (guard: __tests__/oneMenuTree.test.ts).
+ */
+export declare function registryMenuActions(actions: RichDocumentAction[]): RichDocumentAction[];
+/**
+ * The AI submenu, guaranteed present when a host has its own AI rows to fold
+ * in (a ProTextarea's bound agents, the v3 agent-shortcut libraries), at the
+ * position MENU_STRUCTURE gives it — so no host ever grows a second AI family.
+ */
+export declare function withAiSlot(submenus: MenuSubmenuNode[], hasSlot: boolean): MenuSubmenuNode[];
+/** The tree as an ordered id list — what the one-tree guard compares. */
+export declare function flattenMenuTreeIds(tree: MenuTree): string[];
+/** Bumps on every extension, so cached placements rebuild. */
+export declare function menuStructureVersion(): number;
+export declare function extendMenuSection(submenu: string, actionIds: readonly string[]): void;