@beyondwork/docx-react-component 1.0.35 → 1.0.37

package/src/ui/editor-runtime-boundary.ts

@@ -34,6 +34,7 @@ import {
   type DocumentRuntimeEvent,
   type DocumentRuntime,
 } from "../runtime/document-runtime.ts";
+import { createInertLayoutFacet } from "../runtime/layout/index.ts";
 import { loadDocxEditorSession } from "../io/docx-session.ts";
 import {
   decodePersistedSourcePackageBytes,
@@ -738,6 +739,7 @@ function createLoadingRuntimeBridge(input: {
   viewState: EditorViewStateSnapshot;
   navigation: DocumentNavigationSnapshot;
 }): WordReviewEditorRuntime {
+  const inertLayoutFacet = createInertLayoutFacet();
   const emptyFieldSnapshot: FieldSnapshot = {
     totalCount: 0,
     supportedCount: 0,
@@ -772,7 +774,13 @@ function createLoadingRuntimeBridge(input: {
     getCanonicalDocument: () => input.sessionState.canonicalDocument,
     getSourcePackage: () => input.sessionState.sourcePackage,
     replaceText: () => undefined,
-    applyActiveStoryTextCommand: () => undefined,
+    applyActiveStoryTextCommand: () => ({
+      kind: "rejected",
+      newRevisionToken: "",
+      blockedReasons: [
+        { code: "runtime_loading", message: "Document runtime is not ready yet." },
+      ],
+    }),
     dispatch: () => undefined,
     undo: () => undefined,
     redo: () => undefined,
@@ -801,6 +809,7 @@ function createLoadingRuntimeBridge(input: {
     setZoom: () => undefined,
     getPageLayoutSnapshot: () => null,
     getDocumentNavigationSnapshot: () => input.navigation,
+    layout: inertLayoutFacet,
     getCurrentLocation: () => null,
     getLocationForSelection: () => null,
     getLocationForAnchor: () => null,

package/src/ui/editor-surface-controller.tsx

@@ -60,6 +60,9 @@ export interface EditorSurfaceControllerProps {
   activeWorkflowWorkItemId?: string | null;
   activeWorkflowScopeIds?: readonly string[];
   workflowMetadata?: readonly WorkflowMetadataMarkup[];
+  dispatchRuntimeCommand?: (
+    command: import("../ui-tailwind/editor-surface/fast-text-edit-lane.ts").LaneRuntimeCommand,
+  ) => import("../api/public-types.ts").TextCommandAck;
 }
 
 export const EditorSurfaceController = forwardRef<

package/src/ui/headless/chrome-registry.ts

@@ -0,0 +1,235 @@
+import type { WordReviewEditorChromePreset } from "../../api/public-types";
+import type { SelectionToolKind } from "./selection-tool-types";
+
+export type ChromeSurface = "top-toolbar" | "selection-tool";
+export type ChromeDensity = "compact";
+export type ToolbarChromePlacement = "inline" | "overflow" | "hidden";
+
+export type ToolbarChromeItemId =
+  | "history"
+  | "text-style-selectors"
+  | "inline-formatting"
+  | "text-colors"
+  | "paragraph-alignment"
+  | "list-actions"
+  | "indentation"
+  | "list-continuation"
+  | "insert-actions"
+  | "update-actions"
+  | "scope-status"
+  | "story-breadcrumb"
+  | "sidebar-toggle"
+  | "comment"
+  | "tracked-changes-toggle"
+  | "workspace-mode"
+  | "zoom"
+  | "health"
+  | "export";
+
+export interface ChromeRegistryEntryBase {
+  id: string;
+  surfaces: ReadonlyArray<ChromeSurface>;
+  group: string;
+}
+
+export interface SelectionToolRegistryEntry extends ChromeRegistryEntryBase {
+  id: SelectionToolKind;
+  surfaces: ["selection-tool"];
+  precedence: number;
+}
+
+export interface ToolbarChromeRegistryEntry extends ChromeRegistryEntryBase {
+  id: ToolbarChromeItemId;
+  surfaces: ["top-toolbar"];
+  presets: ReadonlyArray<WordReviewEditorChromePreset>;
+  fullPlacement: Exclude<ToolbarChromePlacement, "hidden">;
+  compactPlacement: ToolbarChromePlacement;
+  runtimeBehavior: "always" | "formatting" | "structure" | "comment";
+  scopeBehavior?: "default" | "scoped-only" | "hidden-when-scoped";
+}
+
+export const SELECTION_TOOL_REGISTRY: ReadonlyArray<SelectionToolRegistryEntry> = [
+  { id: "suggestion-review", surfaces: ["selection-tool"], group: "review", precedence: 10 },
+  { id: "comment-thread", surfaces: ["selection-tool"], group: "review", precedence: 20 },
+  { id: "workflow-task", surfaces: ["selection-tool"], group: "workflow", precedence: 30 },
+  { id: "structure-context", surfaces: ["selection-tool"], group: "structure", precedence: 40 },
+  { id: "formatting-inline", surfaces: ["selection-tool"], group: "formatting", precedence: 50 },
+  { id: "blocked-explainer", surfaces: ["selection-tool"], group: "blocked", precedence: 60 },
+];
+
+export const TOOLBAR_CHROME_REGISTRY: ReadonlyArray<ToolbarChromeRegistryEntry> = [
+  {
+    id: "history",
+    surfaces: ["top-toolbar"],
+    group: "history",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+  {
+    id: "text-style-selectors",
+    surfaces: ["top-toolbar"],
+    group: "text",
+    presets: ["advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "overflow",
+    runtimeBehavior: "formatting",
+  },
+  {
+    id: "inline-formatting",
+    surfaces: ["top-toolbar"],
+    group: "text",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "formatting",
+  },
+  {
+    id: "text-colors",
+    surfaces: ["top-toolbar"],
+    group: "text",
+    presets: ["simple", "advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "formatting",
+  },
+  {
+    id: "paragraph-alignment",
+    surfaces: ["top-toolbar"],
+    group: "paragraph",
+    presets: ["simple", "advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "formatting",
+  },
+  {
+    id: "list-actions",
+    surfaces: ["top-toolbar"],
+    group: "paragraph",
+    presets: ["simple", "advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "overflow",
+    runtimeBehavior: "formatting",
+  },
+  {
+    id: "indentation",
+    surfaces: ["top-toolbar"],
+    group: "paragraph",
+    presets: ["simple", "advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "overflow",
+    runtimeBehavior: "formatting",
+  },
+  {
+    id: "list-continuation",
+    surfaces: ["top-toolbar"],
+    group: "paragraph",
+    presets: ["simple", "advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "overflow",
+    runtimeBehavior: "formatting",
+  },
+  {
+    id: "insert-actions",
+    surfaces: ["top-toolbar"],
+    group: "document",
+    presets: ["simple", "advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "overflow",
+    runtimeBehavior: "structure",
+    scopeBehavior: "hidden-when-scoped",
+  },
+  {
+    id: "update-actions",
+    surfaces: ["top-toolbar"],
+    group: "document",
+    presets: ["advanced"],
+    fullPlacement: "inline",
+    compactPlacement: "overflow",
+    runtimeBehavior: "structure",
+    scopeBehavior: "hidden-when-scoped",
+  },
+  {
+    id: "scope-status",
+    surfaces: ["top-toolbar"],
+    group: "scope",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+    scopeBehavior: "scoped-only",
+  },
+  {
+    id: "story-breadcrumb",
+    surfaces: ["top-toolbar"],
+    group: "scope",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+  {
+    id: "sidebar-toggle",
+    surfaces: ["top-toolbar"],
+    group: "review",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+  {
+    id: "comment",
+    surfaces: ["top-toolbar"],
+    group: "review",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "comment",
+  },
+  {
+    id: "tracked-changes-toggle",
+    surfaces: ["top-toolbar"],
+    group: "review",
+    presets: ["advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+  {
+    id: "workspace-mode",
+    surfaces: ["top-toolbar"],
+    group: "view",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+  {
+    id: "zoom",
+    surfaces: ["top-toolbar"],
+    group: "view",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+  {
+    id: "health",
+    surfaces: ["top-toolbar"],
+    group: "status",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+  {
+    id: "export",
+    surfaces: ["top-toolbar"],
+    group: "status",
+    presets: ["simple", "advanced", "review"],
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "always",
+  },
+];

package/src/ui/headless/scoped-chrome-policy.ts

@@ -0,0 +1,164 @@
+import type {
+  ActiveListContext,
+  InteractionGuardSnapshot,
+  WorkflowScopeSnapshot,
+  WordReviewEditorChromePreset,
+} from "../../api/public-types";
+import type { SessionCapabilities } from "../../runtime/session-capabilities";
+import {
+  TOOLBAR_CHROME_REGISTRY,
+  type ToolbarChromeItemId,
+  type ToolbarChromePlacement,
+} from "./chrome-registry";
+import type { SelectionToolKind } from "./selection-tool-types";
+
+export interface ToolbarChromeItemPolicy {
+  visible: boolean;
+  enabled: boolean;
+  placement: ToolbarChromePlacement;
+}
+
+export interface ScopedChromePolicy {
+  density: "compact";
+  activeScopeId?: string;
+  activeWorkItemId?: string | null;
+  scopeStatusLabel?: string;
+  toolbar: Record<ToolbarChromeItemId, ToolbarChromeItemPolicy>;
+  selection: {
+    hiddenKinds: ReadonlyArray<SelectionToolKind>;
+  };
+}
+
+export interface ResolveScopedChromePolicyInput {
+  preset: WordReviewEditorChromePreset;
+  compactMode: boolean;
+  capabilities?: SessionCapabilities;
+  interactionGuardSnapshot?: InteractionGuardSnapshot;
+  workflowScopeSnapshot?: WorkflowScopeSnapshot | null;
+  activeListContext?: ActiveListContext | null;
+}
+
+export function resolveScopedChromePolicy(
+  input: ResolveScopedChromePolicyInput,
+): ScopedChromePolicy {
+  const effectiveMode = input.interactionGuardSnapshot?.effectiveMode ?? "edit";
+  const canFormatText = Boolean(input.capabilities?.canEdit) && effectiveMode === "edit";
+  const canInsertStructural = Boolean(input.capabilities?.canEdit) && effectiveMode === "edit";
+  const canAddComment =
+    Boolean(input.capabilities?.canAddComment) &&
+    effectiveMode !== "view" &&
+    effectiveMode !== "blocked";
+  const activeScopeId = input.interactionGuardSnapshot?.matchedScopeId;
+  const activeWorkItemId = input.workflowScopeSnapshot?.activeWorkItemId ?? null;
+  const hasScopedContext = Boolean(activeScopeId || activeWorkItemId);
+  const scopeStatusLabel =
+    input.workflowScopeSnapshot?.activeWorkItem?.title ??
+    input.workflowScopeSnapshot?.scopes.find((scope) => scope.scopeId === activeScopeId)?.label ??
+    (activeScopeId && input.interactionGuardSnapshot?.matchedScopeMode
+      ? `Scoped ${input.interactionGuardSnapshot.matchedScopeMode}`
+      : undefined);
+
+  const toolbar = Object.fromEntries(
+    TOOLBAR_CHROME_REGISTRY.map((entry) => {
+      let visible = entry.presets.includes(input.preset);
+
+      if (visible) {
+        switch (entry.runtimeBehavior) {
+          case "formatting":
+            visible = canFormatText;
+            break;
+          case "structure":
+            visible = canInsertStructural;
+            break;
+          case "comment":
+            visible = canAddComment;
+            break;
+          default:
+            visible = true;
+            break;
+        }
+      }
+
+      if (visible && entry.id === "list-continuation") {
+        visible = Boolean(input.activeListContext);
+      }
+      if (visible && entry.id === "scope-status") {
+        visible = Boolean(scopeStatusLabel);
+      }
+
+      if (visible && entry.scopeBehavior === "scoped-only") {
+        visible = hasScopedContext;
+      }
+      if (visible && entry.scopeBehavior === "hidden-when-scoped") {
+        visible = !hasScopedContext;
+      }
+
+      const placement = visible
+        ? (input.compactMode ? entry.compactPlacement : entry.fullPlacement)
+        : "hidden";
+      const enabled =
+        visible &&
+        (entry.id !== "tracked-changes-toggle" || Boolean(input.capabilities?.trackChangesSupported)) &&
+        (entry.id !== "export" || Boolean(input.capabilities?.canExport));
+
+      return [
+        entry.id,
+        {
+          visible,
+          enabled,
+          placement,
+        } satisfies ToolbarChromeItemPolicy,
+      ];
+    }),
+  ) as Record<ToolbarChromeItemId, ToolbarChromeItemPolicy>;
+
+  const hiddenKinds = resolveHiddenSelectionToolKinds(effectiveMode);
+
+  return {
+    density: "compact",
+    ...(activeScopeId ? { activeScopeId } : {}),
+    activeWorkItemId,
+    ...(scopeStatusLabel ? { scopeStatusLabel } : {}),
+    toolbar,
+    selection: {
+      hiddenKinds,
+    },
+  };
+}
+
+export function isToolbarChromeItemVisible(
+  policy: ScopedChromePolicy,
+  itemId: ToolbarChromeItemId,
+): boolean {
+  return policy.toolbar[itemId]?.visible ?? false;
+}
+
+export function getToolbarChromePlacement(
+  policy: ScopedChromePolicy,
+  itemId: ToolbarChromeItemId,
+): ToolbarChromePlacement {
+  return policy.toolbar[itemId]?.placement ?? "hidden";
+}
+
+export function shouldRenderSelectionToolKind(
+  policy: ScopedChromePolicy | undefined,
+  kind: SelectionToolKind,
+): boolean {
+  return !policy?.selection.hiddenKinds.includes(kind);
+}
+
+function resolveHiddenSelectionToolKinds(
+  effectiveMode: InteractionGuardSnapshot["effectiveMode"] | "edit",
+): ReadonlyArray<SelectionToolKind> {
+  switch (effectiveMode) {
+    case "suggest":
+      return ["formatting-inline", "structure-context"];
+    case "comment":
+      return ["formatting-inline", "structure-context"];
+    case "view":
+    case "blocked":
+      return ["formatting-inline", "structure-context", "suggestion-review"];
+    default:
+      return [];
+  }
+}

package/src/ui/headless/selection-tool-context.ts

@@ -5,6 +5,7 @@ import type {
   StyleCatalogSnapshot,
 } from "../../api/public-types";
 import type { SessionCapabilities } from "../../runtime/session-capabilities";
+import type { ScopedChromePolicy } from "./scoped-chrome-policy";
 import type { SelectionToolResolverContext } from "./selection-tool-types";
 
 export interface SelectionToolResolverInput extends SelectionToolResolverContext {
@@ -16,4 +17,5 @@ export interface SelectionToolResolverInput extends SelectionToolResolverContext
   preferListStructureContext?: boolean;
   addCommentDisabledReason?: string;
   suppressedSuggestionRevisionId?: string | null;
+  scopedChromePolicy?: ScopedChromePolicy;
 }

package/src/ui/headless/selection-tool-resolver.ts

@@ -17,27 +17,26 @@ import type {
   SuggestionReviewSelectionToolModel,
   WorkflowTaskSelectionToolModel,
 } from "./selection-tool-types";
+import {
+  SELECTION_TOOL_REGISTRY,
+  type SelectionToolRegistryEntry,
+} from "./chrome-registry";
+import { shouldRenderSelectionToolKind } from "./scoped-chrome-policy";
 
 export function resolveActiveSelectionTool(
   input: SelectionToolResolverInput,
 ): ActiveSelectionToolModel | null {
-  const suggestionTool = buildSuggestionReviewSelectionToolModel(input);
-  const commentTool = buildCommentThreadSelectionToolModel(input);
-  const workflowTool = buildWorkflowTaskSelectionToolModel(input);
-  const structureTool = buildStructureContextSelectionToolModel(input);
-  // Semantic targets beat generic range formatting so structure tools do not
-  // leak preview text when the user is acting on a table, image, or object.
-  const formattingTool = buildFormattingInlineSelectionToolModel(input);
-  const blockedTool = buildBlockedExplainerSelectionToolModel(input);
-  const resolvedTool =
-    suggestionTool ??
-    commentTool ??
-    workflowTool ??
-    structureTool ??
-    formattingTool ??
-    blockedTool;
-
-  return resolvedTool;
+  for (const entry of SELECTION_TOOL_REGISTRY) {
+    if (!shouldRenderSelectionToolKind(input.scopedChromePolicy, entry.id)) {
+      continue;
+    }
+    const resolvedTool = buildSelectionToolFromRegistryEntry(entry, input);
+    if (resolvedTool) {
+      return resolvedTool;
+    }
+  }
+
+  return null;
 }
 
 export function buildFormattingInlineSelectionToolModel(
@@ -273,6 +272,26 @@ function selectionMatchesSuggestion(
   );
 }
 
+function buildSelectionToolFromRegistryEntry(
+  entry: SelectionToolRegistryEntry,
+  input: SelectionToolResolverInput,
+): ActiveSelectionToolModel | null {
+  switch (entry.id) {
+    case "suggestion-review":
+      return buildSuggestionReviewSelectionToolModel(input);
+    case "comment-thread":
+      return buildCommentThreadSelectionToolModel(input);
+    case "workflow-task":
+      return buildWorkflowTaskSelectionToolModel(input);
+    case "structure-context":
+      return buildStructureContextSelectionToolModel(input);
+    case "formatting-inline":
+      return buildFormattingInlineSelectionToolModel(input);
+    case "blocked-explainer":
+      return buildBlockedExplainerSelectionToolModel(input);
+  }
+}
+
 function findSelectionMatchingScope(
   activeRange: SelectionToolResolverInput["snapshot"]["selection"]["activeRange"] | null,
   activeStory: EditorStoryTarget,