fix: show linked images

This commit is contained in:
Steffen Becker committed 2026-07-10 00:11:14 +02:00
1 parent efaa9439b5
commit edf51d9a68
4 files changed
+238 -58

No files matched your search

+48 -26
View File
@@ -6,6 +6,7 @@ import { HEADER_SHADE } from '../editor/extensions/tableHeaderRow';
import { orderedTypeFromFormat, orderedTypeAttrAt, childCycle, ROOT_ORDERED_CYCLE, type OrderedCycle } from '../utils/orderedListTypes';
import { bulletCharAttr, bulletCharFromDocx } from '../utils/bulletListTypes';
import { DATE_FORMATS, TIME_FORMATS, docxPicture, toDateValue } from '../utils/dateTime';
import { imageDataUrl } from './imageFormats';
import { PX_PER_CM, type PageMargins } from '../storage/pageMargins';
import type { Orientation } from '../storage/pageOrientation';
import { formatFromCm, type PageFormat } from '../storage/pageFormat';
@@ -51,10 +52,6 @@ const LIST_LEFT_STEP_CM = 1.27; // matches export/docx.ts
const LIST_INDENT_EPS_CM = 0.05;
const LINK_BLUE = '#0563C1'; // the visual the exporter paints on hyperlink runs
const MIME_BY_EXT: Record<string, string> = {
png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', bmp: 'image/bmp', svg: 'image/svg+xml', webp: 'image/webp',
};
// ---- small DOM helpers ------------------------------------------------------
function fc(el: Element | null, localName: string): Element | null {
if (!el) return null;
@@ -83,13 +80,6 @@ function hexColor(v: string | null | undefined): string | undefined {
return /^[0-9a-fA-F]{6}$/.test(v) ? normalizeColor(`#${v}`) : normalizeColor(v);
}
function bytesToBase64(bytes: Uint8Array): string {
let bin = '';
const chunk = 0x8000;
for (let i = 0; i < bytes.length; i += chunk) bin += String.fromCharCode(...bytes.subarray(i, i + chunk));
return btoa(bin);
}
// ---- entry ------------------------------------------------------------------
export function importDocx(bytes: Uint8Array): OdtImportResult {
let files: Record<string, Uint8Array>;
@@ -716,8 +706,8 @@ function loadImageDataUrl(path: string, ctx: Ctx): string | null {
if (cached) return cached;
const bytes = ctx.files[path];
if (!bytes) return null;
const ext = path.split('.').pop()?.toLowerCase() ?? '';
const url = `data:${MIME_BY_EXT[ext] ?? 'image/png'};base64,${bytesToBase64(bytes)}`;
const url = imageDataUrl(bytes, path);
if (!url) return null;
ctx.imageCache.set(path, url);
return url;
}
@@ -731,11 +721,25 @@ function convertDrawing(drawing: Element, ctx: Ctx): Node | null {
if (wsp) return convertWpsShape(wsp, root, !!anchor, ctx);
const blip = drawing.getElementsByTagNameNS(A, 'blip')[0];
if (!blip) { ctx.warnings.add('Drawings were removed'); return null; }
const embed = blip.getAttributeNS(R, 'embed');
const rel = embed ? ctx.rels.get(embed) : undefined;
if (!rel || rel.external) { ctx.warnings.add('Some images could not be read and were skipped'); return null; }
const src = loadImageDataUrl(`word/${rel.target.replace(/^\/+/, '')}`, ctx);
if (!src) { ctx.warnings.add('Some images could not be read and were skipped'); return null; }
// Candidate media: the primary blip plus any SVG alternative (Word 2016+ stores an
// svgBlip beside a raster fallback) — prefer whichever the browser can display.
const candidates: string[] = [];
const pushEmbed = (id: string | null) => {
const rel = id ? ctx.rels.get(id) : undefined;
if (rel && !rel.external) candidates.push(`word/${rel.target.replace(/^\/+/, '')}`);
};
pushEmbed(blip.getAttributeNS(R, 'embed'));
for (const sb of Array.from(blip.getElementsByTagName('*')))
if (sb.localName === 'svgBlip') pushEmbed(sb.getAttributeNS(R, 'embed'));
if (!candidates.length) { ctx.warnings.add('Some images could not be read and were skipped'); return null; }
const path = candidates.find(p => loadImageDataUrl(p, ctx)) ?? candidates[0];
const src = loadImageDataUrl(path, ctx);
if (!src) {
ctx.warnings.add(ctx.files[path]
? 'Images in a format the browser can’t display (e.g. WMF, EMF, TIFF) were removed'
: 'Some images could not be read and were skipped');
return null;
}
const attrs: Record<string, unknown> = { src };
const extent = root.getElementsByTagNameNS(WP, 'extent')[0];
@@ -827,14 +831,7 @@ function convertPict(pict: Element, ctx: Ctx): Node | null {
const shape = Array.from(pict.children).find(
(c) => c.namespaceURI === VML && ['shape', 'rect', 'oval', 'roundrect'].includes(c.localName),
);
const txbxContent = shape
? nsChild(shape.getElementsByTagNameNS(VML, 'textbox')[0] ?? null, W, 'txbxContent')
: null;
if (!shape || !txbxContent) { ctx.warnings.add('Drawings were removed'); return null; }
const attrs: Record<string, unknown> = {};
const kind = shape.localName === 'oval' ? 'ellipse' : shape.localName === 'roundrect' ? 'roundRect' : 'textbox';
if (kind !== 'textbox') attrs.shapeKind = kind;
if (!shape) { ctx.warnings.add('Drawings were removed'); return null; }
const style = shape.getAttribute('style') ?? '';
const dimPx = (key: string): number | null => {
@@ -847,6 +844,31 @@ function convertPict(pict: Element, ctx: Ctx): Node | null {
};
const w = dimPx('width');
const h = dimPx('height');
// A v:imagedata is a legacy inline picture (no text box) → an image node.
const imagedata = shape.getElementsByTagNameNS(VML, 'imagedata')[0];
const imgRel = imagedata ? ctx.rels.get(imagedata.getAttributeNS(R, 'id') ?? '') : undefined;
if (imagedata && imgRel && !imgRel.external) {
const path = `word/${imgRel.target.replace(/^\/+/, '')}`;
const src = loadImageDataUrl(path, ctx);
if (!src) {
ctx.warnings.add(ctx.files[path]
? 'Images in a format the browser can’t display (e.g. WMF, EMF, TIFF) were removed'
: 'Some images could not be read and were skipped');
return null;
}
const imgAttrs: Record<string, unknown> = { src };
if (w) imgAttrs.width = w;
if (h) imgAttrs.height = h;
return { type: 'image', attrs: imgAttrs };
}
const txbxContent = nsChild(shape.getElementsByTagNameNS(VML, 'textbox')[0] ?? null, W, 'txbxContent');
if (!txbxContent) { ctx.warnings.add('Drawings were removed'); return null; }
const attrs: Record<string, unknown> = {};
const kind = shape.localName === 'oval' ? 'ellipse' : shape.localName === 'roundrect' ? 'roundRect' : 'textbox';
if (kind !== 'textbox') attrs.shapeKind = kind;
if (w) attrs.width = w;
if (h) attrs.height = h;
+72
View File
@@ -0,0 +1,72 @@
// Image-format handling shared by the ODF and DOCX importers. An <img> can only
// render a fixed set of formats; anything else (WMF/EMF/SVM/TIFF/…) has to be skipped
// with a warning rather than emitted as a broken image. The format is resolved from
// the file extension first, then confirmed/recovered from the bytes' magic number so a
// mislabelled or extensionless entry still works.
const MIME_BY_EXT: Record<string, string> = {
png: 'image/png',
apng: 'image/apng',
jpg: 'image/jpeg',
jpeg: 'image/jpeg',
jfif: 'image/jpeg',
pjpeg: 'image/jpeg',
pjp: 'image/jpeg',
gif: 'image/gif',
bmp: 'image/bmp',
svg: 'image/svg+xml',
webp: 'image/webp',
avif: 'image/avif',
ico: 'image/x-icon',
};
export function imageExtOf(path: string): string {
const bare = path.split(/[?#]/)[0];
return bare.split('.').pop()?.toLowerCase() ?? '';
}
// A renderable mime from the magic number, or null (unknown/unrenderable). Only the
// formats browsers display are recognised — a metafile/TIFF signature returns null.
function sniffImageMime(bytes: Uint8Array): string | null {
const b = bytes;
if (b.length < 4) return null;
if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) return 'image/png';
if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return 'image/jpeg';
if (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x38) return 'image/gif';
if (b[0] === 0x42 && b[1] === 0x4d) return 'image/bmp';
if (b[0] === 0x00 && b[1] === 0x00 && b[2] === 0x01 && b[3] === 0x00) return 'image/x-icon';
if (b.length >= 12 && b[0] === 0x52 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x46
&& b[8] === 0x57 && b[9] === 0x45 && b[10] === 0x42 && b[11] === 0x50) return 'image/webp';
if (b.length >= 12 && b[4] === 0x66 && b[5] === 0x74 && b[6] === 0x79 && b[7] === 0x70) {
const brand = String.fromCharCode(b[8], b[9], b[10], b[11]);
if (brand === 'avif' || brand === 'avis') return 'image/avif';
}
// SVG is XML text: look for an <svg root within the leading bytes.
const head = String.fromCharCode(...b.subarray(0, Math.min(b.length, 256))).toLowerCase();
if (head.includes('<svg')) return 'image/svg+xml';
return null;
}
// The mime to render `bytes` (from `path`) as, or null when the browser can't display
// the format. Extension wins when renderable; otherwise the magic number is consulted.
export function displayableImageMime(bytes: Uint8Array, path: string): string | null {
const byExt = MIME_BY_EXT[imageExtOf(path)];
if (byExt) return byExt;
return sniffImageMime(bytes);
}
function bytesToBase64(bytes: Uint8Array): string {
let bin = '';
const chunk = 0x8000; // chunk so String.fromCharCode doesn't blow the call stack
for (let i = 0; i < bytes.length; i += chunk) {
bin += String.fromCharCode(...bytes.subarray(i, i + chunk));
}
return btoa(bin);
}
// A base64 data-URI for a displayable image, or null when the format can't be shown.
export function imageDataUrl(bytes: Uint8Array, path: string): string | null {
const mime = displayableImageMime(bytes, path);
if (!mime) return null;
return `data:${mime};base64,${bytesToBase64(bytes)}`;
}
+71 -32
View File
@@ -5,6 +5,7 @@ import { HEADER_SHADE } from '../editor/extensions/tableHeaderRow';
import { orderedTypeFromFormat, orderedTypeAttrAt, childCycle, ROOT_ORDERED_CYCLE, type OrderedCycle } from '../utils/orderedListTypes';
import { bulletCharAttr, bulletCharFromOdf } from '../utils/bulletListTypes';
import { matchFormat, toDateValue, type Token } from '../utils/dateTime';
import { imageDataUrl } from './imageFormats';
import { PX_PER_CM, cmToPx, type PageMargins } from '../storage/pageMargins';
import type { Orientation } from '../storage/pageOrientation';
import type { PageFormat } from '../storage/pageFormat';
@@ -57,33 +58,15 @@ type Ctx = {
pendingBlocks: Node[];
};
const MIME_BY_EXT: Record<string, string> = {
png: 'image/png',
jpg: 'image/jpeg',
jpeg: 'image/jpeg',
gif: 'image/gif',
svg: 'image/svg+xml',
webp: 'image/webp',
bmp: 'image/bmp',
};
function bytesToBase64(bytes: Uint8Array): string {
let bin = '';
const chunk = 0x8000; // chunk so String.fromCharCode doesn't blow the call stack
for (let i = 0; i < bytes.length; i += chunk) {
bin += String.fromCharCode(...bytes.subarray(i, i + chunk));
}
return btoa(bin);
}
// Read a Pictures/ entry from the archive into a base64 data-URI (mime by extension).
// Read a Pictures/ entry into a base64 data-URI; null when it's missing or in a format
// the browser can't display (the caller distinguishes the two for its warning).
function loadImageDataUrl(href: string, ctx: Ctx): string | null {
const cached = ctx.imageCache.get(href);
if (cached) return cached;
const bytes = ctx.files[href];
if (!bytes) return null;
const ext = href.split('.').pop()?.toLowerCase() ?? '';
const url = `data:${MIME_BY_EXT[ext] ?? 'image/png'};base64,${bytesToBase64(bytes)}`;
const url = imageDataUrl(bytes, href);
if (!url) return null;
ctx.imageCache.set(href, url);
return url;
}
@@ -125,13 +108,18 @@ function applyFrameRotationAndWrap(el: Element, attrs: Record<string, unknown>,
// geometry (cm → px). as-char frames stay inline; paragraph/page-anchored frames
// with a wrap become floating (wrap mode + svg:x/svg:y position).
function convertFrame(frame: Element, ctx: Ctx): Node | null {
const image = frame.getElementsByTagNameNS(NS.draw, 'image')[0];
if (!image) return null;
const href = (image.getAttributeNS(NS.xlink, 'href') ?? '').replace(/^\.\//, '');
if (!href) return null;
// A frame may list several <draw:image> alternatives (e.g. a metafile + a bitmap
// fallback) — prefer the first the browser can display.
const hrefs = Array.from(frame.getElementsByTagNameNS(NS.draw, 'image'))
.map(im => (im.getAttributeNS(NS.xlink, 'href') ?? '').replace(/^\.\//, ''))
.filter(Boolean);
if (!hrefs.length) return null;
const href = hrefs.find(h => loadImageDataUrl(h, ctx)) ?? hrefs[0];
const src = loadImageDataUrl(href, ctx);
if (!src) {
ctx.warnings.add('Some images could not be read and were skipped');
ctx.warnings.add(ctx.files[href]
? 'Images in a format the browser can’t display (e.g. WMF, EMF, SVM, TIFF) were removed'
: 'Some images could not be read and were skipped');
return null;
}
const attrs: Record<string, unknown> = { src };
@@ -237,6 +225,16 @@ function convertDrawElement(e: Element, ctx: Ctx): { inline?: Node; block?: Node
const shape = convertShape(e, ctx);
return shape ? { block: shape } : null;
}
if (e.localName === 'a') {
// draw:a wraps a drawing in a hyperlink; the editor has no image link, so unwrap
// to the inner drawing (the link is dropped, like other flattened hyperlinks).
for (const child of Array.from(e.children)) {
if (child.namespaceURI !== NS.draw) continue;
const conv = convertDrawElement(child, ctx);
if (conv) return conv;
}
return null;
}
ctx.warnings.add('Drawings were removed');
return null;
}
@@ -438,8 +436,15 @@ function convertBlocks(elements: Element[], ctx: Ctx, kind: BlockKind, boldByDef
if (el.localName === 'p' || el.localName === 'h') {
pushWithPending(convertParaLike(el, ctx, kind, boldByDefault));
} else if (el.localName === 'list') {
const list = convertList(el, ctx, null, 1);
if (list) out.push(list);
// A list wrapping only headings is ODF outline (chapter) numbering, not a real
// list — unwrap it to plain headings instead of empty nested list levels.
const headingEls = kind === 'body' ? outlineHeadingEls(el) : null;
if (headingEls) {
for (const h of headingEls) out.push(convertParaLike(h, ctx, 'body'));
} else {
const list = convertList(el, ctx, null, 1);
if (list) out.push(list);
}
pushWithPending(null);
} else if (el.localName === 'section') {
const inner = convertBlocks(Array.from(el.children), ctx, kind, boldByDefault);
@@ -659,15 +664,26 @@ function fieldValue(kind: 'date' | 'time', raw: string | null): string {
// A <text:date>/<text:time> whose data style matches a known format → a live field
// node; returns null (keep the shown text) for an unrecognised format.
function convertDateTimeField(e: Element, ctx: Ctx): Node | null {
const kind: 'date' | 'time' = e.localName === 'time' ? 'time' : 'date';
const styleEl = ctx.resolver.numberStyle(e.getAttributeNS(NS.style, 'data-style-name'));
const format = styleEl ? matchFormat(parseNumberStyleTokens(styleEl), kind) : null;
if (!styleEl) return null;
const tokens = parseNumberStyleTokens(styleEl);
// Kind follows the number style's actual tokens, not the element name: OpenOffice
// can wrap a date field in <text:time> yet reference a date-style, and vice versa.
const kind = numberStyleKind(tokens) ?? (e.localName === 'time' ? 'time' : 'date');
const format = matchFormat(tokens, kind);
if (!format) return null;
const fixed = e.getAttributeNS(NS.text, 'fixed') === 'true';
const raw = e.getAttributeNS(NS.text, kind === 'time' ? 'time-value' : 'date-value');
const raw = e.getAttributeNS(NS.text, 'date-value') ?? e.getAttributeNS(NS.text, 'time-value');
return { type: 'dateTimeField', attrs: { kind, format, fixed, value: fieldValue(kind, raw) } };
}
// A number style with any calendar token is a date style; hours/minutes → time; else null.
function numberStyleKind(tokens: Token[]): 'date' | 'time' | null {
if (tokens.some(t => t.t === 'year' || t.t === 'month' || t.t === 'day' || t.t === 'weekday')) return 'date';
if (tokens.some(t => t.t === 'hour24' || t.t === 'hour12' || t.t === 'minute' || t.t === 'second' || t.t === 'ampm')) return 'time';
return null;
}
// ---- inline conversion --------------------------------------------------------
function convertInline(root: Element, ctx: Ctx, baseProps: PropMap, headingLevel: number | null, hfFields = false, boldByDefault = false): Node[] {
@@ -865,6 +881,29 @@ function formatPt(v: number): string {
// ---- lists -----------------------------------------------------------------------
// The heading elements of a <text:list> whose leaves are all headings (each list-item
// holds only a text:h and/or nested such lists) — ODF outline/chapter numbering, not a
// real list, so they import as plain headings. null when it's a genuine list.
function outlineHeadingEls(listEl: Element): Element[] | null {
const out: Element[] = [];
for (const item of Array.from(listEl.children)) {
if (item.namespaceURI !== NS.text || (item.localName !== 'list-item' && item.localName !== 'list-header')) continue;
for (const child of Array.from(item.children)) {
if (child.namespaceURI !== NS.text) return null;
if (child.localName === 'h') {
out.push(child);
} else if (child.localName === 'list') {
const nested = outlineHeadingEls(child);
if (!nested) return null;
out.push(...nested);
} else {
return null; // a paragraph or other content ⇒ a genuine list
}
}
}
return out.length ? out : null;
}
// `inheritedStyleName`: nested text:list elements usually carry no style-name of
// their own — the outermost list's style governs, with one level def per depth.
// `govMultilevel`: this list sits inside a multilevel (display-levels) chain, so an
+47
View File
@@ -0,0 +1,47 @@
import { describe, it, expect } from 'vitest';
import { displayableImageMime, imageDataUrl, imageExtOf } from '../../src/lib/import/imageFormats';
const bytesOf = (...b: number[]) => new Uint8Array(b);
const PNG = bytesOf(0x89, 0x50, 0x4e, 0x47, 0, 0, 0, 0);
const JPEG = bytesOf(0xff, 0xd8, 0xff, 0xe0, 0, 0, 0, 0);
const BMP = bytesOf(0x42, 0x4d, 0, 0, 0, 0, 0, 0);
const SVM = bytesOf(0x56, 0x43, 0x4c, 0x4d, 0x54, 0x46, 1, 0); // "VCLMTF"
const TIFF = bytesOf(0x49, 0x49, 0x2a, 0x00, 0, 0, 0, 0);
const WEBP = bytesOf(0x52, 0x49, 0x46, 0x46, 0, 0, 0, 0, 0x57, 0x45, 0x42, 0x50);
describe('imageExtOf', () => {
it('lowercases and strips query/fragment', () => {
expect(imageExtOf('Pictures/A.PNG')).toBe('png');
expect(imageExtOf('word/media/image1.jpeg?x=1')).toBe('jpeg');
expect(imageExtOf('noext')).toBe('noext');
});
});
describe('displayableImageMime', () => {
it('resolves renderable formats by extension', () => {
expect(displayableImageMime(PNG, 'a.png')).toBe('image/png');
expect(displayableImageMime(JPEG, 'a.jfif')).toBe('image/jpeg');
expect(displayableImageMime(new Uint8Array(4), 'a.avif')).toBe('image/avif');
});
it('returns null for formats the browser cannot display', () => {
expect(displayableImageMime(SVM, 'a.svm')).toBeNull();
expect(displayableImageMime(TIFF, 'a.tiff')).toBeNull();
expect(displayableImageMime(bytesOf(0,0,0,0), 'a.wmf')).toBeNull();
expect(displayableImageMime(bytesOf(0,0,0,0), 'a.emf')).toBeNull();
});
it('recovers a renderable format from magic bytes when the extension is unknown', () => {
expect(displayableImageMime(PNG, 'blob')).toBe('image/png');
expect(displayableImageMime(BMP, 'Pictures/x')).toBe('image/bmp');
expect(displayableImageMime(WEBP, 'x')).toBe('image/webp');
});
it('does not mislabel a metafile as a bitmap when the extension is unknown', () => {
expect(displayableImageMime(SVM, 'Pictures/x')).toBeNull();
});
});
describe('imageDataUrl', () => {
it('emits a data-URI for renderable bytes, null otherwise', () => {
expect(imageDataUrl(PNG, 'a.png')).toMatch(/^data:image\/png;base64,/);
expect(imageDataUrl(SVM, 'a.svm')).toBeNull();
});
});