tabctl 0.1.4 → 0.2.1

package/dist/extension/lib/screenshot.js

@@ -0,0 +1,367 @@
+"use strict";
+// Screenshot pipeline — extracted from background.ts (pure structural refactor).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCREENSHOT_PROCESS_TIMEOUT_MS = exports.SCREENSHOT_CAPTURE_DELAY_MS = exports.SCREENSHOT_SCROLL_DELAY_MS = exports.SCREENSHOT_QUALITY = exports.SCREENSHOT_MAX_BYTES = exports.SCREENSHOT_TILE_MAX_DIM = void 0;
+exports.estimateDataUrlBytes = estimateDataUrlBytes;
+exports.arrayBufferToBase64 = arrayBufferToBase64;
+exports.resizeDataUrl = resizeDataUrl;
+exports.resizeDataUrlToMaxDim = resizeDataUrlToMaxDim;
+exports.cropDataUrl = cropDataUrl;
+exports.ensureMaxBytes = ensureMaxBytes;
+exports.constrainDataUrl = constrainDataUrl;
+exports.captureVisible = captureVisible;
+exports.getPageMetrics = getPageMetrics;
+exports.scrollToPosition = scrollToPosition;
+exports.captureTabTiles = captureTabTiles;
+exports.screenshotTabs = screenshotTabs;
+exports.SCREENSHOT_TILE_MAX_DIM = 2000;
+exports.SCREENSHOT_MAX_BYTES = 2000000;
+exports.SCREENSHOT_QUALITY = 80;
+exports.SCREENSHOT_SCROLL_DELAY_MS = 150;
+exports.SCREENSHOT_CAPTURE_DELAY_MS = 350;
+exports.SCREENSHOT_PROCESS_TIMEOUT_MS = 8000;
+function estimateDataUrlBytes(dataUrl) {
+    const commaIndex = dataUrl.indexOf(",");
+    if (commaIndex < 0) {
+        return dataUrl.length;
+    }
+    const base64 = dataUrl.slice(commaIndex + 1);
+    const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+    return Math.max(0, Math.floor((base64.length * 3) / 4) - padding);
+}
+function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += 1) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+async function resizeDataUrl(dataUrl, format, quality, scale) {
+    if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
+        return null;
+    }
+    const response = await fetch(dataUrl);
+    const blob = await response.blob();
+    const bitmap = await createImageBitmap(blob);
+    const width = Math.max(1, Math.floor(bitmap.width * scale));
+    const height = Math.max(1, Math.floor(bitmap.height * scale));
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+        return null;
+    }
+    ctx.drawImage(bitmap, 0, 0, width, height);
+    const type = format === "jpeg" ? "image/jpeg" : "image/png";
+    const blobOut = await canvas.convertToBlob({ type, quality: format === "jpeg" ? quality / 100 : undefined });
+    const buffer = await blobOut.arrayBuffer();
+    const base64 = arrayBufferToBase64(buffer);
+    return {
+        dataUrl: `data:${type};base64,${base64}`,
+        bytes: buffer.byteLength,
+    };
+}
+async function resizeDataUrlToMaxDim(dataUrl, format, quality, maxDim) {
+    if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
+        return null;
+    }
+    const response = await fetch(dataUrl);
+    const blob = await response.blob();
+    const bitmap = await createImageBitmap(blob);
+    const maxSize = Math.max(bitmap.width, bitmap.height);
+    if (!Number.isFinite(maxSize) || maxSize <= maxDim) {
+        return null;
+    }
+    const scale = maxDim / maxSize;
+    return resizeDataUrl(dataUrl, format, quality, scale);
+}
+async function cropDataUrl(dataUrl, format, quality, width, height, devicePixelRatio) {
+    if (!globalThis.OffscreenCanvas || !globalThis.createImageBitmap) {
+        return dataUrl;
+    }
+    const response = await fetch(dataUrl);
+    const blob = await response.blob();
+    const bitmap = await createImageBitmap(blob);
+    const targetWidth = Math.min(bitmap.width, Math.max(1, Math.round(width * devicePixelRatio)));
+    const targetHeight = Math.min(bitmap.height, Math.max(1, Math.round(height * devicePixelRatio)));
+    if (targetWidth === bitmap.width && targetHeight === bitmap.height) {
+        return dataUrl;
+    }
+    const canvas = new OffscreenCanvas(targetWidth, targetHeight);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+        return dataUrl;
+    }
+    ctx.drawImage(bitmap, 0, 0, targetWidth, targetHeight, 0, 0, targetWidth, targetHeight);
+    const type = format === "jpeg" ? "image/jpeg" : "image/png";
+    const blobOut = await canvas.convertToBlob({ type, quality: format === "jpeg" ? quality / 100 : undefined });
+    const buffer = await blobOut.arrayBuffer();
+    const base64 = arrayBufferToBase64(buffer);
+    return `data:${type};base64,${base64}`;
+}
+async function ensureMaxBytes(dataUrl, format, quality, maxBytes) {
+    let currentUrl = dataUrl;
+    let currentBytes = estimateDataUrlBytes(currentUrl);
+    if (currentBytes <= maxBytes) {
+        return { dataUrl: currentUrl, bytes: currentBytes, scaled: false, oversized: false };
+    }
+    let scaled = false;
+    let attempts = 0;
+    while (currentBytes > maxBytes && attempts < 3) {
+        const scale = Math.max(0.2, Math.sqrt(maxBytes / currentBytes) * 0.95);
+        if (scale >= 0.99) {
+            break;
+        }
+        const resized = await resizeDataUrl(currentUrl, format, quality, scale);
+        if (!resized) {
+            break;
+        }
+        currentUrl = resized.dataUrl;
+        currentBytes = resized.bytes;
+        scaled = true;
+        attempts += 1;
+    }
+    return {
+        dataUrl: currentUrl,
+        bytes: currentBytes,
+        scaled,
+        oversized: currentBytes > maxBytes,
+    };
+}
+async function constrainDataUrl(dataUrl, format, quality, maxDim, maxBytes) {
+    let currentUrl = dataUrl;
+    let currentBytes = estimateDataUrlBytes(currentUrl);
+    let scaled = false;
+    if (Number.isFinite(maxDim) && maxDim > 0) {
+        const resized = await resizeDataUrlToMaxDim(currentUrl, format, quality, maxDim);
+        if (resized) {
+            currentUrl = resized.dataUrl;
+            currentBytes = resized.bytes;
+            scaled = true;
+        }
+    }
+    if (currentBytes > maxBytes) {
+        const resized = await ensureMaxBytes(currentUrl, format, quality, maxBytes);
+        return {
+            dataUrl: resized.dataUrl,
+            bytes: resized.bytes,
+            scaled: scaled || resized.scaled,
+            oversized: resized.oversized,
+        };
+    }
+    return { dataUrl: currentUrl, bytes: currentBytes, scaled, oversized: false };
+}
+async function captureVisible(windowId, format, quality) {
+    const options = { format };
+    if (format === "jpeg") {
+        options.quality = quality;
+    }
+    return chrome.tabs.captureVisibleTab(windowId, options);
+}
+async function getPageMetrics(tabId, timeoutMs, deps) {
+    const result = await deps.executeWithTimeout(tabId, timeoutMs, () => {
+        const doc = document.documentElement;
+        const body = document.body;
+        const pageWidth = Math.max(doc.scrollWidth, doc.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+        const pageHeight = Math.max(doc.scrollHeight, doc.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+        return {
+            pageWidth,
+            pageHeight,
+            viewportWidth: window.innerWidth,
+            viewportHeight: window.innerHeight,
+            devicePixelRatio: window.devicePixelRatio || 1,
+            scrollX: window.scrollX || window.pageXOffset || 0,
+            scrollY: window.scrollY || window.pageYOffset || 0,
+        };
+    });
+    if (!result || typeof result !== "object") {
+        return null;
+    }
+    return result;
+}
+async function scrollToPosition(tabId, timeoutMs, x, y, deps) {
+    const result = await deps.executeWithTimeout(tabId, timeoutMs, (scrollX, scrollY) => {
+        window.scrollTo(scrollX, scrollY);
+        return {
+            scrollX: window.scrollX || window.pageXOffset || 0,
+            scrollY: window.scrollY || window.pageYOffset || 0,
+        };
+    }, [x, y]);
+    if (!result || typeof result !== "object") {
+        return null;
+    }
+    return result;
+}
+async function captureTabTiles(tab, options, deps) {
+    const tabId = tab.tabId;
+    const windowId = tab.windowId;
+    if (!Number.isFinite(tabId) || !Number.isFinite(windowId)) {
+        throw new Error("Missing tab/window id");
+    }
+    const metrics = await getPageMetrics(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, deps);
+    if (!metrics) {
+        throw new Error("Failed to read page metrics");
+    }
+    const pageWidth = Number(metrics.pageWidth);
+    const pageHeight = Number(metrics.pageHeight);
+    const viewportWidth = Number(metrics.viewportWidth);
+    const viewportHeight = Number(metrics.viewportHeight);
+    const devicePixelRatio = Number(metrics.devicePixelRatio) || 1;
+    const startScrollX = Number(metrics.scrollX) || 0;
+    const startScrollY = Number(metrics.scrollY) || 0;
+    if (!Number.isFinite(viewportWidth) || !Number.isFinite(viewportHeight)) {
+        throw new Error("Viewport size unavailable");
+    }
+    const tiles = [];
+    let tileIndex = 0;
+    const captureTile = async (x, y, width, height, total) => {
+        if (tileIndex > 0) {
+            await deps.delay(exports.SCREENSHOT_CAPTURE_DELAY_MS);
+        }
+        const rawDataUrl = await captureVisible(windowId, options.format, options.quality);
+        if (!rawDataUrl) {
+            throw new Error("Capture failed");
+        }
+        const croppedUrl = await cropDataUrl(rawDataUrl, options.format, options.quality, width, height, devicePixelRatio);
+        const sizeResult = await constrainDataUrl(croppedUrl, options.format, options.quality, options.tileMaxDim, options.maxBytes);
+        tiles.push({
+            index: tileIndex,
+            total,
+            x,
+            y,
+            width,
+            height,
+            scale: devicePixelRatio,
+            format: options.format,
+            bytes: sizeResult.bytes,
+            scaled: sizeResult.scaled,
+            oversized: sizeResult.oversized,
+            dataUrl: sizeResult.dataUrl,
+        });
+        tileIndex += 1;
+    };
+    if (options.mode === "viewport") {
+        await captureTile(startScrollX, startScrollY, viewportWidth, viewportHeight, 1);
+        return tiles;
+    }
+    const stepX = viewportWidth;
+    const stepY = Math.min(viewportHeight, options.tileMaxDim);
+    const maxX = viewportWidth;
+    const maxY = Math.max(viewportHeight, pageHeight);
+    const tileCount = Math.ceil(maxX / stepX) * Math.ceil(maxY / stepY);
+    for (let y = 0; y < maxY; y += stepY) {
+        for (let x = 0; x < maxX; x += stepX) {
+            await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, x, y, deps);
+            await deps.delay(exports.SCREENSHOT_SCROLL_DELAY_MS);
+            const width = Math.min(stepX, maxX - x);
+            const height = Math.min(stepY, maxY - y);
+            try {
+                await captureTile(x, y, width, height, tileCount);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : "capture_failed";
+                if (message.includes("MAX_CAPTURE_VISIBLE_TAB_CALLS_PER_SECOND")) {
+                    await deps.delay(1000);
+                    await captureTile(x, y, width, height, tileCount);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, startScrollX, startScrollY, deps);
+    return tiles;
+}
+async function screenshotTabs(params, requestId, deps) {
+    const snapshot = await deps.getTabSnapshot();
+    const selection = deps.selectTabsByScope(snapshot, params);
+    if (selection.error) {
+        throw selection.error;
+    }
+    const mode = params.mode === "full" ? "full" : "viewport";
+    const format = params.format === "jpeg" ? "jpeg" : "png";
+    const qualityRaw = Number(params.quality);
+    const quality = Number.isFinite(qualityRaw) ? Math.min(100, Math.max(0, Math.floor(qualityRaw))) : exports.SCREENSHOT_QUALITY;
+    const tileMaxDimRaw = Number(params.tileMaxDim);
+    const tileMaxDim = Number.isFinite(tileMaxDimRaw) && tileMaxDimRaw > 0 ? Math.floor(tileMaxDimRaw) : exports.SCREENSHOT_TILE_MAX_DIM;
+    const adjustedTileMaxDim = tileMaxDim < 50 ? 50 : tileMaxDim;
+    const maxBytesRaw = Number(params.maxBytes);
+    const maxBytes = Number.isFinite(maxBytesRaw) && maxBytesRaw > 0 ? Math.floor(maxBytesRaw) : exports.SCREENSHOT_MAX_BYTES;
+    const adjustedMaxBytes = maxBytes < 50000 ? 50000 : maxBytes;
+    const progressEnabled = params.progress === true;
+    const tabs = selection.tabs;
+    const entries = [];
+    let totalTiles = 0;
+    const startedAt = Date.now();
+    for (let index = 0; index < tabs.length; index += 1) {
+        const tab = tabs[index];
+        const tabId = tab.tabId;
+        const url = tab.url;
+        if (!deps.isScriptableUrl(url)) {
+            entries.push({
+                tabId,
+                windowId: tab.windowId,
+                groupId: tab.groupId,
+                url: tab.url,
+                title: tab.title,
+                error: { message: "unsupported_url" },
+                tiles: [],
+            });
+            if (progressEnabled) {
+                deps.sendProgress(requestId, { phase: "screenshot", processed: index + 1, total: tabs.length, tabId });
+            }
+            continue;
+        }
+        let tiles = [];
+        let error = null;
+        try {
+            const windowId = tab.windowId;
+            const activeTabs = await chrome.tabs.query({ windowId, active: true });
+            const activeTabId = activeTabs[0]?.id ?? null;
+            if (activeTabId && activeTabId !== tabId) {
+                await chrome.tabs.update(tabId, { active: true });
+                await deps.delay(exports.SCREENSHOT_SCROLL_DELAY_MS);
+            }
+            try {
+                await deps.waitForTabReady(tabId, params, exports.SCREENSHOT_PROCESS_TIMEOUT_MS);
+                tiles = await captureTabTiles(tab, { mode, format, quality, tileMaxDim: adjustedTileMaxDim, maxBytes: adjustedMaxBytes }, deps);
+            }
+            finally {
+                if (activeTabId && activeTabId !== tabId) {
+                    await chrome.tabs.update(activeTabId, { active: true });
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "capture_failed";
+            error = { message };
+        }
+        totalTiles += tiles.length;
+        entries.push({
+            tabId: tab.tabId,
+            windowId: tab.windowId,
+            groupId: tab.groupId,
+            url: tab.url,
+            title: tab.title,
+            tiles,
+            ...(error ? { error } : {}),
+        });
+        if (progressEnabled) {
+            deps.sendProgress(requestId, { phase: "screenshot", processed: index + 1, total: tabs.length, tabId });
+        }
+    }
+    return {
+        generatedAt: Date.now(),
+        totals: { tabs: tabs.length, tiles: totalTiles },
+        meta: {
+            durationMs: Date.now() - startedAt,
+            mode,
+            format,
+            quality: format === "jpeg" ? quality : null,
+            tileMaxDim: adjustedTileMaxDim,
+            maxBytes: adjustedMaxBytes,
+        },
+        entries,
+    };
+}