@vlandoss/loggy 0.0.1

package/README.md

@@ -0,0 +1,9 @@
+# Loggy
+
+Console wrapper to make logging fun again
+
+## Installation
+
+```sh
+pnpm add @vlandoss/loggy
+```

package/dist/index.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Loggy: () => Loggy,
+  createLoggy: () => createLoggy
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/loggy.ts
+var import_node_util2 = __toESM(require("util"), 1);
+var import_consola = require("consola");
+var import_debug = __toESM(require("debug"), 1);
+
+// src/const.ts
+var import_node_util = __toESM(require("util"), 1);
+var DEFAULT_FORMAT_OPTIONS = {
+  colors: true,
+  depth: 3,
+  maxArrayLength: 50,
+  breakLength: 80
+};
+var DEFAULT_FORMATTERS = {
+  o: (arg) => {
+    return import_node_util.default.inspect(arg, DEFAULT_FORMAT_OPTIONS).split("\n").map((str) => str.trim()).join(" ");
+  },
+  O: (arg) => {
+    return import_node_util.default.inspect(arg, DEFAULT_FORMAT_OPTIONS);
+  }
+};
+
+// src/loggy.ts
+var Loggy = class _Loggy {
+  #options;
+  #debug;
+  #consola;
+  constructor(options) {
+    this.#options = options;
+    this.#debug = (0, import_debug.default)(`${options.namespace}:root`);
+    this.#consola = (0, import_consola.createConsola)({
+      formatOptions: options.formatOptions
+    });
+  }
+  get namespace() {
+    return this.#options.namespace;
+  }
+  debug(...args) {
+    this.#debug(...args);
+  }
+  error(messageOrError, ...args) {
+    this.#consola.error(messageOrError, ...args);
+  }
+  info(...args) {
+    this.#consola.info(this.#format(...args));
+  }
+  trace(...args) {
+    this.#consola.trace(this.#format(...args));
+  }
+  warn(...args) {
+    this.#consola.warn(this.#format(...args));
+  }
+  child(namespace) {
+    return new _Loggy({
+      ...this.#options,
+      namespace: `${this.#options.namespace}:${namespace}`
+    });
+  }
+  start(...args) {
+    this.#consola.start(this.#format(...args));
+  }
+  success(...args) {
+    this.#consola.success(this.#format(...args));
+  }
+  subdebug(namespace) {
+    return (0, import_debug.default)(`${this.#options.namespace}:${namespace}`);
+  }
+  #format(...args) {
+    const formattedArgs = [...args];
+    if (typeof formattedArgs[0] !== "string") {
+      formattedArgs.unshift("%O");
+    }
+    const [message, ...replacements] = formattedArgs;
+    let replacementIndex = -1;
+    const formattedMessage = message.replace(
+      /%([a-zA-Z%])/g,
+      // matches %o, %O, %%, etc.
+      (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(`
+${" ".repeat(2)}`);
+    return import_node_util2.default.formatWithOptions(this.#options.formatOptions, formattedMessage, ...replacements);
+  }
+};
+function createLoggy(options) {
+  return new Loggy({
+    namespace: options.namespace,
+    formatOptions: {
+      ...DEFAULT_FORMAT_OPTIONS,
+      ...options.formatOptions
+    },
+    formatters: {
+      ...DEFAULT_FORMATTERS,
+      ...options.formatters
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Loggy,
+  createLoggy
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/loggy.ts","../src/const.ts"],"sourcesContent":["export * from \"./loggy\";\nexport * from \"./types\";\n","import util from \"node:util\";\nimport { type ConsolaInstance, createConsola } from \"consola\";\nimport createDebug from \"debug\";\nimport { DEFAULT_FORMATTERS, DEFAULT_FORMAT_OPTIONS } from \"./const\";\nimport type { AnyLogger, CreateOptions, LoggerOptions } from \"./types\";\n\nexport class Loggy implements AnyLogger {\n  #options: LoggerOptions;\n  #debug: ReturnType<typeof createDebug>;\n  #consola: ConsolaInstance;\n\n  constructor(options: LoggerOptions) {\n    this.#options = options;\n    this.#debug = createDebug(`${options.namespace}:root`);\n    this.#consola = createConsola({\n      formatOptions: options.formatOptions,\n    });\n  }\n\n  get namespace() {\n    return this.#options.namespace;\n  }\n\n  debug(...args: unknown[]) {\n    // @ts-expect-error - it really accepts this signature\n    this.#debug(...args);\n  }\n\n  error(messageOrError: string | unknown, ...args: unknown[]) {\n    this.#consola.error(messageOrError, ...args);\n  }\n\n  info(...args: unknown[]) {\n    this.#consola.info(this.#format(...args));\n  }\n\n  trace(...args: unknown[]) {\n    this.#consola.trace(this.#format(...args));\n  }\n\n  warn(...args: unknown[]) {\n    this.#consola.warn(this.#format(...args));\n  }\n\n  child(namespace: string) {\n    return new Loggy({\n      ...this.#options,\n      namespace: `${this.#options.namespace}:${namespace}`,\n    });\n  }\n\n  start(...args: unknown[]) {\n    this.#consola.start(this.#format(...args));\n  }\n\n  success(...args: unknown[]) {\n    this.#consola.success(this.#format(...args));\n  }\n\n  subdebug(namespace: string) {\n    return createDebug(`${this.#options.namespace}:${namespace}`);\n  }\n\n  #format(...args: unknown[]) {\n    const formattedArgs = [...args];\n\n    if (typeof formattedArgs[0] !== \"string\") {\n      formattedArgs.unshift(\"%O\");\n    }\n\n    const [message, ...replacements] = formattedArgs;\n    let replacementIndex = -1;\n\n    // @ts-expect-error - we're sure that message is a string due to the above check\n    const formattedMessage = message\n      .replace(\n        /%([a-zA-Z%])/g, // matches %o, %O, %%, etc.\n        (match: string, formatKey: string) => {\n          if (formatKey === \"%\") {\n            return \"%\";\n          }\n\n          replacementIndex++;\n\n          const formatter = this.#options.formatters[formatKey];\n\n          if (typeof formatter !== \"function\") {\n            return match;\n          }\n\n          const replacement = replacements[replacementIndex];\n          const formattedMatch = formatter(replacement);\n\n          replacements.splice(replacementIndex, 1);\n          replacementIndex--;\n\n          return formattedMatch;\n        },\n      )\n      .split(\"\\n\")\n      .join(`\\n${\" \".repeat(2)}`);\n\n    return util.formatWithOptions(this.#options.formatOptions, formattedMessage, ...replacements);\n  }\n}\n\nexport function createLoggy(options: CreateOptions) {\n  return new Loggy({\n    namespace: options.namespace,\n    formatOptions: {\n      ...DEFAULT_FORMAT_OPTIONS,\n      ...options.formatOptions,\n    },\n    formatters: {\n      ...DEFAULT_FORMATTERS,\n      ...options.formatters,\n    },\n  });\n}\n","import util from \"node:util\";\nimport type { FormatOptions, Formatters } from \"./types\";\n\nexport const DEFAULT_FORMAT_OPTIONS: FormatOptions = {\n  colors: true,\n  depth: 3,\n  maxArrayLength: 50,\n  breakLength: 80,\n};\n\nexport const DEFAULT_FORMATTERS: Formatters = {\n  o: (arg: unknown) => {\n    return util\n      .inspect(arg, DEFAULT_FORMAT_OPTIONS)\n      .split(\"\\n\")\n      .map((str) => str.trim())\n      .join(\" \");\n  },\n  O: (arg: unknown) => {\n    return util.inspect(arg, DEFAULT_FORMAT_OPTIONS);\n  },\n};\n"],"mappings":"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","names":["import_node_util","util","createDebug","util"]}

package/dist/index.d.cts

@@ -0,0 +1,46 @@
+import createDebug from 'debug';
+import { FormatOptions } from 'consola';
+export { FormatOptions } from 'consola';
+
+type AnyLogFn = (...args: unknown[]) => void;
+type Formatters = Record<string, (arg: unknown) => string>;
+type AnyLogger = {
+    namespace: string;
+    debug: AnyLogFn;
+    error: AnyLogFn;
+    info: AnyLogFn;
+    trace: AnyLogFn;
+    warn: AnyLogFn;
+    child: (namespace: string) => AnyLogger;
+    subdebug: (namespace: string) => AnyLogFn;
+    start: AnyLogFn;
+    success: AnyLogFn;
+};
+type CreateOptions = {
+    namespace: string;
+    formatOptions?: FormatOptions;
+    formatters?: Formatters;
+};
+type LoggerOptions = {
+    namespace: string;
+    formatOptions: FormatOptions;
+    formatters: Formatters;
+};
+
+declare class Loggy implements AnyLogger {
+    #private;
+    constructor(options: LoggerOptions);
+    get namespace(): string;
+    debug(...args: unknown[]): void;
+    error(messageOrError: string | unknown, ...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    child(namespace: string): Loggy;
+    start(...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    subdebug(namespace: string): createDebug.Debugger;
+}
+declare function createLoggy(options: CreateOptions): Loggy;
+
+export { type AnyLogFn, type AnyLogger, type CreateOptions, type Formatters, type LoggerOptions, Loggy, createLoggy };

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import createDebug from 'debug';
+import { FormatOptions } from 'consola';
+export { FormatOptions } from 'consola';
+
+type AnyLogFn = (...args: unknown[]) => void;
+type Formatters = Record<string, (arg: unknown) => string>;
+type AnyLogger = {
+    namespace: string;
+    debug: AnyLogFn;
+    error: AnyLogFn;
+    info: AnyLogFn;
+    trace: AnyLogFn;
+    warn: AnyLogFn;
+    child: (namespace: string) => AnyLogger;
+    subdebug: (namespace: string) => AnyLogFn;
+    start: AnyLogFn;
+    success: AnyLogFn;
+};
+type CreateOptions = {
+    namespace: string;
+    formatOptions?: FormatOptions;
+    formatters?: Formatters;
+};
+type LoggerOptions = {
+    namespace: string;
+    formatOptions: FormatOptions;
+    formatters: Formatters;
+};
+
+declare class Loggy implements AnyLogger {
+    #private;
+    constructor(options: LoggerOptions);
+    get namespace(): string;
+    debug(...args: unknown[]): void;
+    error(messageOrError: string | unknown, ...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    child(namespace: string): Loggy;
+    start(...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    subdebug(namespace: string): createDebug.Debugger;
+}
+declare function createLoggy(options: CreateOptions): Loggy;
+
+export { type AnyLogFn, type AnyLogger, type CreateOptions, type Formatters, type LoggerOptions, Loggy, createLoggy };

package/dist/index.js

@@ -0,0 +1,115 @@
+// src/loggy.ts
+import util2 from "node:util";
+import { createConsola } from "consola";
+import createDebug from "debug";
+
+// src/const.ts
+import util from "node:util";
+var DEFAULT_FORMAT_OPTIONS = {
+  colors: true,
+  depth: 3,
+  maxArrayLength: 50,
+  breakLength: 80
+};
+var 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);
+  }
+};
+
+// src/loggy.ts
+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(messageOrError, ...args) {
+    this.#consola.error(messageOrError, ...args);
+  }
+  info(...args) {
+    this.#consola.info(this.#format(...args));
+  }
+  trace(...args) {
+    this.#consola.trace(this.#format(...args));
+  }
+  warn(...args) {
+    this.#consola.warn(this.#format(...args));
+  }
+  child(namespace) {
+    return new _Loggy({
+      ...this.#options,
+      namespace: `${this.#options.namespace}:${namespace}`
+    });
+  }
+  start(...args) {
+    this.#consola.start(this.#format(...args));
+  }
+  success(...args) {
+    this.#consola.success(this.#format(...args));
+  }
+  subdebug(namespace) {
+    return createDebug(`${this.#options.namespace}:${namespace}`);
+  }
+  #format(...args) {
+    const formattedArgs = [...args];
+    if (typeof formattedArgs[0] !== "string") {
+      formattedArgs.unshift("%O");
+    }
+    const [message, ...replacements] = formattedArgs;
+    let replacementIndex = -1;
+    const formattedMessage = message.replace(
+      /%([a-zA-Z%])/g,
+      // matches %o, %O, %%, etc.
+      (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(`
+${" ".repeat(2)}`);
+    return util2.formatWithOptions(this.#options.formatOptions, formattedMessage, ...replacements);
+  }
+};
+function createLoggy(options) {
+  return new Loggy({
+    namespace: options.namespace,
+    formatOptions: {
+      ...DEFAULT_FORMAT_OPTIONS,
+      ...options.formatOptions
+    },
+    formatters: {
+      ...DEFAULT_FORMATTERS,
+      ...options.formatters
+    }
+  });
+}
+export {
+  Loggy,
+  createLoggy
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/loggy.ts","../src/const.ts"],"sourcesContent":["import util from \"node:util\";\nimport { type ConsolaInstance, createConsola } from \"consola\";\nimport createDebug from \"debug\";\nimport { DEFAULT_FORMATTERS, DEFAULT_FORMAT_OPTIONS } from \"./const\";\nimport type { AnyLogger, CreateOptions, LoggerOptions } from \"./types\";\n\nexport class Loggy implements AnyLogger {\n  #options: LoggerOptions;\n  #debug: ReturnType<typeof createDebug>;\n  #consola: ConsolaInstance;\n\n  constructor(options: LoggerOptions) {\n    this.#options = options;\n    this.#debug = createDebug(`${options.namespace}:root`);\n    this.#consola = createConsola({\n      formatOptions: options.formatOptions,\n    });\n  }\n\n  get namespace() {\n    return this.#options.namespace;\n  }\n\n  debug(...args: unknown[]) {\n    // @ts-expect-error - it really accepts this signature\n    this.#debug(...args);\n  }\n\n  error(messageOrError: string | unknown, ...args: unknown[]) {\n    this.#consola.error(messageOrError, ...args);\n  }\n\n  info(...args: unknown[]) {\n    this.#consola.info(this.#format(...args));\n  }\n\n  trace(...args: unknown[]) {\n    this.#consola.trace(this.#format(...args));\n  }\n\n  warn(...args: unknown[]) {\n    this.#consola.warn(this.#format(...args));\n  }\n\n  child(namespace: string) {\n    return new Loggy({\n      ...this.#options,\n      namespace: `${this.#options.namespace}:${namespace}`,\n    });\n  }\n\n  start(...args: unknown[]) {\n    this.#consola.start(this.#format(...args));\n  }\n\n  success(...args: unknown[]) {\n    this.#consola.success(this.#format(...args));\n  }\n\n  subdebug(namespace: string) {\n    return createDebug(`${this.#options.namespace}:${namespace}`);\n  }\n\n  #format(...args: unknown[]) {\n    const formattedArgs = [...args];\n\n    if (typeof formattedArgs[0] !== \"string\") {\n      formattedArgs.unshift(\"%O\");\n    }\n\n    const [message, ...replacements] = formattedArgs;\n    let replacementIndex = -1;\n\n    // @ts-expect-error - we're sure that message is a string due to the above check\n    const formattedMessage = message\n      .replace(\n        /%([a-zA-Z%])/g, // matches %o, %O, %%, etc.\n        (match: string, formatKey: string) => {\n          if (formatKey === \"%\") {\n            return \"%\";\n          }\n\n          replacementIndex++;\n\n          const formatter = this.#options.formatters[formatKey];\n\n          if (typeof formatter !== \"function\") {\n            return match;\n          }\n\n          const replacement = replacements[replacementIndex];\n          const formattedMatch = formatter(replacement);\n\n          replacements.splice(replacementIndex, 1);\n          replacementIndex--;\n\n          return formattedMatch;\n        },\n      )\n      .split(\"\\n\")\n      .join(`\\n${\" \".repeat(2)}`);\n\n    return util.formatWithOptions(this.#options.formatOptions, formattedMessage, ...replacements);\n  }\n}\n\nexport function createLoggy(options: CreateOptions) {\n  return new Loggy({\n    namespace: options.namespace,\n    formatOptions: {\n      ...DEFAULT_FORMAT_OPTIONS,\n      ...options.formatOptions,\n    },\n    formatters: {\n      ...DEFAULT_FORMATTERS,\n      ...options.formatters,\n    },\n  });\n}\n","import util from \"node:util\";\nimport type { FormatOptions, Formatters } from \"./types\";\n\nexport const DEFAULT_FORMAT_OPTIONS: FormatOptions = {\n  colors: true,\n  depth: 3,\n  maxArrayLength: 50,\n  breakLength: 80,\n};\n\nexport const DEFAULT_FORMATTERS: Formatters = {\n  o: (arg: unknown) => {\n    return util\n      .inspect(arg, DEFAULT_FORMAT_OPTIONS)\n      .split(\"\\n\")\n      .map((str) => str.trim())\n      .join(\" \");\n  },\n  O: (arg: unknown) => {\n    return util.inspect(arg, DEFAULT_FORMAT_OPTIONS);\n  },\n};\n"],"mappings":"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","names":["util","util"]}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@vlandoss/loggy",
+  "version": "0.0.1",
+  "description": "Console wrapper to make logging fun again",
+  "homepage": "https://github.com/variableland/dx/tree/main/packages/loggy#readme",
+  "bugs": {
+    "url": "https://github.com/variableland/dx/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/variableland/dx.git"
+  },
+  "license": "MIT",
+  "author": "rcrd <rcrd@variable.land>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "consola": "^3.4.2",
+    "debug": "^4.4.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "rr tsc"
+  }
+}

package/src/const.ts

@@ -0,0 +1,22 @@
+import util from "node:util";
+import type { FormatOptions, Formatters } from "./types";
+
+export const DEFAULT_FORMAT_OPTIONS: FormatOptions = {
+  colors: true,
+  depth: 3,
+  maxArrayLength: 50,
+  breakLength: 80,
+};
+
+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";
+export * from "./types";

package/src/loggy.ts

@@ -0,0 +1,119 @@
+import util from "node:util";
+import { type ConsolaInstance, createConsola } from "consola";
+import createDebug from "debug";
+import { DEFAULT_FORMATTERS, DEFAULT_FORMAT_OPTIONS } from "./const";
+import type { AnyLogger, CreateOptions, LoggerOptions } from "./types";
+
+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(messageOrError: string | unknown, ...args: unknown[]) {
+    this.#consola.error(messageOrError, ...args);
+  }
+
+  info(...args: unknown[]) {
+    this.#consola.info(this.#format(...args));
+  }
+
+  trace(...args: unknown[]) {
+    this.#consola.trace(this.#format(...args));
+  }
+
+  warn(...args: unknown[]) {
+    this.#consola.warn(this.#format(...args));
+  }
+
+  child(namespace: string) {
+    return new Loggy({
+      ...this.#options,
+      namespace: `${this.#options.namespace}:${namespace}`,
+    });
+  }
+
+  start(...args: unknown[]) {
+    this.#consola.start(this.#format(...args));
+  }
+
+  success(...args: unknown[]) {
+    this.#consola.success(this.#format(...args));
+  }
+
+  subdebug(namespace: string) {
+    return createDebug(`${this.#options.namespace}:${namespace}`);
+  }
+
+  #format(...args: unknown[]) {
+    const formattedArgs = [...args];
+
+    if (typeof formattedArgs[0] !== "string") {
+      formattedArgs.unshift("%O");
+    }
+
+    const [message, ...replacements] = formattedArgs;
+    let replacementIndex = -1;
+
+    // @ts-expect-error - we're sure that message is a string due to the above check
+    const 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)}`);
+
+    return util.formatWithOptions(this.#options.formatOptions, formattedMessage, ...replacements);
+  }
+}
+
+export function createLoggy(options: CreateOptions) {
+  return new Loggy({
+    namespace: options.namespace,
+    formatOptions: {
+      ...DEFAULT_FORMAT_OPTIONS,
+      ...options.formatOptions,
+    },
+    formatters: {
+      ...DEFAULT_FORMATTERS,
+      ...options.formatters,
+    },
+  });
+}

package/src/types.ts

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