take-shot/dist/lib/dom/extra/dataurl.js

Screenshots with JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resourceToDataURL = exports.fetchAsDataURL = exports.makeDataUrl = exports.isDataUrl = void 0;
function getContentFromDataUrl(dataURL) {
    return dataURL.split(/,/)[1];
}
function isDataUrl(url) {
    return url.search(/^(data:)/) !== -1;
}
exports.isDataUrl = isDataUrl;
function makeDataUrl(content, mimeType) {
    return `data:${mimeType};base64,${content}`;
}
exports.makeDataUrl = makeDataUrl;
async function fetchAsDataURL(url, process) {
    const failPromise = (uri) => new Promise((resolve) => {
        resolve((uri || url));
    });
    try {
        const res = await fetch(url, {
            credentials: 'include',
            headers: {
                origin: window.location.origin,
                host: window.location.host,
                mode: 'no-cors',
                'Access-Control-Allow-Origin': '*',
                Connection: 'keep-alive',
                'Access-Control-Allow-Headers': '*',
                'Access-Control-Allow-Credentials': 'true',
                "Content-Type": "application/octet-stream"
            },
        });
        if (res.status === 404) {
            return failPromise('');
        }
        const blob = await res.blob();
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            reader.onerror = reject;
            reader.onloadend = () => {
                try {
                    resolve(process({ res, result: reader.result }));
                }
                catch (error) {
                    reject(error);
                }
            };
            reader.readAsDataURL(blob);
        });
    }
    catch (e) {
        return failPromise();
    }
}
exports.fetchAsDataURL = fetchAsDataURL;
const cache = {};
function getCacheKey(url, contentType) {
    let key = url.replace(/\?.*/, '');
    // font resource
    if (/ttf|otf|eot|woff2?/i.test(key)) {
        key = key.replace(/.*\//, '');
    }
    return contentType ? `[${contentType}]${key}` : key;
}
const getPlaceholder = async (url, placeholder) => {
    const imgs = ['png', 'jpg', 'jpeg', 'gif', 'tiff', 'svg', 'webp'];
    if (imgs.some(img => url.includes(img)) && placeholder) {
        return placeholder;
    }
    return url;
};
async function resourceToDataURL(resourceUrl, contentType, placeholder) {
    const cacheKey = getCacheKey(resourceUrl, contentType);
    if (cache[cacheKey] != null) {
        return cache[cacheKey];
    }
    let dataURL;
    try {
        const content = await fetchAsDataURL(resourceUrl, ({ res, result }) => {
            if (!contentType) {
                // eslint-disable-next-line no-param-reassign
                contentType = res.headers.get('Content-Type') || '';
            }
            return getContentFromDataUrl(result);
        });
        if (content.includes('http'))
            return await getPlaceholder(content, placeholder);
        dataURL = makeDataUrl(content, contentType);
    }
    catch (error) {
        dataURL = '';
        let msg = `Failed to fetch resource: ${resourceUrl}`;
        if (error) {
            msg = typeof error === 'string' ? error : error.message;
        }
        if (msg) {
            console.warn(msg, 'error on get');
        }
    }
    cache[cacheKey] = dataURL;
    return dataURL;
}
exports.resourceToDataURL = resourceToDataURL;
//# sourceMappingURL=dataurl.js.map