@jacobbubu/md-to-lark 1.4.2 → 1.4.4

package/dist/lark/docx/render-post-process.js

@@ -1,3 +1,4 @@
+import { getScaledHeightForLocalImage } from '../../shared/image-metadata.js';
 import { createBoardPlantumlNode, getDocumentBlockById, getRawDocumentBlockById, isRelationMismatchError, replaceFileBlock, replaceImageBlock, uploadBinaryToNode, } from './ops.js';
 import { toObjectRecord } from './render-payload.js';
 function extractWhiteboardId(rawBlock) {
@@ -25,9 +26,12 @@ export async function applyCreatedImageBlock(client, documentId, createdBlockId,
     const localPath = image && typeof image.local_path === 'string' ? image.local_path : '';
     if (!localPath)
         return null;
+    const width = image && typeof image.width === 'number' && image.width > 0 ? image.width : undefined;
+    const explicitHeight = image && typeof image.height === 'number' && image.height > 0 ? image.height : undefined;
+    const proportionalHeight = explicitHeight ?? getScaledHeightForLocalImage(localPath, width);
     const replaceOptions = {
-        ...(image && typeof image.width === 'number' ? { width: image.width } : {}),
-        ...(image && typeof image.height === 'number' ? { height: image.height } : {}),
+        ...(typeof width === 'number' ? { width } : {}),
+        ...(typeof proportionalHeight === 'number' ? { height: proportionalHeight } : {}),
         ...(image && typeof image.align === 'number' ? { align: image.align } : {}),
         ...(image && toObjectRecord(image.caption) ? { caption: toObjectRecord(image.caption) } : {}),
         ...(image && typeof image.scale === 'number' ? { scale: image.scale } : {}),

package/dist/publish/common.js

@@ -42,6 +42,9 @@ export function resolveLocalPathFromSource(sourceUrl, baseDir) {
     const raw = sourceUrl.trim();
     if (!raw)
         return null;
+    if (raw.startsWith('#')) {
+        return null;
+    }
     if (isHttpLike(raw)) {
         if (/^https?:/i.test(raw)) {
             return null;
@@ -49,6 +52,9 @@ export function resolveLocalPathFromSource(sourceUrl, baseDir) {
         return null;
     }
     const decoded = safeDecodeURIComponent(stripQueryAndHash(raw));
+    if (!decoded.trim()) {
+        return null;
+    }
     const absolute = path.isAbsolute(decoded) ? decoded : path.resolve(baseDir, decoded);
     return absolute;
 }

package/dist/shared/image-metadata.js

@@ -0,0 +1,152 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const JPEG_SOF_MARKERS = new Set([
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf,
+]);
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function normalizeDimensions(width, height) {
+    if (!isPositiveInteger(width) || !isPositiveInteger(height)) {
+        return null;
+    }
+    return { width, height };
+}
+function readPngDimensions(buffer) {
+    if (buffer.length < 24 || !buffer.subarray(0, 8).equals(PNG_SIGNATURE)) {
+        return null;
+    }
+    return normalizeDimensions(buffer.readUInt32BE(16), buffer.readUInt32BE(20));
+}
+function readGifDimensions(buffer) {
+    if (buffer.length < 10)
+        return null;
+    const signature = buffer.toString('ascii', 0, 6);
+    if (signature !== 'GIF87a' && signature !== 'GIF89a')
+        return null;
+    return normalizeDimensions(buffer.readUInt16LE(6), buffer.readUInt16LE(8));
+}
+function readBmpDimensions(buffer) {
+    if (buffer.length < 26 || buffer.toString('ascii', 0, 2) !== 'BM') {
+        return null;
+    }
+    const width = buffer.readInt32LE(18);
+    const height = Math.abs(buffer.readInt32LE(22));
+    return normalizeDimensions(width, height);
+}
+function readJpegDimensions(buffer) {
+    if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) {
+        return null;
+    }
+    let offset = 2;
+    while (offset + 4 <= buffer.length) {
+        while (offset < buffer.length && buffer[offset] === 0xff) {
+            offset += 1;
+        }
+        if (offset >= buffer.length)
+            return null;
+        const marker = buffer.readUInt8(offset);
+        offset += 1;
+        if (marker === 0xd8 || marker === 0xd9) {
+            continue;
+        }
+        if (offset + 2 > buffer.length)
+            return null;
+        const segmentLength = buffer.readUInt16BE(offset);
+        if (segmentLength < 2 || offset + segmentLength > buffer.length)
+            return null;
+        if (JPEG_SOF_MARKERS.has(marker)) {
+            if (segmentLength < 7)
+                return null;
+            const height = buffer.readUInt16BE(offset + 3);
+            const width = buffer.readUInt16BE(offset + 5);
+            return normalizeDimensions(width, height);
+        }
+        offset += segmentLength;
+    }
+    return null;
+}
+function readWebpDimensions(buffer) {
+    if (buffer.length < 30 ||
+        buffer.toString('ascii', 0, 4) !== 'RIFF' ||
+        buffer.toString('ascii', 8, 12) !== 'WEBP') {
+        return null;
+    }
+    const chunkType = buffer.toString('ascii', 12, 16);
+    if (chunkType === 'VP8X' && buffer.length >= 30) {
+        const width = 1 + buffer.readUIntLE(24, 3);
+        const height = 1 + buffer.readUIntLE(27, 3);
+        return normalizeDimensions(width, height);
+    }
+    if (chunkType === 'VP8L' && buffer.length >= 25) {
+        const byte20 = buffer.readUInt8(20);
+        const byte21 = buffer.readUInt8(21);
+        const byte22 = buffer.readUInt8(22);
+        const byte23 = buffer.readUInt8(23);
+        const byte24 = buffer.readUInt8(24);
+        const width = 1 + (((byte21 & 0x3f) << 8) | byte20);
+        const height = 1 + (((byte24 & 0x0f) << 10) | (byte23 << 2) | ((byte22 & 0xc0) >> 6));
+        return normalizeDimensions(width, height);
+    }
+    if (chunkType === 'VP8 ' && buffer.length >= 30) {
+        const width = buffer.readUInt16LE(26) & 0x3fff;
+        const height = buffer.readUInt16LE(28) & 0x3fff;
+        return normalizeDimensions(width, height);
+    }
+    return null;
+}
+function parseSvgLength(value) {
+    if (!value)
+        return null;
+    const match = value.trim().match(/^([0-9]+(?:\.[0-9]+)?)/);
+    if (!match)
+        return null;
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function readSvgDimensions(filePath) {
+    const source = readFileSync(filePath, 'utf8');
+    if (!/<svg\b/i.test(source))
+        return null;
+    const widthMatch = source.match(/\bwidth\s*=\s*["']([^"']+)["']/i);
+    const heightMatch = source.match(/\bheight\s*=\s*["']([^"']+)["']/i);
+    const width = parseSvgLength(widthMatch?.[1]);
+    const height = parseSvgLength(heightMatch?.[1]);
+    if (width && height) {
+        return normalizeDimensions(Math.round(width), Math.round(height));
+    }
+    const viewBoxMatch = source.match(/\bviewBox\s*=\s*["']([^"']+)["']/i);
+    if (!viewBoxMatch)
+        return null;
+    const parts = (viewBoxMatch[1] ?? '')
+        .trim()
+        .split(/[\s,]+/)
+        .map((part) => Number(part));
+    if (parts.length !== 4 || parts.some((part) => !Number.isFinite(part))) {
+        return null;
+    }
+    return normalizeDimensions(Math.round(parts[2] ?? 0), Math.round(parts[3] ?? 0));
+}
+export function readLocalImageDimensions(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension === '.svg') {
+        return readSvgDimensions(filePath);
+    }
+    const buffer = readFileSync(filePath);
+    return (readPngDimensions(buffer) ??
+        readJpegDimensions(buffer) ??
+        readGifDimensions(buffer) ??
+        readWebpDimensions(buffer) ??
+        readBmpDimensions(buffer));
+}
+export function getScaledHeightForWidth(dimensions, targetWidth) {
+    if (!dimensions || !Number.isFinite(targetWidth) || !targetWidth || targetWidth <= 0) {
+        return undefined;
+    }
+    const scaled = Math.round((dimensions.height * targetWidth) / dimensions.width);
+    return scaled > 0 ? scaled : undefined;
+}
+export function getScaledHeightForLocalImage(filePath, targetWidth) {
+    return getScaledHeightForWidth(readLocalImageDimensions(filePath), targetWidth);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacobbubu/md-to-lark",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Publish Markdown to Feishu docs with a stable pipeline.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",