@niceties/logger 1.1.12 → 2.0.0

package/index.d.ts

@@ -0,0 +1,362 @@
+declare module '@niceties/logger' {
+	export type LogMessage<ErrorContext = Error> = LogMessage_1<ErrorContext>;
+	export type LogLevel = number;
+	export namespace LogLevel {
+		let verbose: number;
+		let info: number;
+		let warn: number;
+		let error: number;
+	}
+	export type Action = number;
+	export namespace Action {
+		let start: 0;
+		let update: 1;
+		let finish: 2;
+		let log: 3;
+	}
+	export interface DefaultExtendedApi {
+		setMinLevel: (logLevel: number) => void;
+	}
+	export type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	export type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	export type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	type LogMessage_1<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	export type Appender<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: LogMessage_1<ErrorContext>) => void) & {
+		api?: Api;
+	};
+	export type Identity = {
+		id?: number | undefined;
+	};
+	export type Prefixes = {
+		[index: number]: string;
+	};
+	export type ColorFormatters = {
+		[index: number]: ((text: string) => string) | undefined;
+	};
+	export type Formatter<ErrorContext = Error> = (message: LogMessage_1<ErrorContext>, usePrefix?: string | boolean | undefined, indentation?: number | undefined) => string;
+	export type Logger<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: string, loglevel?: number, context?: ErrorContext) => void) & {
+		start(message: string, loglevel?: number, context?: ErrorContext): void;
+		update(message: string, loglevel?: number, context?: ErrorContext): void;
+		finish(message: string, loglevel?: number, context?: ErrorContext): void;
+		appender(appender?: Appender<ErrorContext, Api>): (message: LogMessage_1<ErrorContext>) => void;
+	} & Identity & Api;
+	export function createLogger<ErrorContext = Error, Api = DefaultExtendedApi>(...args: (string | Identity_1 | undefined)[]): ((message: string, loglevel?: number, context?: ErrorContext) => void) & {
+		start(message: string, loglevel?: number, context?: ErrorContext): void;
+		update(message: string, loglevel?: number, context?: ErrorContext): void;
+		finish(message: string, loglevel?: number, context?: ErrorContext): void;
+		appender(appender?: Appender_1<ErrorContext, Api>): (message: LogMessage_1_2<ErrorContext>) => void;
+	} & Identity_1 & Api;
+	type Appender_1<ErrorContext = Error, Api = DefaultExtendedApi> = Appender<ErrorContext, Api>;
+	type LogMessage_1_2<ErrorContext = Error> = LogMessage_1<ErrorContext>;
+	type Identity_1 = Identity;
+	export function appender<ErrorContext = Error, Api = DefaultExtendedApi>(newAppender?: Appender_1_2<ErrorContext, Api>): Appender_1_2<unknown> | undefined;
+	type Appender_1_2<ErrorContext = Error, Api = DefaultExtendedApi> = Appender<ErrorContext, Api>;
+
+	export {};
+}
+
+declare module '@niceties/logger/default-formatting' {
+	export const unicodePrefixes: Prefixes;
+
+	export const asciiPrefixes: Prefixes;
+
+	export const unicodeLogPrefixes: Prefixes;
+
+	export const asciiLogPrefixes: Prefixes;
+
+	export const colors: ColorFormatters;
+	export function tagFactory(tag: string): string;
+	export type ColorFormatters = ColorFormatters_1;
+	export type Prefixes = Prefixes_1;
+	type Prefixes_1 = {
+		[index: number]: string;
+	};
+	type ColorFormatters_1 = {
+		[index: number]: ((text: string) => string) | undefined;
+	};
+
+	export {};
+}
+
+declare module '@niceties/logger/core' {
+	export function createLogger<ErrorContext = Error, Api = DefaultExtendedApi>(...args: (string | Identity | undefined)[]): ((message: string, loglevel?: number, context?: ErrorContext) => void) & {
+		start(message: string, loglevel?: number, context?: ErrorContext): void;
+		update(message: string, loglevel?: number, context?: ErrorContext): void;
+		finish(message: string, loglevel?: number, context?: ErrorContext): void;
+		appender(appender?: Appender<ErrorContext, Api>): (message: LogMessage<ErrorContext>) => void;
+	} & Identity & Api;
+	export type Appender<ErrorContext = Error, Api = DefaultExtendedApi> = Appender_1<ErrorContext, Api>;
+	export type LogMessage<ErrorContext = Error> = LogMessage_1<ErrorContext>;
+	export type Identity = Identity_1;
+	interface DefaultExtendedApi {
+		setMinLevel: (logLevel: number) => void;
+	}
+	type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	type LogMessage_1<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	type Appender_1<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: LogMessage_1<ErrorContext>) => void) & {
+		api?: Api;
+	};
+	type Identity_1 = {
+		id?: number | undefined;
+	};
+
+	export {};
+}
+
+declare module '@niceties/logger/simple' {
+	export function createLogger<ErrorContext = Error, Api = DefaultExtendedApi>(tag?: string): ((message: string, loglevel?: number, context?: ErrorContext) => void) & {
+		appender(appender?: Appender<ErrorContext, Api>): (message: LogMessage<ErrorContext>) => void;
+	} & Api;
+	export type Appender<ErrorContext = Error, Api = DefaultExtendedApi> = Appender_1<ErrorContext, Api>;
+	export type LogMessage<ErrorContext = Error> = LogMessage_1<ErrorContext>;
+	interface DefaultExtendedApi {
+		setMinLevel: (logLevel: number) => void;
+	}
+	type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	type LogMessage_1<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	type Appender_1<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: LogMessage_1<ErrorContext>) => void) & {
+		api?: Api;
+	};
+
+	export {};
+}
+
+declare module '@niceties/logger/console-appender' {
+	export function createConsoleAppender(formatter: Formatter): Appender;
+	export type Formatter = Formatter_1;
+	export type LogMessage = LogMessage_1;
+	export type Appender = Appender_1;
+	interface DefaultExtendedApi {
+		setMinLevel: (logLevel: number) => void;
+	}
+	type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	type LogMessage_1<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	type Appender_1<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: LogMessage_1<ErrorContext>) => void) & {
+		api?: Api;
+	};
+	type Formatter_1<ErrorContext = Error> = (message: LogMessage_1<ErrorContext>, usePrefix?: string | boolean | undefined, indentation?: number | undefined) => string;
+
+	export {};
+}
+
+declare module '@niceties/logger/format-utils' {
+	export function createFormatter(colors: ColorFormatters, prefixes: Prefixes, logPrefixes: Prefixes, tagFactory: (tag: string) => string): (message: LogMessage, usePrefix?: string | boolean, indentation?: number) => string;
+	export function terminalSupportsUnicode(): boolean;
+	export type LogMessage = LogMessage_1;
+	export type ColorFormatters = ColorFormatters_1;
+	export type Prefixes = Prefixes_1;
+	type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	type LogMessage_1<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	type Prefixes_1 = {
+		[index: number]: string;
+	};
+	type ColorFormatters_1 = {
+		[index: number]: ((text: string) => string) | undefined;
+	};
+
+	export {};
+}
+
+declare module '@niceties/logger/global-appender' {
+	export let globalAppender: Appender<unknown> | undefined;
+	export function appender<ErrorContext = Error, Api = DefaultExtendedApi>(newAppender?: Appender<ErrorContext, Api>): Appender<unknown> | undefined;
+	export type Appender<ErrorContext = Error, Api = DefaultExtendedApi> = Appender_1<ErrorContext, Api>;
+	interface DefaultExtendedApi {
+		setMinLevel: (logLevel: number) => void;
+	}
+	type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	type LogMessage<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	type Appender_1<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: LogMessage<ErrorContext>) => void) & {
+		api?: Api;
+	};
+
+	export {};
+}
+
+declare module '@niceties/logger/appender-utils' {
+	export function filterMessages<ErrorContext = Error, Api = DefaultExtendedApi>(predicate: (logMessage: LogMessage<ErrorContext>) => boolean, appender: Appender<ErrorContext, Api>): Appender<ErrorContext, Api>;
+	export function combineAppenders<ErrorContext = Error, Api = DefaultExtendedApi>(...appenders: Appender<ErrorContext, Api>[]): Appender<ErrorContext, Api>;
+	export type LogMessage<ErrorContext = Error> = LogMessage_1<ErrorContext>;
+	export type Appender<ErrorContext = Error, Api = DefaultExtendedApi> = Appender_1<ErrorContext, Api>;
+	interface DefaultExtendedApi {
+		setMinLevel: (logLevel: number) => void;
+	}
+	type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	type LogMessage_1<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	type Appender_1<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: LogMessage_1<ErrorContext>) => void) & {
+		api?: Api;
+	};
+
+	export {};
+}
+
+declare module '@niceties/logger/types' {
+	export type LogLevel = number;
+	export namespace LogLevel {
+		let verbose: number;
+		let info: number;
+		let warn: number;
+		let error: number;
+	}
+	export type Action = number;
+	export namespace Action {
+		let start: 0;
+		let update: 1;
+		let finish: 2;
+		let log: 3;
+	}
+	export interface DefaultExtendedApi {
+		setMinLevel: (logLevel: number) => void;
+	}
+	export type LogMessageBase<ErrorContext = Error> = {
+		loglevel: number;
+		message: string;
+		tag?: string | undefined;
+		parentId?: number | undefined;
+		context?: ErrorContext | undefined;
+	};
+	export type LogMessageWithInput<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId: number;
+		action: 0 | 1 | 2;
+		ref: WeakRef<never>;
+	};
+	export type LogMessageLog<ErrorContext = Error> = LogMessageBase<ErrorContext> & {
+		inputId?: number;
+		action: 3;
+		ref?: WeakRef<never>;
+	};
+	export type LogMessage<ErrorContext = Error> = LogMessageWithInput<ErrorContext> | LogMessageLog<ErrorContext>;
+	export type Appender<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: LogMessage<ErrorContext>) => void) & {
+		api?: Api;
+	};
+	export type Identity = {
+		id?: number | undefined;
+	};
+	export type Prefixes = {
+		[index: number]: string;
+	};
+	export type ColorFormatters = {
+		[index: number]: ((text: string) => string) | undefined;
+	};
+	export type Formatter<ErrorContext = Error> = (message: LogMessage<ErrorContext>, usePrefix?: string | boolean | undefined, indentation?: number | undefined) => string;
+	export type Logger<ErrorContext = Error, Api = DefaultExtendedApi> = ((message: string, loglevel?: number, context?: ErrorContext) => void) & {
+		start(message: string, loglevel?: number, context?: ErrorContext): void;
+		update(message: string, loglevel?: number, context?: ErrorContext): void;
+		finish(message: string, loglevel?: number, context?: ErrorContext): void;
+		appender(appender?: Appender<ErrorContext, Api>): (message: LogMessage<ErrorContext>) => void;
+	} & Identity & Api;
+
+	export {};
+}
+
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1,48 @@
+{
+	"version": 3,
+	"file": "index.d.ts",
+	"names": [
+		"Identity",
+		"Prefixes",
+		"ColorFormatters",
+		"createLogger",
+		"appender",
+		"unicodePrefixes",
+		"asciiPrefixes",
+		"unicodeLogPrefixes",
+		"asciiLogPrefixes",
+		"colors",
+		"tagFactory",
+		"createConsoleAppender",
+		"Formatter",
+		"LogMessage",
+		"Appender",
+		"createFormatter",
+		"terminalSupportsUnicode",
+		"globalAppender",
+		"filterMessages",
+		"combineAppenders"
+	],
+	"sources": [
+		"core.js",
+		"types.js",
+		"global-appender.js",
+		"default-formatting.js",
+		"simple.js",
+		"console-appender.js",
+		"format-utils.js",
+		"appender-utils.js"
+	],
+	"sourcesContent": [
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null,
+		null
+	],
+	"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBaG,YAAYA;;;;;;;;;iBErBZC,QAAQA;;;;;;;cCERC,eAAeA;;cAEfC,aAAaA;;cAEbC,kBAAkBA;;cAElBC,gBAAgBA;;cAEhBC,MAAMA;iBAENC,UAAUA;;;;;;;;;;;;;;iBHSVP,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBIpBZA,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCDZQ,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCArBI,eAAeA;iBAgBfC,uBAAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YJlBzBC,cAAcA;iBAEZb,QAAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBKFRc,cAAcA;iBAadC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+	"ignoreList": []
+}

package/index.js

@@ -0,0 +1,40 @@
+import { createLogger } from './core.js';
+import { appender } from './global-appender.js';
+import { LogLevel } from './types.js';
+
+if (!appender()) {
+    const [
+        { asciiPrefixes, asciiLogPrefixes, colors, unicodePrefixes, unicodeLogPrefixes, tagFactory },
+        { createConsoleAppender },
+        { createFormatter, terminalSupportsUnicode },
+        { filterMessages },
+    ] = await Promise.all([
+        import('./default-formatting.js'),
+        import('./console-appender.js'),
+        import('./format-utils.js'),
+        import('./appender-utils.js'),
+    ]);
+    const unicode = terminalSupportsUnicode();
+    const formatter = createFormatter(
+        colors,
+        unicode ? unicodePrefixes : asciiPrefixes,
+        unicode ? unicodeLogPrefixes : asciiLogPrefixes,
+        tagFactory
+    );
+    let minLogLevel = LogLevel.info;
+    const filtered = filterMessages(
+
+        message =>  (message.loglevel) >= minLogLevel,
+        createConsoleAppender(formatter)
+    );
+    filtered.api = {
+
+        setMinLevel(logLevel) {
+            minLogLevel = logLevel;
+        },
+    };
+    appender(filtered);
+}
+
+export * from './types.js';
+export { createLogger, appender };

package/package.json

@@ -1,59 +1,51 @@
 {
-  "version": "1.1.12",
+  "version": "2.0.0",
   "license": "MIT",
   "name": "@niceties/logger",
   "author": "Konstantin Shutkin",
   "type": "module",
+  "types": "./index.d.ts",
   "exports": {
     ".": {
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.mjs"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./default-formatting": {
-      "require": "./dist/default-formatting.cjs",
-      "default": "./dist/default-formatting.mjs"
+      "types": "./index.d.ts",
+      "default": "./default-formatting.js"
     },
     "./core": {
-      "require": "./dist/core.cjs",
-      "default": "./dist/core.mjs"
+      "types": "./index.d.ts",
+      "default": "./core.js"
     },
     "./simple": {
-      "require": "./dist/simple.cjs",
-      "default": "./dist/simple.mjs"
+      "types": "./index.d.ts",
+      "default": "./simple.js"
     },
     "./console-appender": {
-      "require": "./dist/console-appender.cjs",
-      "default": "./dist/console-appender.mjs"
+      "types": "./index.d.ts",
+      "default": "./console-appender.js"
     },
     "./format-utils": {
-      "require": "./dist/format-utils.cjs",
-      "default": "./dist/format-utils.mjs"
+      "types": "./index.d.ts",
+      "default": "./format-utils.js"
     },
     "./global-appender": {
-      "require": "./dist/global-appender.cjs",
-      "default": "./dist/global-appender.mjs"
+      "types": "./index.d.ts",
+      "default": "./global-appender.js"
     },
     "./appender-utils": {
-      "require": "./dist/appender-utils.cjs",
-      "default": "./dist/appender-utils.mjs"
+      "types": "./index.d.ts",
+      "default": "./appender-utils.js"
+    },
+    "./types": {
+      "types": "./index.d.ts",
+      "default": "./types.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "typings": "./dist/index.d.ts",
-  "unpkg": "./dist/simple.umd.js",
-  "files": [
-    "dist",
-    "default-formatting",
-    "core",
-    "console-appender",
-    "global-appender",
-    "appender-utils",
-    "format-utils",
-    "types",
-    "simple"
-  ],
+  "main": "./index.js",
+  "module": "./index.js",
   "engines": {
     "node": ">=15"
   },
@@ -74,10 +66,5 @@
   ],
   "dependencies": {
     "kleur": "^4.1.4"
-  },
-  "scripts": {
-    "build": "pkgbld-internal --umd=core,simple,console-appender,global-appender,appender-utils --preprocess=index",
-    "test": "jest --collectCoverage",
-    "lint": "eslint ./src"
   }
 }

package/simple.js

@@ -0,0 +1,42 @@
+import { globalAppender } from './global-appender.js';
+import { Action, LogLevel } from './types.js';
+
+export const createLogger = tag => {
+
+    let myAppender = message => {
+        globalAppender?.(message);
+    };
+
+    const loggerInstance = Object.assign(
+
+        (message, loglevel = LogLevel.info, context) => {
+            myAppender?.(
+                 ({
+                    action: Action.log,
+                    message,
+                    loglevel,
+                    tag,
+                    context,
+                })
+            );
+        },
+        {
+
+            appender(appender) {
+                if (appender !== undefined) {
+                    myAppender = appender;
+                    const api = appender.api;
+                    if (api != null) {
+                        Object.setPrototypeOf(api, Function.prototype);
+                        Object.setPrototypeOf(loggerInstance, api);
+                    } else {
+                        Object.setPrototypeOf(loggerInstance, Function.prototype);
+                    }
+                }
+                return myAppender;
+            },
+        }
+    );
+
+    return  (loggerInstance);
+};

package/types.js

@@ -0,0 +1,17 @@
+export const LogLevel =  ({
+
+    verbose:  (0),
+
+    info:  (1),
+
+    warn:  (2),
+
+    error:  (3),
+});
+
+export const Action =  ({
+    start: 0,
+    update: 1,
+    finish: 2,
+    log: 3,
+});

package/appender-utils/package.json

@@ -1,5 +0,0 @@
-{
-  "type": "module",
-  "types": "../dist/appender-utils.d.ts",
-  "main": "../dist/appender-utils.mjs"
-}

package/console-appender/package.json

@@ -1,5 +0,0 @@
-{
-  "type": "module",
-  "types": "../dist/console-appender.d.ts",
-  "main": "../dist/console-appender.mjs"
-}

package/core/package.json

@@ -1,5 +0,0 @@
-{
-  "type": "module",
-  "types": "../dist/core.d.ts",
-  "main": "../dist/core.mjs"
-}

package/default-formatting/package.json

@@ -1,5 +0,0 @@
-{
-  "type": "module",
-  "types": "../dist/default-formatting.d.ts",
-  "main": "../dist/default-formatting.mjs"
-}

package/dist/appender-utils.cjs

@@ -1,22 +0,0 @@
-'use strict';
-
-const filterMessages = (predicate, appender, api) => {
-    return Object.assign(function (logMessage) {
-        if (predicate(logMessage)) {
-            appender(logMessage);
-        }
-    }, api);
-};
-const combineAppenders = (...appenders) => {
-    return (message) => {
-        for (const appender of appenders) {
-            try {
-                appender(message);
-            }
-            catch (e) { /* eat the error */ }
-        }
-    };
-};
-
-exports.combineAppenders = combineAppenders;
-exports.filterMessages = filterMessages;

package/dist/appender-utils.d.ts

@@ -1,3 +0,0 @@
-import { Appender, LogMessage } from './types';
-export declare const filterMessages: <ErrorContext = Error, Api extends object = object>(predicate: (logMessage: LogMessage<ErrorContext>) => boolean, appender: Appender<ErrorContext>, api?: Api | undefined) => Appender<ErrorContext> & Api;
-export declare const combineAppenders: <ErrorContext = Error>(...appenders: Appender<ErrorContext>[]) => Appender<ErrorContext>;

package/dist/appender-utils.mjs

@@ -1,19 +0,0 @@
-const filterMessages = (predicate, appender, api) => {
-    return Object.assign(function (logMessage) {
-        if (predicate(logMessage)) {
-            appender(logMessage);
-        }
-    }, api);
-};
-const combineAppenders = (...appenders) => {
-    return (message) => {
-        for (const appender of appenders) {
-            try {
-                appender(message);
-            }
-            catch (e) { /* eat the error */ }
-        }
-    };
-};
-
-export { combineAppenders, filterMessages };