@geekmidas/logger 10.0.0-alpha.99 → 10.0.0

package/dist/redact-paths.mjs

@@ -1,114 +1,3 @@
-//#region src/redact-paths.ts
-/**
-* Default sensitive field paths for redaction.
-*
-* These paths are automatically used when `redact: true` is set,
-* and merged with custom paths unless `resolution: 'override'` is specified.
-*
-* Includes:
-* - Authentication: password, token, apiKey, authorization, credentials
-* - Headers: authorization, cookie, x-api-key, x-auth-token
-* - Personal data: ssn, creditCard, cvv, pin
-* - Secrets: secret, connectionString, databaseUrl
-* - Wildcards: *.password, *.secret, *.token (catches nested fields)
-*/
-const DEFAULT_REDACT_PATHS = [
-	"password",
-	"pass",
-	"passwd",
-	"secret",
-	"token",
-	"accessToken",
-	"refreshToken",
-	"idToken",
-	"apiKey",
-	"api_key",
-	"apikey",
-	"auth",
-	"authorization",
-	"credential",
-	"credentials",
-	"*.password",
-	"*.secret",
-	"*.token",
-	"*.apiKey",
-	"*.api_key",
-	"*.authorization",
-	"*.accessToken",
-	"*.refreshToken",
-	"headers.authorization",
-	"headers.Authorization",
-	"headers[\"authorization\"]",
-	"headers[\"Authorization\"]",
-	"headers.cookie",
-	"headers.Cookie",
-	"headers[\"x-api-key\"]",
-	"headers[\"X-Api-Key\"]",
-	"headers[\"x-auth-token\"]",
-	"headers[\"X-Auth-Token\"]",
-	"ssn",
-	"socialSecurityNumber",
-	"social_security_number",
-	"creditCard",
-	"credit_card",
-	"cardNumber",
-	"card_number",
-	"cvv",
-	"cvc",
-	"pin",
-	"connectionString",
-	"connection_string",
-	"databaseUrl",
-	"database_url"
-];
-/**
-* `scheme://user:password@` — the userinfo of a URL that carries a secret.
-* A user with no password (`ssh://git@host`) names nobody's secret and is left
-* alone.
-*/
-const URL_CREDENTIALS = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/?#@:]*:[^\s/?#@]*@/gi;
-/**
-* Replace the credentials of every URL in `text` with `REDACTED`, so
-* `s3://KEY:SECRET@uploads` is logged as `s3://REDACTED@uploads`.
-*
-* Path redaction cannot catch these: a URL turns up under any field name —
-* `url`, `origin`, `endpoint` — or inside a message, and blanking every such
-* field would hide the half of it that is useful.
-*/
-function redactUrlCredentials(text) {
-	return text.replace(URL_CREDENTIALS, "$1REDACTED@");
-}
-/** Deep enough for a log object; past it, values are logged as they are. */
-const MAX_DEPTH = 6;
-/**
-* A copy of `value` with {@link redactUrlCredentials} applied to every string
-* in it. Objects and arrays without such a string are returned as they were.
-*/
-function redactUrlCredentialsIn(value, depth = 0) {
-	if (typeof value === "string") return redactUrlCredentials(value);
-	if (depth >= MAX_DEPTH || value === null || typeof value !== "object") return value;
-	if (Array.isArray(value)) {
-		let changed = false;
-		const next = value.map((item) => {
-			const redacted = redactUrlCredentialsIn(item, depth + 1);
-			if (redacted !== item) changed = true;
-			return redacted;
-		});
-		return changed ? next : value;
-	}
-	const proto = Object.getPrototypeOf(value);
-	if (proto !== Object.prototype && proto !== null) return value;
-	let next;
-	for (const [key, item] of Object.entries(value)) {
-		const redacted = redactUrlCredentialsIn(item, depth + 1);
-		if (redacted !== item) {
-			next ??= { ...value };
-			next[key] = redacted;
-		}
-	}
-	return next ?? value;
-}
-//#endregion
-export { DEFAULT_REDACT_PATHS, redactUrlCredentials, redactUrlCredentialsIn };
+import { DEFAULT_REDACT_PATHS } from "./redact-paths-DQoIXhkS.mjs";
 
-//# sourceMappingURL=redact-paths.mjs.map
+export { DEFAULT_REDACT_PATHS };

package/dist/types-BDdpcrpy.d.mts

@@ -0,0 +1,166 @@
+//#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",
+}
+/**
+ * Redaction configuration for masking sensitive data in logs.
+ * Uses pino's fast-redact library under the hood.
+ *
+ * By default, custom paths are merged with the default sensitive paths.
+ * Use `resolution: 'override'` to use only your custom paths.
+ *
+ * @example
+ * ```typescript
+ * // Simple path array (merges with defaults)
+ * redact: ['user.ssn', 'custom.field']
+ *
+ * // Override defaults completely
+ * redact: {
+ *   paths: ['only.these.paths'],
+ *   resolution: 'override',
+ * }
+ *
+ * // With custom censor
+ * redact: {
+ *   paths: ['extra.secret'],
+ *   censor: '***',
+ * }
+ *
+ * // Remove fields entirely
+ * redact: {
+ *   paths: ['temporary.data'],
+ *   remove: true,
+ * }
+ * ```
+ */
+type RedactOptions = string[] | {
+  /** Paths to redact using dot notation or bracket notation for special chars */
+  paths: string[];
+  /** Custom replacement text (default: '[REDACTED]') */
+  censor?: string | ((value: unknown, path: string[]) => unknown);
+  /** Remove the field entirely instead of replacing (default: false) */
+  remove?: boolean;
+  /**
+   * How to combine custom paths with default sensitive paths.
+   * - 'merge': Custom paths are added to default paths (default)
+   * - 'override': Only custom paths are used, defaults are ignored
+   */
+  resolution?: 'merge' | 'override';
+};
+type CreateLoggerOptions = {
+  /** Enable pretty printing with colors (disabled in production) */
+  pretty?: boolean;
+  /** Minimum log level to output */
+  level?: LogLevel;
+  /**
+   * Redaction configuration for masking sensitive data.
+   *
+   * - `true`: Uses default sensitive paths (password, token, secret, etc.)
+   * - `false` or `undefined`: No redaction applied
+   * - `string[]`: Custom paths merged with defaults
+   * - `object`: Advanced config with paths, censor, remove, and resolution options
+   *
+   * By default, custom paths are **merged** with the default sensitive paths.
+   * Use `resolution: 'override'` to disable defaults and use only your paths.
+   *
+   * @example
+   * ```typescript
+   * // Use defaults only
+   * createLogger({ redact: true });
+   *
+   * // Add custom paths (merged with defaults)
+   * createLogger({ redact: ['user.ssn', 'custom.field'] });
+   *
+   * // Override defaults completely
+   * createLogger({
+   *   redact: {
+   *     paths: ['only.these.paths'],
+   *     resolution: 'override',
+   *   }
+   * });
+   *
+   * // Merge with custom censor
+   * createLogger({
+   *   redact: {
+   *     paths: ['extra.secret'],
+   *     censor: '***',
+   *   }
+   * });
+   * ```
+   */
+  redact?: boolean | RedactOptions;
+};
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+export { CreateLoggerOptions, LogFn, LogLevel, Logger, RedactOptions };
+//# sourceMappingURL=types-BDdpcrpy.d.mts.map

package/dist/types-BDdpcrpy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BDdpcrpy.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;AAaA;AAaA;;;;;;;;;AAoB+B;AAoB/B;AAyCY,KA9FA,KAAA,GA8Fa;EAiBb;EAAmB,CAAA,UAAA,MAAA,CAAA,CAAA,GAAA,EA7GN,CA6GM,EAAA,GAAA,CAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,GAAA,EAAA,CAAA,EAAA,IAAA;EAAA;EAId,CAAA,GAqCG,EAAA,MAAA,CAAA,EAAA,IAAA;AAAa,CAAA;;;;;;;UA3IhB,MAAA;;SAET;;QAED;;QAEA;;SAEC;;SAEA;;SAEA;;;;;;;;0BAQiB;;;;;;;;;;;;;;;;;;;aAoBb,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyCA,aAAA;;;;;;;;;;;;;;KAiBA,mBAAA;;;;UAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCW"}

package/dist/types-Dk_k2-f_.d.cts

@@ -0,0 +1,166 @@
+//#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",
+}
+/**
+ * Redaction configuration for masking sensitive data in logs.
+ * Uses pino's fast-redact library under the hood.
+ *
+ * By default, custom paths are merged with the default sensitive paths.
+ * Use `resolution: 'override'` to use only your custom paths.
+ *
+ * @example
+ * ```typescript
+ * // Simple path array (merges with defaults)
+ * redact: ['user.ssn', 'custom.field']
+ *
+ * // Override defaults completely
+ * redact: {
+ *   paths: ['only.these.paths'],
+ *   resolution: 'override',
+ * }
+ *
+ * // With custom censor
+ * redact: {
+ *   paths: ['extra.secret'],
+ *   censor: '***',
+ * }
+ *
+ * // Remove fields entirely
+ * redact: {
+ *   paths: ['temporary.data'],
+ *   remove: true,
+ * }
+ * ```
+ */
+type RedactOptions = string[] | {
+  /** Paths to redact using dot notation or bracket notation for special chars */
+  paths: string[];
+  /** Custom replacement text (default: '[REDACTED]') */
+  censor?: string | ((value: unknown, path: string[]) => unknown);
+  /** Remove the field entirely instead of replacing (default: false) */
+  remove?: boolean;
+  /**
+   * How to combine custom paths with default sensitive paths.
+   * - 'merge': Custom paths are added to default paths (default)
+   * - 'override': Only custom paths are used, defaults are ignored
+   */
+  resolution?: 'merge' | 'override';
+};
+type CreateLoggerOptions = {
+  /** Enable pretty printing with colors (disabled in production) */
+  pretty?: boolean;
+  /** Minimum log level to output */
+  level?: LogLevel;
+  /**
+   * Redaction configuration for masking sensitive data.
+   *
+   * - `true`: Uses default sensitive paths (password, token, secret, etc.)
+   * - `false` or `undefined`: No redaction applied
+   * - `string[]`: Custom paths merged with defaults
+   * - `object`: Advanced config with paths, censor, remove, and resolution options
+   *
+   * By default, custom paths are **merged** with the default sensitive paths.
+   * Use `resolution: 'override'` to disable defaults and use only your paths.
+   *
+   * @example
+   * ```typescript
+   * // Use defaults only
+   * createLogger({ redact: true });
+   *
+   * // Add custom paths (merged with defaults)
+   * createLogger({ redact: ['user.ssn', 'custom.field'] });
+   *
+   * // Override defaults completely
+   * createLogger({
+   *   redact: {
+   *     paths: ['only.these.paths'],
+   *     resolution: 'override',
+   *   }
+   * });
+   *
+   * // Merge with custom censor
+   * createLogger({
+   *   redact: {
+   *     paths: ['extra.secret'],
+   *     censor: '***',
+   *   }
+   * });
+   * ```
+   */
+  redact?: boolean | RedactOptions;
+};
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+export { CreateLoggerOptions, LogFn, LogLevel, Logger, RedactOptions };
+//# sourceMappingURL=types-Dk_k2-f_.d.cts.map

package/dist/types-Dk_k2-f_.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Dk_k2-f_.d.cts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;AAaA;AAaA;;;;;;;;;AAoB+B;AAoB/B;AAyCY,KA9FA,KAAA,GA8Fa;EAiBb;EAAmB,CAAA,UAAA,MAAA,CAAA,CAAA,GAAA,EA7GN,CA6GM,EAAA,GAAA,CAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,GAAA,EAAA,CAAA,EAAA,IAAA;EAAA;EAId,CAAA,GAqCG,EAAA,MAAA,CAAA,EAAA,IAAA;AAAa,CAAA;;;;;;;UA3IhB,MAAA;;SAET;;QAED;;QAEA;;SAEC;;SAEA;;SAEA;;;;;;;;0BAQiB;;;;;;;;;;;;;;;;;;;aAoBb,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyCA,aAAA;;;;;;;;;;;;;;KAiBA,mBAAA;;;;UAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCW"}

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\t/** Structured logging with context object, optional message, and additional arguments */\n\t<T extends object>(obj: T, msg?: string, ...args: any[]): void;\n\t/** Simple string logging */\n\t(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\t/** Debug level logging - verbose information for debugging */\n\tdebug: LogFn;\n\t/** Info level logging - general informational messages */\n\tinfo: LogFn;\n\t/** Warning level logging - potentially harmful situations */\n\twarn: LogFn;\n\t/** Error level logging - error events that might still allow the application to continue */\n\terror: LogFn;\n\t/** Fatal level logging - severe errors that will likely cause the application to abort */\n\tfatal: LogFn;\n\t/** Trace level logging - most detailed information */\n\ttrace: LogFn;\n\t/**\n\t * Creates a child logger with additional context.\n\t * Child loggers inherit parent context and add their own.\n\t *\n\t * @param obj - Additional context to include in all child logger calls\n\t * @returns A new Logger instance with merged context\n\t */\n\tchild: (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\tTrace = 'trace',\n\tDebug = 'debug',\n\tInfo = 'info',\n\tWarn = 'warn',\n\tError = 'error',\n\tFatal = 'fatal',\n\tSilent = 'silent',\n}\n\n/**\n * Redaction configuration for masking sensitive data in logs.\n * Uses pino's fast-redact library under the hood.\n *\n * By default, custom paths are merged with the default sensitive paths.\n * Use `resolution: 'override'` to use only your custom paths.\n *\n * @example\n * ```typescript\n * // Simple path array (merges with defaults)\n * redact: ['user.ssn', 'custom.field']\n *\n * // Override defaults completely\n * redact: {\n *   paths: ['only.these.paths'],\n *   resolution: 'override',\n * }\n *\n * // With custom censor\n * redact: {\n *   paths: ['extra.secret'],\n *   censor: '***',\n * }\n *\n * // Remove fields entirely\n * redact: {\n *   paths: ['temporary.data'],\n *   remove: true,\n * }\n * ```\n */\nexport type RedactOptions =\n\t| string[]\n\t| {\n\t\t\t/** Paths to redact using dot notation or bracket notation for special chars */\n\t\t\tpaths: string[];\n\t\t\t/** Custom replacement text (default: '[REDACTED]') */\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\t/** Remove the field entirely instead of replacing (default: false) */\n\t\t\tremove?: boolean;\n\t\t\t/**\n\t\t\t * How to combine custom paths with default sensitive paths.\n\t\t\t * - 'merge': Custom paths are added to default paths (default)\n\t\t\t * - 'override': Only custom paths are used, defaults are ignored\n\t\t\t */\n\t\t\tresolution?: 'merge' | 'override';\n\t  };\n\nexport type CreateLoggerOptions = {\n\t/** Enable pretty printing with colors (disabled in production) */\n\tpretty?: boolean;\n\t/** Minimum log level to output */\n\tlevel?: LogLevel;\n\t/**\n\t * Redaction configuration for masking sensitive data.\n\t *\n\t * - `true`: Uses default sensitive paths (password, token, secret, etc.)\n\t * - `false` or `undefined`: No redaction applied\n\t * - `string[]`: Custom paths merged with defaults\n\t * - `object`: Advanced config with paths, censor, remove, and resolution options\n\t *\n\t * By default, custom paths are **merged** with the default sensitive paths.\n\t * Use `resolution: 'override'` to disable defaults and use only your paths.\n\t *\n\t * @example\n\t * ```typescript\n\t * // Use defaults only\n\t * createLogger({ redact: true });\n\t *\n\t * // Add custom paths (merged with defaults)\n\t * createLogger({ redact: ['user.ssn', 'custom.field'] });\n\t *\n\t * // Override defaults completely\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['only.these.paths'],\n\t *     resolution: 'override',\n\t *   }\n\t * });\n\t *\n\t * // Merge with custom censor\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['extra.secret'],\n\t *     censor: '***',\n\t *   }\n\t * });\n\t * ```\n\t */\n\tredact?: boolean | RedactOptions;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkEA,IAAY,gDAAL;AACN;AACA;AACA;AACA;AACA;AACA;AACA;;AACA"}

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\t/** Structured logging with context object, optional message, and additional arguments */\n\t<T extends object>(obj: T, msg?: string, ...args: any[]): void;\n\t/** Simple string logging */\n\t(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\t/** Debug level logging - verbose information for debugging */\n\tdebug: LogFn;\n\t/** Info level logging - general informational messages */\n\tinfo: LogFn;\n\t/** Warning level logging - potentially harmful situations */\n\twarn: LogFn;\n\t/** Error level logging - error events that might still allow the application to continue */\n\terror: LogFn;\n\t/** Fatal level logging - severe errors that will likely cause the application to abort */\n\tfatal: LogFn;\n\t/** Trace level logging - most detailed information */\n\ttrace: LogFn;\n\t/**\n\t * Creates a child logger with additional context.\n\t * Child loggers inherit parent context and add their own.\n\t *\n\t * @param obj - Additional context to include in all child logger calls\n\t * @returns A new Logger instance with merged context\n\t */\n\tchild: (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\tTrace = 'trace',\n\tDebug = 'debug',\n\tInfo = 'info',\n\tWarn = 'warn',\n\tError = 'error',\n\tFatal = 'fatal',\n\tSilent = 'silent',\n}\n\n/**\n * Redaction configuration for masking sensitive data in logs.\n * Uses pino's fast-redact library under the hood.\n *\n * By default, custom paths are merged with the default sensitive paths.\n * Use `resolution: 'override'` to use only your custom paths.\n *\n * @example\n * ```typescript\n * // Simple path array (merges with defaults)\n * redact: ['user.ssn', 'custom.field']\n *\n * // Override defaults completely\n * redact: {\n *   paths: ['only.these.paths'],\n *   resolution: 'override',\n * }\n *\n * // With custom censor\n * redact: {\n *   paths: ['extra.secret'],\n *   censor: '***',\n * }\n *\n * // Remove fields entirely\n * redact: {\n *   paths: ['temporary.data'],\n *   remove: true,\n * }\n * ```\n */\nexport type RedactOptions =\n\t| string[]\n\t| {\n\t\t\t/** Paths to redact using dot notation or bracket notation for special chars */\n\t\t\tpaths: string[];\n\t\t\t/** Custom replacement text (default: '[REDACTED]') */\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\t/** Remove the field entirely instead of replacing (default: false) */\n\t\t\tremove?: boolean;\n\t\t\t/**\n\t\t\t * How to combine custom paths with default sensitive paths.\n\t\t\t * - 'merge': Custom paths are added to default paths (default)\n\t\t\t * - 'override': Only custom paths are used, defaults are ignored\n\t\t\t */\n\t\t\tresolution?: 'merge' | 'override';\n\t  };\n\nexport type CreateLoggerOptions = {\n\t/** Enable pretty printing with colors (disabled in production) */\n\tpretty?: boolean;\n\t/** Minimum log level to output */\n\tlevel?: LogLevel;\n\t/**\n\t * Redaction configuration for masking sensitive data.\n\t *\n\t * - `true`: Uses default sensitive paths (password, token, secret, etc.)\n\t * - `false` or `undefined`: No redaction applied\n\t * - `string[]`: Custom paths merged with defaults\n\t * - `object`: Advanced config with paths, censor, remove, and resolution options\n\t *\n\t * By default, custom paths are **merged** with the default sensitive paths.\n\t * Use `resolution: 'override'` to disable defaults and use only your paths.\n\t *\n\t * @example\n\t * ```typescript\n\t * // Use defaults only\n\t * createLogger({ redact: true });\n\t *\n\t * // Add custom paths (merged with defaults)\n\t * createLogger({ redact: ['user.ssn', 'custom.field'] });\n\t *\n\t * // Override defaults completely\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['only.these.paths'],\n\t *     resolution: 'override',\n\t *   }\n\t * });\n\t *\n\t * // Merge with custom censor\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['extra.secret'],\n\t *     censor: '***',\n\t *   }\n\t * });\n\t * ```\n\t */\n\tredact?: boolean | RedactOptions;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkEA,IAAY,gDAAL;AACN;AACA;AACA;AACA;AACA;AACA;AACA;;AACA"}

package/dist/types.cjs

@@ -1,33 +1,3 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#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) {
-	LogLevel["Trace"] = "trace";
-	LogLevel["Debug"] = "debug";
-	LogLevel["Info"] = "info";
-	LogLevel["Warn"] = "warn";
-	LogLevel["Error"] = "error";
-	LogLevel["Fatal"] = "fatal";
-	LogLevel["Silent"] = "silent";
-	return LogLevel;
-}({});
-//#endregion
-exports.LogLevel = LogLevel;
+const require_types = require('./types-ag_0Cvbg.cjs');
 
-//# sourceMappingURL=types.cjs.map
+exports.LogLevel = require_types.LogLevel;