@atlaspack/logger 2.14.5-canary.38 → 2.14.5-canary.381

package/lib/types/Logger.d.ts

@@ -0,0 +1,129 @@
+import type { IDisposable, LogEvent, PluginLogger as IPluginLogger } from '@atlaspack/types-internal';
+import type { Diagnostic, Diagnostifiable, DiagnosticWithoutOrigin } from '@atlaspack/diagnostic';
+import { ValueEmitter } from '@atlaspack/events';
+export { tracer, 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 assert: {
+        (condition?: boolean, ...data: any[]): void;
+        (value: any, message?: string, ...optionalParams: any[]): void;
+    };
+    readonly clear: {
+        (): void;
+        (): void;
+    };
+    readonly count: {
+        (label?: string): void;
+        (label?: string): void;
+    };
+    readonly countReset: {
+        (label?: string): void;
+        (label?: string): void;
+    };
+    readonly debug: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    readonly dir: {
+        (item?: any, options?: any): void;
+        (obj: any, options?: import("util").InspectOptions): void;
+    };
+    readonly dirxml: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+    };
+    readonly error: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    readonly group: {
+        (...data: any[]): void;
+        (...label: any[]): void;
+    };
+    readonly groupCollapsed: {
+        (...data: any[]): void;
+        (...label: any[]): void;
+    };
+    readonly groupEnd: {
+        (): void;
+        (): void;
+    };
+    readonly info: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    readonly log: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    readonly table: {
+        (tabularData?: any, properties?: string[]): void;
+        (tabularData: any, properties?: readonly string[]): void;
+    };
+    readonly time: {
+        (label?: string): void;
+        (label?: string): void;
+    };
+    readonly timeEnd: {
+        (label?: string): void;
+        (label?: string): void;
+    };
+    readonly timeLog: {
+        (label?: string, ...data: any[]): void;
+        (label?: string, ...data: any[]): void;
+    };
+    readonly timeStamp: {
+        (label?: string): void;
+        (label?: string): void;
+    };
+    readonly trace: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    readonly warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    readonly Console: console.ConsoleConstructor;
+    readonly profile: (label?: string) => void;
+    readonly profileEnd: (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/types/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/logger",
-  "version": "2.14.5-canary.38+a1d0dcea5",
+  "version": "2.14.5-canary.381+a631dcd96",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,22 +10,21 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/Logger.js",
-  "source": "src/Logger.js",
-  "exports": {
-    ".": {
-      "@atlaspack::sources": "./src/Logger.js",
-      "default": "./lib/Logger.js"
-    }
-  },
+  "main": "./lib/Logger.js",
+  "source": "./src/Logger.ts",
+  "types": "./lib/types/Logger.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.106+a1d0dcea5",
-    "@atlaspack/events": "2.14.1-canary.106+a1d0dcea5",
-    "@atlaspack/rust": "3.2.1-canary.38+a1d0dcea5"
+    "@atlaspack/diagnostic": "2.14.1-canary.449+a631dcd96",
+    "@atlaspack/events": "2.14.1-canary.449+a631dcd96",
+    "@atlaspack/rust": "3.2.1-canary.381+a631dcd96",
+    "@atlaspack/types-internal": "2.14.1-canary.449+a631dcd96"
   },
   "type": "commonjs",
-  "gitHead": "a1d0dcea5980bde5a3d1907d60359b85eedd8664"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "a631dcd961112db072b0f8de0831efd178f355a7"
+}

package/src/{Logger.js → Logger.ts}

@@ -1,10 +1,8 @@
-// @flow strict-local
-
 import type {
   IDisposable,
   LogEvent,
   PluginLogger as IPluginLogger,
-} from '@atlaspack/types';
+} from '@atlaspack/types-internal';
 import type {
   Diagnostic,
   Diagnostifiable,
@@ -15,17 +13,17 @@ import {ValueEmitter} from '@atlaspack/events';
 import {inspect} from 'util';
 import {errorToDiagnostic, anyToDiagnostic} from '@atlaspack/diagnostic';
 
-export {instrument, instrumentAsync} from './tracer';
+export {tracer, instrument, instrumentAsync} from './tracer';
 
 class Logger {
-  #logEmitter /*: ValueEmitter<LogEvent> */ = new ValueEmitter();
+  logEmitter: ValueEmitter<LogEvent> = new ValueEmitter();
 
-  onLog(cb: (event: LogEvent) => mixed): IDisposable {
-    return this.#logEmitter.addListener(cb);
+  onLog(cb: (event: LogEvent) => unknown): IDisposable {
+    return this.logEmitter.addListener(cb);
   }
 
   verbose(diagnostic: Diagnostic | Array<Diagnostic>): void {
-    this.#logEmitter.emit({
+    this.logEmitter.emit({
       type: 'log',
       level: 'verbose',
       diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
@@ -37,7 +35,7 @@ class Logger {
   }
 
   log(diagnostic: Diagnostic | Array<Diagnostic>): void {
-    this.#logEmitter.emit({
+    this.logEmitter.emit({
       type: 'log',
       level: 'info',
       diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
@@ -45,7 +43,7 @@ class Logger {
   }
 
   warn(diagnostic: Diagnostic | Array<Diagnostic>): void {
-    this.#logEmitter.emit({
+    this.logEmitter.emit({
       type: 'log',
       level: 'warn',
       diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
@@ -53,7 +51,7 @@ class Logger {
   }
 
   error(input: Diagnostifiable, realOrigin?: string): void {
-    let diagnostic = anyToDiagnostic(input);
+    let diagnostic = anyToDiagnostic(input) as Diagnostic | Array<Diagnostic>;
     if (typeof realOrigin === 'string') {
       diagnostic = Array.isArray(diagnostic)
         ? diagnostic.map((d) => {
@@ -65,7 +63,7 @@ class Logger {
           };
     }
 
-    this.#logEmitter.emit({
+    this.logEmitter.emit({
       type: 'log',
       level: 'error',
       diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
@@ -73,7 +71,7 @@ class Logger {
   }
 
   progress(message: string): void {
-    this.#logEmitter.emit({
+    this.logEmitter.emit({
       type: 'log',
       level: 'progress',
       message,
@@ -85,9 +83,9 @@ const logger: Logger = new Logger();
 export default logger;
 
 /** @private */
-export type PluginLoggerOpts = {|
-  origin: string,
-|};
+export type PluginLoggerOpts = {
+  origin: string;
+};
 
 export class PluginLogger implements IPluginLogger {
   /** @private */
@@ -106,7 +104,7 @@ export class PluginLogger implements IPluginLogger {
       ? diagnostic.map((d) => {
           return {...d, origin: this.origin};
         })
-      : {...diagnostic, origin: this.origin};
+      : ({...diagnostic, origin: this.origin} as Diagnostic);
   }
 
   verbose(
@@ -149,7 +147,7 @@ export class PluginLogger implements IPluginLogger {
 }
 
 /** @private */
-export const INTERNAL_ORIGINAL_CONSOLE = {...console};
+export const INTERNAL_ORIGINAL_CONSOLE = {...console} as const;
 let consolePatched = false;
 
 /**
@@ -162,24 +160,20 @@ export function patchConsole() {
   if (consolePatched) return;
 
   /* eslint-disable no-console */
-  // $FlowFixMe
-  console.log = console.info = (...messages: Array<mixed>) => {
+  console.log = console.info = (...messages: Array<unknown>) => {
     logger.info(messagesToDiagnostic(messages));
   };
 
-  // $FlowFixMe
-  console.debug = (...messages: Array<mixed>) => {
+  console.debug = (...messages: Array<unknown>) => {
     // TODO: dedicated debug level?
     logger.verbose(messagesToDiagnostic(messages));
   };
 
-  // $FlowFixMe
-  console.warn = (...messages: Array<mixed>) => {
+  console.warn = (...messages: Array<unknown>) => {
     logger.warn(messagesToDiagnostic(messages));
   };
 
-  // $FlowFixMe
-  console.error = (...messages: Array<mixed>) => {
+  console.error = (...messages: Array<unknown>) => {
     logger.error(messagesToDiagnostic(messages));
   };
 
@@ -193,19 +187,14 @@ export function unpatchConsole() {
   if (!consolePatched) return;
 
   /* eslint-disable no-console */
-  // $FlowFixMe
   console.log = INTERNAL_ORIGINAL_CONSOLE.log;
 
-  // $FlowFixMe
   console.info = INTERNAL_ORIGINAL_CONSOLE.info;
 
-  // $FlowFixMe
   console.debug = INTERNAL_ORIGINAL_CONSOLE.debug;
 
-  // $FlowFixMe
   console.warn = INTERNAL_ORIGINAL_CONSOLE.warn;
 
-  // $FlowFixMe
   console.error = INTERNAL_ORIGINAL_CONSOLE.error;
 
   /* eslint-enable no-console */
@@ -213,11 +202,11 @@ export function unpatchConsole() {
 }
 
 function messagesToDiagnostic(
-  messages: Array<mixed>,
+  messages: Array<unknown>,
 ): Diagnostic | Array<Diagnostic> {
   if (messages.length === 1 && messages[0] instanceof Error) {
     let error: Error = messages[0];
-    let diagnostic = errorToDiagnostic(error);
+    let diagnostic = errorToDiagnostic(error) as Diagnostic | Array<Diagnostic>;
 
     if (Array.isArray(diagnostic)) {
       return diagnostic.map((d) => {
@@ -241,7 +230,7 @@ function messagesToDiagnostic(
   }
 }
 
-function joinLogMessages(messages: Array<mixed>): string {
+function joinLogMessages(messages: Array<unknown>): string {
   return messages
     .map((m) => (typeof m === 'string' ? m : inspect(m)))
     .join(' ');

package/src/{tracer.js → tracer.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {AtlaspackTracer} from '@atlaspack/rust';
 
 export const tracer: AtlaspackTracer = new AtlaspackTracer();

package/test/{Logger.test.js → Logger.test.ts}

@@ -1,12 +1,10 @@
-// @flow strict-local
-
 import assert from 'assert';
 import sinon from 'sinon';
 import Logger from '../src/Logger';
 
 describe('Logger', () => {
-  let onLog;
-  let logDisposable;
+  let onLog: any;
+  let logDisposable: any;
   beforeEach(() => {
     onLog = sinon.spy();
     logDisposable = Logger.onLog(onLog);

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../utils/events/tsconfig.json"
+    },
+    {
+      "path": "../diagnostic/tsconfig.json"
+    },
+    {
+      "path": "../rust/tsconfig.json"
+    },
+    {
+      "path": "../types-internal/tsconfig.json"
+    }
+  ]
+}