@flareapp/vite-plugin-sourcemap-uploader/dist/index.js

The Flare Vite plugin helps you send sourcemaps of your compiled JavaScript code to Flare. This way, reports sent using the `@flareapp/flare-client` will be formatted correctly.

var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "path", "fs", "fast-glob", "./util", "./flareApi"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    const path_1 = require("path");
    const fs_1 = require("fs");
    const fast_glob_1 = __importDefault(require("fast-glob"));
    const util_1 = require("./util");
    const flareApi_1 = __importDefault(require("./flareApi"));
    function flareSourcemapUploader({ key, base, apiEndpoint = 'https://flareapp.io/api/sourcemaps', runInDevelopment = false, version = (0, util_1.uuid)(), removeSourcemaps = false, }) {
        if (!key) {
            flareLog('No Flare API key was provided, not uploading sourcemaps to Flare.');
        }
        const flare = new flareApi_1.default(apiEndpoint, key, version);
        const enableUploadingSourcemaps = key && (process.env.NODE_ENV !== 'development' || runInDevelopment) && process.env.SKIP_SOURCEMAPS !== 'true';
        return {
            name: 'flare-vite-plugin',
            apply: 'build',
            config({ build }, { mode }) {
                return {
                    // Set FLARE_SOURCEMAP_VERSION and API key so the Flare JS client can read it
                    define: {
                        FLARE_SOURCEMAP_VERSION: `'${version}'`,
                        FLARE_JS_KEY: `'${key}'`,
                    },
                    build: {
                        sourcemap: (() => {
                            if ((build === null || build === void 0 ? void 0 : build.sourcemap) !== undefined)
                                return build.sourcemap;
                            const enableSourcemaps = enableUploadingSourcemaps && mode !== 'development';
                            if (enableSourcemaps)
                                return 'hidden';
                            return false;
                        })(),
                    },
                };
            },
            configResolved(config) {
                base = base || config.base;
                base += base.endsWith('/') ? '' : '/';
            },
            async writeBundle(outputConfig) {
                if (!enableUploadingSourcemaps) {
                    return;
                }
                const outputDir = outputConfig.dir || '';
                const files = await (0, fast_glob_1.default)('./**/*.map', { cwd: outputDir });
                const sourcemaps = files
                    .map((file) => {
                    const sourcePath = file.replace(/\.map$/, '');
                    const sourceFilename = (0, path_1.resolve)(outputDir, sourcePath);
                    if (!(0, fs_1.existsSync)(sourceFilename)) {
                        flareLog(`no corresponding source found for "${file}"`, true);
                        return null;
                    }
                    const sourcemapLocation = (0, path_1.resolve)(outputDir, file);
                    try {
                        return {
                            content: (0, fs_1.readFileSync)(sourcemapLocation, 'utf8'),
                            sourcemap_url: sourcemapLocation,
                            original_file: `${base}${sourcePath}`,
                        };
                    }
                    catch (error) {
                        flareLog('Error reading sourcemap file ' + sourcemapLocation + ': ' + error, true);
                        return null;
                    }
                })
                    .filter((sourcemap) => sourcemap !== null);
                if (!sourcemaps.length) {
                    return;
                }
                flareLog(`Uploading ${sourcemaps.length} sourcemap files to Flare.`);
                const pendingUploads = sourcemaps.map((sourcemap) => () => flare.uploadSourcemap(sourcemap));
                try {
                    while (pendingUploads.length) {
                        // Maximum 10 at once https://stackoverflow.com/a/58686835
                        await Promise.all(pendingUploads.splice(0, 10).map((f) => f()));
                    }
                    flareLog('Successfully uploaded sourcemaps to Flare.');
                }
                catch (error) {
                    flareLog(`Something went wrong while uploading the sourcemaps to Flare: ${error}`, true);
                }
                if (removeSourcemaps) {
                    sourcemaps.forEach(({ sourcemap_url }) => {
                        try {
                            (0, fs_1.unlinkSync)(sourcemap_url);
                        }
                        catch (error) {
                            console.error('Error removing sourcemap file', sourcemap_url, ': ', error);
                        }
                    });
                    flareLog('Successfully removed sourcemaps.');
                }
            },
        };
    }
    exports.default = flareSourcemapUploader;
    function flareLog(message, isError = false) {
        const formattedMessage = '@flareapp/vite-plugin-sourcemap-uploader: ' + message;
        if (isError) {
            console.error(formattedMessage);
            return;
        }
        console.log(formattedMessage);
    }
});