@briangits/node-log 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,181 @@
+# node-log
+
+> Logging for Node.js with typed writers, log levels, and structured output.
+
+## Features
+
+- **Sync & Async Writers** — Log to the console synchronously or to files asynchronously.
+- **Log Levels** — `TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `CRITICAL`.
+- **Tags** — Attach contextual tags to every log record.
+- **Structured Output** — Built-in JSON Lines writer with automatic serialization of `Error`, `Map`, `Set`, and `bigint`.
+- **Customizable Formatting** — Console writer supports format strings with placeholders.
+- **TypeScript First** — Fully typed with declaration maps.
+- **Dual Format** — Ships both ESM and CJS builds.
+
+## Installation
+
+```bash
+# pnpm
+pnpm add @briangits/node-log
+
+# npm
+npm install @briangits/node-log
+
+# yarn
+yarn add @briangits/node-log
+```
+
+## Quick Start
+
+```typescript
+import { Logger, ConsoleLogWriter, LogLevel } from '@briangits/node-log'
+
+const logger = new Logger(new ConsoleLogWriter())
+
+logger.info('Server started on port', 3000)
+logger.warn('High memory usage', { used: '1.2GB' })
+logger.error('Connection failed', new Error('timeout'))
+```
+
+**Console output:**
+
+```
+[2026-06-25T06:30:00.000Z] [INFO]: Server started on port 3000
+[2026-06-25T06:30:00.001Z] [WARN]: High memory usage { used: '1.2GB' }
+[2026-06-25T06:30:00.002Z] [ERROR]: Connection failed Error: timeout
+```
+
+## Writers
+
+Writers are the target destination for log records. The library provides two built-in writers and a simple interface for creating your own.
+
+### ConsoleLogWriter
+
+Outputs formatted log records to `stdout`.
+
+```typescript
+import { Logger, ConsoleLogWriter } from '@briangits/node-log'
+
+const logger = new Logger(new ConsoleLogWriter('[%t] %l — %msg'))
+
+logger.info('Hello, world!')
+// => [2026-06-25T06:30:00.000Z] INFO — Hello, world!
+```
+
+**Message extraction:**
+
+- If the **first** argument is a string, it is used as the message.
+- Otherwise, if the **last** argument is a string, it is used as the message.
+- Any remaining arguments are passed through as additional data.
+
+**Format placeholders:**
+
+| Placeholder | Description                                     |
+| ----------- | ----------------------------------------------- |
+| `%t`        | ISO timestamp                                   |
+| `%l`        | Log level name (e.g., `INFO`)                   |
+| `%tag`      | Tags joined by `/` (omitted if no tags are set) |
+| `%msg`      | Log message                                     |
+
+Additional arguments are appended after the formatted message and passed directly to `console.log`.
+
+### JSONLFileLogWriter
+
+Appends log records as JSON Lines to a file. Automatically normalizes special values so they remain serializable.
+
+```typescript
+import { Logger, JSONLFileLogWriter } from '@briangits/node-log'
+
+const logger = new Logger(new JSONLFileLogWriter('./app.log'))
+
+await logger.info('User logged in', { userId: 42 })
+```
+
+**Serialized output (`./app.log`):**
+
+```json
+{
+    "level": 30,
+    "time": "2026-06-25T06:30:00.000Z",
+    "tags": [],
+    "message": "User logged in",
+    "args": [{ "userId": 42 }]
+}
+```
+
+**Normalization rules:**
+
+| Type     | Serialized as                         |
+| -------- | ------------------------------------- |
+| `Error`  | `{ name, message, stack }`            |
+| `Map`    | Plain object via `Object.fromEntries` |
+| `Set`    | Array via `[...set]`                  |
+| `bigint` | String via `.toString()`              |
+
+### Custom Writer
+
+Implement `LogWriter` for synchronous output or `AsyncLogWriter` for asynchronous output.
+
+```typescript
+import { LogWriter, LogRecord, Logger } from '@briangits/node-log'
+
+class SyslogWriter implements LogWriter {
+    write(log: LogRecord): void {
+        // forward to syslog, etc.
+    }
+}
+
+const logger = new Logger(new SyslogWriter())
+logger.info('Sent to syslog')
+```
+
+## API Reference
+
+### `Logger<Writer>`
+
+The main entry point for creating log records.
+
+```typescript
+new Logger(writer: Writer, tags?: string[])
+```
+
+| Method                | Description                             |
+| --------------------- | --------------------------------------- |
+| `log(level, ...args)` | Write a record at the given `LogLevel`. |
+| `trace(...args)`      | Write a `TRACE` record.                 |
+| `debug(...args)`      | Write a `DEBUG` record.                 |
+| `info(...args)`       | Write an `INFO` record.                 |
+| `warn(...args)`       | Write a `WARN` record.                  |
+| `error(...args)`      | Write an `ERROR` record.                |
+| `critical(...args)`   | Write a `CRITICAL` record.              |
+
+When the writer is an `AsyncLogWriter`, all methods return `Promise<void>`; otherwise they return `void`.
+
+### `LogLevel`
+
+```typescript
+enum LogLevel {
+    TRACE = 10,
+    DEBUG = 20,
+    INFO = 30,
+    WARN = 40,
+    ERROR = 50,
+    CRITICAL = 60
+}
+```
+
+### `LogRecord`
+
+```typescript
+interface LogRecord {
+    level: LogLevel
+    time: Date
+    tags: string[]
+    message: string | undefined
+    args: unknown[]
+}
+```
+
+## License
+
+Apache-2.0

package/dist/index.cjs

@@ -0,0 +1,217 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_fs_promises = require("node:fs/promises");
+//#region src/LogLevel.ts
+/**
+* Defines the severity levels for log records.
+*
+* Levels are ordered by increasing severity:
+* `TRACE` < `DEBUG` < `INFO` < `WARN` < `ERROR` < `CRITICAL`.
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	/** Fine-grained informational events useful for deep debugging. */
+	LogLevel[LogLevel["TRACE"] = 10] = "TRACE";
+	/** Informational events useful for debugging an application. */
+	LogLevel[LogLevel["DEBUG"] = 20] = "DEBUG";
+	/** Informational messages that highlight the progress of the application. */
+	LogLevel[LogLevel["INFO"] = 30] = "INFO";
+	/** Potentially harmful situations that do not prevent execution. */
+	LogLevel[LogLevel["WARN"] = 40] = "WARN";
+	/** Error events that might still allow the application to continue running. */
+	LogLevel[LogLevel["ERROR"] = 50] = "ERROR";
+	/** Very severe error events that will presumably lead the application to abort. */
+	LogLevel[LogLevel["CRITICAL"] = 60] = "CRITICAL";
+	return LogLevel;
+}({});
+//#endregion
+//#region src/Logger.ts
+/**
+* A logger that accepts log records and forwards them to a {@link LogWriter}.
+*
+* The generic `Writer` type controls whether logging is synchronous or asynchronous.
+*/
+var Logger = class {
+	writer;
+	tags;
+	/**
+	* Creates a new `Logger` instance.
+	* @param writer - The log writer to receive records.
+	* @param tags - Optional tags to attach to every record.
+	*/
+	constructor(writer, tags = []) {
+		this.writer = writer;
+		this.tags = tags;
+	}
+	/**
+	* Extracts an optional message string from the argument list.
+	* If the first argument is a string it is treated as the message;
+	* otherwise, if the last argument is a string it is treated as the message.
+	* @param args - The raw arguments passed to a log method.
+	* @returns The message and remaining arguments.
+	*/
+	parseArgs(...args) {
+		let msg = void 0;
+		let data = args;
+		if (typeof args[0] === "string") {
+			msg = args[0];
+			data = args.slice(1);
+		} else if (args.length > 0 && typeof args[args.length - 1] === "string") {
+			msg = args[args.length - 1];
+			data = args.slice(0, -1);
+		}
+		return {
+			msg,
+			args: data
+		};
+	}
+	/**
+	* Writes a log record at the specified level.
+	* @param level - The severity level.
+	* @param args - The log message and any additional data.
+	* @returns A `Promise<void>` when using an {@link AsyncLogWriter}, otherwise `void`.
+	*/
+	log(level, ...args) {
+		const { msg, args: _args } = this.parseArgs(...args);
+		return this.writer.write({
+			level,
+			time: /* @__PURE__ */ new Date(),
+			tags: this.tags,
+			message: msg,
+			args: _args
+		});
+	}
+	/**
+	* Writes a `TRACE` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	trace(...args) {
+		return this.log(10, ...args);
+	}
+	/**
+	* Writes a `DEBUG` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	debug(...args) {
+		return this.log(20, ...args);
+	}
+	/**
+	* Writes an `INFO` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	info(...args) {
+		return this.log(30, ...args);
+	}
+	/**
+	* Writes a `WARN` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	warn(...args) {
+		return this.log(40, ...args);
+	}
+	/**
+	* Writes an `ERROR` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	error(...args) {
+		return this.log(50, ...args);
+	}
+	/**
+	* Writes a `CRITICAL` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	critical(...args) {
+		return this.log(60, ...args);
+	}
+};
+//#endregion
+//#region src/writer/ConsoleLogWriter.ts
+/**
+* A synchronous log writer that outputs formatted log records
+* to the console. Supports customizable format strings
+* using placeholders: `%t` (timestamp), `%l` (level), `%tag` (tags), `%msg` (message).
+*/
+var ConsoleLogWriter = class {
+	format;
+	/**
+	* Creates a new `ConsoleLogWriter` instance.
+	* @param format - The format string. Defaults to `[%t] [%l] [%tag]: %msg`.
+	*/
+	constructor(format = "[%t] [%l] [%tag]: %msg") {
+		this.format = format;
+	}
+	/**
+	* Formats a `LogRecord` into an array suitable for `console.log`.
+	* @param log - The log record to format.
+	* @returns An array of formatted values and extras.
+	*/
+	fmt(log) {
+		const tag = log.tags.length > 0 ? `[${log.tags.join("/")}]` : "";
+		return [this.format.replace("%t", log.time.toISOString()).replace("%l", LogLevel[log.level]).replace("%tag", tag).replace("%msg", log.message ?? "").trim(), ...log.args];
+	}
+	/**
+	* Writes a log record to the console.
+	* @param log - The log record to write.
+	*/
+	write(log) {
+		console.log(...this.fmt(log));
+	}
+};
+//#endregion
+//#region src/writer/JSONLFileLogWriter.ts
+/**
+* An asynchronous log writer that serializes log records as JSON Lines
+* and appends them to a file. Special values like `Error`, `Map`, `Set`,
+* and `bigint` are normalized before serialization.
+*/
+var JSONLFileLogWriter = class {
+	path;
+	/**
+	* Creates a new `JSONLFileLogWriter` instance.
+	* @param path - The path to the JSON Lines file.
+	*/
+	constructor(path) {
+		this.path = path;
+	}
+	/**
+	* Serializes a `LogRecord` into a plain object.
+	* @param log - The log record to serialize.
+	* @returns A plain object representation of the log record.
+	* @private
+	*/
+	serialize(log) {
+		return {
+			...log,
+			args: log.args.map((arg) => this.serializeValue(arg))
+		};
+	}
+	/**
+	* Serializes the `value` to a plain object
+	* @param value - The value to serialize.
+	* @return A plain object representation of the value.
+	* @private
+	*/
+	serializeValue(value) {
+		if (value instanceof Error) return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		if (value instanceof Map) return Object.fromEntries(value);
+		if (value instanceof Set) return [...value];
+		if (typeof value === "bigint") return value.toString();
+		return value;
+	}
+	/**
+	* Writes a log record to the log file.
+	* @param log - The log record to write.
+	*/
+	async write(log) {
+		await (0, node_fs_promises.appendFile)(this.path, JSON.stringify(this.serialize(log)) + "\n");
+	}
+};
+//#endregion
+exports.ConsoleLogWriter = ConsoleLogWriter;
+exports.JSONLFileLogWriter = JSONLFileLogWriter;
+exports.LogLevel = LogLevel;
+exports.Logger = Logger;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/LogLevel.ts","../src/Logger.ts","../src/writer/ConsoleLogWriter.ts","../src/writer/JSONLFileLogWriter.ts"],"sourcesContent":["/**\n * Defines the severity levels for log records.\n *\n * Levels are ordered by increasing severity:\n * `TRACE` < `DEBUG` < `INFO` < `WARN` < `ERROR` < `CRITICAL`.\n */\nexport enum LogLevel {\n    /** Fine-grained informational events useful for deep debugging. */\n    TRACE = 10,\n\n    /** Informational events useful for debugging an application. */\n    DEBUG = 20,\n\n    /** Informational messages that highlight the progress of the application. */\n    INFO = 30,\n\n    /** Potentially harmful situations that do not prevent execution. */\n    WARN = 40,\n\n    /** Error events that might still allow the application to continue running. */\n    ERROR = 50,\n\n    /** Very severe error events that will presumably lead the application to abort. */\n    CRITICAL = 60\n}\n","import { LogLevel } from './LogLevel'\nimport { MaybePromise } from './MaybePromise'\nimport { AsyncLogWriter, LogWriter } from './writer'\n\n/**\n * A logger that accepts log records and forwards them to a {@link LogWriter}.\n *\n * The generic `Writer` type controls whether logging is synchronous or asynchronous.\n */\nexport class Logger<Writer extends LogWriter | AsyncLogWriter = LogWriter> {\n    /**\n     * Creates a new `Logger` instance.\n     * @param writer - The log writer to receive records.\n     * @param tags - Optional tags to attach to every record.\n     */\n    constructor(\n        private readonly writer: Writer,\n        private readonly tags: string[] = []\n    ) {}\n\n    /**\n     * Extracts an optional message string from the argument list.\n     * If the first argument is a string it is treated as the message;\n     * otherwise, if the last argument is a string it is treated as the message.\n     * @param args - The raw arguments passed to a log method.\n     * @returns The message and remaining arguments.\n     */\n    private parseArgs(...args: unknown[]): {\n        msg: string | undefined\n        args: unknown[]\n    } {\n        let msg: string | undefined = undefined\n        let data: unknown[] = args\n\n        if (typeof args[0] === 'string') {\n            msg = args[0]\n            data = args.slice(1)\n        } else if (args.length > 0 && typeof args[args.length - 1] === 'string') {\n            msg = args[args.length - 1] as any\n            data = args.slice(0, -1)\n        }\n\n        return { msg, args: data }\n    }\n\n    /**\n     * Writes a log record at the specified level.\n     * @param level - The severity level.\n     * @param args - The log message and any additional data.\n     * @returns A `Promise<void>` when using an {@link AsyncLogWriter}, otherwise `void`.\n     */\n    log(level: LogLevel, ...args: unknown[]): MaybePromise<Writer, void> {\n        const { msg, args: _args } = this.parseArgs(...args)\n\n        return this.writer.write({\n            level,\n            time: new Date(),\n            tags: this.tags,\n            message: msg,\n            args: _args\n        }) as MaybePromise<Writer, void>\n    }\n\n    /**\n     * Writes a `TRACE` level log record.\n     * @param args - The log message and any additional data.\n     */\n    trace(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.TRACE, ...args)\n    }\n\n    /**\n     * Writes a `DEBUG` level log record.\n     * @param args - The log message and any additional data.\n     */\n    debug(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.DEBUG, ...args)\n    }\n\n    /**\n     * Writes an `INFO` level log record.\n     * @param args - The log message and any additional data.\n     */\n    info(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.INFO, ...args)\n    }\n\n    /**\n     * Writes a `WARN` level log record.\n     * @param args - The log message and any additional data.\n     */\n    warn(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.WARN, ...args)\n    }\n\n    /**\n     * Writes an `ERROR` level log record.\n     * @param args - The log message and any additional data.\n     */\n    error(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.ERROR, ...args)\n    }\n\n    /**\n     * Writes a `CRITICAL` level log record.\n     * @param args - The log message and any additional data.\n     */\n    critical(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.CRITICAL, ...args)\n    }\n}\n","import { LogLevel } from '../LogLevel'\nimport { LogRecord } from '../LogRecord'\nimport { LogWriter } from './LogWriter'\n\n/**\n * A synchronous log writer that outputs formatted log records\n * to the console. Supports customizable format strings\n * using placeholders: `%t` (timestamp), `%l` (level), `%tag` (tags), `%msg` (message).\n */\nexport class ConsoleLogWriter implements LogWriter {\n    /**\n     * Creates a new `ConsoleLogWriter` instance.\n     * @param format - The format string. Defaults to `[%t] [%l] [%tag]: %msg`.\n     */\n    constructor(private readonly format: string = '[%t] [%l] [%tag]: %msg') {}\n\n    /**\n     * Formats a `LogRecord` into an array suitable for `console.log`.\n     * @param log - The log record to format.\n     * @returns An array of formatted values and extras.\n     */\n    private fmt(log: LogRecord): unknown[] {\n        const tag = log.tags.length > 0 ? `[${log.tags.join('/')}]` : ''\n\n        return [\n            this.format\n                .replace('%t', log.time.toISOString())\n                .replace('%l', LogLevel[log.level])\n                .replace('%tag', tag)\n                .replace('%msg', log.message ?? '')\n                .trim(),\n            ...log.args\n        ]\n    }\n\n    /**\n     * Writes a log record to the console.\n     * @param log - The log record to write.\n     */\n    write(log: LogRecord): void {\n        console.log(...this.fmt(log))\n    }\n}\n","import { appendFile } from 'node:fs/promises'\nimport { LogRecord } from '../LogRecord'\nimport { AsyncLogWriter } from './AsyncLogWriter'\n\n/**\n * An asynchronous log writer that serializes log records as JSON Lines\n * and appends them to a file. Special values like `Error`, `Map`, `Set`,\n * and `bigint` are normalized before serialization.\n */\nexport class JSONLFileLogWriter implements AsyncLogWriter {\n    /**\n     * Creates a new `JSONLFileLogWriter` instance.\n     * @param path - The path to the JSON Lines file.\n     */\n    constructor(private readonly path: string) {}\n\n    /**\n     * Serializes a `LogRecord` into a plain object.\n     * @param log - The log record to serialize.\n     * @returns A plain object representation of the log record.\n     * @private\n     */\n    private serialize(log: LogRecord): object {\n        return {\n            ...log,\n            args: log.args.map(arg => this.serializeValue(arg))\n        }\n    }\n\n    /**\n     * Serializes the `value` to a plain object\n     * @param value - The value to serialize.\n     * @return A plain object representation of the value.\n     * @private\n     */\n    private serializeValue(value: unknown): unknown {\n        if (value instanceof Error) {\n            return {\n                name: value.name,\n                message: value.message,\n                stack: value.stack\n            }\n        }\n\n        if (value instanceof Map) {\n            return Object.fromEntries(value)\n        }\n\n        if (value instanceof Set) {\n            return [...value]\n        }\n\n        if (typeof value === 'bigint') {\n            return value.toString()\n        }\n\n        return value\n    }\n\n    /**\n     * Writes a log record to the log file.\n     * @param log - The log record to write.\n     */\n    async write(log: LogRecord): Promise<void> {\n        await appendFile(this.path, JSON.stringify(this.serialize(log)) + '\\n')\n    }\n}\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,200 @@
+//#region src/LogLevel.d.ts
+/**
+ * Defines the severity levels for log records.
+ *
+ * Levels are ordered by increasing severity:
+ * `TRACE` < `DEBUG` < `INFO` < `WARN` < `ERROR` < `CRITICAL`.
+ */
+declare enum LogLevel {
+  /** Fine-grained informational events useful for deep debugging. */
+  TRACE = 10,
+  /** Informational events useful for debugging an application. */
+  DEBUG = 20,
+  /** Informational messages that highlight the progress of the application. */
+  INFO = 30,
+  /** Potentially harmful situations that do not prevent execution. */
+  WARN = 40,
+  /** Error events that might still allow the application to continue running. */
+  ERROR = 50,
+  /** Very severe error events that will presumably lead the application to abort. */
+  CRITICAL = 60
+}
+//#endregion
+//#region src/LogRecord.d.ts
+/**
+ * Represents a single log record containing metadata, the message,
+ * and any additional arguments.
+ */
+interface LogRecord {
+  /** The level of the log. */
+  level: LogLevel;
+  /** The timestamp when the log record was created. */
+  time: Date;
+  /** The tags associated with the log record. */
+  tags: string[];
+  /** The log message, if any. */
+  message: string | undefined;
+  /** Additional arguments passed to the log. */
+  args: unknown[];
+}
+//#endregion
+//#region src/writer/AsyncLogWriter.d.ts
+/**
+ * Defines an asynchronous log writer that accepts log records
+ * and writes them to a target output (console, file, etc.).
+ */
+interface AsyncLogWriter {
+  /**
+   * Writes a single log record asynchronously.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): Promise<void>;
+}
+//#endregion
+//#region src/writer/LogWriter.d.ts
+/**
+ * Defines a synchronous log writer that accepts log records
+ * and writes them to a target output (console, file, etc.).
+ */
+interface LogWriter {
+  /**
+   * Writes a single log record synchronously.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): void;
+}
+//#endregion
+//#region src/writer/ConsoleLogWriter.d.ts
+/**
+ * A synchronous log writer that outputs formatted log records
+ * to the console. Supports customizable format strings
+ * using placeholders: `%t` (timestamp), `%l` (level), `%tag` (tags), `%msg` (message).
+ */
+declare class ConsoleLogWriter implements LogWriter {
+  private readonly format;
+  /**
+   * Creates a new `ConsoleLogWriter` instance.
+   * @param format - The format string. Defaults to `[%t] [%l] [%tag]: %msg`.
+   */
+  constructor(format?: string);
+  /**
+   * Formats a `LogRecord` into an array suitable for `console.log`.
+   * @param log - The log record to format.
+   * @returns An array of formatted values and extras.
+   */
+  private fmt;
+  /**
+   * Writes a log record to the console.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): void;
+}
+//#endregion
+//#region src/writer/JSONLFileLogWriter.d.ts
+/**
+ * An asynchronous log writer that serializes log records as JSON Lines
+ * and appends them to a file. Special values like `Error`, `Map`, `Set`,
+ * and `bigint` are normalized before serialization.
+ */
+declare class JSONLFileLogWriter implements AsyncLogWriter {
+  private readonly path;
+  /**
+   * Creates a new `JSONLFileLogWriter` instance.
+   * @param path - The path to the JSON Lines file.
+   */
+  constructor(path: string);
+  /**
+   * Serializes a `LogRecord` into a plain object.
+   * @param log - The log record to serialize.
+   * @returns A plain object representation of the log record.
+   * @private
+   */
+  private serialize;
+  /**
+   * Serializes the `value` to a plain object
+   * @param value - The value to serialize.
+   * @return A plain object representation of the value.
+   * @private
+   */
+  private serializeValue;
+  /**
+   * Writes a log record to the log file.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): Promise<void>;
+}
+//#endregion
+//#region src/MaybePromise.d.ts
+/**
+ * A conditional type that resolves to `Promise<R>` when the writer is
+ * an {@link AsyncLogWriter}, otherwise `R`.
+ *
+ * @typeParam Writer - The writer type to check.
+ * @typeParam R - The return type of the operation.
+ */
+type MaybePromise<Writer extends LogWriter | AsyncLogWriter, R> = Writer extends AsyncLogWriter ? Promise<R> : R;
+//#endregion
+//#region src/Logger.d.ts
+/**
+ * A logger that accepts log records and forwards them to a {@link LogWriter}.
+ *
+ * The generic `Writer` type controls whether logging is synchronous or asynchronous.
+ */
+declare class Logger<Writer extends LogWriter | AsyncLogWriter = LogWriter> {
+  private readonly writer;
+  private readonly tags;
+  /**
+   * Creates a new `Logger` instance.
+   * @param writer - The log writer to receive records.
+   * @param tags - Optional tags to attach to every record.
+   */
+  constructor(writer: Writer, tags?: string[]);
+  /**
+   * Extracts an optional message string from the argument list.
+   * If the first argument is a string it is treated as the message;
+   * otherwise, if the last argument is a string it is treated as the message.
+   * @param args - The raw arguments passed to a log method.
+   * @returns The message and remaining arguments.
+   */
+  private parseArgs;
+  /**
+   * Writes a log record at the specified level.
+   * @param level - The severity level.
+   * @param args - The log message and any additional data.
+   * @returns A `Promise<void>` when using an {@link AsyncLogWriter}, otherwise `void`.
+   */
+  log(level: LogLevel, ...args: unknown[]): MaybePromise<Writer, void>;
+  /**
+   * Writes a `TRACE` level log record.
+   * @param args - The log message and any additional data.
+   */
+  trace(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes a `DEBUG` level log record.
+   * @param args - The log message and any additional data.
+   */
+  debug(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes an `INFO` level log record.
+   * @param args - The log message and any additional data.
+   */
+  info(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes a `WARN` level log record.
+   * @param args - The log message and any additional data.
+   */
+  warn(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes an `ERROR` level log record.
+   * @param args - The log message and any additional data.
+   */
+  error(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes a `CRITICAL` level log record.
+   * @param args - The log message and any additional data.
+   */
+  critical(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+}
+//#endregion
+export { AsyncLogWriter, ConsoleLogWriter, JSONLFileLogWriter, LogLevel, LogRecord, LogWriter, Logger, MaybePromise };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/LogLevel.ts","../src/LogRecord.ts","../src/writer/AsyncLogWriter.ts","../src/writer/LogWriter.ts","../src/writer/ConsoleLogWriter.ts","../src/writer/JSONLFileLogWriter.ts","../src/MaybePromise.ts","../src/Logger.ts"],"mappings":";;AAMA;;;;;aAAY,QAAA;EAQR;EANA,KAAA;EAYA;EATA,KAAA;EAYQ;EATR,IAAA;;EAGA,IAAA;;EAGA,KAAA;ECdsB;EDiBtB,QAAA;AAAA;;;AAjBJ;;;;AAAA,UCAiB,SAAA;EDKb;ECHA,KAAA,EAAO,QAAA;EDSP;ECPA,IAAA,EAAM,IAAI;EDaV;ECXA,IAAA;EDWQ;ECTR,OAAA;;EAEA,IAAA;AAAA;;;ADVJ;;;;AAAA,UEAiB,cAAA;EFKb;;;;EEAA,KAAA,CAAM,GAAA,EAAK,SAAA,GAAY,OAAO;AAAA;;;AFLlC;;;;AAAA,UGAiB,SAAA;EHKb;;;;EGAA,KAAA,CAAM,GAAA,EAAK,SAAS;AAAA;;;;;;;;cCFX,gBAAA,YAA4B,SAAS;EAAA,iBAKjB,MAAA;EJM7B;;;AAGQ;cITqB,MAAA;;;AHRjC;;;UGeY,GAAA;EHbR;;;;EG+BA,KAAA,CAAM,GAAA,EAAK,SAAA;AAAA;;;;;;;;cC9BF,kBAAA,YAA8B,cAAA;EAAA,iBAKV,IAAA;ELM7B;;;AAGQ;cKTqB,IAAA;;;AJRjC;;;;UIgBY,SAAA;EJdD;;;;;;EAAA,QI2BC,cAAA;EJnBJ;;;;EI+CE,KAAA,CAAM,GAAA,EAAK,SAAA,GAAY,OAAA;AAAA;;;ALzDjC;;;;;;;AAAA,KMGY,YAAA,gBACO,SAAA,GAAY,cAAA,OAE3B,MAAA,SAAe,cAAA,GAAiB,OAAA,CAAQ,CAAA,IAAK,CAAA;;;;;;;;cCHpC,MAAA,gBAAsB,SAAA,GAAY,cAAA,GAAiB,SAAA;EAAA,iBAOvC,MAAA;EAAA,iBACA,IAAA;EPMb;AAAA;;;;cOPa,MAAA,EAAQ,MAAA,EACR,IAAA;ENXC;;;;;;;EAAA,QMqBd,SAAA;ENbR;;;AAEI;;;EMmCJ,GAAA,CAAI,KAAA,EAAO,QAAA,KAAa,IAAA,cAAkB,YAAA,CAAa,MAAA;EL7C1C;;;;EK6Db,KAAA,IAAS,IAAA,cAAkB,YAAA,aAAyB,MAAA;ELxDzC;;;;EKgEX,KAAA,IAAS,IAAA,cAAkB,YAAA,aAAyB,MAAA;;;;AJrExD;EI6EI,IAAA,IAAQ,IAAA,cAAkB,YAAA,aAAyB,MAAA;;;;;EAQnD,IAAA,IAAQ,IAAA,cAAkB,YAAA,aAAyB,MAAA;EJhF/B;AAAA;;;EIwFpB,KAAA,IAAS,IAAA,cAAkB,YAAA,aAAyB,MAAA;EH1F3C;;;;EGkGT,QAAA,IAAY,IAAA,cAAkB,YAAA,aAAyB,MAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,200 @@
+//#region src/LogLevel.d.ts
+/**
+ * Defines the severity levels for log records.
+ *
+ * Levels are ordered by increasing severity:
+ * `TRACE` < `DEBUG` < `INFO` < `WARN` < `ERROR` < `CRITICAL`.
+ */
+declare enum LogLevel {
+  /** Fine-grained informational events useful for deep debugging. */
+  TRACE = 10,
+  /** Informational events useful for debugging an application. */
+  DEBUG = 20,
+  /** Informational messages that highlight the progress of the application. */
+  INFO = 30,
+  /** Potentially harmful situations that do not prevent execution. */
+  WARN = 40,
+  /** Error events that might still allow the application to continue running. */
+  ERROR = 50,
+  /** Very severe error events that will presumably lead the application to abort. */
+  CRITICAL = 60
+}
+//#endregion
+//#region src/LogRecord.d.ts
+/**
+ * Represents a single log record containing metadata, the message,
+ * and any additional arguments.
+ */
+interface LogRecord {
+  /** The level of the log. */
+  level: LogLevel;
+  /** The timestamp when the log record was created. */
+  time: Date;
+  /** The tags associated with the log record. */
+  tags: string[];
+  /** The log message, if any. */
+  message: string | undefined;
+  /** Additional arguments passed to the log. */
+  args: unknown[];
+}
+//#endregion
+//#region src/writer/AsyncLogWriter.d.ts
+/**
+ * Defines an asynchronous log writer that accepts log records
+ * and writes them to a target output (console, file, etc.).
+ */
+interface AsyncLogWriter {
+  /**
+   * Writes a single log record asynchronously.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): Promise<void>;
+}
+//#endregion
+//#region src/writer/LogWriter.d.ts
+/**
+ * Defines a synchronous log writer that accepts log records
+ * and writes them to a target output (console, file, etc.).
+ */
+interface LogWriter {
+  /**
+   * Writes a single log record synchronously.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): void;
+}
+//#endregion
+//#region src/writer/ConsoleLogWriter.d.ts
+/**
+ * A synchronous log writer that outputs formatted log records
+ * to the console. Supports customizable format strings
+ * using placeholders: `%t` (timestamp), `%l` (level), `%tag` (tags), `%msg` (message).
+ */
+declare class ConsoleLogWriter implements LogWriter {
+  private readonly format;
+  /**
+   * Creates a new `ConsoleLogWriter` instance.
+   * @param format - The format string. Defaults to `[%t] [%l] [%tag]: %msg`.
+   */
+  constructor(format?: string);
+  /**
+   * Formats a `LogRecord` into an array suitable for `console.log`.
+   * @param log - The log record to format.
+   * @returns An array of formatted values and extras.
+   */
+  private fmt;
+  /**
+   * Writes a log record to the console.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): void;
+}
+//#endregion
+//#region src/writer/JSONLFileLogWriter.d.ts
+/**
+ * An asynchronous log writer that serializes log records as JSON Lines
+ * and appends them to a file. Special values like `Error`, `Map`, `Set`,
+ * and `bigint` are normalized before serialization.
+ */
+declare class JSONLFileLogWriter implements AsyncLogWriter {
+  private readonly path;
+  /**
+   * Creates a new `JSONLFileLogWriter` instance.
+   * @param path - The path to the JSON Lines file.
+   */
+  constructor(path: string);
+  /**
+   * Serializes a `LogRecord` into a plain object.
+   * @param log - The log record to serialize.
+   * @returns A plain object representation of the log record.
+   * @private
+   */
+  private serialize;
+  /**
+   * Serializes the `value` to a plain object
+   * @param value - The value to serialize.
+   * @return A plain object representation of the value.
+   * @private
+   */
+  private serializeValue;
+  /**
+   * Writes a log record to the log file.
+   * @param log - The log record to write.
+   */
+  write(log: LogRecord): Promise<void>;
+}
+//#endregion
+//#region src/MaybePromise.d.ts
+/**
+ * A conditional type that resolves to `Promise<R>` when the writer is
+ * an {@link AsyncLogWriter}, otherwise `R`.
+ *
+ * @typeParam Writer - The writer type to check.
+ * @typeParam R - The return type of the operation.
+ */
+type MaybePromise<Writer extends LogWriter | AsyncLogWriter, R> = Writer extends AsyncLogWriter ? Promise<R> : R;
+//#endregion
+//#region src/Logger.d.ts
+/**
+ * A logger that accepts log records and forwards them to a {@link LogWriter}.
+ *
+ * The generic `Writer` type controls whether logging is synchronous or asynchronous.
+ */
+declare class Logger<Writer extends LogWriter | AsyncLogWriter = LogWriter> {
+  private readonly writer;
+  private readonly tags;
+  /**
+   * Creates a new `Logger` instance.
+   * @param writer - The log writer to receive records.
+   * @param tags - Optional tags to attach to every record.
+   */
+  constructor(writer: Writer, tags?: string[]);
+  /**
+   * Extracts an optional message string from the argument list.
+   * If the first argument is a string it is treated as the message;
+   * otherwise, if the last argument is a string it is treated as the message.
+   * @param args - The raw arguments passed to a log method.
+   * @returns The message and remaining arguments.
+   */
+  private parseArgs;
+  /**
+   * Writes a log record at the specified level.
+   * @param level - The severity level.
+   * @param args - The log message and any additional data.
+   * @returns A `Promise<void>` when using an {@link AsyncLogWriter}, otherwise `void`.
+   */
+  log(level: LogLevel, ...args: unknown[]): MaybePromise<Writer, void>;
+  /**
+   * Writes a `TRACE` level log record.
+   * @param args - The log message and any additional data.
+   */
+  trace(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes a `DEBUG` level log record.
+   * @param args - The log message and any additional data.
+   */
+  debug(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes an `INFO` level log record.
+   * @param args - The log message and any additional data.
+   */
+  info(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes a `WARN` level log record.
+   * @param args - The log message and any additional data.
+   */
+  warn(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes an `ERROR` level log record.
+   * @param args - The log message and any additional data.
+   */
+  error(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+  /**
+   * Writes a `CRITICAL` level log record.
+   * @param args - The log message and any additional data.
+   */
+  critical(...args: unknown[]): MaybePromise<typeof this.writer, void>;
+}
+//#endregion
+export { AsyncLogWriter, ConsoleLogWriter, JSONLFileLogWriter, LogLevel, LogRecord, LogWriter, Logger, MaybePromise };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/LogLevel.ts","../src/LogRecord.ts","../src/writer/AsyncLogWriter.ts","../src/writer/LogWriter.ts","../src/writer/ConsoleLogWriter.ts","../src/writer/JSONLFileLogWriter.ts","../src/MaybePromise.ts","../src/Logger.ts"],"mappings":";;AAMA;;;;;aAAY,QAAA;EAQR;EANA,KAAA;EAYA;EATA,KAAA;EAYQ;EATR,IAAA;;EAGA,IAAA;;EAGA,KAAA;ECdsB;EDiBtB,QAAA;AAAA;;;AAjBJ;;;;AAAA,UCAiB,SAAA;EDKb;ECHA,KAAA,EAAO,QAAA;EDSP;ECPA,IAAA,EAAM,IAAI;EDaV;ECXA,IAAA;EDWQ;ECTR,OAAA;;EAEA,IAAA;AAAA;;;ADVJ;;;;AAAA,UEAiB,cAAA;EFKb;;;;EEAA,KAAA,CAAM,GAAA,EAAK,SAAA,GAAY,OAAO;AAAA;;;AFLlC;;;;AAAA,UGAiB,SAAA;EHKb;;;;EGAA,KAAA,CAAM,GAAA,EAAK,SAAS;AAAA;;;;;;;;cCFX,gBAAA,YAA4B,SAAS;EAAA,iBAKjB,MAAA;EJM7B;;;AAGQ;cITqB,MAAA;;;AHRjC;;;UGeY,GAAA;EHbR;;;;EG+BA,KAAA,CAAM,GAAA,EAAK,SAAA;AAAA;;;;;;;;cC9BF,kBAAA,YAA8B,cAAA;EAAA,iBAKV,IAAA;ELM7B;;;AAGQ;cKTqB,IAAA;;;AJRjC;;;;UIgBY,SAAA;EJdD;;;;;;EAAA,QI2BC,cAAA;EJnBJ;;;;EI+CE,KAAA,CAAM,GAAA,EAAK,SAAA,GAAY,OAAA;AAAA;;;ALzDjC;;;;;;;AAAA,KMGY,YAAA,gBACO,SAAA,GAAY,cAAA,OAE3B,MAAA,SAAe,cAAA,GAAiB,OAAA,CAAQ,CAAA,IAAK,CAAA;;;;;;;;cCHpC,MAAA,gBAAsB,SAAA,GAAY,cAAA,GAAiB,SAAA;EAAA,iBAOvC,MAAA;EAAA,iBACA,IAAA;EPMb;AAAA;;;;cOPa,MAAA,EAAQ,MAAA,EACR,IAAA;ENXC;;;;;;;EAAA,QMqBd,SAAA;ENbR;;;AAEI;;;EMmCJ,GAAA,CAAI,KAAA,EAAO,QAAA,KAAa,IAAA,cAAkB,YAAA,CAAa,MAAA;EL7C1C;;;;EK6Db,KAAA,IAAS,IAAA,cAAkB,YAAA,aAAyB,MAAA;ELxDzC;;;;EKgEX,KAAA,IAAS,IAAA,cAAkB,YAAA,aAAyB,MAAA;;;;AJrExD;EI6EI,IAAA,IAAQ,IAAA,cAAkB,YAAA,aAAyB,MAAA;;;;;EAQnD,IAAA,IAAQ,IAAA,cAAkB,YAAA,aAAyB,MAAA;EJhF/B;AAAA;;;EIwFpB,KAAA,IAAS,IAAA,cAAkB,YAAA,aAAyB,MAAA;EH1F3C;;;;EGkGT,QAAA,IAAY,IAAA,cAAkB,YAAA,aAAyB,MAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,213 @@
+import { appendFile } from "node:fs/promises";
+//#region src/LogLevel.ts
+/**
+* Defines the severity levels for log records.
+*
+* Levels are ordered by increasing severity:
+* `TRACE` < `DEBUG` < `INFO` < `WARN` < `ERROR` < `CRITICAL`.
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	/** Fine-grained informational events useful for deep debugging. */
+	LogLevel[LogLevel["TRACE"] = 10] = "TRACE";
+	/** Informational events useful for debugging an application. */
+	LogLevel[LogLevel["DEBUG"] = 20] = "DEBUG";
+	/** Informational messages that highlight the progress of the application. */
+	LogLevel[LogLevel["INFO"] = 30] = "INFO";
+	/** Potentially harmful situations that do not prevent execution. */
+	LogLevel[LogLevel["WARN"] = 40] = "WARN";
+	/** Error events that might still allow the application to continue running. */
+	LogLevel[LogLevel["ERROR"] = 50] = "ERROR";
+	/** Very severe error events that will presumably lead the application to abort. */
+	LogLevel[LogLevel["CRITICAL"] = 60] = "CRITICAL";
+	return LogLevel;
+}({});
+//#endregion
+//#region src/Logger.ts
+/**
+* A logger that accepts log records and forwards them to a {@link LogWriter}.
+*
+* The generic `Writer` type controls whether logging is synchronous or asynchronous.
+*/
+var Logger = class {
+	writer;
+	tags;
+	/**
+	* Creates a new `Logger` instance.
+	* @param writer - The log writer to receive records.
+	* @param tags - Optional tags to attach to every record.
+	*/
+	constructor(writer, tags = []) {
+		this.writer = writer;
+		this.tags = tags;
+	}
+	/**
+	* Extracts an optional message string from the argument list.
+	* If the first argument is a string it is treated as the message;
+	* otherwise, if the last argument is a string it is treated as the message.
+	* @param args - The raw arguments passed to a log method.
+	* @returns The message and remaining arguments.
+	*/
+	parseArgs(...args) {
+		let msg = void 0;
+		let data = args;
+		if (typeof args[0] === "string") {
+			msg = args[0];
+			data = args.slice(1);
+		} else if (args.length > 0 && typeof args[args.length - 1] === "string") {
+			msg = args[args.length - 1];
+			data = args.slice(0, -1);
+		}
+		return {
+			msg,
+			args: data
+		};
+	}
+	/**
+	* Writes a log record at the specified level.
+	* @param level - The severity level.
+	* @param args - The log message and any additional data.
+	* @returns A `Promise<void>` when using an {@link AsyncLogWriter}, otherwise `void`.
+	*/
+	log(level, ...args) {
+		const { msg, args: _args } = this.parseArgs(...args);
+		return this.writer.write({
+			level,
+			time: /* @__PURE__ */ new Date(),
+			tags: this.tags,
+			message: msg,
+			args: _args
+		});
+	}
+	/**
+	* Writes a `TRACE` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	trace(...args) {
+		return this.log(10, ...args);
+	}
+	/**
+	* Writes a `DEBUG` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	debug(...args) {
+		return this.log(20, ...args);
+	}
+	/**
+	* Writes an `INFO` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	info(...args) {
+		return this.log(30, ...args);
+	}
+	/**
+	* Writes a `WARN` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	warn(...args) {
+		return this.log(40, ...args);
+	}
+	/**
+	* Writes an `ERROR` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	error(...args) {
+		return this.log(50, ...args);
+	}
+	/**
+	* Writes a `CRITICAL` level log record.
+	* @param args - The log message and any additional data.
+	*/
+	critical(...args) {
+		return this.log(60, ...args);
+	}
+};
+//#endregion
+//#region src/writer/ConsoleLogWriter.ts
+/**
+* A synchronous log writer that outputs formatted log records
+* to the console. Supports customizable format strings
+* using placeholders: `%t` (timestamp), `%l` (level), `%tag` (tags), `%msg` (message).
+*/
+var ConsoleLogWriter = class {
+	format;
+	/**
+	* Creates a new `ConsoleLogWriter` instance.
+	* @param format - The format string. Defaults to `[%t] [%l] [%tag]: %msg`.
+	*/
+	constructor(format = "[%t] [%l] [%tag]: %msg") {
+		this.format = format;
+	}
+	/**
+	* Formats a `LogRecord` into an array suitable for `console.log`.
+	* @param log - The log record to format.
+	* @returns An array of formatted values and extras.
+	*/
+	fmt(log) {
+		const tag = log.tags.length > 0 ? `[${log.tags.join("/")}]` : "";
+		return [this.format.replace("%t", log.time.toISOString()).replace("%l", LogLevel[log.level]).replace("%tag", tag).replace("%msg", log.message ?? "").trim(), ...log.args];
+	}
+	/**
+	* Writes a log record to the console.
+	* @param log - The log record to write.
+	*/
+	write(log) {
+		console.log(...this.fmt(log));
+	}
+};
+//#endregion
+//#region src/writer/JSONLFileLogWriter.ts
+/**
+* An asynchronous log writer that serializes log records as JSON Lines
+* and appends them to a file. Special values like `Error`, `Map`, `Set`,
+* and `bigint` are normalized before serialization.
+*/
+var JSONLFileLogWriter = class {
+	path;
+	/**
+	* Creates a new `JSONLFileLogWriter` instance.
+	* @param path - The path to the JSON Lines file.
+	*/
+	constructor(path) {
+		this.path = path;
+	}
+	/**
+	* Serializes a `LogRecord` into a plain object.
+	* @param log - The log record to serialize.
+	* @returns A plain object representation of the log record.
+	* @private
+	*/
+	serialize(log) {
+		return {
+			...log,
+			args: log.args.map((arg) => this.serializeValue(arg))
+		};
+	}
+	/**
+	* Serializes the `value` to a plain object
+	* @param value - The value to serialize.
+	* @return A plain object representation of the value.
+	* @private
+	*/
+	serializeValue(value) {
+		if (value instanceof Error) return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		if (value instanceof Map) return Object.fromEntries(value);
+		if (value instanceof Set) return [...value];
+		if (typeof value === "bigint") return value.toString();
+		return value;
+	}
+	/**
+	* Writes a log record to the log file.
+	* @param log - The log record to write.
+	*/
+	async write(log) {
+		await appendFile(this.path, JSON.stringify(this.serialize(log)) + "\n");
+	}
+};
+//#endregion
+export { ConsoleLogWriter, JSONLFileLogWriter, LogLevel, Logger };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/LogLevel.ts","../src/Logger.ts","../src/writer/ConsoleLogWriter.ts","../src/writer/JSONLFileLogWriter.ts"],"sourcesContent":["/**\n * Defines the severity levels for log records.\n *\n * Levels are ordered by increasing severity:\n * `TRACE` < `DEBUG` < `INFO` < `WARN` < `ERROR` < `CRITICAL`.\n */\nexport enum LogLevel {\n    /** Fine-grained informational events useful for deep debugging. */\n    TRACE = 10,\n\n    /** Informational events useful for debugging an application. */\n    DEBUG = 20,\n\n    /** Informational messages that highlight the progress of the application. */\n    INFO = 30,\n\n    /** Potentially harmful situations that do not prevent execution. */\n    WARN = 40,\n\n    /** Error events that might still allow the application to continue running. */\n    ERROR = 50,\n\n    /** Very severe error events that will presumably lead the application to abort. */\n    CRITICAL = 60\n}\n","import { LogLevel } from './LogLevel'\nimport { MaybePromise } from './MaybePromise'\nimport { AsyncLogWriter, LogWriter } from './writer'\n\n/**\n * A logger that accepts log records and forwards them to a {@link LogWriter}.\n *\n * The generic `Writer` type controls whether logging is synchronous or asynchronous.\n */\nexport class Logger<Writer extends LogWriter | AsyncLogWriter = LogWriter> {\n    /**\n     * Creates a new `Logger` instance.\n     * @param writer - The log writer to receive records.\n     * @param tags - Optional tags to attach to every record.\n     */\n    constructor(\n        private readonly writer: Writer,\n        private readonly tags: string[] = []\n    ) {}\n\n    /**\n     * Extracts an optional message string from the argument list.\n     * If the first argument is a string it is treated as the message;\n     * otherwise, if the last argument is a string it is treated as the message.\n     * @param args - The raw arguments passed to a log method.\n     * @returns The message and remaining arguments.\n     */\n    private parseArgs(...args: unknown[]): {\n        msg: string | undefined\n        args: unknown[]\n    } {\n        let msg: string | undefined = undefined\n        let data: unknown[] = args\n\n        if (typeof args[0] === 'string') {\n            msg = args[0]\n            data = args.slice(1)\n        } else if (args.length > 0 && typeof args[args.length - 1] === 'string') {\n            msg = args[args.length - 1] as any\n            data = args.slice(0, -1)\n        }\n\n        return { msg, args: data }\n    }\n\n    /**\n     * Writes a log record at the specified level.\n     * @param level - The severity level.\n     * @param args - The log message and any additional data.\n     * @returns A `Promise<void>` when using an {@link AsyncLogWriter}, otherwise `void`.\n     */\n    log(level: LogLevel, ...args: unknown[]): MaybePromise<Writer, void> {\n        const { msg, args: _args } = this.parseArgs(...args)\n\n        return this.writer.write({\n            level,\n            time: new Date(),\n            tags: this.tags,\n            message: msg,\n            args: _args\n        }) as MaybePromise<Writer, void>\n    }\n\n    /**\n     * Writes a `TRACE` level log record.\n     * @param args - The log message and any additional data.\n     */\n    trace(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.TRACE, ...args)\n    }\n\n    /**\n     * Writes a `DEBUG` level log record.\n     * @param args - The log message and any additional data.\n     */\n    debug(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.DEBUG, ...args)\n    }\n\n    /**\n     * Writes an `INFO` level log record.\n     * @param args - The log message and any additional data.\n     */\n    info(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.INFO, ...args)\n    }\n\n    /**\n     * Writes a `WARN` level log record.\n     * @param args - The log message and any additional data.\n     */\n    warn(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.WARN, ...args)\n    }\n\n    /**\n     * Writes an `ERROR` level log record.\n     * @param args - The log message and any additional data.\n     */\n    error(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.ERROR, ...args)\n    }\n\n    /**\n     * Writes a `CRITICAL` level log record.\n     * @param args - The log message and any additional data.\n     */\n    critical(...args: unknown[]): MaybePromise<typeof this.writer, void> {\n        return this.log(LogLevel.CRITICAL, ...args)\n    }\n}\n","import { LogLevel } from '../LogLevel'\nimport { LogRecord } from '../LogRecord'\nimport { LogWriter } from './LogWriter'\n\n/**\n * A synchronous log writer that outputs formatted log records\n * to the console. Supports customizable format strings\n * using placeholders: `%t` (timestamp), `%l` (level), `%tag` (tags), `%msg` (message).\n */\nexport class ConsoleLogWriter implements LogWriter {\n    /**\n     * Creates a new `ConsoleLogWriter` instance.\n     * @param format - The format string. Defaults to `[%t] [%l] [%tag]: %msg`.\n     */\n    constructor(private readonly format: string = '[%t] [%l] [%tag]: %msg') {}\n\n    /**\n     * Formats a `LogRecord` into an array suitable for `console.log`.\n     * @param log - The log record to format.\n     * @returns An array of formatted values and extras.\n     */\n    private fmt(log: LogRecord): unknown[] {\n        const tag = log.tags.length > 0 ? `[${log.tags.join('/')}]` : ''\n\n        return [\n            this.format\n                .replace('%t', log.time.toISOString())\n                .replace('%l', LogLevel[log.level])\n                .replace('%tag', tag)\n                .replace('%msg', log.message ?? '')\n                .trim(),\n            ...log.args\n        ]\n    }\n\n    /**\n     * Writes a log record to the console.\n     * @param log - The log record to write.\n     */\n    write(log: LogRecord): void {\n        console.log(...this.fmt(log))\n    }\n}\n","import { appendFile } from 'node:fs/promises'\nimport { LogRecord } from '../LogRecord'\nimport { AsyncLogWriter } from './AsyncLogWriter'\n\n/**\n * An asynchronous log writer that serializes log records as JSON Lines\n * and appends them to a file. Special values like `Error`, `Map`, `Set`,\n * and `bigint` are normalized before serialization.\n */\nexport class JSONLFileLogWriter implements AsyncLogWriter {\n    /**\n     * Creates a new `JSONLFileLogWriter` instance.\n     * @param path - The path to the JSON Lines file.\n     */\n    constructor(private readonly path: string) {}\n\n    /**\n     * Serializes a `LogRecord` into a plain object.\n     * @param log - The log record to serialize.\n     * @returns A plain object representation of the log record.\n     * @private\n     */\n    private serialize(log: LogRecord): object {\n        return {\n            ...log,\n            args: log.args.map(arg => this.serializeValue(arg))\n        }\n    }\n\n    /**\n     * Serializes the `value` to a plain object\n     * @param value - The value to serialize.\n     * @return A plain object representation of the value.\n     * @private\n     */\n    private serializeValue(value: unknown): unknown {\n        if (value instanceof Error) {\n            return {\n                name: value.name,\n                message: value.message,\n                stack: value.stack\n            }\n        }\n\n        if (value instanceof Map) {\n            return Object.fromEntries(value)\n        }\n\n        if (value instanceof Set) {\n            return [...value]\n        }\n\n        if (typeof value === 'bigint') {\n            return value.toString()\n        }\n\n        return value\n    }\n\n    /**\n     * Writes a log record to the log file.\n     * @param log - The log record to write.\n     */\n    async write(log: LogRecord): Promise<void> {\n        await appendFile(this.path, JSON.stringify(this.serialize(log)) + '\\n')\n    }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@briangits/node-log",
+  "version": "0.0.1",
+  "description": "Logging for Node.js",
+  "author": "Gits (https://github.com/briangits)",
+  "license": "Apache-2.0",
+  "keywords": [
+    "log",
+    "logging",
+    "logger"
+  ],
+  "homepage": "https://github.com/briangits/node-log#readme",
+  "bugs": {
+    "url": "https://github.com/briangits/node-log/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/briangits/node-log.git"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "^11.7.0",
+      "onFail": "download"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "prettier": "^3.8.4",
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "tsdown": "^0.22.3",
+    "vitest": "^4.1.9"
+  },
+  "prettier": {
+    "printWidth": 100,
+    "tabWidth": 4,
+    "useTabs": false,
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "none",
+    "bracketSpacing": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf",
+    "plugins": [
+      "prettier-plugin-organize-imports"
+    ]
+  },
+  "scripts": {
+    "lint": "prettier --check '**/*' --ignore-path .gitignore --ignore-unknown",
+    "format": "prettier --write '**/*' --ignore-path .gitignore --ignore-unknown",
+    "test": "vitest run",
+    "build": "tsdown -c tsdown.config.ts"
+  }
+}