@beyondwork/docx-react-component 1.0.55 → 1.0.57

package/src/runtime/edit-ops/index.ts

@@ -0,0 +1,129 @@
+/**
+ * R.2 EditLayer — named module for atomic content mutations. See
+ * `docs/plans/lane-1-editing-foundation.md` §R.2.
+ *
+ * The layer is a thin named seam over the existing pure functions in
+ * `src/core/commands/text-commands.ts`. Each method delegates verbatim — no
+ * behavior change, no new bookkeeping. The value is the named entry point:
+ * callers consume `editLayer.applyTextInsert(doc, sel, text, ctx, formatting?)`
+ * instead of reaching into `insertText` directly, which gives R.5.b (post-edit
+ * validation hook) and R.5.a (action bracketing) a central site to attach.
+ *
+ * `EditResult` is re-exported as `TextTransactionResult` — the layer returns
+ * exactly what the underlying pure functions return. Adding
+ * `{revisionId, changedParagraphIds}` metadata is deferred; those values live
+ * at the runtime level (snapshot emission) and don't belong in a pure edit-op.
+ */
+
+import type { TextFormattingDirective } from "../../api/public-types.ts";
+import {
+  deleteSelectionOrBackward,
+  deleteSelectionOrForward,
+  insertHardBreak,
+  insertTab,
+  insertText,
+  splitParagraph,
+  type TextCommandContext,
+} from "../../core/commands/text-commands.ts";
+import type {
+  CanonicalDocumentEnvelope,
+  SelectionSnapshot,
+} from "../../core/state/editor-state.ts";
+import type { TextTransactionResult } from "../../core/state/text-transaction.ts";
+import { validateSelectionAgainstDocument } from "../selection/post-edit-validator.ts";
+
+export type EditResult = TextTransactionResult;
+
+export interface EditLayer {
+  /**
+   * Insert `text` at the current selection, optionally with a formatting
+   * directive (I7). Returns the post-edit document + selection.
+   */
+  applyTextInsert(
+    doc: CanonicalDocumentEnvelope,
+    selection: SelectionSnapshot,
+    text: string,
+    context: TextCommandContext,
+    formatting?: TextFormattingDirective,
+  ): EditResult;
+
+  /** Delete the selected range or, when collapsed, the character before the caret. */
+  applyDeleteBackward(
+    doc: CanonicalDocumentEnvelope,
+    selection: SelectionSnapshot,
+    context: TextCommandContext,
+  ): EditResult;
+
+  /** Delete the selected range or, when collapsed, the character after the caret. */
+  applyDeleteForward(
+    doc: CanonicalDocumentEnvelope,
+    selection: SelectionSnapshot,
+    context: TextCommandContext,
+  ): EditResult;
+
+  /** Insert a literal tab character. */
+  applyInsertTab(
+    doc: CanonicalDocumentEnvelope,
+    selection: SelectionSnapshot,
+    context: TextCommandContext,
+  ): EditResult;
+
+  /** Insert a hard break (`<w:br/>`). */
+  applyInsertHardBreak(
+    doc: CanonicalDocumentEnvelope,
+    selection: SelectionSnapshot,
+    context: TextCommandContext,
+  ): EditResult;
+
+  /** Split the current paragraph at the selection (Enter / paragraph-break). */
+  applySplitParagraph(
+    doc: CanonicalDocumentEnvelope,
+    selection: SelectionSnapshot,
+    context: TextCommandContext,
+  ): EditResult;
+}
+
+/**
+ * R.5.b — every EditLayer return passes through the post-edit selection
+ * validator before leaving the layer. The underlying commands already
+ * produce in-bounds selections on the golden path; this is a defense-in-
+ * depth hook so a future command that gets the math wrong is caught at the
+ * layer boundary rather than at render time.
+ *
+ * `result.storyText.length` is the authoritative post-mutation maximum
+ * offset (computed by `applyTextTransaction` from the new story). The
+ * validator is O(1) on in-bounds selections and returns the same reference,
+ * so the hook costs nothing on the hot path.
+ */
+function validateResult(result: TextTransactionResult): TextTransactionResult {
+  const maxOffset = result.storyText.length;
+  const validated = validateSelectionAgainstDocument(result.document, result.selection, maxOffset);
+  if (validated === result.selection) {
+    return result;
+  }
+  return { ...result, selection: validated };
+}
+
+/**
+ * Default stateless EditLayer instance. Safe to share across runtimes.
+ */
+export const editLayer: EditLayer = {
+  applyTextInsert(doc, selection, text, context, formatting) {
+    return validateResult(insertText(doc, selection, text, context, formatting));
+  },
+  applyDeleteBackward(doc, selection, context) {
+    return validateResult(deleteSelectionOrBackward(doc, selection, context));
+  },
+  applyDeleteForward(doc, selection, context) {
+    return validateResult(deleteSelectionOrForward(doc, selection, context));
+  },
+  applyInsertTab(doc, selection, context) {
+    return validateResult(insertTab(doc, selection, context));
+  },
+  applyInsertHardBreak(doc, selection, context) {
+    return validateResult(insertHardBreak(doc, selection, context));
+  },
+  applySplitParagraph(doc, selection, context) {
+    return validateResult(splitParagraph(doc, selection, context));
+  },
+};

package/src/runtime/event-refresh-hints.ts

@@ -16,6 +16,13 @@ export function describeEventImpact(
         staleTargets: ["anchors"],
         changeKinds: ["selection", "structure"],
       };
+    case "toc_auto_refreshed":
+      return {
+        invalidate: ["render", "navigation", "outline", "toc", "locations"],
+        staleTargets: ["none"],
+        changeKinds: ["content", "structure"],
+        tocRefreshTrigger: event.trigger,
+      };
     case "workflow_overlay_changed":
     case "workflow_active_work_item_changed":
       return {

package/src/runtime/field-resolver.ts

@@ -0,0 +1,341 @@
+/**
+ * CO3.2b — Field resolver
+ *
+ * Resolves PAGE, NUMPAGES, PAGEREF, REF, STYLEREF field entries against a
+ * RuntimePageGraph, a bookmark map, and a paragraph offset table. TOC entries
+ * return `undefined` (not refreshable at runtime).
+ */
+
+import type {
+  FieldRefreshStatus,
+  FieldRegistryEntry,
+  InlineNode,
+  ParagraphNode,
+  StylesCatalog,
+} from "../model/canonical-document.ts";
+import type { RuntimePageGraph, RuntimePageNode } from "./layout/page-graph.ts";
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/**
+ * Structural content root type: any object that has `type: string` and
+ * optional `children` / `rows` arrays. The real root is `DocumentRootNode`
+ * from canonical-document but callers that build minimal stubs (e.g. tests)
+ * cast with `as never`.
+ */
+export interface DocumentContainerNode {
+  type: string;
+  children?: unknown[];
+  rows?: unknown[];
+}
+
+export interface FieldResolverInput {
+  pageGraph: RuntimePageGraph;
+  activePageIndex: number;
+  bookmarkMap: Map<string, { bookmarkId: string; paragraphIndex: number }>;
+  paragraphOffsets: readonly number[];
+  styles: StylesCatalog;
+  contentRoot: DocumentContainerNode;
+}
+
+export interface ResolvedField {
+  displayText: string;
+  refreshStatus: FieldRefreshStatus;
+  /** True when the field's `\h` switch is set — renderers should wrap result in a hyperlink to the target bookmark. */
+  asHyperlink?: boolean;
+}
+
+export interface FieldResolver {
+  resolve(entry: FieldRegistryEntry): ResolvedField | undefined;
+  cacheKey: string;
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export function createFieldResolver(input: FieldResolverInput): FieldResolver {
+  const { pageGraph, activePageIndex, bookmarkMap, paragraphOffsets, contentRoot } = input;
+
+  // Cache key captures the dimensions that affect resolution output.
+  const cacheKey = `${pageGraph.revision}:${bookmarkMap.size}:${activePageIndex}`;
+
+  function resolve(entry: FieldRegistryEntry): ResolvedField | undefined {
+    switch (entry.fieldFamily) {
+      case "PAGE": {
+        const page = pageGraph.pages[activePageIndex];
+        if (!page) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        return {
+          displayText: String(page.stories.displayPageNumber),
+          refreshStatus: "current",
+        };
+      }
+
+      case "NUMPAGES": {
+        if (pageGraph.contentPageCount === 0) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        return {
+          displayText: String(pageGraph.contentPageCount),
+          refreshStatus: "current",
+        };
+      }
+
+      case "PAGEREF": {
+        if (!entry.fieldTarget) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const bookmark = bookmarkMap.get(entry.fieldTarget);
+        if (!bookmark) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        if (entry.switches?.relativePosition) {
+          const positionText =
+            bookmark.paragraphIndex < entry.paragraphIndex
+              ? "above"
+              : bookmark.paragraphIndex > entry.paragraphIndex
+                ? "below"
+                : "on this page";
+          return {
+            displayText: positionText,
+            refreshStatus: "current",
+            ...(entry.switches.hyperlink ? { asHyperlink: true as const } : {}),
+          };
+        }
+        const offset = paragraphOffsets[bookmark.paragraphIndex];
+        if (offset === undefined) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const page = findPageForOffset(pageGraph.pages, offset);
+        if (!page) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        return {
+          displayText: String(page.stories.displayPageNumber),
+          refreshStatus: "current",
+          ...(entry.switches?.hyperlink ? { asHyperlink: true as const } : {}),
+        };
+      }
+
+      case "REF": {
+        if (!entry.fieldTarget) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        if (entry.switches?.relativePosition) {
+          const bookmark = bookmarkMap.get(entry.fieldTarget);
+          if (!bookmark) {
+            return { displayText: "", refreshStatus: "unresolvable" };
+          }
+          const positionText =
+            bookmark.paragraphIndex < entry.paragraphIndex
+              ? "above"
+              : bookmark.paragraphIndex > entry.paragraphIndex
+                ? "below"
+                : "on this page";
+          return {
+            displayText: positionText,
+            refreshStatus: "current",
+            ...(entry.switches.hyperlink ? { asHyperlink: true as const } : {}),
+          };
+        }
+        const text = resolveRefText(contentRoot, bookmarkMap, entry.fieldTarget, paragraphOffsets);
+        if (text === undefined) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const displayText = entry.switches?.includeNumbering
+          ? extractNumberingPrefix(text)
+          : text;
+        return {
+          displayText,
+          refreshStatus: "current",
+          ...(entry.switches?.hyperlink ? { asHyperlink: true as const } : {}),
+        };
+      }
+
+      case "STYLEREF": {
+        if (!entry.fieldTarget) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const text = resolveStyleRefText(contentRoot, entry.fieldTarget);
+        return text !== undefined
+          ? { displayText: text, refreshStatus: "current" }
+          : { displayText: "", refreshStatus: "unresolvable" };
+      }
+
+      case "TOC":
+        // TOC is not refreshable at runtime; return undefined so callers
+        // preserve the existing display text unchanged.
+        return undefined;
+
+      default:
+        return undefined;
+    }
+  }
+
+  return { resolve, cacheKey };
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the leading numbering prefix from heading text. The `\w` switch on
+ * REF strips the body of the heading and emits only its numbering marker.
+ *
+ * Heuristic: take everything up to the first whitespace that follows at least
+ * one digit. If no digits appear before the first whitespace, return the
+ * original string unchanged.
+ *
+ * Examples: `"1.2.3 Overview"` → `"1.2.3"`; `"Chapter 5. Intro"` → `"Chapter 5."`;
+ * `"Plain heading"` → `"Plain heading"` (no digits — nothing to strip).
+ */
+function extractNumberingPrefix(text: string): string {
+  const match = /^(\S*\d[\d.\-]*)\s/.exec(text);
+  return match ? match[1]! : text;
+}
+
+/**
+ * Binary-search `pages` (sorted by `startOffset`) for the last page whose
+ * `startOffset` is ≤ `offset`. Returns `undefined` when the list is empty.
+ */
+function findPageForOffset(
+  pages: readonly RuntimePageNode[],
+  offset: number,
+): RuntimePageNode | undefined {
+  let lo = 0;
+  let hi = pages.length - 1;
+  let result: RuntimePageNode | undefined;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const page = pages[mid]!;
+    if (page.startOffset <= offset) {
+      result = page;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return result;
+}
+
+/**
+ * Walk paragraphs in document order and invoke `visit` for each one.
+ * Tables are traversed via their `rows` arrays, cells via their `children`.
+ */
+function walkParagraphs(
+  node: DocumentContainerNode,
+  visit: (para: ParagraphNode) => void,
+): void {
+  if (node.type === "paragraph") {
+    visit(node as unknown as ParagraphNode);
+    return;
+  }
+
+  const children = node.children;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      if (child != null && typeof child === "object" && "type" in child) {
+        walkParagraphs(child as DocumentContainerNode, visit);
+      }
+    }
+  }
+
+  // Tables carry rows separately from children in the canonical model.
+  if (node.type === "table") {
+    const rows = node.rows;
+    if (Array.isArray(rows)) {
+      for (const row of rows) {
+        if (row != null && typeof row === "object" && "type" in row) {
+          walkParagraphs(row as DocumentContainerNode, visit);
+        }
+      }
+    }
+  }
+
+  // Table rows carry cells separately from children; recurse into each cell
+  // so paragraphs nested inside table cells are visited.
+  if (node.type === "table_row") {
+    const cells = (node as { cells?: unknown[] }).cells;
+    if (Array.isArray(cells)) {
+      for (const cell of cells) {
+        if (cell && typeof cell === "object" && "type" in cell) {
+          walkParagraphs(cell as DocumentContainerNode, visit);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Flatten the inline children of a paragraph to plain text.
+ * Hyperlinks and fields are recursed; tabs become "\t"; hard/column breaks
+ * become "\n"; everything else (images, symbols, etc.) is omitted.
+ */
+function flattenText(children: InlineNode[]): string {
+  return children
+    .map((c) => {
+      switch (c.type) {
+        case "text":
+          return c.text;
+        case "tab":
+          return "\t";
+        case "hard_break":
+        case "column_break":
+          return "\n";
+        case "hyperlink":
+        case "field":
+          return flattenText(c.children);
+        default:
+          return "";
+      }
+    })
+    .join("");
+}
+
+/**
+ * Resolve a REF field by locating the paragraph identified by `target` in
+ * `bookmarkMap` and flattening its text.
+ */
+function resolveRefText(
+  root: DocumentContainerNode,
+  bookmarkMap: Map<string, { bookmarkId: string; paragraphIndex: number }>,
+  target: string,
+  _paragraphOffsets: readonly number[],
+): string | undefined {
+  const bookmark = bookmarkMap.get(target);
+  if (!bookmark) return undefined;
+
+  let index = -1;
+  let result: string | undefined;
+  walkParagraphs(root, (para) => {
+    index += 1;
+    if (result === undefined && index === bookmark.paragraphIndex) {
+      result = flattenText(para.children);
+    }
+  });
+  return result;
+}
+
+/**
+ * Resolve a STYLEREF field by finding the first paragraph whose `styleId`
+ * matches `styleId` and returning its flattened text (trimmed).
+ */
+function resolveStyleRefText(
+  root: DocumentContainerNode,
+  styleId: string,
+): string | undefined {
+  let result: string | undefined;
+  walkParagraphs(root, (para) => {
+    if (result !== undefined) return;
+    if (para.styleId === styleId) {
+      const text = flattenText(para.children).trim();
+      if (text.length > 0) result = text;
+    }
+  });
+  return result;
+}

package/src/runtime/footnote-resolver.ts

@@ -0,0 +1,55 @@
+import type {
+  EndnoteProperties,
+  FootnoteCollection,
+  FootnoteProperties,
+  SectionProperties,
+} from "../model/canonical-document.ts";
+
+export interface FootnoteResolver {
+  getContinuationSeparatorContent(kind: "footnote" | "endnote"): string | undefined;
+  getSeparatorContent(kind: "footnote" | "endnote"): string | undefined;
+  getFootnoteCount(): number;
+  getEndnoteCount(): number;
+  /**
+   * Resolve the effective `<w:footnotePr>` for a given section. Returns the
+   * section's typed properties when present, or `undefined` when the section
+   * has no override (callers should fall back to Word defaults). File-level
+   * defaults from `settings.xml` are not yet wired in — that's a later slice.
+   */
+  getFootnoteProperties(sectionIndex?: number): FootnoteProperties | undefined;
+  /**
+   * Resolve the effective `<w:endnotePr>` for a given section. Same semantics
+   * as `getFootnoteProperties` but reads `endnotePr` from the section list.
+   */
+  getEndnoteProperties(sectionIndex?: number): EndnoteProperties | undefined;
+}
+
+export function createFootnoteResolver(
+  collection: FootnoteCollection,
+  sections?: readonly SectionProperties[],
+): FootnoteResolver {
+  return {
+    getContinuationSeparatorContent(kind) {
+      const separators = kind === "footnote" ? collection.footnoteSeparators : collection.endnoteSeparators;
+      return separators?.continuationSeparatorContent;
+    },
+    getSeparatorContent(kind) {
+      const separators = kind === "footnote" ? collection.footnoteSeparators : collection.endnoteSeparators;
+      return separators?.separatorContent;
+    },
+    getFootnoteCount() {
+      return Object.keys(collection.footnotes).length;
+    },
+    getEndnoteCount() {
+      return Object.keys(collection.endnotes).length;
+    },
+    getFootnoteProperties(sectionIndex) {
+      if (sectionIndex === undefined || !sections) return undefined;
+      return sections[sectionIndex]?.footnotePr;
+    },
+    getEndnoteProperties(sectionIndex) {
+      if (sectionIndex === undefined || !sections) return undefined;
+      return sections[sectionIndex]?.endnotePr;
+    },
+  };
+}

package/src/runtime/hyperlink-color-resolver.ts

@@ -20,7 +20,8 @@
  *   4. Hardcoded Word default `#0563C1`.
  *
  * The resolver also honors `colorThemeSlot` + `colorThemeTint`/`colorThemeShade`
- * from L2.c by delegating to `resolveThemeColorHex`.
+ * by delegating to `ThemeColorResolver.resolveWordThemeColor` (which applies
+ * `w:clrSchemeMapping` remap).
  *
  * Contract: the returned `CanonicalRunFormatting` is the effective cascade
  * result with `colorHex` concretized to a non-theme hex (or `"auto"`). The
@@ -31,11 +32,9 @@
 
 import type {
   CanonicalRunFormatting,
-  ResolvedTheme,
   StylesCatalog,
 } from "../model/canonical-document.ts";
-import { resolveThemeColor } from "../io/ooxml/parse-theme.ts";
-import { resolveThemeColorHex } from "./theme-color-resolver.ts";
+import { ThemeColorResolver } from "./theme-color-resolver.ts";
 import {
   resolveEffectiveRunFormatting,
   type RunResolveInput,
@@ -64,7 +63,7 @@ export const DEFAULT_HYPERLINK_COLOR_HEX = "0563C1";
 export function resolveHyperlinkRunFormatting(
   input: RunResolveInput,
   catalog: StylesCatalog | undefined,
-  theme: ResolvedTheme | undefined,
+  resolver: ThemeColorResolver | undefined,
 ): CanonicalRunFormatting {
   // V7a — auto-apply the Hyperlink character style when the caller did
   // not supply one (runs inside <w:hyperlink> typically lack explicit
@@ -77,7 +76,7 @@ export function resolveHyperlinkRunFormatting(
   const cascade = resolveEffectiveRunFormatting(augmentedInput, catalog);
 
   // V7b — concretize the color through the theme resolver + Word default.
-  const resolvedColor = resolveHyperlinkColorHex(cascade, theme);
+  const resolvedColor = resolveHyperlinkColorHex(cascade, resolver);
   if (resolvedColor && resolvedColor !== cascade.colorHex) {
     return { ...cascade, colorHex: resolvedColor };
   }
@@ -93,7 +92,7 @@ export function resolveHyperlinkColorHex(
     CanonicalRunFormatting,
     "colorHex" | "colorThemeSlot" | "colorThemeTint" | "colorThemeShade"
   >,
-  theme: ResolvedTheme | undefined,
+  resolver: ThemeColorResolver | undefined,
 ): string | undefined {
   // Tier 1 — direct non-auto hex wins.
   if (cascade.colorHex && cascade.colorHex !== "auto") {
@@ -101,8 +100,12 @@ export function resolveHyperlinkColorHex(
   }
   // Tier 2 — theme-slot reference from the cascade (which now includes the
   // Hyperlink style's rPr — typically `<w:color w:themeColor="hlink"/>`).
-  if (cascade.colorThemeSlot) {
-    const viaTheme = resolveThemeColorHex(cascade, theme);
+  if (cascade.colorThemeSlot && resolver) {
+    const viaTheme = resolver.resolveWordThemeColor(
+      cascade.colorThemeSlot,
+      cascade.colorThemeTint,
+      cascade.colorThemeShade,
+    );
     if (viaTheme && viaTheme !== "auto") {
       return viaTheme;
     }
@@ -110,7 +113,7 @@ export function resolveHyperlinkColorHex(
   // Tier 3 — theme hlink slot even when the cascade never wrote a slot
   // reference. This catches docs whose Hyperlink style lacks a color
   // declaration entirely but whose theme defines hlink.
-  const themeHlink = resolveThemeColor(theme, "hlink");
+  const themeHlink = resolver?.resolveSchemeSlot("hlink");
   if (themeHlink) {
     return themeHlink;
   }

package/src/runtime/object-grab/index.ts

@@ -0,0 +1,51 @@
+/**
+ * R.3 ObjectGrabLayer — runtime-side grab state for inline / floating
+ * objects (images, shapes). Lane 6 P11 paints the chrome handles; this
+ * module owns the state model so both sides reference one source of truth.
+ *
+ * Design invariants:
+ * 1. **Single-select.** One grabbed object at a time (matches LibreOffice
+ *    `SwFEShell::SelectObj`); multi-select for Alt+Shift drag selection
+ *    lands in a follow-up once user flows require it.
+ * 2. **Local-only, not collab-broadcast.** A remote peer's grab state is
+ *    surfaced via remote-cursor awareness, not via this layer — each peer
+ *    has their own grab state, matching the text-selection model.
+ * 3. **Pure state transitions.** Every mutation returns a new object; the
+ *    runtime stores the state alongside selection and emits on snapshot.
+ * 4. **String ids, not node references.** Grab state uses `objectId` so
+ *    the state survives snapshot replacement. The runtime resolves the id
+ *    to the current node when it needs to dispatch image commands.
+ *
+ * What this module deliberately does NOT do in Item C:
+ *   - Rotation / anchor-mode / z-order mutation — those are image.set-*
+ *     commands on the existing `image-commands.ts` module; the grab layer
+ *     is just "which object has focus". Host wires chrome interactions to
+ *     those commands via the ref methods.
+ *   - Hit-testing — chrome layer uses Lane 3a P9 `RenderAnchorIndex` to
+ *     convert click coords to an object id, then calls `selectObject(id)`.
+ */
+
+export interface ObjectGrabState {
+  /** The grabbed object's stable id (image.mediaId / shape.shapeId), or null. */
+  objectId: string | null;
+}
+
+export function createObjectGrabState(): ObjectGrabState {
+  return { objectId: null };
+}
+
+export function selectObject(state: ObjectGrabState, objectId: string): ObjectGrabState {
+  if (state.objectId === objectId) {
+    return state; // idempotent — same id, same state (reference-equal)
+  }
+  return { objectId };
+}
+
+export function deselectObject(state: ObjectGrabState): ObjectGrabState {
+  if (state.objectId === null) return state;
+  return { objectId: null };
+}
+
+export function getGrabbedObject(state: ObjectGrabState): string | null {
+  return state.objectId;
+}