@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/dist/ReporterRunner.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportWorker = reportWorker;
+exports.report = report;
+const assert_1 = __importDefault(require("assert"));
+const Bundle_1 = require("./public/Bundle");
+const workers_1 = require("@atlaspack/workers");
+const logger_1 = __importStar(require("@atlaspack/logger"));
+const PluginOptions_1 = __importDefault(require("./public/PluginOptions"));
+const BundleGraph_1 = __importDefault(require("./BundleGraph"));
+const profiler_1 = require("@atlaspack/profiler");
+const diagnostic_1 = require("@atlaspack/diagnostic");
+const instances = new Set();
+class ReporterRunner {
+    constructor(opts) {
+        this.eventHandler = (event) => {
+            if (event.type === 'buildProgress' &&
+                (event.phase === 'optimizing' || event.phase === 'packaging') &&
+                !(event.bundle instanceof Bundle_1.NamedBundle)) {
+                // @ts-expect-error TS2339
+                let bundleGraphRef = event.bundleGraphRef;
+                // @ts-expect-error TS2739
+                let bundle = event.bundle;
+                // Convert any internal bundles back to their public equivalents as reporting
+                // is public api
+                let bundleGraph = this.workerFarm.workerApi.getSharedReference(bundleGraphRef);
+                (0, assert_1.default)(bundleGraph instanceof BundleGraph_1.default);
+                this.report({
+                    ...event,
+                    bundle: Bundle_1.NamedBundle.get(bundle, bundleGraph, this.options),
+                });
+                return;
+            }
+            this.report(event);
+        };
+        this.errors = [];
+        this.options = opts.options;
+        this.reporters = opts.reporters;
+        this.workerFarm = opts.workerFarm;
+        this.pluginOptions = new PluginOptions_1.default(this.options);
+        logger_1.default.onLog((event) => this.report(event));
+        profiler_1.tracer.onTrace((event) => this.report(event));
+        workers_1.bus.on('reporterEvent', this.eventHandler);
+        instances.add(this);
+        if (this.options.shouldPatchConsole) {
+            (0, logger_1.patchConsole)();
+        }
+        else {
+            (0, logger_1.unpatchConsole)();
+        }
+    }
+    async report(unsanitisedEvent) {
+        let event = unsanitisedEvent;
+        // @ts-expect-error TS2339
+        if (event.diagnostics) {
+            // Sanitise input before passing to reporters
+            event = {
+                ...event,
+                // @ts-expect-error TS2322
+                diagnostics: (0, diagnostic_1.anyToDiagnostic)(event.diagnostics),
+            };
+        }
+        for (let reporter of this.reporters) {
+            let measurement;
+            try {
+                // To avoid an infinite loop we don't measure trace events, as they'll
+                // result in another trace!
+                if (event.type !== 'trace') {
+                    measurement = profiler_1.tracer.createMeasurement(reporter.name, 'reporter');
+                }
+                await reporter.plugin.report({
+                    event,
+                    options: this.pluginOptions,
+                    logger: new logger_1.PluginLogger({ origin: reporter.name }),
+                    tracer: new profiler_1.PluginTracer({
+                        origin: reporter.name,
+                        category: 'reporter',
+                    }),
+                });
+            }
+            catch (reportError) {
+                if (event.type !== 'buildSuccess') {
+                    // This will be captured by consumers
+                    logger_1.INTERNAL_ORIGINAL_CONSOLE.error(reportError);
+                }
+                this.errors.push(reportError);
+            }
+            finally {
+                measurement && measurement.end();
+            }
+        }
+    }
+    dispose() {
+        workers_1.bus.off('reporterEvent', this.eventHandler);
+        instances.delete(this);
+    }
+}
+exports.default = ReporterRunner;
+function reportWorker(workerApi, event) {
+    if (event.type === 'buildProgress' &&
+        (event.phase === 'optimizing' || event.phase === 'packaging')) {
+        // Convert any public api bundles to their internal equivalents for
+        // easy serialization
+        workers_1.bus.emit('reporterEvent', {
+            ...event,
+            bundle: (0, Bundle_1.bundleToInternalBundle)(event.bundle),
+            bundleGraphRef: workerApi.resolveSharedReference((0, Bundle_1.bundleToInternalBundleGraph)(event.bundle)),
+        });
+        return;
+    }
+    workers_1.bus.emit('reporterEvent', event);
+}
+async function report(event) {
+    await Promise.all([...instances].map((instance) => instance.report(event)));
+}