@variablelab/loggy 0.0.0-stage → 0.2.2

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# Loggy
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Console wrapper to make logging fun again
+
+## Installation
+
+```sh
+pnpm add @variablelab/loggy
+```

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+import { FormatOptions } from "consola";
+import createDebug from "debug";
+
+//#region src/types.d.ts
+type AnyLogFn = (...args: unknown[]) => void;
+type LogFn = (opts: LogFnOptions | string, ...args: unknown[]) => void;
+type Formatters = Record<string, (arg: unknown) => string>;
+type AnyLogger = {
+  namespace: string;
+  debug: AnyLogFn;
+  error: AnyLogFn;
+  info: LogFn;
+  trace: LogFn;
+  warn: LogFn;
+  child: (options: CreateOptions) => AnyLogger;
+  subdebug: (namespace: string) => AnyLogFn;
+  start: LogFn;
+  success: LogFn;
+};
+type CreateOptions = {
+  namespace: string;
+  tag?: string;
+  formatOptions?: FormatOptions;
+  formatters?: Formatters;
+};
+type LoggerOptions = {
+  tag?: string;
+  namespace: string;
+  formatOptions: FormatOptions;
+  formatters: Formatters;
+};
+type LogFnOptions = {
+  tag: string;
+  message: string;
+};
+//#endregion
+//#region src/loggy.d.ts
+declare class Loggy implements AnyLogger {
+  #private;
+  constructor(options: LoggerOptions);
+  get namespace(): string;
+  debug(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  info(opts: LogFnOptions | string, ...args: unknown[]): void;
+  trace(opts: LogFnOptions | string, ...args: unknown[]): void;
+  warn(opts: LogFnOptions | string, ...args: unknown[]): void;
+  child(options: CreateOptions): Loggy;
+  start(opts: LogFnOptions | string, ...args: unknown[]): void;
+  success(opts: LogFnOptions | string, ...args: unknown[]): void;
+  subdebug(namespace: string): createDebug.Debugger;
+}
+declare function createLoggy(options: CreateOptions): Loggy;
+//#endregion
+export { AnyLogFn, AnyLogger, CreateOptions, type FormatOptions, Formatters, LogFn, LogFnOptions, LoggerOptions, Loggy, createLoggy };

package/dist/index.mjs

@@ -0,0 +1,111 @@
+import util from "node:util";
+import { createConsola } from "consola";
+import { colors } from "consola/utils";
+import createDebug from "debug";
+//#region src/const.ts
+const DEFAULT_FORMAT_OPTIONS = {
+	colors: true,
+	depth: 3,
+	maxArrayLength: 50,
+	breakLength: 80,
+	date: false
+};
+const DEFAULT_FORMATTERS = {
+	o: (arg) => {
+		return util.inspect(arg, DEFAULT_FORMAT_OPTIONS).split("\n").map((str) => str.trim()).join(" ");
+	},
+	O: (arg) => {
+		return util.inspect(arg, DEFAULT_FORMAT_OPTIONS);
+	}
+};
+//#endregion
+//#region src/loggy.ts
+function isLogFnOptions(arg) {
+	try {
+		return typeof arg.message === "string" && typeof arg.tag === "string";
+	} catch {
+		return false;
+	}
+}
+var Loggy = class Loggy {
+	#options;
+	#debug;
+	#consola;
+	constructor(options) {
+		this.#options = options;
+		this.#debug = createDebug(`${options.namespace}:root`);
+		this.#consola = createConsola({ formatOptions: options.formatOptions });
+	}
+	get namespace() {
+		return this.#options.namespace;
+	}
+	debug(...args) {
+		this.#debug(...args);
+	}
+	error(...args) {
+		this.#consola.error(this.#format(...args));
+	}
+	info(opts, ...args) {
+		this.#consola.info(this.#format(opts, ...args));
+	}
+	trace(opts, ...args) {
+		this.#consola.trace(this.#format(opts, ...args));
+	}
+	warn(opts, ...args) {
+		this.#consola.warn(this.#format(opts, ...args));
+	}
+	child(options) {
+		return new Loggy({
+			...this.#options,
+			...options,
+			namespace: `${this.#options.namespace}:${options.namespace}`
+		});
+	}
+	start(opts, ...args) {
+		this.#consola.start(this.#format(opts, ...args));
+	}
+	success(opts, ...args) {
+		this.#consola.success(this.#format(opts, ...args));
+	}
+	subdebug(namespace) {
+		return createDebug(`${this.#options.namespace}:${namespace}`);
+	}
+	#format(...args) {
+		const [firstArg, ...restArgs] = args;
+		const tag = isLogFnOptions(firstArg) ? firstArg.tag : this.#options.tag;
+		const formattedArgs = isLogFnOptions(firstArg) ? [firstArg.message, ...restArgs] : args;
+		if (typeof formattedArgs[0] !== "string") formattedArgs.unshift("%O");
+		const [message, ...replacements] = formattedArgs;
+		let replacementIndex = -1;
+		if (typeof message !== "string") throw new TypeError("message must be a string");
+		let formattedMessage = message.replace(/%([a-zA-Z%])/g, (match, formatKey) => {
+			if (formatKey === "%") return "%";
+			replacementIndex++;
+			const formatter = this.#options.formatters[formatKey];
+			if (typeof formatter !== "function") return match;
+			const replacement = replacements[replacementIndex];
+			const formattedMatch = formatter(replacement);
+			replacements.splice(replacementIndex, 1);
+			replacementIndex--;
+			return formattedMatch;
+		}).split("\n").join(`\n${" ".repeat(2)}`);
+		formattedMessage = !tag ? formattedMessage : `${colors.cyan(`[${tag}]`)} ${formattedMessage}`;
+		return util.formatWithOptions(this.#options.formatOptions, formattedMessage, ...replacements);
+	}
+};
+function createLoggy(options) {
+	return new Loggy({
+		namespace: options.namespace,
+		tag: options.tag,
+		formatOptions: {
+			...DEFAULT_FORMAT_OPTIONS,
+			...options.formatOptions
+		},
+		formatters: {
+			...DEFAULT_FORMATTERS,
+			...options.formatters
+		}
+	});
+}
+//#endregion
+export { Loggy, createLoggy };

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@variablelab/loggy",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.2",
+  "description": "Console wrapper to make logging fun again",
+  "homepage": "https://github.com/withvariablelab/dx/tree/main/shared/loggy#readme",
+  "bugs": {
+    "url": "https://github.com/withvariablelab/dx/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/withvariablelab/dx.git",
+    "directory": "shared/loggy"
+  },
+  "license": "MIT",
+  "author": "rcrd <rcrd@variable.land>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "consola": "3.4.2",
+    "debug": "4.4.3"
+  },
+  "devDependencies": {
+    "@types/debug": "4.1.12",
+    "@rrlab/tsdown-config": "^0.1.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "tscheck": "rr tsc"
+  }
 }

package/src/const.ts

@@ -0,0 +1,23 @@
+import util from "node:util";
+import type { FormatOptions, Formatters } from "./types.ts";
+
+export const DEFAULT_FORMAT_OPTIONS: FormatOptions = {
+  colors: true,
+  depth: 3,
+  maxArrayLength: 50,
+  breakLength: 80,
+  date: false,
+};
+
+export const DEFAULT_FORMATTERS: Formatters = {
+  o: (arg: unknown) => {
+    return util
+      .inspect(arg, DEFAULT_FORMAT_OPTIONS)
+      .split("\n")
+      .map((str) => str.trim())
+      .join(" ");
+  },
+  O: (arg: unknown) => {
+    return util.inspect(arg, DEFAULT_FORMAT_OPTIONS);
+  },
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./loggy.ts";
+export * from "./types.ts";

package/src/loggy.ts

@@ -0,0 +1,139 @@
+import util from "node:util";
+import { type ConsolaInstance, createConsola } from "consola";
+import { colors } from "consola/utils";
+import createDebug from "debug";
+import { DEFAULT_FORMAT_OPTIONS, DEFAULT_FORMATTERS } from "./const.ts";
+import type { AnyLogger, CreateOptions, LogFnOptions, LoggerOptions } from "./types.ts";
+
+function isLogFnOptions(arg: unknown): arg is LogFnOptions {
+  try {
+    // @ts-expect-error
+    return typeof arg.message === "string" && typeof arg.tag === "string";
+  } catch {
+    return false;
+  }
+}
+
+export class Loggy implements AnyLogger {
+  #options: LoggerOptions;
+  #debug: ReturnType<typeof createDebug>;
+  #consola: ConsolaInstance;
+
+  constructor(options: LoggerOptions) {
+    this.#options = options;
+    this.#debug = createDebug(`${options.namespace}:root`);
+    this.#consola = createConsola({
+      formatOptions: options.formatOptions,
+    });
+  }
+
+  get namespace() {
+    return this.#options.namespace;
+  }
+
+  debug(...args: unknown[]) {
+    // @ts-expect-error - it really accepts this signature
+    this.#debug(...args);
+  }
+
+  error(...args: unknown[]) {
+    this.#consola.error(this.#format(...args));
+  }
+
+  info(opts: LogFnOptions | string, ...args: unknown[]) {
+    this.#consola.info(this.#format(opts, ...args));
+  }
+
+  trace(opts: LogFnOptions | string, ...args: unknown[]) {
+    this.#consola.trace(this.#format(opts, ...args));
+  }
+
+  warn(opts: LogFnOptions | string, ...args: unknown[]) {
+    this.#consola.warn(this.#format(opts, ...args));
+  }
+
+  child(options: CreateOptions) {
+    return new Loggy({
+      ...this.#options,
+      ...options,
+      namespace: `${this.#options.namespace}:${options.namespace}`,
+    });
+  }
+
+  start(opts: LogFnOptions | string, ...args: unknown[]) {
+    this.#consola.start(this.#format(opts, ...args));
+  }
+
+  success(opts: LogFnOptions | string, ...args: unknown[]) {
+    this.#consola.success(this.#format(opts, ...args));
+  }
+
+  subdebug(namespace: string) {
+    return createDebug(`${this.#options.namespace}:${namespace}`);
+  }
+
+  #format(...args: unknown[]) {
+    const [firstArg, ...restArgs] = args;
+
+    const tag = isLogFnOptions(firstArg) ? firstArg.tag : this.#options.tag;
+    const formattedArgs = isLogFnOptions(firstArg) ? [firstArg.message, ...restArgs] : args;
+
+    if (typeof formattedArgs[0] !== "string") {
+      formattedArgs.unshift("%O");
+    }
+
+    const [message, ...replacements] = formattedArgs;
+    let replacementIndex = -1;
+
+    if (typeof message !== "string") {
+      throw new TypeError("message must be a string");
+    }
+
+    let formattedMessage = message
+      .replace(
+        /%([a-zA-Z%])/g, // matches %o, %O, %%, etc.
+        (match: string, formatKey: string) => {
+          if (formatKey === "%") {
+            return "%";
+          }
+
+          replacementIndex++;
+
+          const formatter = this.#options.formatters[formatKey];
+
+          if (typeof formatter !== "function") {
+            return match;
+          }
+
+          const replacement = replacements[replacementIndex];
+          const formattedMatch = formatter(replacement);
+
+          replacements.splice(replacementIndex, 1);
+          replacementIndex--;
+
+          return formattedMatch;
+        },
+      )
+      .split("\n")
+      .join(`\n${" ".repeat(2)}`);
+
+    formattedMessage = !tag ? formattedMessage : `${colors.cyan(`[${tag}]`)} ${formattedMessage}`;
+
+    return util.formatWithOptions(this.#options.formatOptions, formattedMessage, ...replacements);
+  }
+}
+
+export function createLoggy(options: CreateOptions) {
+  return new Loggy({
+    namespace: options.namespace,
+    tag: options.tag,
+    formatOptions: {
+      ...DEFAULT_FORMAT_OPTIONS,
+      ...options.formatOptions,
+    },
+    formatters: {
+      ...DEFAULT_FORMATTERS,
+      ...options.formatters,
+    },
+  });
+}

package/src/types.ts

@@ -0,0 +1,43 @@
+import type { FormatOptions } from "consola";
+
+export type AnyLogFn = (...args: unknown[]) => void;
+
+export type LogFn = (opts: LogFnOptions | string, ...args: unknown[]) => void;
+
+export type Formatters = Record<string, (arg: unknown) => string>;
+
+export type AnyLogger = {
+  namespace: string;
+  debug: AnyLogFn;
+  error: AnyLogFn;
+  info: LogFn;
+  trace: LogFn;
+  warn: LogFn;
+  child: (options: CreateOptions) => AnyLogger;
+  // { extras
+  subdebug: (namespace: string) => AnyLogFn;
+  start: LogFn;
+  success: LogFn;
+  // }
+};
+
+export type CreateOptions = {
+  namespace: string;
+  tag?: string;
+  formatOptions?: FormatOptions;
+  formatters?: Formatters;
+};
+
+export type LoggerOptions = {
+  tag?: string;
+  namespace: string;
+  formatOptions: FormatOptions;
+  formatters: Formatters;
+};
+
+export type LogFnOptions = {
+  tag: string;
+  message: string;
+};
+
+export type { FormatOptions };