fix: image rendering (#2796)

* fix: image rendering

* chore: update test case

Author: VladaHarbour

packages/layout-engine/pm-adapter/src/utilities.test.ts

@@ -752,6 +752,36 @@ describe('Media Utilities', () => {
       expect(result[0].src).toBe('data:image/png;base64,base64data');
     });
 
+    it('hydrates word/media src from media storage key', () => {
+      const blocks: FlowBlock[] = [
+        {
+          kind: 'image',
+          id: '1',
+          src: 'word/media/image.png',
+          runs: [],
+        },
+      ];
+      const mediaFiles = { 'media/image.png': 'base64data' };
+
+      const result = hydrateImageBlocks(blocks, mediaFiles);
+      expect(result[0].src).toBe('data:image/png;base64,base64data');
+    });
+
+    it('hydrates media src from word/media storage key', () => {
+      const blocks: FlowBlock[] = [
+        {
+          kind: 'image',
+          id: '1',
+          src: 'media/image.png',
+          runs: [],
+        },
+      ];
+      const mediaFiles = { 'word/media/image.png': 'base64data' };
+
+      const result = hydrateImageBlocks(blocks, mediaFiles);
+      expect(result[0].src).toBe('data:image/png;base64,base64data');
+    });
+
     it('uses rId fallback when direct path does not match', () => {
       const blocks: FlowBlock[] = [
         {

packages/layout-engine/pm-adapter/src/utilities.ts

@@ -1001,9 +1001,18 @@ export function hydrateImageBlocks(blocks: FlowBlock[], mediaFiles?: Record<stri
       return undefined;
     }
 
+    const addPathCandidates = (value?: string) => {
+      if (!value) return [] as string[];
+      const normalized = normalizeMediaKey(value);
+      if (!normalized) return [value];
+      const withoutWordPrefix = normalized.startsWith('word/') ? normalized.slice(5) : normalized;
+      const withWordPrefix = normalized.startsWith('word/') ? normalized : `word/${normalized}`;
+      return [value, normalized, withoutWordPrefix, withWordPrefix];
+    };
+
     const candidates = new Set<string>();
-    candidates.add(src);
-    if (attrSrc) candidates.add(attrSrc);
+    addPathCandidates(src).forEach((candidate) => candidates.add(candidate));
+    if (attrSrc) addPathCandidates(attrSrc).forEach((candidate) => candidates.add(candidate));
     if (relId) {
       const inferredExt = extension ?? inferExtensionFromPath(src) ?? 'jpeg';
       candidates.add(`word/media/${relId}.${inferredExt}`);

packages/super-editor/src/editors/v1/core/super-converter/v3/handlers/mc/altermateContent/alternate-content-translator.js

@@ -116,10 +116,11 @@ export function selectAlternateContentElements(node) {
     const requiresAttr = choice?.attributes?.Requires || choice?.attributes?.requires;
     if (!requiresAttr) return false;
 
-    return requiresAttr
-      .split(/\s+/)
-      .filter(Boolean)
-      .some((namespace) => SUPPORTED_ALTERNATE_CONTENT_REQUIRES.has(namespace));
+    const requiredNamespaces = requiresAttr.split(/\s+/).filter(Boolean);
+    if (requiredNamespaces.length === 0) return false;
+
+    // ECMA-376 mc:Choice requires ALL listed namespaces to be understood.
+    return requiredNamespaces.every((namespace) => SUPPORTED_ALTERNATE_CONTENT_REQUIRES.has(namespace));
   });
 
   const branch = supportedChoice || fallback || choices[0] || null;

packages/super-editor/src/editors/v1/core/super-converter/v3/handlers/mc/altermateContent/alternate-content-translator.test.js

@@ -178,10 +178,10 @@ describe('selectAlternateContentElements', () => {
     expect(SUPPORTED_ALTERNATE_CONTENT_REQUIRES.has('w16sdtfl')).toBe(true);
   });
 
-  it('selects supported choice when namespace matches set', () => {
+  it('selects supported choice when all required namespaces are supported', () => {
     const choice = {
       name: 'mc:Choice',
-      attributes: { Requires: 'foo wps bar' },
+      attributes: { Requires: 'wps w14' },
       elements: [{ name: 'w:r' }],
     };
     const node = {
@@ -193,6 +193,22 @@ describe('selectAlternateContentElements', () => {
     expect(elements).toEqual(choice.elements);
   });
 
+  it('falls back when mc:Choice requires an unsupported namespace', () => {
+    const fallback = { name: 'mc:Fallback', elements: [{ name: 'w:p' }] };
+    const mixedChoice = {
+      name: 'mc:Choice',
+      attributes: { Requires: 'wps unknownNs' },
+      elements: [{ name: 'w:r' }],
+    };
+    const node = {
+      elements: [mixedChoice, fallback],
+    };
+
+    const { branch, elements } = selectAlternateContentElements(node);
+    expect(branch).toBe(fallback);
+    expect(elements).toEqual(fallback.elements);
+  });
+
   it('returns fallback when no choice is supported', () => {
     const fallback = { name: 'mc:Fallback', elements: [{ name: 'w:p' }] };
     const node = {

packages/super-editor/src/editors/v1/tests/import/alternateChoiceImporter.test.js

@@ -194,7 +194,7 @@ describe('alternateChoiceHandler', () => {
     expect(text).toBe('cell choice');
   });
 
-  it('selects a supported choice when Requires contains multiple namespaces', () => {
+  it('falls back when Requires lists any unsupported namespace (all must be supported)', () => {
     const altNode = {
       type: 'element',
       name: 'mc:AlternateContent',
@@ -203,6 +203,38 @@ describe('alternateChoiceHandler', () => {
           type: 'element',
           name: 'mc:Choice',
           attributes: { Requires: 'foo wps bar' },
+          elements: [createTextRun('choice run')],
+        },
+        {
+          type: 'element',
+          name: 'mc:Fallback',
+          elements: [createTextRun('fallback run')],
+        },
+      ],
+    };
+
+    const { handlerSpy, result } = callHandler([altNode]);
+
+    expect(result.consumed).toBe(1);
+    expect(handlerSpy).toHaveBeenCalledTimes(1);
+    const handledCall = handlerSpy.mock.calls[0][0];
+    const handledNodes = handledCall?.nodes ?? [];
+    expect(handledNodes).toHaveLength(1);
+    const run = handledNodes[0];
+    const textElement = run.elements?.find((el) => el.name === 'w:t');
+    const textNode = textElement?.elements?.find((el) => el.type === 'text');
+    expect(textNode?.text).toBe('fallback run');
+  });
+
+  it('selects choice when every Requires namespace is supported', () => {
+    const altNode = {
+      type: 'element',
+      name: 'mc:AlternateContent',
+      elements: [
+        {
+          type: 'element',
+          name: 'mc:Choice',
+          attributes: { Requires: 'wps w14' },
           elements: [createTextRun('supported choice')],
         },
         {