Merge branch 'main' into stable

Author: harbournick

packages/layout-engine/pm-adapter/src/converters/math-block.test.ts

@@ -80,4 +80,34 @@ describe('handleMathBlockNode', () => {
     handleMathBlockNode(makeNode({ textContent: 'b' }) as any, context);
     expect(blocks[0].id).not.toBe(blocks[1].id);
   });
+
+  it('resolves paragraph spacing from paragraphProperties', () => {
+    const { context, blocks } = makeContext();
+    const node = makeNode({
+      textContent: 'x',
+      paragraphProperties: { spacing: { before: 240, after: 160, line: 276, lineRule: 'auto' } },
+    });
+
+    handleMathBlockNode(node as any, context);
+
+    const block = blocks[0] as ParagraphBlock;
+    expect(block.attrs?.spacing).toBeDefined();
+    expect(block.attrs?.spacing?.before).toBeGreaterThan(0);
+    expect(block.attrs?.spacing?.after).toBeGreaterThan(0);
+  });
+
+  it('falls back to paragraph alignment when justification is unknown', () => {
+    const { context, blocks } = makeContext();
+    const node = makeNode({
+      textContent: 'x',
+      justification: 'unknown',
+      paragraphProperties: { justification: 'right' },
+    });
+
+    handleMathBlockNode(node as any, context);
+
+    const block = blocks[0] as ParagraphBlock;
+    // When math justification is unknown, falls back to paragraphAttrs alignment
+    expect(block.attrs?.alignment).toBeDefined();
+  });
 });

packages/layout-engine/pm-adapter/src/converters/math-block.ts

@@ -1,6 +1,7 @@
 import type { ParagraphBlock, MathRun } from '@superdoc/contracts';
 import type { PMNode, NodeHandlerContext } from '../types.js';
 import { estimateMathDimensions } from './math-constants.js';
+import { computeParagraphAttrs } from '../attributes/index.js';
 
 const JUSTIFICATION_TO_ALIGN: Record<string, 'left' | 'center' | 'right'> = {
   center: 'center',
@@ -32,12 +33,17 @@ export function handleMathBlockNode(node: PMNode, context: NodeHandlerContext):
     pmEnd: pos?.end,
   };
 
+  // Resolve paragraph spacing from the parent w:p's properties (carried via paragraphProperties attr).
+  // This ensures display math paragraphs get the same spacing as their containing paragraph.
+  const { paragraphAttrs } = computeParagraphAttrs(node, context.converterContext);
+
   const block: ParagraphBlock = {
     kind: 'paragraph',
     id: nextBlockId('paragraph'),
     runs: [mathRun],
     attrs: {
-      alignment: JUSTIFICATION_TO_ALIGN[justification] ?? 'center',
+      ...paragraphAttrs,
+      alignment: JUSTIFICATION_TO_ALIGN[justification] ?? paragraphAttrs.alignment ?? 'center',
     },
   };
 

packages/sdk/codegen/src/generate-intent-tools.mjs

@@ -1,5 +1,5 @@
-import path from 'node:path';
 import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 import { loadContract, REPO_ROOT, stripBoundParams, writeGeneratedFile } from './shared.mjs';
 
 const TOOLS_OUTPUT_DIR = path.join(REPO_ROOT, 'packages/sdk/tools');
@@ -495,15 +495,11 @@ function toOpenAiTool(entry) {
 }
 
 function toAnthropicTool(entry) {
-  const tool = {
+  return {
     name: entry.toolName,
     description: entry.description,
     input_schema: entry.inputSchema,
   };
-  if (entry.inputExamples?.length) {
-    tool.input_examples = entry.inputExamples;
-  }
-  return tool;
 }
 
 function toVercelTool(entry) {

packages/super-editor/src/editors/v1/components/ImageResizeOverlay.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mount } from '@vue/test-utils';
+import ImageResizeOverlay from './ImageResizeOverlay.vue';
+
+vi.mock('@superdoc/layout-bridge', () => ({
+  measureCache: {
+    invalidate: vi.fn(),
+  },
+}));
+
+function createMockEditor(overrides = {}) {
+  return {
+    options: { documentMode: 'editing' },
+    isEditable: true,
+    view: {
+      dom: document.createElement('div'),
+      state: { doc: { nodeAt: vi.fn() }, tr: { setNodeMarkup: vi.fn().mockReturnThis() } },
+      dispatch: vi.fn(),
+    },
+    ...overrides,
+  };
+}
+
+describe('ImageResizeOverlay', () => {
+  describe('isResizeDisabled guard', () => {
+    it('should report resize disabled when documentMode is viewing', () => {
+      const editor = createMockEditor({ options: { documentMode: 'viewing' }, isEditable: false });
+      const imageEl = document.createElement('div');
+
+      const wrapper = mount(ImageResizeOverlay, {
+        props: { editor, visible: true, imageElement: imageEl },
+      });
+
+      expect(wrapper.vm.isResizeDisabled).toBe(true);
+    });
+
+    it('should report resize disabled when editor is not editable', () => {
+      const editor = createMockEditor({ isEditable: false });
+      const imageEl = document.createElement('div');
+
+      const wrapper = mount(ImageResizeOverlay, {
+        props: { editor, visible: true, imageElement: imageEl },
+      });
+
+      expect(wrapper.vm.isResizeDisabled).toBe(true);
+    });
+
+    it('should not report resize disabled in editing mode', () => {
+      const editor = createMockEditor();
+      const imageEl = document.createElement('div');
+
+      const wrapper = mount(ImageResizeOverlay, {
+        props: { editor, visible: true, imageElement: imageEl },
+      });
+
+      expect(wrapper.vm.isResizeDisabled).toBe(false);
+    });
+  });
+});

packages/super-editor/src/editors/v1/components/ImageResizeOverlay.vue

@@ -72,6 +72,8 @@ const props = defineProps({
 
 const emit = defineEmits(['resize-start', 'resize-move', 'resize-end', 'resize-success', 'resize-error']);
 
+const isResizeDisabled = computed(() => props.editor?.options?.documentMode === 'viewing' || !props.editor?.isEditable);
+
 /**
  * Parsed image metadata from data-image-metadata attribute
  */
@@ -320,6 +322,8 @@ function onHandleMouseDown(event, handlePosition) {
   event.preventDefault();
   event.stopPropagation();
 
+  if (isResizeDisabled.value) return;
+
   if (!isValidEditor(props.editor) || !imageMetadata.value || !props.imageElement) return;
 
   const rect = props.imageElement.getBoundingClientRect();

packages/super-editor/src/editors/v1/components/SuperEditor.test.js

@@ -18,6 +18,10 @@ const EditorConstructor = vi.hoisted(() => {
     });
     this.off = vi.fn();
     this.view = { focus: vi.fn() };
+    this.setDocumentMode = vi.fn((mode) => {
+      this.options.documentMode = mode;
+      this.listeners.documentModeChange?.({ documentMode: mode, editor: this });
+    });
     this.destroy = vi.fn();
   });
 
@@ -1328,6 +1332,126 @@ describe('SuperEditor.vue', () => {
         wrapper.unmount();
         vi.useRealTimers();
       });
+
+      it('should hide image resize overlay and skip image hover updates in viewing mode', async () => {
+        vi.useFakeTimers();
+        EditorConstructor.loadXmlData.mockResolvedValueOnce(['<docx />', {}, {}, {}]);
+
+        const wrapper = mount(SuperEditor, {
+          props: {
+            documentId: 'doc-image-view-guard',
+            options: {},
+          },
+        });
+
+        await flushPromises();
+        await flushPromises();
+
+        const updateSpy = vi.spyOn(wrapper.vm, 'updateImageResizeOverlay');
+
+        Object.defineProperty(wrapper.vm, 'activeEditor', {
+          value: {
+            value: {
+              options: { documentMode: 'viewing' },
+              isEditable: false,
+              view: { focus: vi.fn() },
+            },
+          },
+        });
+        wrapper.vm.getDocumentMode = () => 'viewing';
+        wrapper.vm.isViewingMode = () => true;
+
+        wrapper.vm.imageResizeState.visible = true;
+        wrapper.vm.imageResizeState.imageElement = document.createElement('div');
+        wrapper.vm.imageResizeState.blockId = 'image-block';
+
+        wrapper.vm.handleOverlayUpdates(new MouseEvent('mousemove'));
+
+        expect(updateSpy).not.toHaveBeenCalled();
+        expect(wrapper.vm.imageResizeState.visible).toBe(false);
+        expect(wrapper.vm.imageResizeState.imageElement).toBe(null);
+        expect(wrapper.vm.imageResizeState.blockId).toBe(null);
+
+        wrapper.unmount();
+        vi.useRealTimers();
+      });
+
+      it('should not apply image selection outline in viewing mode', async () => {
+        vi.useFakeTimers();
+        EditorConstructor.loadXmlData.mockResolvedValueOnce(['<docx />', {}, {}, {}]);
+
+        const wrapper = mount(SuperEditor, {
+          props: {
+            documentId: 'doc-image-selection-view-guard',
+            options: {},
+          },
+        });
+
+        await flushPromises();
+        await flushPromises();
+
+        Object.defineProperty(wrapper.vm, 'activeEditor', {
+          value: {
+            value: {
+              options: { documentMode: 'viewing' },
+              isEditable: false,
+              view: { focus: vi.fn() },
+            },
+          },
+        });
+        wrapper.vm.getDocumentMode = () => 'viewing';
+        wrapper.vm.isViewingMode = () => true;
+
+        const imageEl = document.createElement('div');
+        wrapper.vm.setSelectedImage(imageEl, 'image-block', 42);
+
+        expect(imageEl.classList.contains('superdoc-image-selected')).toBe(false);
+        expect(wrapper.vm.selectedImageState.element).toBe(null);
+        expect(wrapper.vm.selectedImageState.blockId).toBe(null);
+        expect(wrapper.vm.selectedImageState.pmStart).toBe(null);
+
+        wrapper.unmount();
+        vi.useRealTimers();
+      });
+
+      it('should clear image selection when props switch to viewing mode', async () => {
+        vi.useFakeTimers();
+        EditorConstructor.loadXmlData.mockResolvedValueOnce(['<docx />', {}, {}, {}]);
+
+        const wrapper = mount(SuperEditor, {
+          props: {
+            documentId: 'doc-image-selection-mode-switch',
+            options: { documentMode: 'editing' },
+          },
+        });
+
+        await flushPromises();
+        await flushPromises();
+
+        const imageEl = document.createElement('div');
+        imageEl.classList.add('superdoc-image-selected');
+        wrapper.vm.selectedImageState.element = imageEl;
+        wrapper.vm.selectedImageState.blockId = 'image-block';
+        wrapper.vm.selectedImageState.pmStart = 42;
+        wrapper.vm.imageResizeState.visible = true;
+        wrapper.vm.imageResizeState.imageElement = imageEl;
+        wrapper.vm.imageResizeState.blockId = 'image-block';
+
+        await wrapper.setProps({
+          options: { documentMode: 'viewing' },
+        });
+
+        expect(imageEl.classList.contains('superdoc-image-selected')).toBe(false);
+        expect(wrapper.vm.selectedImageState.element).toBe(null);
+        expect(wrapper.vm.selectedImageState.blockId).toBe(null);
+        expect(wrapper.vm.selectedImageState.pmStart).toBe(null);
+        expect(wrapper.vm.imageResizeState.visible).toBe(false);
+        expect(wrapper.vm.imageResizeState.imageElement).toBe(null);
+        expect(wrapper.vm.imageResizeState.blockId).toBe(null);
+
+        wrapper.unmount();
+        vi.useRealTimers();
+      });
     });
   });
 });