@vsfedorenko/next-logger 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * # @vsfedorenko/next-logger
+ *
+ * A universal logging kit for Next.js. Monkeypatches Next.js' internal
+ * logger (`next/dist/build/output/log`) and the global `console.*` so all
+ * diagnostic output flows through a single level-controllable sink —
+ * consola by default, with reporters for Sentry, JSON, and more — without a
+ * custom Next.js server.
+ *
+ * ## Usage
+ *
+ * ### Instrumentation hook (Next.js ≥ 9.3 / instrumentationHook)
+ *
+ * ```ts
+ * // instrumentation.ts (project root)
+ * export async function register() {
+ *   if (process.env.NEXT_RUNTIME === "nodejs") {
+ *     await import("@vsfedorenko/next-logger");
+ *   }
+ * }
+ * ```
+ *
+ * The default import applies both patches (Next logger + console). To patch
+ * only Next's logger:
+ *
+ * ```ts
+ * await import("@vsfedorenko/next-logger/presets/next-only");
+ * ```
+ *
+ * ### `-r` preload
+ *
+ * ```sh
+ * node -r @vsfedorenko/next-logger server.js
+ * ```
+ *
+ * ## Configuration
+ *
+ * Optional `next-logger.config.ts` (discovered from cwd upward):
+ *
+ * ```ts
+ * import { createConsola } from "consola";
+ *
+ * export default {
+ *   consola: createConsola({ level: 4 }), // full custom instance
+ * };
+ * ```
+ *
+ * Or partial options (merged with defaults):
+ *
+ * ```ts
+ * export default {
+ *   consola: { level: 4, formatOptions: { date: false } },
+ * };
+ * ```
+ *
+ * Or a factory (receives the library's default options):
+ *
+ * ```ts
+ * import type { ConsolaOptions } from "consola";
+ *
+ * export default {
+ *   consola: (defaults: Partial<ConsolaOptions>) =>
+ *     createConsola({ ...defaults, level: 5 }),
+ * };
+ * ```
+ *
+ * ## Log level
+ *
+ * Without a config file, the level resolves from (in order) `LOG_LEVEL` or
+ * `NEXT_PUBLIC_LOG_LEVEL` (numeric or named: silent/fatal/error/warn/info/log/
+ * debug/trace/verbose), falling back to `3` (info).
+ */
+import "./presets/all";
+export { logger } from "./logger";
+export { loadConfig } from "./config";
+export type { NextLoggerConfig, ResolvedConfig } from "./config";
+export { defaultConsolaOptions, resolveFormat } from "./defaults";
+export type { LogFormat } from "./defaults";
+export { createJsonReporter } from "./reporters/json";
+export { patchNext, routeNextMethod, NEXT_PREFIXES } from "./patches/next";
+export type { NextMethodName } from "./patches/next";
+export { patchConsole, routeConsoleMethod, CONSOLE_METHODS } from "./patches/console";
+export type { ConsoleMethodName } from "./patches/console";
+export { isEmptyMessage, skipEmpty } from "./patches/util";
+export type { LogFunction, NextLogFn, NextLogModule } from "./types";
+export type { ConsolaInstance, ConsolaOptions, ConsolaReporter, FormatOptions, InputLogObject, LogLevel, LogObject, LogType, } from "consola";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH,OAAO,eAAe,CAAC;AAGvB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAClE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAGtD,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC3E,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACtF,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3D,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAIrE,YAAY,EACV,eAAe,EACf,cAAc,EACd,eAAe,EACf,aAAa,EACb,cAAc,EACd,QAAQ,EACR,SAAS,EACT,OAAO,GACR,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * # @vsfedorenko/next-logger
+ *
+ * A universal logging kit for Next.js. Monkeypatches Next.js' internal
+ * logger (`next/dist/build/output/log`) and the global `console.*` so all
+ * diagnostic output flows through a single level-controllable sink —
+ * consola by default, with reporters for Sentry, JSON, and more — without a
+ * custom Next.js server.
+ *
+ * ## Usage
+ *
+ * ### Instrumentation hook (Next.js ≥ 9.3 / instrumentationHook)
+ *
+ * ```ts
+ * // instrumentation.ts (project root)
+ * export async function register() {
+ *   if (process.env.NEXT_RUNTIME === "nodejs") {
+ *     await import("@vsfedorenko/next-logger");
+ *   }
+ * }
+ * ```
+ *
+ * The default import applies both patches (Next logger + console). To patch
+ * only Next's logger:
+ *
+ * ```ts
+ * await import("@vsfedorenko/next-logger/presets/next-only");
+ * ```
+ *
+ * ### `-r` preload
+ *
+ * ```sh
+ * node -r @vsfedorenko/next-logger server.js
+ * ```
+ *
+ * ## Configuration
+ *
+ * Optional `next-logger.config.ts` (discovered from cwd upward):
+ *
+ * ```ts
+ * import { createConsola } from "consola";
+ *
+ * export default {
+ *   consola: createConsola({ level: 4 }), // full custom instance
+ * };
+ * ```
+ *
+ * Or partial options (merged with defaults):
+ *
+ * ```ts
+ * export default {
+ *   consola: { level: 4, formatOptions: { date: false } },
+ * };
+ * ```
+ *
+ * Or a factory (receives the library's default options):
+ *
+ * ```ts
+ * import type { ConsolaOptions } from "consola";
+ *
+ * export default {
+ *   consola: (defaults: Partial<ConsolaOptions>) =>
+ *     createConsola({ ...defaults, level: 5 }),
+ * };
+ * ```
+ *
+ * ## Log level
+ *
+ * Without a config file, the level resolves from (in order) `LOG_LEVEL` or
+ * `NEXT_PUBLIC_LOG_LEVEL` (numeric or named: silent/fatal/error/warn/info/log/
+ * debug/trace/verbose), falling back to `3` (info).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipEmpty = exports.isEmptyMessage = exports.CONSOLE_METHODS = exports.routeConsoleMethod = exports.patchConsole = exports.NEXT_PREFIXES = exports.routeNextMethod = exports.patchNext = exports.createJsonReporter = exports.resolveFormat = exports.defaultConsolaOptions = exports.loadConfig = exports.logger = void 0;
+require("./presets/all");
+// Core instance + config.
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+var defaults_1 = require("./defaults");
+Object.defineProperty(exports, "defaultConsolaOptions", { enumerable: true, get: function () { return defaults_1.defaultConsolaOptions; } });
+Object.defineProperty(exports, "resolveFormat", { enumerable: true, get: function () { return defaults_1.resolveFormat; } });
+// JSON reporter (server-side structured logging).
+var json_1 = require("./reporters/json");
+Object.defineProperty(exports, "createJsonReporter", { enumerable: true, get: function () { return json_1.createJsonReporter; } });
+// Patching API.
+var next_1 = require("./patches/next");
+Object.defineProperty(exports, "patchNext", { enumerable: true, get: function () { return next_1.patchNext; } });
+Object.defineProperty(exports, "routeNextMethod", { enumerable: true, get: function () { return next_1.routeNextMethod; } });
+Object.defineProperty(exports, "NEXT_PREFIXES", { enumerable: true, get: function () { return next_1.NEXT_PREFIXES; } });
+var console_1 = require("./patches/console");
+Object.defineProperty(exports, "patchConsole", { enumerable: true, get: function () { return console_1.patchConsole; } });
+Object.defineProperty(exports, "routeConsoleMethod", { enumerable: true, get: function () { return console_1.routeConsoleMethod; } });
+Object.defineProperty(exports, "CONSOLE_METHODS", { enumerable: true, get: function () { return console_1.CONSOLE_METHODS; } });
+var util_1 = require("./patches/util");
+Object.defineProperty(exports, "isEmptyMessage", { enumerable: true, get: function () { return util_1.isEmptyMessage; } });
+Object.defineProperty(exports, "skipEmpty", { enumerable: true, get: function () { return util_1.skipEmpty; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;;;AAEH,yBAAuB;AAEvB,0BAA0B;AAC1B,mCAAkC;AAAzB,gGAAA,MAAM,OAAA;AACf,mCAAsC;AAA7B,oGAAA,UAAU,OAAA;AAEnB,uCAAkE;AAAzD,iHAAA,qBAAqB,OAAA;AAAE,yGAAA,aAAa,OAAA;AAG7C,kDAAkD;AAClD,yCAAsD;AAA7C,0GAAA,kBAAkB,OAAA;AAE3B,gBAAgB;AAChB,uCAA2E;AAAlE,iGAAA,SAAS,OAAA;AAAE,uGAAA,eAAe,OAAA;AAAE,qGAAA,aAAa,OAAA;AAElD,6CAAsF;AAA7E,uGAAA,YAAY,OAAA;AAAE,6GAAA,kBAAkB,OAAA;AAAE,0GAAA,eAAe,OAAA;AAE1D,uCAA2D;AAAlD,sGAAA,cAAc,OAAA;AAAE,iGAAA,SAAS,OAAA"}

package/dist/logger.d.ts

@@ -0,0 +1,21 @@
+import { type ConsolaInstance } from "consola";
+/**
+ * The shared consola instance backing all patches.
+ *
+ * Resolution order:
+ *   1. `next-logger.config.{ts,js,cjs,...}` → `consola` key is a
+ *      {@link ConsolaInstance} or a factory → used directly.
+ *   2. Same config → `consola` key is a partial options object → merged with
+ *      defaults, then built.
+ *   3. No config → built from {@link defaultConsolaOptions}.
+ *
+ * When `LOG_FORMAT=json` (or `NEXT_PUBLIC_LOG_FORMAT=json`), the logger uses
+ * the {@link createJsonReporter} instead of consola's default pretty reporter.
+ * A config file's custom instance / factory bypasses format selection — the
+ * user's instance controls everything.
+ *
+ * Both patches (`patches/next`, `patches/console`) call `.withTag()` on this
+ * object so they can namespace their output.
+ */
+export declare const logger: ConsolaInstance;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAK9D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,EAAE,eAA+B,CAAC"}

package/dist/logger.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const consola_1 = require("consola");
+const config_1 = require("./config");
+const defaults_1 = require("./defaults");
+const json_1 = require("./reporters/json");
+/**
+ * The shared consola instance backing all patches.
+ *
+ * Resolution order:
+ *   1. `next-logger.config.{ts,js,cjs,...}` → `consola` key is a
+ *      {@link ConsolaInstance} or a factory → used directly.
+ *   2. Same config → `consola` key is a partial options object → merged with
+ *      defaults, then built.
+ *   3. No config → built from {@link defaultConsolaOptions}.
+ *
+ * When `LOG_FORMAT=json` (or `NEXT_PUBLIC_LOG_FORMAT=json`), the logger uses
+ * the {@link createJsonReporter} instead of consola's default pretty reporter.
+ * A config file's custom instance / factory bypasses format selection — the
+ * user's instance controls everything.
+ *
+ * Both patches (`patches/next`, `patches/console`) call `.withTag()` on this
+ * object so they can namespace their output.
+ */
+exports.logger = buildLogger();
+function buildLogger() {
+    const resolved = (0, config_1.loadConfig)();
+    switch (resolved.kind) {
+        case "instance":
+            return resolved.instance;
+        case "options": {
+            const instance = (0, consola_1.createConsola)(resolved.options);
+            // Override reporters when JSON format is requested. Only applies to the
+            // options path (custom instances are used as-is).
+            if ((0, defaults_1.resolveFormat)() === "json") {
+                instance.setReporters([(0, json_1.createJsonReporter)()]);
+            }
+            return instance;
+        }
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":";;;AAAA,qCAA8D;AAC9D,qCAAsC;AACtC,yCAA2C;AAC3C,2CAAsD;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACU,QAAA,MAAM,GAAoB,WAAW,EAAE,CAAC;AAErD,SAAS,WAAW;IAClB,MAAM,QAAQ,GAAG,IAAA,mBAAU,GAAE,CAAC;IAE9B,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtB,KAAK,UAAU;YACb,OAAO,QAAQ,CAAC,QAAQ,CAAC;QAC3B,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,MAAM,QAAQ,GAAG,IAAA,uBAAa,EAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAEjD,wEAAwE;YACxE,kDAAkD;YAClD,IAAI,IAAA,wBAAa,GAAE,KAAK,MAAM,EAAE,CAAC;gBAC/B,QAAQ,CAAC,YAAY,CAAC,CAAC,IAAA,yBAAkB,GAAE,CAAC,CAAC,CAAC;YAChD,CAAC;YAED,OAAO,QAAQ,CAAC;QAClB,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/patches/console.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Patches the global `console.*` methods so every call routes through the
+ * shared consola instance tagged `console`.
+ *
+ * This captures diagnostic output from third-party libraries and application
+ * code that calls `console.log`/`console.error` directly — funnelling it
+ * through the same level-controllable sink as Next's own logs.
+ *
+ * This is a side-effect module — importing it applies the patch exactly once.
+ */
+import type { ConsolaInstance } from "consola";
+import type { LogFunction } from "../types";
+/**
+ * The console methods this patch overwrites.
+ */
+export declare const CONSOLE_METHODS: readonly ["log", "debug", "info", "warn", "error"];
+/** A console method name we patch. */
+export type ConsoleMethodName = (typeof CONSOLE_METHODS)[number];
+/**
+ * Maps a console method name to the corresponding consola log function.
+ *
+ * `console.log` and `console.info` both map to consola `info` (matching the
+ * original's behaviour). The returned function is bound to a child logger
+ * tagged with `tag`, so every call is namespaced.
+ *
+ * Pure function — given a consola instance and a tag, returns the routing
+ * function. Exported so the level mapping can be unit-tested without touching
+ * the global `console`.
+ */
+export declare function routeConsoleMethod(method: ConsoleMethodName | string, consola: ConsolaInstance, tag: string): LogFunction;
+/**
+ * Applies the console patch. Overwrites `console.log`, `console.debug`,
+ * `console.info`, `console.warn`, `console.error` with bound consola methods.
+ *
+ * @param tagOverride override the `console` tag (useful for tests).
+ */
+export declare function patchConsole(tagOverride?: string): void;
+//# sourceMappingURL=console.d.ts.map

package/dist/patches/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/patches/console.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C;;GAEG;AACH,eAAO,MAAM,eAAe,oDAMlB,CAAC;AAEX,sCAAsC;AACtC,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,GAAG,MAAM,EAClC,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,MAAM,GACV,WAAW,CAKb;AAyBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAOvD"}

package/dist/patches/console.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Patches the global `console.*` methods so every call routes through the
+ * shared consola instance tagged `console`.
+ *
+ * This captures diagnostic output from third-party libraries and application
+ * code that calls `console.log`/`console.error` directly — funnelling it
+ * through the same level-controllable sink as Next's own logs.
+ *
+ * This is a side-effect module — importing it applies the patch exactly once.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSOLE_METHODS = void 0;
+exports.routeConsoleMethod = routeConsoleMethod;
+exports.patchConsole = patchConsole;
+const logger_1 = require("../logger");
+const util_1 = require("./util");
+/**
+ * The console methods this patch overwrites.
+ */
+exports.CONSOLE_METHODS = [
+    "log",
+    "debug",
+    "info",
+    "warn",
+    "error",
+];
+/**
+ * Maps a console method name to the corresponding consola log function.
+ *
+ * `console.log` and `console.info` both map to consola `info` (matching the
+ * original's behaviour). The returned function is bound to a child logger
+ * tagged with `tag`, so every call is namespaced.
+ *
+ * Pure function — given a consola instance and a tag, returns the routing
+ * function. Exported so the level mapping can be unit-tested without touching
+ * the global `console`.
+ */
+function routeConsoleMethod(method, consola, tag) {
+    const child = consola.withTag(tag);
+    const bound = selectConsolaMethod(method, child);
+    return (0, util_1.skipEmpty)(bound);
+}
+/**
+ * Selects the consola method matching a console method name.
+ *
+ * The bound function is returned directly; consola's methods accept the same
+ * `(...args: unknown[])` shape as {@link LogFunction}.
+ */
+function selectConsolaMethod(method, consola) {
+    switch (method) {
+        case "error":
+            return consola.error.bind(consola);
+        case "warn":
+            return consola.warn.bind(consola);
+        case "debug":
+            return consola.debug.bind(consola);
+        case "log":
+        case "info":
+            return consola.info.bind(consola);
+        default:
+            // Unknown method name — default to info (same as the original).
+            return consola.info.bind(consola);
+    }
+}
+/**
+ * Applies the console patch. Overwrites `console.log`, `console.debug`,
+ * `console.info`, `console.warn`, `console.error` with bound consola methods.
+ *
+ * @param tagOverride override the `console` tag (useful for tests).
+ */
+function patchConsole(tagOverride) {
+    const tag = tagOverride ?? "console";
+    for (const method of exports.CONSOLE_METHODS) {
+        const routed = routeConsoleMethod(method, logger_1.logger, tag);
+        console[method] = routed;
+    }
+}
+// Apply on import (side effect), matching the original's
+// `require('./patches/console')` semantics.
+patchConsole();
+//# sourceMappingURL=console.js.map

package/dist/patches/console.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.js","sourceRoot":"","sources":["../../src/patches/console.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAgCH,gDASC;AA+BD,oCAOC;AA5ED,sCAAmC;AAEnC,iCAAmC;AAEnC;;GAEG;AACU,QAAA,eAAe,GAAG;IAC7B,KAAK;IACL,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;CACC,CAAC;AAKX;;;;;;;;;;GAUG;AACH,SAAgB,kBAAkB,CAChC,MAAkC,EAClC,OAAwB,EACxB,GAAW;IAEX,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAEnC,MAAM,KAAK,GAAgB,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9D,OAAO,IAAA,gBAAS,EAAC,KAAK,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,MAAc,EAAE,OAAwB;IACnE,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,OAAO;YACV,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACpD,KAAK,MAAM;YACT,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACnD,KAAK,OAAO;YACV,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACpD,KAAK,KAAK,CAAC;QACX,KAAK,MAAM;YACT,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;QACnD;YACE,gEAAgE;YAChE,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAgB,CAAC;IACrD,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,WAAoB;IAC/C,MAAM,GAAG,GAAG,WAAW,IAAI,SAAS,CAAC;IAErC,KAAK,MAAM,MAAM,IAAI,uBAAe,EAAE,CAAC;QACrC,MAAM,MAAM,GAAG,kBAAkB,CAAC,MAAM,EAAE,eAAM,EAAE,GAAG,CAAC,CAAC;QACvD,OAAO,CAAC,MAAM,CAAC,GAAG,MAAoC,CAAC;IACzD,CAAC;AACH,CAAC;AAED,yDAAyD;AACzD,4CAA4C;AAC5C,YAAY,EAAE,CAAC"}

package/dist/patches/next.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Patches Next.js' internal logger (`next/dist/build/output/log`) so every
+ * call routes through the shared consola instance tagged `next.js`.
+ *
+ * Next 13+ defines its logger exports as non-configurable accessor properties,
+ * which would throw under a plain redefinition. We work around this by
+ * replacing `require.cache[...].exports` with a shallow copy (the original's
+ * approach), then defining each method as a plain value property on the copy.
+ *
+ * This is a side-effect module — importing it applies the patch exactly once.
+ */
+import type { ConsolaInstance } from "consola";
+import type { LogFunction } from "../types";
+/**
+ * The methods exported by Next's log module that we patch.
+ *
+ * `prefixes` is the set Next itself advertises (wait/error/warn/ready/info/
+ * event/trace). `bootstrap` is an extra export that bypasses the prefix logic
+ * (raw `console.log`) — we route it too so it stays consistent.
+ */
+export declare const NEXT_PREFIXES: readonly ["wait", "error", "warn", "ready", "info", "event", "trace"];
+/** A Next.js prefix method name we patch. */
+export type NextMethodName = (typeof NEXT_PREFIXES)[number];
+/**
+ * Maps a Next.js prefix name to the corresponding consola log function.
+ * `trace` maps to consola's native `trace` — no fallback needed (consola has
+ * it; the pino original had to fall back to `debug` for Winston which lacks
+ * trace).
+ *
+ * Pure function — given a consola instance and a tag, returns the routing
+ * function. Exported so the level mapping can be unit-tested without touching
+ * `require.cache` or a real Next.js install.
+ */
+export declare function routeNextMethod(method: NextMethodName | string, consola: ConsolaInstance, tag: string): LogFunction;
+/**
+ * Applies the Next.js logger patch. Safe to call multiple times — it
+ * re-derives the methods from the current {@link logger} each time.
+ *
+ * @param tagOverride override the `next.js` tag (useful for tests).
+ */
+export declare function patchNext(tagOverride?: string): void;
+//# sourceMappingURL=next.d.ts.map

package/dist/patches/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/patches/next.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,UAAU,CAAC;AAG3D;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,uEAQhB,CAAC;AAEX,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,cAAc,GAAG,MAAM,EAC/B,OAAO,EAAE,eAAe,EACxB,GAAG,EAAE,MAAM,GACV,WAAW,CAKb;AAmBD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAuCpD"}

package/dist/patches/next.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Patches Next.js' internal logger (`next/dist/build/output/log`) so every
+ * call routes through the shared consola instance tagged `next.js`.
+ *
+ * Next 13+ defines its logger exports as non-configurable accessor properties,
+ * which would throw under a plain redefinition. We work around this by
+ * replacing `require.cache[...].exports` with a shallow copy (the original's
+ * approach), then defining each method as a plain value property on the copy.
+ *
+ * This is a side-effect module — importing it applies the patch exactly once.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEXT_PREFIXES = void 0;
+exports.routeNextMethod = routeNextMethod;
+exports.patchNext = patchNext;
+const logger_1 = require("../logger");
+const util_1 = require("./util");
+/**
+ * The methods exported by Next's log module that we patch.
+ *
+ * `prefixes` is the set Next itself advertises (wait/error/warn/ready/info/
+ * event/trace). `bootstrap` is an extra export that bypasses the prefix logic
+ * (raw `console.log`) — we route it too so it stays consistent.
+ */
+exports.NEXT_PREFIXES = [
+    "wait",
+    "error",
+    "warn",
+    "ready",
+    "info",
+    "event",
+    "trace",
+];
+/**
+ * Maps a Next.js prefix name to the corresponding consola log function.
+ * `trace` maps to consola's native `trace` — no fallback needed (consola has
+ * it; the pino original had to fall back to `debug` for Winston which lacks
+ * trace).
+ *
+ * Pure function — given a consola instance and a tag, returns the routing
+ * function. Exported so the level mapping can be unit-tested without touching
+ * `require.cache` or a real Next.js install.
+ */
+function routeNextMethod(method, consola, tag) {
+    const child = consola.withTag(tag);
+    const bound = selectConsolaMethod(method, child);
+    return (0, util_1.skipEmpty)(bound);
+}
+/**
+ * Selects the consola method matching a Next.js method name.
+ */
+function selectConsolaMethod(method, consola) {
+    switch (method) {
+        case "error":
+            return consola.error.bind(consola);
+        case "warn":
+            return consola.warn.bind(consola);
+        case "trace":
+            return consola.trace.bind(consola);
+        default:
+            // wait, ready, info, event, bootstrap → info
+            return consola.info.bind(consola);
+    }
+}
+/**
+ * Applies the Next.js logger patch. Safe to call multiple times — it
+ * re-derives the methods from the current {@link logger} each time.
+ *
+ * @param tagOverride override the `next.js` tag (useful for tests).
+ */
+function patchNext(tagOverride) {
+    const tag = tagOverride ?? "next.js";
+    let nextLog;
+    try {
+        nextLog = require("next/dist/build/output/log");
+    }
+    catch {
+        // `next` is not installed — nothing to patch.
+        return;
+    }
+    // Build the routed methods for every prefix + bootstrap.
+    const methodNames = [...Object.keys(nextLog.prefixes), "bootstrap"];
+    const routed = {};
+    for (const method of methodNames) {
+        routed[method] = routeNextMethod(method, logger_1.logger, tag);
+    }
+    // Strategy 1: if we have access to the CJS module cache, replace the exports
+    // with a fresh shallow copy. This sidesteps the non-configurable accessor
+    // properties Next 13+ defines (they throw under defineProperty).
+    const cacheObject = tryGetCache("next/dist/build/output/log");
+    if (cacheObject !== null) {
+        cacheObject.exports = { ...nextLog, ...routed };
+        return;
+    }
+    // Strategy 2 (fallback): mutate the live exports object in place. Try plain
+    // assignment first; if the property is non-configurable + non-writable,
+    // skip silently (the routing function is still correct — verified by unit
+    // tests on routeNextMethod directly).
+    const target = nextLog;
+    for (const [method, fn] of Object.entries(routed)) {
+        try {
+            target[method] = fn;
+        }
+        catch {
+            // Non-writable, non-configurable — skip.
+        }
+    }
+}
+/** Looks up a module in the CJS cache by specifier; returns null if absent. */
+function tryGetCache(specifier) {
+    try {
+        const resolved = require.resolve(specifier);
+        const cached = require.cache[resolved];
+        return cached ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// Apply on import (side effect), matching the original's
+// `require('./patches/next')` semantics.
+patchNext();
+//# sourceMappingURL=next.js.map

package/dist/patches/next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.js","sourceRoot":"","sources":["../../src/patches/next.ts"],"names":[],"mappings":"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"}

package/dist/patches/util.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared helpers for the patch modules.
+ */
+/**
+ * Returns `true` when the arguments constitute an "empty" message — i.e. there
+ * is nothing meaningful to log. Used to skip printing when Next.js or `console`
+ * calls a method with no arguments, or with only `undefined`/`null`/`""`.
+ *
+ * Matches the upstream sainsburys-tech/next-logger behaviour where an empty
+ * message produces no output, and avoids consola emitting a bare tag line with
+ * no payload.
+ *
+ * Note: falsy-but-present values (`0`, `false`) are **not** considered empty —
+ * they carry diagnostic value and are printed normally.
+ */
+export declare function isEmptyMessage(args: readonly unknown[]): boolean;
+/**
+ * Wraps a log function so it becomes a no-op for empty messages (see
+ * {@link isEmptyMessage}). Non-empty messages pass through unchanged.
+ *
+ * Generic over the input function's parameter types, so the returned wrapper
+ * has the same call signature as `fn` — no `unknown[]` widening.
+ */
+export declare function skipEmpty<TArgs extends unknown[]>(fn: (...args: TArgs) => void): (...args: TArgs) => void;
+//# sourceMappingURL=util.d.ts.map

package/dist/patches/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/patches/util.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAMhE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,SAAS,OAAO,EAAE,EAC/C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,GAC3B,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,CAK1B"}

package/dist/patches/util.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Shared helpers for the patch modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmptyMessage = isEmptyMessage;
+exports.skipEmpty = skipEmpty;
+/**
+ * Returns `true` when the arguments constitute an "empty" message — i.e. there
+ * is nothing meaningful to log. Used to skip printing when Next.js or `console`
+ * calls a method with no arguments, or with only `undefined`/`null`/`""`.
+ *
+ * Matches the upstream sainsburys-tech/next-logger behaviour where an empty
+ * message produces no output, and avoids consola emitting a bare tag line with
+ * no payload.
+ *
+ * Note: falsy-but-present values (`0`, `false`) are **not** considered empty —
+ * they carry diagnostic value and are printed normally.
+ */
+function isEmptyMessage(args) {
+    if (args.length === 0)
+        return true;
+    // Skip when every argument is `undefined`, `null`, or `""` — these carry no
+    // diagnostic value and would render as an empty/blank line under consola.
+    return args.every((arg) => arg === undefined || arg === null || arg === "");
+}
+/**
+ * Wraps a log function so it becomes a no-op for empty messages (see
+ * {@link isEmptyMessage}). Non-empty messages pass through unchanged.
+ *
+ * Generic over the input function's parameter types, so the returned wrapper
+ * has the same call signature as `fn` — no `unknown[]` widening.
+ */
+function skipEmpty(fn) {
+    return (...args) => {
+        if (isEmptyMessage(args))
+            return;
+        fn(...args);
+    };
+}
+//# sourceMappingURL=util.js.map

package/dist/patches/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/patches/util.ts"],"names":[],"mappings":";AAAA;;GAEG;;AAcH,wCAMC;AASD,8BAOC;AAlCD;;;;;;;;;;;GAWG;AACH,SAAgB,cAAc,CAAC,IAAwB;IACrD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEnC,4EAA4E;IAC5E,0EAA0E;IAC1E,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,EAAE,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,SAAS,CACvB,EAA4B;IAE5B,OAAO,CAAC,GAAG,IAAW,EAAQ,EAAE;QAC9B,IAAI,cAAc,CAAC,IAAI,CAAC;YAAE,OAAO;QACjC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;IACd,CAAC,CAAC;AACJ,CAAC"}