@atlaspack/logger 2.14.14-typescript-b27501580.0 → 2.14.14-typescript-5b4d3ad41.0

package/lib/Logger.d.ts

@@ -0,0 +1,69 @@
+import type { IDisposable, LogEvent, PluginLogger as IPluginLogger } from '@atlaspack/types';
+import type { Diagnostic, Diagnostifiable, DiagnosticWithoutOrigin } from '@atlaspack/diagnostic';
+import { ValueEmitter } from '@atlaspack/events';
+export { instrument, instrumentAsync } from './tracer';
+declare class Logger {
+    logEmitter: ValueEmitter<LogEvent>;
+    onLog(cb: (event: LogEvent) => unknown): IDisposable;
+    verbose(diagnostic: Diagnostic | Array<Diagnostic>): void;
+    info(diagnostic: Diagnostic | Array<Diagnostic>): void;
+    log(diagnostic: Diagnostic | Array<Diagnostic>): void;
+    warn(diagnostic: Diagnostic | Array<Diagnostic>): void;
+    error(input: Diagnostifiable, realOrigin?: string): void;
+    progress(message: string): void;
+}
+declare const logger: Logger;
+export default logger;
+/** @private */
+export type PluginLoggerOpts = {
+    origin: string;
+};
+export declare class PluginLogger implements IPluginLogger {
+    /** @private */
+    origin: string;
+    /** @private */
+    constructor(opts: PluginLoggerOpts);
+    /** @private */
+    updateOrigin(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): Diagnostic | Array<Diagnostic>;
+    verbose(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    info(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    log(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    warn(diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    error(input: Diagnostifiable | DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>): void;
+    /** @private */
+    progress(message: string): void;
+}
+/** @private */
+export declare const INTERNAL_ORIGINAL_CONSOLE: {
+    readonly Console: console.ConsoleConstructor;
+    readonly assert: (value: any, message?: string, ...optionalParams: any[]) => void;
+    readonly clear: () => void;
+    readonly count: (label?: string) => void;
+    readonly countReset: (label?: string) => void;
+    readonly debug: (message?: any, ...optionalParams: any[]) => void;
+    readonly dir: (obj: any, options?: import("util").InspectOptions) => void;
+    readonly dirxml: (...data: any[]) => void;
+    readonly error: (message?: any, ...optionalParams: any[]) => void;
+    readonly group: (...label: any[]) => void;
+    readonly groupCollapsed: (...label: any[]) => void;
+    readonly groupEnd: () => void;
+    readonly info: (message?: any, ...optionalParams: any[]) => void;
+    readonly log: (message?: any, ...optionalParams: any[]) => void;
+    readonly table: (tabularData: any, properties?: readonly string[]) => void;
+    readonly time: (label?: string) => void;
+    readonly timeEnd: (label?: string) => void;
+    readonly timeLog: (label?: string, ...data: any[]) => void;
+    readonly trace: (message?: any, ...optionalParams: any[]) => void;
+    readonly warn: (message?: any, ...optionalParams: any[]) => void;
+    readonly profile: (label?: string) => void;
+    readonly profileEnd: (label?: string) => void;
+    readonly timeStamp: (label?: string) => void;
+};
+/**
+ * Patch `console` APIs within workers to forward their messages to the Logger
+ * at the appropriate levels.
+ * @private
+ */
+export declare function patchConsole(): void;
+/** @private */
+export declare function unpatchConsole(): void;

package/lib/Logger.js

@@ -0,0 +1,221 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.PluginLogger = exports.INTERNAL_ORIGINAL_CONSOLE = void 0;
+Object.defineProperty(exports, "instrument", {
+  enumerable: true,
+  get: function () {
+    return _tracer.instrument;
+  }
+});
+Object.defineProperty(exports, "instrumentAsync", {
+  enumerable: true,
+  get: function () {
+    return _tracer.instrumentAsync;
+  }
+});
+exports.patchConsole = patchConsole;
+exports.unpatchConsole = unpatchConsole;
+function _events() {
+  const data = require("@atlaspack/events");
+  _events = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = require("@atlaspack/diagnostic");
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+var _tracer = require("./tracer");
+class Logger {
+  logEmitter = new (_events().ValueEmitter)();
+  onLog(cb) {
+    return this.logEmitter.addListener(cb);
+  }
+  verbose(diagnostic) {
+    this.logEmitter.emit({
+      type: 'log',
+      level: 'verbose',
+      diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic]
+    });
+  }
+  info(diagnostic) {
+    this.log(diagnostic);
+  }
+  log(diagnostic) {
+    this.logEmitter.emit({
+      type: 'log',
+      level: 'info',
+      diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic]
+    });
+  }
+  warn(diagnostic) {
+    this.logEmitter.emit({
+      type: 'log',
+      level: 'warn',
+      diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic]
+    });
+  }
+  error(input, realOrigin) {
+    let diagnostic = (0, _diagnostic().anyToDiagnostic)(input);
+    if (typeof realOrigin === 'string') {
+      diagnostic = Array.isArray(diagnostic) ? diagnostic.map(d => {
+        return {
+          ...d,
+          origin: realOrigin
+        };
+      }) : {
+        ...diagnostic,
+        origin: realOrigin
+      };
+    }
+    this.logEmitter.emit({
+      type: 'log',
+      level: 'error',
+      diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic]
+    });
+  }
+  progress(message) {
+    this.logEmitter.emit({
+      type: 'log',
+      level: 'progress',
+      message
+    });
+  }
+}
+const logger = new Logger();
+var _default = exports.default = logger;
+/** @private */
+class PluginLogger {
+  /** @private */
+
+  /** @private */
+  constructor(opts) {
+    this.origin = opts.origin;
+  }
+
+  /** @private */
+  updateOrigin(diagnostic) {
+    return Array.isArray(diagnostic) ? diagnostic.map(d => {
+      return {
+        ...d,
+        origin: this.origin
+      };
+    }) : {
+      ...diagnostic,
+      origin: this.origin
+    };
+  }
+  verbose(diagnostic) {
+    logger.verbose(this.updateOrigin(diagnostic));
+  }
+  info(diagnostic) {
+    logger.info(this.updateOrigin(diagnostic));
+  }
+  log(diagnostic) {
+    logger.log(this.updateOrigin(diagnostic));
+  }
+  warn(diagnostic) {
+    logger.warn(this.updateOrigin(diagnostic));
+  }
+  error(input) {
+    logger.error(input, this.origin);
+  }
+
+  /** @private */
+  progress(message) {
+    logger.progress(message);
+  }
+}
+
+/** @private */
+exports.PluginLogger = PluginLogger;
+const INTERNAL_ORIGINAL_CONSOLE = exports.INTERNAL_ORIGINAL_CONSOLE = {
+  ...console
+};
+let consolePatched = false;
+
+/**
+ * Patch `console` APIs within workers to forward their messages to the Logger
+ * at the appropriate levels.
+ * @private
+ */
+function patchConsole() {
+  // Skip if console is already patched...
+  if (consolePatched) return;
+
+  /* eslint-disable no-console */
+  console.log = console.info = (...messages) => {
+    logger.info(messagesToDiagnostic(messages));
+  };
+  console.debug = (...messages) => {
+    // TODO: dedicated debug level?
+    logger.verbose(messagesToDiagnostic(messages));
+  };
+  console.warn = (...messages) => {
+    logger.warn(messagesToDiagnostic(messages));
+  };
+  console.error = (...messages) => {
+    logger.error(messagesToDiagnostic(messages));
+  };
+
+  /* eslint-enable no-console */
+  consolePatched = true;
+}
+
+/** @private */
+function unpatchConsole() {
+  // Skip if console isn't patched...
+  if (!consolePatched) return;
+
+  /* eslint-disable no-console */
+  console.log = INTERNAL_ORIGINAL_CONSOLE.log;
+  console.info = INTERNAL_ORIGINAL_CONSOLE.info;
+  console.debug = INTERNAL_ORIGINAL_CONSOLE.debug;
+  console.warn = INTERNAL_ORIGINAL_CONSOLE.warn;
+  console.error = INTERNAL_ORIGINAL_CONSOLE.error;
+
+  /* eslint-enable no-console */
+  consolePatched = false;
+}
+function messagesToDiagnostic(messages) {
+  if (messages.length === 1 && messages[0] instanceof Error) {
+    let error = messages[0];
+    let diagnostic = (0, _diagnostic().errorToDiagnostic)(error);
+    if (Array.isArray(diagnostic)) {
+      return diagnostic.map(d => {
+        return {
+          ...d,
+          skipFormatting: true
+        };
+      });
+    } else {
+      return {
+        ...diagnostic,
+        skipFormatting: true
+      };
+    }
+  } else {
+    return {
+      message: joinLogMessages(messages),
+      origin: 'console',
+      skipFormatting: true
+    };
+  }
+}
+function joinLogMessages(messages) {
+  return messages.map(m => typeof m === 'string' ? m : (0, _util().inspect)(m)).join(' ');
+}

package/lib/tracer.d.ts

@@ -0,0 +1,4 @@
+import { AtlaspackTracer } from '@atlaspack/rust';
+export declare const tracer: AtlaspackTracer;
+export declare function instrument<T>(label: string, fn: () => T): T;
+export declare function instrumentAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;

package/lib/tracer.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instrument = instrument;
+exports.instrumentAsync = instrumentAsync;
+exports.tracer = void 0;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+const tracer = exports.tracer = new (_rust().AtlaspackTracer)();
+function instrument(label, fn) {
+  const span = tracer.enter(label);
+  try {
+    const result = fn();
+    return result;
+  } finally {
+    tracer.exit(span);
+  }
+}
+async function instrumentAsync(label, fn) {
+  const span = tracer.enter(label);
+  let result;
+  try {
+    result = await fn();
+  } finally {
+    tracer.exit(span);
+  }
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/logger",
-  "version": "2.14.14-typescript-b27501580.0",
+  "version": "2.14.14-typescript-5b4d3ad41.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -17,13 +17,13 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.2-typescript-b27501580.0",
-    "@atlaspack/events": "2.14.2-typescript-b27501580.0",
-    "@atlaspack/rust": "3.4.2-typescript-b27501580.0"
+    "@atlaspack/diagnostic": "2.14.2-typescript-5b4d3ad41.0",
+    "@atlaspack/events": "2.14.2-typescript-5b4d3ad41.0",
+    "@atlaspack/rust": "3.4.2-typescript-5b4d3ad41.0"
   },
   "type": "commonjs",
   "scripts": {
     "check-ts": "tsc --emitDeclarationOnly --rootDir src"
   },
-  "gitHead": "b275015805a058452afb6fb48c078ecd4de925f2"
+  "gitHead": "5b4d3ad41ffa002b989ba77271bb3010a1f05b2a"
 }