@geekmidas/logger 0.0.1

package/dist/pino.cjs

@@ -0,0 +1,48 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const pino = __toESM(require("pino"));
+
+//#region src/pino.ts
+function createLogger(options) {
+	const pretty = options?.pretty && process.NODE_ENV !== "production";
+	const baseOptions = pretty ? { transport: {
+		target: "pino-pretty",
+		options: { colorize: true }
+	} } : {};
+	return (0, pino.pino)({
+		...baseOptions,
+		formatters: {
+			bindings() {
+				return { nodeVersion: process.version };
+			},
+			level: (label) => {
+				return { level: label.toUpperCase() };
+			}
+		}
+	});
+}
+
+//#endregion
+exports.createLogger = createLogger;
+//# sourceMappingURL=pino.cjs.map

package/dist/pino.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.cjs","names":["options: CreateLoggerOptions"],"sources":["../src/pino.ts"],"sourcesContent":["import { pino } from 'pino';\nimport type { CreateLoggerOptions } from './types';\n\nexport function createLogger(options: CreateLoggerOptions) {\n  // @ts-ignore\n  const pretty = options?.pretty && process.NODE_ENV !== 'production';\n  const baseOptions = pretty\n    ? {\n        transport: {\n          target: 'pino-pretty',\n          options: { colorize: true },\n        },\n      }\n    : {};\n  return pino({\n    ...baseOptions,\n    formatters: {\n      bindings() {\n        return { nodeVersion: process.version };\n      },\n      level: (label) => {\n        return { level: label.toUpperCase() };\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,SAAgB,aAAaA,SAA8B;CAEzD,MAAM,SAAS,SAAS,UAAU,QAAQ,aAAa;CACvD,MAAM,cAAc,SAChB,EACE,WAAW;EACT,QAAQ;EACR,SAAS,EAAE,UAAU,KAAM;CAC5B,EACF,IACD,CAAE;AACN,QAAO,eAAK;EACV,GAAG;EACH,YAAY;GACV,WAAW;AACT,WAAO,EAAE,aAAa,QAAQ,QAAS;GACxC;GACD,OAAO,CAAC,UAAU;AAChB,WAAO,EAAE,OAAO,MAAM,aAAa,CAAE;GACtC;EACF;CACF,EAAC;AACH"}

package/dist/pino.d.cts

@@ -0,0 +1,8 @@
+import { CreateLoggerOptions } from "./types-DXdmn7h5.cjs";
+import * as pino0 from "pino";
+
+//#region src/pino.d.ts
+declare function createLogger(options: CreateLoggerOptions): pino0.Logger<never, boolean>;
+//#endregion
+export { createLogger };
+//# sourceMappingURL=pino.d.cts.map

package/dist/pino.d.mts

@@ -0,0 +1,8 @@
+import { CreateLoggerOptions } from "./types-C1RfRbo6.mjs";
+import * as pino0 from "pino";
+
+//#region src/pino.d.ts
+declare function createLogger(options: CreateLoggerOptions): pino0.Logger<never, boolean>;
+//#endregion
+export { createLogger };
+//# sourceMappingURL=pino.d.mts.map

package/dist/pino.mjs

@@ -0,0 +1,25 @@
+import { pino } from "pino";
+
+//#region src/pino.ts
+function createLogger(options) {
+	const pretty = options?.pretty && process.NODE_ENV !== "production";
+	const baseOptions = pretty ? { transport: {
+		target: "pino-pretty",
+		options: { colorize: true }
+	} } : {};
+	return pino({
+		...baseOptions,
+		formatters: {
+			bindings() {
+				return { nodeVersion: process.version };
+			},
+			level: (label) => {
+				return { level: label.toUpperCase() };
+			}
+		}
+	});
+}
+
+//#endregion
+export { createLogger };
+//# sourceMappingURL=pino.mjs.map

package/dist/pino.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.mjs","names":["options: CreateLoggerOptions"],"sources":["../src/pino.ts"],"sourcesContent":["import { pino } from 'pino';\nimport type { CreateLoggerOptions } from './types';\n\nexport function createLogger(options: CreateLoggerOptions) {\n  // @ts-ignore\n  const pretty = options?.pretty && process.NODE_ENV !== 'production';\n  const baseOptions = pretty\n    ? {\n        transport: {\n          target: 'pino-pretty',\n          options: { colorize: true },\n        },\n      }\n    : {};\n  return pino({\n    ...baseOptions,\n    formatters: {\n      bindings() {\n        return { nodeVersion: process.version };\n      },\n      level: (label) => {\n        return { level: label.toUpperCase() };\n      },\n    },\n  });\n}\n"],"mappings":";;;AAGA,SAAgB,aAAaA,SAA8B;CAEzD,MAAM,SAAS,SAAS,UAAU,QAAQ,aAAa;CACvD,MAAM,cAAc,SAChB,EACE,WAAW;EACT,QAAQ;EACR,SAAS,EAAE,UAAU,KAAM;CAC5B,EACF,IACD,CAAE;AACN,QAAO,KAAK;EACV,GAAG;EACH,YAAY;GACV,WAAW;AACT,WAAO,EAAE,aAAa,QAAQ,QAAS;GACxC;GACD,OAAO,CAAC,UAAU;AAChB,WAAO,EAAE,OAAO,MAAM,aAAa,CAAE;GACtC;EACF;CACF,EAAC;AACH"}

package/dist/types-C1RfRbo6.d.mts

@@ -0,0 +1,81 @@
+//#region src/types.d.ts
+/**
+ * Logging function type that supports both structured and simple logging.
+ * Can be called with an object for structured logging or just a message string.
+ *
+ * @example
+ * ```typescript
+ * // Structured logging with context object
+ * logger.info({ userId: 123, action: 'login' }, 'User logged in');
+ *
+ * // Simple string logging
+ * logger.info('Application started');
+ * ```
+ */
+type LogFn = {
+  /** Structured logging with context object, optional message, and additional arguments */
+  <T extends object>(obj: T, msg?: string, ...args: any[]): void;
+  /** Simple string logging */
+  (msg: string): void;
+};
+/**
+ * Standard logger interface with multiple log levels and child logger support.
+ * Follows common logging patterns with structured logging capabilities.
+ *
+ * @interface Logger
+ */
+interface Logger {
+  /** Debug level logging - verbose information for debugging */
+  debug: LogFn;
+  /** Info level logging - general informational messages */
+  info: LogFn;
+  /** Warning level logging - potentially harmful situations */
+  warn: LogFn;
+  /** Error level logging - error events that might still allow the application to continue */
+  error: LogFn;
+  /** Fatal level logging - severe errors that will likely cause the application to abort */
+  fatal: LogFn;
+  /** Trace level logging - most detailed information */
+  trace: LogFn;
+  /**
+   * Creates a child logger with additional context.
+   * Child loggers inherit parent context and add their own.
+   *
+   * @param obj - Additional context to include in all child logger calls
+   * @returns A new Logger instance with merged context
+   */
+  child: (obj: object) => Logger;
+}
+/**
+ * Console-based logger implementation that outputs to standard console methods.
+ * Supports structured logging with automatic timestamp injection and context inheritance.
+ *
+ * @implements {Logger}
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });
+ * logger.info({ userId: 123 }, 'User action performed');
+ * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed
+ *
+ * const childLogger = logger.child({ module: 'auth' });
+ * childLogger.debug({ action: 'validate' }, 'Validating token');
+ * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token
+ * ```
+ */
+declare enum LogLevel {
+  Trace = "trace",
+  Debug = "debug",
+  Info = "info",
+  Warn = "warn",
+  Error = "error",
+  Fatal = "fatal",
+  Silent = "silent",
+}
+type CreateLoggerOptions = {
+  pretty?: boolean;
+  level?: LogLevel;
+};
+//#endregion
+export { CreateLoggerOptions, LogFn, LogLevel, Logger };
+//# sourceMappingURL=types-C1RfRbo6.d.mts.map

package/dist/types-DXdmn7h5.d.cts

@@ -0,0 +1,81 @@
+//#region src/types.d.ts
+/**
+ * Logging function type that supports both structured and simple logging.
+ * Can be called with an object for structured logging or just a message string.
+ *
+ * @example
+ * ```typescript
+ * // Structured logging with context object
+ * logger.info({ userId: 123, action: 'login' }, 'User logged in');
+ *
+ * // Simple string logging
+ * logger.info('Application started');
+ * ```
+ */
+type LogFn = {
+  /** Structured logging with context object, optional message, and additional arguments */
+  <T extends object>(obj: T, msg?: string, ...args: any[]): void;
+  /** Simple string logging */
+  (msg: string): void;
+};
+/**
+ * Standard logger interface with multiple log levels and child logger support.
+ * Follows common logging patterns with structured logging capabilities.
+ *
+ * @interface Logger
+ */
+interface Logger {
+  /** Debug level logging - verbose information for debugging */
+  debug: LogFn;
+  /** Info level logging - general informational messages */
+  info: LogFn;
+  /** Warning level logging - potentially harmful situations */
+  warn: LogFn;
+  /** Error level logging - error events that might still allow the application to continue */
+  error: LogFn;
+  /** Fatal level logging - severe errors that will likely cause the application to abort */
+  fatal: LogFn;
+  /** Trace level logging - most detailed information */
+  trace: LogFn;
+  /**
+   * Creates a child logger with additional context.
+   * Child loggers inherit parent context and add their own.
+   *
+   * @param obj - Additional context to include in all child logger calls
+   * @returns A new Logger instance with merged context
+   */
+  child: (obj: object) => Logger;
+}
+/**
+ * Console-based logger implementation that outputs to standard console methods.
+ * Supports structured logging with automatic timestamp injection and context inheritance.
+ *
+ * @implements {Logger}
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });
+ * logger.info({ userId: 123 }, 'User action performed');
+ * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed
+ *
+ * const childLogger = logger.child({ module: 'auth' });
+ * childLogger.debug({ action: 'validate' }, 'Validating token');
+ * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token
+ * ```
+ */
+declare enum LogLevel {
+  Trace = "trace",
+  Debug = "debug",
+  Info = "info",
+  Warn = "warn",
+  Error = "error",
+  Fatal = "fatal",
+  Silent = "silent",
+}
+type CreateLoggerOptions = {
+  pretty?: boolean;
+  level?: LogLevel;
+};
+//#endregion
+export { CreateLoggerOptions, LogFn, LogLevel, Logger };
+//# sourceMappingURL=types-DXdmn7h5.d.cts.map

package/dist/types-ag_0Cvbg.cjs

@@ -0,0 +1,38 @@
+
+//#region src/types.ts
+/**
+* Console-based logger implementation that outputs to standard console methods.
+* Supports structured logging with automatic timestamp injection and context inheritance.
+*
+* @implements {Logger}
+*
+* @example
+* ```typescript
+* const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });
+* logger.info({ userId: 123 }, 'User action performed');
+* // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed
+*
+* const childLogger = logger.child({ module: 'auth' });
+* childLogger.debug({ action: 'validate' }, 'Validating token');
+* // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token
+* ```
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1["Trace"] = "trace";
+	LogLevel$1["Debug"] = "debug";
+	LogLevel$1["Info"] = "info";
+	LogLevel$1["Warn"] = "warn";
+	LogLevel$1["Error"] = "error";
+	LogLevel$1["Fatal"] = "fatal";
+	LogLevel$1["Silent"] = "silent";
+	return LogLevel$1;
+}({});
+
+//#endregion
+Object.defineProperty(exports, 'LogLevel', {
+  enumerable: true,
+  get: function () {
+    return LogLevel;
+  }
+});
+//# sourceMappingURL=types-ag_0Cvbg.cjs.map

package/dist/types-ag_0Cvbg.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-ag_0Cvbg.cjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Logging function type that supports both structured and simple logging.\n * Can be called with an object for structured logging or just a message string.\n *\n * @example\n * ```typescript\n * // Structured logging with context object\n * logger.info({ userId: 123, action: 'login' }, 'User logged in');\n *\n * // Simple string logging\n * logger.info('Application started');\n * ```\n */\nexport type LogFn = {\n  /** Structured logging with context object, optional message, and additional arguments */\n  <T extends object>(obj: T, msg?: string, ...args: any[]): void;\n  /** Simple string logging */\n  (msg: string): void;\n};\n\n/**\n * Standard logger interface with multiple log levels and child logger support.\n * Follows common logging patterns with structured logging capabilities.\n *\n * @interface Logger\n */\nexport interface Logger {\n  /** Debug level logging - verbose information for debugging */\n  debug: LogFn;\n  /** Info level logging - general informational messages */\n  info: LogFn;\n  /** Warning level logging - potentially harmful situations */\n  warn: LogFn;\n  /** Error level logging - error events that might still allow the application to continue */\n  error: LogFn;\n  /** Fatal level logging - severe errors that will likely cause the application to abort */\n  fatal: LogFn;\n  /** Trace level logging - most detailed information */\n  trace: LogFn;\n  /**\n   * Creates a child logger with additional context.\n   * Child loggers inherit parent context and add their own.\n   *\n   * @param obj - Additional context to include in all child logger calls\n   * @returns A new Logger instance with merged context\n   */\n  child: (obj: object) => Logger;\n}\n\n/**\n * Console-based logger implementation that outputs to standard console methods.\n * Supports structured logging with automatic timestamp injection and context inheritance.\n *\n * @implements {Logger}\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });\n * logger.info({ userId: 123 }, 'User action performed');\n * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed\n *\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ action: 'validate' }, 'Validating token');\n * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token\n * ```\n */\nexport enum LogLevel {\n  Trace = 'trace',\n  Debug = 'debug',\n  Info = 'info',\n  Warn = 'warn',\n  Error = 'error',\n  Fatal = 'fatal',\n  Silent = 'silent',\n}\n\nexport type CreateLoggerOptions = {\n  pretty?: boolean;\n  level?: LogLevel;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkEA,IAAY,gDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AACD"}

package/dist/types-yQ6XOihF.mjs

@@ -0,0 +1,32 @@
+//#region src/types.ts
+/**
+* Console-based logger implementation that outputs to standard console methods.
+* Supports structured logging with automatic timestamp injection and context inheritance.
+*
+* @implements {Logger}
+*
+* @example
+* ```typescript
+* const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });
+* logger.info({ userId: 123 }, 'User action performed');
+* // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed
+*
+* const childLogger = logger.child({ module: 'auth' });
+* childLogger.debug({ action: 'validate' }, 'Validating token');
+* // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token
+* ```
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1["Trace"] = "trace";
+	LogLevel$1["Debug"] = "debug";
+	LogLevel$1["Info"] = "info";
+	LogLevel$1["Warn"] = "warn";
+	LogLevel$1["Error"] = "error";
+	LogLevel$1["Fatal"] = "fatal";
+	LogLevel$1["Silent"] = "silent";
+	return LogLevel$1;
+}({});
+
+//#endregion
+export { LogLevel };
+//# sourceMappingURL=types-yQ6XOihF.mjs.map

package/dist/types-yQ6XOihF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-yQ6XOihF.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Logging function type that supports both structured and simple logging.\n * Can be called with an object for structured logging or just a message string.\n *\n * @example\n * ```typescript\n * // Structured logging with context object\n * logger.info({ userId: 123, action: 'login' }, 'User logged in');\n *\n * // Simple string logging\n * logger.info('Application started');\n * ```\n */\nexport type LogFn = {\n  /** Structured logging with context object, optional message, and additional arguments */\n  <T extends object>(obj: T, msg?: string, ...args: any[]): void;\n  /** Simple string logging */\n  (msg: string): void;\n};\n\n/**\n * Standard logger interface with multiple log levels and child logger support.\n * Follows common logging patterns with structured logging capabilities.\n *\n * @interface Logger\n */\nexport interface Logger {\n  /** Debug level logging - verbose information for debugging */\n  debug: LogFn;\n  /** Info level logging - general informational messages */\n  info: LogFn;\n  /** Warning level logging - potentially harmful situations */\n  warn: LogFn;\n  /** Error level logging - error events that might still allow the application to continue */\n  error: LogFn;\n  /** Fatal level logging - severe errors that will likely cause the application to abort */\n  fatal: LogFn;\n  /** Trace level logging - most detailed information */\n  trace: LogFn;\n  /**\n   * Creates a child logger with additional context.\n   * Child loggers inherit parent context and add their own.\n   *\n   * @param obj - Additional context to include in all child logger calls\n   * @returns A new Logger instance with merged context\n   */\n  child: (obj: object) => Logger;\n}\n\n/**\n * Console-based logger implementation that outputs to standard console methods.\n * Supports structured logging with automatic timestamp injection and context inheritance.\n *\n * @implements {Logger}\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });\n * logger.info({ userId: 123 }, 'User action performed');\n * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed\n *\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ action: 'validate' }, 'Validating token');\n * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token\n * ```\n */\nexport enum LogLevel {\n  Trace = 'trace',\n  Debug = 'debug',\n  Info = 'info',\n  Warn = 'warn',\n  Error = 'error',\n  Fatal = 'fatal',\n  Silent = 'silent',\n}\n\nexport type CreateLoggerOptions = {\n  pretty?: boolean;\n  level?: LogLevel;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkEA,IAAY,gDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AACD"}

package/dist/types.cjs

@@ -0,0 +1,3 @@
+const require_types = require('./types-ag_0Cvbg.cjs');
+
+exports.LogLevel = require_types.LogLevel;

package/dist/types.d.cts

@@ -0,0 +1,2 @@
+import { CreateLoggerOptions, LogFn, LogLevel, Logger } from "./types-DXdmn7h5.cjs";
+export { CreateLoggerOptions, LogFn, LogLevel, Logger };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { CreateLoggerOptions, LogFn, LogLevel, Logger } from "./types-C1RfRbo6.mjs";
+export { CreateLoggerOptions, LogFn, LogLevel, Logger };

package/dist/types.mjs

@@ -0,0 +1,3 @@
+import { LogLevel } from "./types-yQ6XOihF.mjs";
+
+export { LogLevel };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@geekmidas/logger",
+  "version": "0.0.1",
+  "description": "A simple and flexible logging library for Node.js and the browser",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./pino": {
+      "types": "./dist/pino.d.ts",
+      "import": "./dist/pino.mjs",
+      "require": "./dist/pino.cjs"
+    },
+    "./console": {
+      "types": "./dist/console.d.ts",
+      "import": "./dist/console.mjs",
+      "require": "./dist/console.cjs"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "peerDependencies": {
+    "pino-pretty": "~13.1.2",
+    "pino": "~10.0.0"
+  }
+}