@breadc/logger 0.9.7-beta.0 → 1.0.0-beta.1

package/dist/index.d.mts

@@ -0,0 +1,102 @@
+//#region src/level.d.ts
+type LogLevel = 0 | 1 | 2 | 3 | 4 | 5 | (number & {});
+declare const LogLevels: Record<LogType, number>;
+type LogType = 'silent' | 'fatal' | 'error' | 'warn' | 'log' | 'info' | 'success' | 'fail' | 'ready' | 'start' | 'box' | 'debug' | 'trace' | 'verbose';
+//#endregion
+//#region src/types.d.ts
+interface LoggerPlugin {}
+interface LoggerOptions {
+  reporter: Reporter[];
+  level: LogLevel;
+  defaults: InputLogObject;
+  format: FormatOptions;
+  stdout?: NodeJS.WriteStream;
+  stderr?: NodeJS.WriteStream;
+  plugins: LoggerPlugin[];
+}
+interface InputLogObject {
+  level?: LogLevel;
+  type?: LogType;
+  tag?: string;
+  date?: Date;
+  message?: string;
+  args?: any[];
+}
+interface LogObject extends InputLogObject {
+  level: LogLevel;
+  type: LogType;
+  date: Date;
+}
+type InputLogItem = string | number | Omit<InputLogObject, 'level' | 'type'>;
+interface PrintContext {
+  options: LoggerOptions;
+}
+interface Reporter {
+  print: (log: LogObject, ctx: PrintContext) => void;
+}
+/**
+ * @see https://nodejs.org/api/util.html#util_util_inspect_object_showhidden_depth_colors
+ */
+interface FormatOptions {
+  columns?: number;
+  date?: boolean;
+  colors?: boolean;
+  compact?: boolean | number;
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/logger.d.ts
+declare class BreadcLogger<T extends {}> {
+  private _overrides;
+  readonly options: LoggerOptions;
+  constructor(options: LoggerOptions);
+  get level(): LogLevel;
+  set level(level: LogLevel);
+  get reporter(): Reporter[];
+  extend<U extends {}>(overrides: U): BreadcLogger<T & U> & T & U;
+  withDefaults(defaults: InputLogObject): BreadcLogger<T> & T;
+  withTag(tag: string): BreadcLogger<T> & T;
+  private shouldPrint;
+  print(defaults: InputLogObject, input: InputLogObject): void;
+  resolveInput(input: InputLogItem, args: any[]): Omit<InputLogObject, "level" | "type">;
+  log(input: InputLogItem, ...args: any[]): void;
+}
+type LogFn = (message: InputLogItem, ...args: any[]) => void;
+//#endregion
+//#region src/reporters/types.d.ts
+interface FormatReporterOptions {
+  prefix: string;
+}
+interface FormatReporter$1 extends Reporter {
+  formatArgs(opts: FormatOptions, message?: string, args?: any[]): string;
+  formatLogObject(obj: LogObject, ctx: PrintContext): string;
+}
+//#endregion
+//#region src/reporters/mock.d.ts
+interface HistoryLog {
+  readonly output: string;
+  readonly object: LogObject;
+}
+declare const MockReporter: (reporter: FormatReporter$1, history?: HistoryLog[]) => Reporter & {
+  history: HistoryLog[];
+};
+//#endregion
+//#region src/reporters/basic.d.ts
+interface BasicReporterOptions extends FormatReporterOptions {}
+declare const BasicReporter: (options?: Partial<BasicReporterOptions>) => FormatReporter$1;
+//#endregion
+//#region src/reporters/fancy.d.ts
+interface FancyReporterOptions extends FormatReporterOptions {}
+declare const FancyReporter: (options?: Partial<FancyReporterOptions>) => FormatReporter$1;
+//#endregion
+//#region src/reporters/index.d.ts
+declare const FormatReporter: (options: Partial<FormatReporterOptions> & {
+  fancy?: boolean;
+}) => FormatReporter$1;
+//#endregion
+//#region src/index.d.ts
+declare const Logger: (options?: Partial<LoggerOptions> & {
+  fancy?: boolean;
+}) => BreadcLogger<Record<LogType, LogFn>> & Record<LogType, LogFn>;
+//#endregion
+export { BasicReporter, BasicReporterOptions, BreadcLogger, FancyReporter, FancyReporterOptions, FormatOptions, FormatReporter, InputLogItem, InputLogObject, LogFn, LogLevel, LogLevels, LogObject, LogType, Logger, LoggerOptions, LoggerPlugin, MockReporter, PrintContext, Reporter };

package/dist/index.mjs

@@ -1,5 +1,218 @@
-function createLogger(options = {}) {
-  return {};
+import { hasTTY, isCI, isDebug, isTest } from "std-env";
+import { formatWithOptions } from "node:util";
+
+//#region src/level.ts
+const LogLevels = {
+	silent: Number.NEGATIVE_INFINITY,
+	fatal: 0,
+	error: 0,
+	warn: 1,
+	log: 2,
+	info: 3,
+	success: 3,
+	fail: 3,
+	ready: 3,
+	start: 3,
+	box: 3,
+	debug: 4,
+	trace: 5,
+	verbose: Number.POSITIVE_INFINITY
+};
+
+//#endregion
+//#region src/utils/format.ts
+const bracket = (text) => {
+	if (text) return `[${text}]`;
+	else return;
+};
+
+//#endregion
+//#region src/utils/stream.ts
+function writeStream(data, stream) {
+	return (stream.__write || stream.write).call(stream, data);
+}
+
+//#endregion
+//#region src/reporters/fancy.ts
+const FancyReporter = (options = {}) => {
+	return {
+		formatArgs(opts, message, args = []) {
+			return formatWithOptions(opts, message, ...args);
+		},
+		formatLogObject(obj, ctx) {
+			const message = this.formatArgs(ctx.options.format, obj.message, obj.args);
+			return [
+				options.prefix,
+				bracket(obj.type === "log" ? void 0 : obj.type),
+				bracket(obj.tag),
+				message
+			].filter(Boolean).join(" ");
+		},
+		print(obj, ctx) {
+			writeStream(this.formatLogObject(obj, ctx), obj.level < LogLevels.log ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout);
+		}
+	};
+};
+
+//#endregion
+//#region src/reporters/basic.ts
+const BasicReporter = (options = {}) => {
+	return {
+		formatArgs(opts, message, args = []) {
+			return formatWithOptions(opts, message, ...args);
+		},
+		formatLogObject(obj, ctx) {
+			const message = this.formatArgs(ctx.options.format, obj.message, obj.args);
+			return [
+				options.prefix,
+				bracket(obj.type === "log" ? void 0 : obj.type),
+				bracket(obj.tag),
+				message
+			].filter(Boolean).join(" ");
+		},
+		print(obj, ctx) {
+			writeStream(this.formatLogObject(obj, ctx), obj.level < LogLevels.log ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout);
+		}
+	};
+};
+
+//#endregion
+//#region src/reporters/mock.ts
+const MockReporter = (reporter, history = []) => {
+	return {
+		history,
+		print(object, ctx) {
+			history.push({
+				output: reporter.formatLogObject(object, ctx),
+				object
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/reporters/index.ts
+const FormatReporter = (options) => {
+	return (options.fancy === true || options.fancy === void 0 && hasTTY) && !(isCI || isTest) ? FancyReporter() : BasicReporter();
+};
+
+//#endregion
+//#region src/logger.ts
+var BreadcLogger = class BreadcLogger {
+	constructor(options) {
+		this._overrides = {};
+		this.options = options;
+	}
+	get level() {
+		return this.options.level;
+	}
+	set level(level) {
+		this.options.level = level;
+	}
+	get reporter() {
+		return this.options.reporter;
+	}
+	extend(overrides) {
+		const that = this;
+		Object.assign(that._overrides, overrides);
+		return Object.assign(that, overrides);
+	}
+	withDefaults(defaults) {
+		const ins = new BreadcLogger({
+			...this.options,
+			defaults: {
+				...this.options.defaults,
+				...defaults
+			}
+		});
+		ins._overrides = this._overrides;
+		return Object.assign(ins, this._overrides);
+	}
+	withTag(tag) {
+		return this.withDefaults({ tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag });
+	}
+	shouldPrint(obj) {
+		return obj.level <= this.level;
+	}
+	print(defaults, input) {
+		const date = /* @__PURE__ */ new Date();
+		const obj = {
+			level: LogLevels["log"],
+			type: "log",
+			...this.options.defaults,
+			...defaults,
+			...input,
+			date
+		};
+		if (this.shouldPrint(obj)) for (const reporter of this.options.reporter) reporter.print(obj, { options: this.options });
+	}
+	resolveInput(input, args) {
+		if (typeof input === "string") return {
+			message: input,
+			args
+		};
+		else if (typeof input === "number") return {
+			message: String(input),
+			args
+		};
+		else {
+			if ("level" in input) delete input["level"];
+			if ("type" in input) delete input["type"];
+			if (Array.isArray(input.args)) input.args.push(...args);
+			return input;
+		}
+	}
+	log(input, ...args) {
+		const type = "log";
+		const defaults = {
+			type,
+			level: LogLevels[type]
+		};
+		this.print(defaults, this.resolveInput(input, args));
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const Logger = (options = {}) => {
+	const level = getDefaultLogLevel();
+	const logger = new BreadcLogger({
+		reporter: options.reporter || [FormatReporter({ fancy: options.fancy })],
+		level,
+		defaults: {},
+		format: {},
+		stdout: process?.stdout,
+		stderr: process?.stderr,
+		plugins: [],
+		...options
+	});
+	const fns = Object.fromEntries([
+		"fatal",
+		"error",
+		"warn",
+		"info",
+		"fail",
+		"ready",
+		"box",
+		"start",
+		"success",
+		"debug",
+		"trace",
+		"verbose"
+	].map((type) => [type, function(input, ...args) {
+		const defaults = {
+			type,
+			level: LogLevels[type]
+		};
+		this.print(defaults, this.resolveInput(input, args));
+	}]));
+	return logger.extend(fns);
+};
+function getDefaultLogLevel() {
+	if (isDebug) return LogLevels.debug;
+	else if (isTest) return LogLevels.warn;
+	else return LogLevels.info;
 }
 
-export { createLogger };
+//#endregion
+export { BasicReporter, BreadcLogger, FancyReporter, FormatReporter, LogLevels, Logger, MockReporter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@breadc/logger",
-  "version": "0.9.7-beta.0",
+  "version": "1.0.0-beta.1",
   "description": "CLI logger for Breadc",
   "keywords": [
     "breadc",
@@ -23,24 +23,21 @@
   "type": "module",
   "exports": {
     ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     }
   },
-  "main": "dist/index.cjs",
   "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "types": "dist/index.d.mts",
   "files": [
     "dist"
   ],
-  "devDependencies": {
-    "@types/node": "^18.17.5",
-    "vitest": "0.33.0"
+  "dependencies": {
+    "std-env": "^3.10.0",
+    "@breadc/color": "1.0.0-beta.1"
   },
   "scripts": {
-    "build": "unbuild",
-    "format": "prettier --write src/**/*.ts test/*.ts",
+    "build": "tsdown",
     "test": "vitest",
     "test:ci": "vitest --run",
     "typecheck": "tsc --noEmit"

package/dist/index.cjs

@@ -1,7 +0,0 @@
-'use strict';
-
-function createLogger(options = {}) {
-  return {};
-}
-
-exports.createLogger = createLogger;

package/dist/index.d.ts

@@ -1,22 +0,0 @@
-type LogLevel = 'info' | 'warn' | 'error' | 'debug';
-interface LogObject {
-    level?: LogLevel;
-    tag?: string;
-    date?: Date;
-    message?: string;
-}
-interface Reporter {
-    print: (log: LogObject) => void;
-}
-interface FormatOptions {
-}
-interface LoggerOptions {
-    reporter: Reporter[];
-    level: LogLevel;
-    format: FormatOptions;
-    stdout: NodeJS.WriteStream;
-    stderr: NodeJS.WriteStream;
-}
-declare function createLogger(options?: Partial<LoggerOptions>): {};
-
-export { createLogger };