@rx-ted/packages-logger 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ben
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# @rx-ted/logger
+
+A lightweight logging library with modular architecture — Logger, Handler, and Formatter separation. Supports multiple handlers, child loggers, and file rotation.
+
+## Features
+
+- **Modular Architecture**: Logger → Handler → Formatter separation
+- **Multiple Handlers**: Console and File handlers with independent configuration
+- **Child Loggers**: Inheritance with scope-based namespaces
+- **File Rotation**: Auto-dated filenames with max file count limits
+- **Dual Formatters**: JSON and TEXT formats
+- **Multi-Runtime**: Works with Bun, Node.js, Deno, and Cloudflare Workers
+
+## Install
+
+```bash
+pnpm add @rx-ted/logger
+```
+
+## Quick Start
+
+```typescript
+import { Logger } from "@rx-ted/logger";
+
+const logger = new Logger({ name: "app" });
+
+logger.info("Hello World");
+logger.debug("Debug info", { userId: 123 });
+logger.warn("Warning message");
+logger.error("Error occurred", { code: "ERR_001" });
+```
+
+## Logger Options
+
+| Option      | Type                                     | Default   | Description            |
+| ----------- | ---------------------------------------- | --------- | ---------------------- |
+| `name`      | `string`                                 | `'app'`   | Logger namespace       |
+| `scope`     | `string`                                 | -         | Child logger scope     |
+| `level`     | `'debug' \| 'info' \| 'warn' \| 'error'` | `'info'`  | Log level              |
+| `handlers`  | `HandlerConfig[]`                        | `console` | Handler configurations |
+| `propagate` | `boolean`                                | `true`    | Propagate to parent    |
+| `onError`   | `(err: LogError) => void`                | -         | Error callback         |
+
+## Handlers
+
+### Console Handler
+
+```typescript
+const logger = new Logger({
+  name: "app",
+  handlers: [
+    {
+      type: "console",
+      level: "debug",
+      formatter: {
+        type: "text",
+        template: "[{time}] [{level}] {namespace}: {message}",
+        colors: true,
+      },
+    },
+  ],
+});
+```
+
+### File Handler
+
+```typescript
+const logger = new Logger({
+  name: "app",
+  handlers: [
+    {
+      type: "file",
+      level: "info",
+      formatter: { type: "json" }, // or 'text'
+      maxSize: "10MB", // default: 10MB
+      maxFiles: 7, // default: 7
+    },
+  ],
+});
+```
+
+File handler features:
+
+- Auto-dated filenames: `app.2026-04-20.json`
+- Automatic old file cleanup when exceeding `maxFiles`
+- Automatic date rollover at midnight
+
+## Child Loggers
+
+```typescript
+const logger = new Logger({ name: "app" });
+
+const child = logger.child("module");
+
+console.log(child.namespace); // "app.module"
+```
+
+Child loggers:
+
+- Inherit parent's handlers by default
+- Inherit parent's level
+- Disable propagation by default (set `propagate: true` to enable)
+- Require `scope` option (cannot use `name`)
+
+## Methods
+
+- `debug(message, context?)` - Debug level
+- `info(message, context?)` - Info level
+- `warn(message, context?)` - Warning level
+- `error(message, context?)` - Error level
+- `child(scope, options?)` - Create child logger
+- `setLevel(level)` - Change log level
+- `addHandler(handler)` - Add handler
+- `close()` - Close all handlers
+
+## Error Handling
+
+```typescript
+const logger = new Logger({
+  name: "app",
+  handlers: [
+    {
+      type: "file",
+      onError: (err) => {
+        console.error("Handler error:", err.error);
+      },
+    },
+  ],
+  onError: (err) => {
+    console.error("Logger error:", err.error);
+  },
+});
+```
+
+## Runtime Notes
+
+- File handler is automatically disabled in Cloudflare Workers environment
+- Supports Bun, Node.js, and Deno runtimes
+
+## Testing
+
+```bash
+pnpm test          # Run tests
+pnpm test:coverage     # Run with coverage
+```

package/dist/index.cjs

@@ -0,0 +1,424 @@
+'use strict';
+
+var stdEnv = require('std-env');
+
+// src/formatter/json.ts
+var JsonFormatter = class {
+  fields;
+  constructor(config = { type: "json" }) {
+    this.fields = config.fields ?? [];
+  }
+  format(entry) {
+    const output = {
+      ...entry.context,
+      level: entry.level,
+      time: entry.time,
+      namespace: entry.namespace,
+      message: entry.message
+    };
+    for (const field of this.fields) {
+      if (entry[field] !== void 0) {
+        output[field] = entry[field];
+      }
+    }
+    return JSON.stringify(output);
+  }
+};
+
+// src/formatter/text.ts
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var GRAY = "\x1B[90m";
+var colors = {
+  debug: GRAY,
+  info: BLUE,
+  warn: YELLOW,
+  error: RED
+};
+var TextFormatter = class {
+  template;
+  colors;
+  constructor(config) {
+    this.template = config.template ?? "[{time}] [{level}] {namespace}: {message}";
+    this.colors = config.colors ?? true;
+  }
+  format(entry) {
+    let message = this.template.replace(/{time}/g, entry.time).replace(/{level}/g, entry.level).replace(/{namespace}/g, entry.namespace).replace(/{message}/g, entry.message);
+    if (entry.context) {
+      message += ` ${JSON.stringify(entry.context)}`;
+    }
+    if (this.colors) {
+      const color = colors[entry.level] ?? "";
+      return `${color}${message}${RESET}`;
+    }
+    return message;
+  }
+};
+
+// src/formatter/index.ts
+function createFormatter(config) {
+  if (config.type === "json") {
+    return new JsonFormatter(config);
+  }
+  return new TextFormatter(config);
+}
+var formatters = {
+  json: () => new JsonFormatter({ type: "json" }),
+  consoleText: () => new TextFormatter({
+    type: "text",
+    template: "[{time}] [{level}] {namespace}: {message}",
+    colors: true
+  }),
+  fileText: () => new TextFormatter({
+    type: "text",
+    template: "[{time}] [{level}] {namespace}: {message}",
+    colors: false
+  })
+};
+
+// src/levels.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function shouldLog(level, minLevel) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+}
+function normalizeLevel(level) {
+  if (!level) return "info";
+  const normalized = level.toLowerCase();
+  if (normalized === "debug" || normalized === "info" || normalized === "warn" || normalized === "error") {
+    return normalized;
+  }
+  return "info";
+}
+
+// src/handler/console.ts
+var ConsoleHandler = class {
+  level;
+  formatter;
+  onError;
+  constructor(config) {
+    this.level = config.level ?? "debug";
+    this.onError = config.onError;
+    this.formatter = createFormatter(
+      config.formatter ?? {
+        type: "text",
+        template: "[{time}] [{level}] {namespace}: {message}",
+        colors: true
+      }
+    );
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  write(entry) {
+    if (!shouldLog(entry.level, this.level)) return;
+    const output = this.formatter.format(entry);
+    if (entry.level === "warn") {
+      console.warn(output);
+    } else if (entry.level === "error") {
+      console.error(output);
+    } else {
+      console.log(output);
+    }
+  }
+  async close() {
+  }
+  notifyError(err) {
+    if (this.onError) {
+      this.onError(err);
+    }
+  }
+};
+
+// src/handler/file.ts
+function parseSize(size) {
+  const match = size.match(/^(\d+)(MB|KB)?$/i);
+  if (!match) return 10 * 1024 * 1024;
+  const value = Number.parseInt(match[1], 10);
+  const unit = match[2]?.toUpperCase() || "MB";
+  return unit === "KB" ? value * 1024 : value * 1024 * 1024;
+}
+var FileHandler = class {
+  constructor(config, namespace) {
+    this.config = config;
+    this.level = config.level ?? "debug";
+    this.onError = config.onError;
+    this.formatter = createFormatter(config.formatter ?? { type: "json" });
+    this.maxFiles = config.maxFiles ?? 7;
+    this.prefix = namespace.replace(/\./g, "-");
+    this.ext = this.config.formatter?.type === "text" ? "log" : "jsonl";
+    this.baseDir = "./logs";
+    this.currentPath = this.getTodayPath();
+  }
+  config;
+  level;
+  formatter;
+  buffer = [];
+  timer;
+  size = 0;
+  closed = false;
+  currentPath;
+  maxFiles;
+  baseDir;
+  prefix;
+  ext;
+  onError;
+  getTodayPath() {
+    const now = /* @__PURE__ */ new Date();
+    const date = now.toISOString().split("T")[0];
+    return `${this.baseDir}/${this.prefix}.${date}.${this.ext}`;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  write(entry) {
+    if (this.closed || !shouldLog(entry.level, this.level)) return;
+    const now = /* @__PURE__ */ new Date();
+    const today = now.toISOString().split("T")[0];
+    if (!this.currentPath.includes(today)) {
+      this.currentPath = `${this.baseDir}/${this.prefix}.${today}.${this.ext}`;
+    }
+    const output = `${this.formatter.format(entry)}
+`;
+    this.buffer.push(output);
+    this.size += output.length;
+    if (!this.timer) {
+      this.timer = setTimeout(async () => {
+        this.timer = void 0;
+        await this.flush();
+      }, 1e3);
+    }
+    if (this.size >= parseSize(this.config.maxSize ?? "10MB")) {
+      this.flush().catch(() => {
+      });
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0 || this.closed) return;
+    const content = this.buffer.join("");
+    this.buffer = [];
+    this.size = 0;
+    await this.writeToFile(content);
+    await this.cleanupOldFiles();
+  }
+  async ensureDir() {
+    try {
+      const Bun = globalThis.Bun;
+      const Deno = globalThis.Deno;
+      if (Bun) {
+        Bun.mkdir(this.baseDir, { recursive: true });
+      } else if (Deno) {
+        await Deno.mkdir(this.baseDir, { recursive: true });
+      } else {
+        const fs = await import('fs/promises');
+        await fs.mkdir(this.baseDir, { recursive: true });
+      }
+    } catch (err) {
+      console.error("Failed to create log directory:", err);
+    }
+  }
+  async writeToFile(content) {
+    await this.ensureDir();
+    try {
+      const Bun = globalThis.Bun;
+      const Deno = globalThis.Deno;
+      if (Bun) {
+        Bun.write(this.currentPath, content, { flag: "a" });
+      } else if (Deno) {
+        await Deno.writeTextFile(this.currentPath, content);
+      } else {
+        const fs = await import('fs/promises');
+        await fs.writeFile(this.currentPath, content, { flag: "a" });
+      }
+    } catch (err) {
+      console.error("Failed to write to log file:", err);
+    }
+  }
+  async cleanupOldFiles() {
+    try {
+      const Bun = globalThis.Bun;
+      const Deno = globalThis.Deno;
+      let files;
+      if (Bun) {
+        const entries = Bun.readdir(this.baseDir);
+        files = entries.filter((f) => f.startsWith(this.prefix)).sort();
+      } else if (Deno) {
+        const entries = await Deno.readDir(this.baseDir);
+        files = [];
+        for await (const entry of entries) {
+          if (entry.isFile && entry.name.startsWith(this.prefix)) {
+            files.push(entry.name);
+          }
+        }
+        files.sort();
+      } else {
+        const fs = await import('fs/promises');
+        const entries = await fs.readdir(this.baseDir);
+        files = entries.filter((f) => f.startsWith(this.prefix)).sort();
+      }
+      while (files.length >= this.maxFiles) {
+        const oldest = files.shift();
+        if (oldest) {
+          const filePath = `${this.baseDir}/${oldest}`;
+          if (Bun) {
+            Bun.remove(filePath);
+          } else if (Deno) {
+            await Deno.remove(filePath);
+          } else {
+            const fs = await import('fs/promises');
+            await fs.unlink(filePath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async close() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    const content = this.buffer.join("");
+    this.buffer = [];
+    this.size = 0;
+    this.closed = true;
+    if (content) {
+      await this.writeToFile(content);
+    }
+  }
+  notifyError(err) {
+    if (this.onError) {
+      this.onError(err);
+    }
+  }
+};
+
+// src/handler/index.ts
+function createHandler(config, namespace) {
+  if (config.type === "console") {
+    return new ConsoleHandler(config);
+  }
+  return new FileHandler(config, namespace);
+}
+var Logger = class _Logger {
+  namespace;
+  level;
+  handlers;
+  propagate;
+  parent;
+  onError;
+  constructor(options = {}) {
+    const parent = options.logger instanceof _Logger ? options.logger : void 0;
+    const isChild = !!parent;
+    if (parent && options.name) {
+      throw new Error(
+        'Cannot use "name" when creating child logger with parent. Use "scope" only.'
+      );
+    }
+    this.level = options.level ?? parent?.level ?? "info";
+    this.propagate = isChild ? false : options.propagate ?? true;
+    this.parent = parent;
+    this.onError = options.onError;
+    if (parent) {
+      if (!options.scope) {
+        throw new Error('Child logger requires "scope" option.');
+      }
+      this.namespace = `${parent.namespace}.${options.scope}`;
+    } else {
+      this.namespace = options.name ?? options.scope ?? "app";
+    }
+    if (isChild) {
+      this.handlers = parent?.handlers ?? [];
+    } else {
+      const configs = options.handlers ?? [{ type: "console" }];
+      this.handlers = configs.filter((c) => c.type !== "file" || !stdEnv.isWorkerd).map((config) => createHandler(config, this.namespace));
+    }
+  }
+  child(scope, options) {
+    return new _Logger({
+      ...options,
+      scope,
+      logger: this
+    });
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  log(level, args) {
+    if (!shouldLog(level, normalizeLevel(this.level))) return;
+    const lastArg = args[args.length - 1];
+    const context = args.length > 1 && typeof lastArg === "object" && !Array.isArray(lastArg) ? lastArg : void 0;
+    const messageArgs = context ? args.slice(0, -1) : args;
+    const message = messageArgs.map(String).join(" ");
+    const entry = {
+      level,
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      namespace: this.namespace,
+      message,
+      context
+    };
+    this.writeToHandlers(entry);
+    if (this.propagate && this.parent) {
+      this.parent.writeToHandlers(entry);
+    }
+  }
+  writeToHandlers(entry) {
+    for (const handler of this.handlers) {
+      try {
+        handler.write(entry);
+      } catch (err) {
+        const logError = {
+          error: err instanceof Error ? err : new Error(String(err)),
+          entry,
+          handler
+        };
+        handler.notifyError(logError);
+        if (this.onError) {
+          this.onError(logError);
+        }
+      }
+    }
+  }
+  debug(...args) {
+    this.log("debug", args);
+  }
+  info(...args) {
+    this.log("info", args);
+  }
+  warn(...args) {
+    this.log("warn", args);
+  }
+  error(...args) {
+    this.log("error", args);
+  }
+  access(message, context = {}) {
+    this.log("info", [message, context]);
+  }
+  async close() {
+    await Promise.all(this.handlers.map((h) => h.close()));
+  }
+};
+function createLogger(options) {
+  return new Logger(options);
+}
+
+exports.Logger = Logger;
+exports.createFormatter = createFormatter;
+exports.createHandler = createHandler;
+exports.createLogger = createLogger;
+exports.formatters = formatters;

package/dist/index.d.cts

@@ -0,0 +1,102 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogEntry {
+    level: LogLevel;
+    time: string;
+    namespace: string;
+    message: string;
+    context?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface LogError {
+    error: Error;
+    entry?: LogEntry;
+    handler: unknown;
+}
+interface FormatterConfig {
+    type: 'json' | 'text';
+    template?: string;
+    timeFormat?: 'iso' | 'local';
+    colors?: boolean;
+    fields?: string[];
+}
+type HandlerType = 'console' | 'file';
+interface HandlerConfig {
+    type: HandlerType;
+    level?: LogLevel;
+    formatter?: FormatterConfig;
+    path?: string;
+    maxSize?: string;
+    maxFiles?: number;
+    onError?: (err: LogError) => void;
+    sync?: boolean;
+}
+interface ILogger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    close(): Promise<void>;
+}
+interface LoggerOptions {
+    name?: string;
+    scope?: string;
+    level?: LogLevel;
+    handlers?: HandlerConfig[];
+    propagate?: boolean;
+    logger?: ILogger;
+    onError?: (err: LogError) => void;
+}
+
+declare class JsonFormatter {
+    private fields;
+    constructor(config?: FormatterConfig);
+    format(entry: LogEntry): string;
+}
+
+declare class TextFormatter {
+    private template;
+    private colors;
+    constructor(config: FormatterConfig);
+    format(entry: LogEntry): string;
+}
+
+type Formatter = {
+    format(entry: LogEntry): string;
+};
+declare function createFormatter(config: FormatterConfig): Formatter;
+declare const formatters: {
+    json: () => JsonFormatter;
+    consoleText: () => TextFormatter;
+    fileText: () => TextFormatter;
+};
+
+type Handler = {
+    write(entry: LogEntry): void;
+    notifyError(err: LogError): void;
+    close(): Promise<void>;
+};
+declare function createHandler(config: HandlerConfig, namespace: string): Handler;
+
+declare class Logger {
+    readonly namespace: string;
+    level: LogLevel;
+    readonly handlers: Handler[];
+    readonly propagate: boolean;
+    private parent?;
+    private onError?;
+    constructor(options?: LoggerOptions);
+    child(scope: string, options?: LoggerOptions): Logger;
+    setLevel(level: LogLevel): void;
+    addHandler(handler: Handler): void;
+    private log;
+    private writeToHandlers;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    access(message: string, context?: Record<string, unknown>): void;
+    close(): Promise<void>;
+}
+declare function createLogger(options?: LoggerOptions): Logger;
+
+export { type FormatterConfig, type Handler, type HandlerConfig, type HandlerType, type ILogger, type LogEntry, type LogError, type LogLevel, Logger, type LoggerOptions, createFormatter, createHandler, createLogger, formatters };

package/dist/index.d.ts

@@ -0,0 +1,102 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogEntry {
+    level: LogLevel;
+    time: string;
+    namespace: string;
+    message: string;
+    context?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface LogError {
+    error: Error;
+    entry?: LogEntry;
+    handler: unknown;
+}
+interface FormatterConfig {
+    type: 'json' | 'text';
+    template?: string;
+    timeFormat?: 'iso' | 'local';
+    colors?: boolean;
+    fields?: string[];
+}
+type HandlerType = 'console' | 'file';
+interface HandlerConfig {
+    type: HandlerType;
+    level?: LogLevel;
+    formatter?: FormatterConfig;
+    path?: string;
+    maxSize?: string;
+    maxFiles?: number;
+    onError?: (err: LogError) => void;
+    sync?: boolean;
+}
+interface ILogger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    close(): Promise<void>;
+}
+interface LoggerOptions {
+    name?: string;
+    scope?: string;
+    level?: LogLevel;
+    handlers?: HandlerConfig[];
+    propagate?: boolean;
+    logger?: ILogger;
+    onError?: (err: LogError) => void;
+}
+
+declare class JsonFormatter {
+    private fields;
+    constructor(config?: FormatterConfig);
+    format(entry: LogEntry): string;
+}
+
+declare class TextFormatter {
+    private template;
+    private colors;
+    constructor(config: FormatterConfig);
+    format(entry: LogEntry): string;
+}
+
+type Formatter = {
+    format(entry: LogEntry): string;
+};
+declare function createFormatter(config: FormatterConfig): Formatter;
+declare const formatters: {
+    json: () => JsonFormatter;
+    consoleText: () => TextFormatter;
+    fileText: () => TextFormatter;
+};
+
+type Handler = {
+    write(entry: LogEntry): void;
+    notifyError(err: LogError): void;
+    close(): Promise<void>;
+};
+declare function createHandler(config: HandlerConfig, namespace: string): Handler;
+
+declare class Logger {
+    readonly namespace: string;
+    level: LogLevel;
+    readonly handlers: Handler[];
+    readonly propagate: boolean;
+    private parent?;
+    private onError?;
+    constructor(options?: LoggerOptions);
+    child(scope: string, options?: LoggerOptions): Logger;
+    setLevel(level: LogLevel): void;
+    addHandler(handler: Handler): void;
+    private log;
+    private writeToHandlers;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    access(message: string, context?: Record<string, unknown>): void;
+    close(): Promise<void>;
+}
+declare function createLogger(options?: LoggerOptions): Logger;
+
+export { type FormatterConfig, type Handler, type HandlerConfig, type HandlerType, type ILogger, type LogEntry, type LogError, type LogLevel, Logger, type LoggerOptions, createFormatter, createHandler, createLogger, formatters };

package/dist/index.js

@@ -0,0 +1,418 @@
+import { isWorkerd } from 'std-env';
+
+// src/formatter/json.ts
+var JsonFormatter = class {
+  fields;
+  constructor(config = { type: "json" }) {
+    this.fields = config.fields ?? [];
+  }
+  format(entry) {
+    const output = {
+      ...entry.context,
+      level: entry.level,
+      time: entry.time,
+      namespace: entry.namespace,
+      message: entry.message
+    };
+    for (const field of this.fields) {
+      if (entry[field] !== void 0) {
+        output[field] = entry[field];
+      }
+    }
+    return JSON.stringify(output);
+  }
+};
+
+// src/formatter/text.ts
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var GRAY = "\x1B[90m";
+var colors = {
+  debug: GRAY,
+  info: BLUE,
+  warn: YELLOW,
+  error: RED
+};
+var TextFormatter = class {
+  template;
+  colors;
+  constructor(config) {
+    this.template = config.template ?? "[{time}] [{level}] {namespace}: {message}";
+    this.colors = config.colors ?? true;
+  }
+  format(entry) {
+    let message = this.template.replace(/{time}/g, entry.time).replace(/{level}/g, entry.level).replace(/{namespace}/g, entry.namespace).replace(/{message}/g, entry.message);
+    if (entry.context) {
+      message += ` ${JSON.stringify(entry.context)}`;
+    }
+    if (this.colors) {
+      const color = colors[entry.level] ?? "";
+      return `${color}${message}${RESET}`;
+    }
+    return message;
+  }
+};
+
+// src/formatter/index.ts
+function createFormatter(config) {
+  if (config.type === "json") {
+    return new JsonFormatter(config);
+  }
+  return new TextFormatter(config);
+}
+var formatters = {
+  json: () => new JsonFormatter({ type: "json" }),
+  consoleText: () => new TextFormatter({
+    type: "text",
+    template: "[{time}] [{level}] {namespace}: {message}",
+    colors: true
+  }),
+  fileText: () => new TextFormatter({
+    type: "text",
+    template: "[{time}] [{level}] {namespace}: {message}",
+    colors: false
+  })
+};
+
+// src/levels.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function shouldLog(level, minLevel) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+}
+function normalizeLevel(level) {
+  if (!level) return "info";
+  const normalized = level.toLowerCase();
+  if (normalized === "debug" || normalized === "info" || normalized === "warn" || normalized === "error") {
+    return normalized;
+  }
+  return "info";
+}
+
+// src/handler/console.ts
+var ConsoleHandler = class {
+  level;
+  formatter;
+  onError;
+  constructor(config) {
+    this.level = config.level ?? "debug";
+    this.onError = config.onError;
+    this.formatter = createFormatter(
+      config.formatter ?? {
+        type: "text",
+        template: "[{time}] [{level}] {namespace}: {message}",
+        colors: true
+      }
+    );
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  write(entry) {
+    if (!shouldLog(entry.level, this.level)) return;
+    const output = this.formatter.format(entry);
+    if (entry.level === "warn") {
+      console.warn(output);
+    } else if (entry.level === "error") {
+      console.error(output);
+    } else {
+      console.log(output);
+    }
+  }
+  async close() {
+  }
+  notifyError(err) {
+    if (this.onError) {
+      this.onError(err);
+    }
+  }
+};
+
+// src/handler/file.ts
+function parseSize(size) {
+  const match = size.match(/^(\d+)(MB|KB)?$/i);
+  if (!match) return 10 * 1024 * 1024;
+  const value = Number.parseInt(match[1], 10);
+  const unit = match[2]?.toUpperCase() || "MB";
+  return unit === "KB" ? value * 1024 : value * 1024 * 1024;
+}
+var FileHandler = class {
+  constructor(config, namespace) {
+    this.config = config;
+    this.level = config.level ?? "debug";
+    this.onError = config.onError;
+    this.formatter = createFormatter(config.formatter ?? { type: "json" });
+    this.maxFiles = config.maxFiles ?? 7;
+    this.prefix = namespace.replace(/\./g, "-");
+    this.ext = this.config.formatter?.type === "text" ? "log" : "jsonl";
+    this.baseDir = "./logs";
+    this.currentPath = this.getTodayPath();
+  }
+  config;
+  level;
+  formatter;
+  buffer = [];
+  timer;
+  size = 0;
+  closed = false;
+  currentPath;
+  maxFiles;
+  baseDir;
+  prefix;
+  ext;
+  onError;
+  getTodayPath() {
+    const now = /* @__PURE__ */ new Date();
+    const date = now.toISOString().split("T")[0];
+    return `${this.baseDir}/${this.prefix}.${date}.${this.ext}`;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  write(entry) {
+    if (this.closed || !shouldLog(entry.level, this.level)) return;
+    const now = /* @__PURE__ */ new Date();
+    const today = now.toISOString().split("T")[0];
+    if (!this.currentPath.includes(today)) {
+      this.currentPath = `${this.baseDir}/${this.prefix}.${today}.${this.ext}`;
+    }
+    const output = `${this.formatter.format(entry)}
+`;
+    this.buffer.push(output);
+    this.size += output.length;
+    if (!this.timer) {
+      this.timer = setTimeout(async () => {
+        this.timer = void 0;
+        await this.flush();
+      }, 1e3);
+    }
+    if (this.size >= parseSize(this.config.maxSize ?? "10MB")) {
+      this.flush().catch(() => {
+      });
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0 || this.closed) return;
+    const content = this.buffer.join("");
+    this.buffer = [];
+    this.size = 0;
+    await this.writeToFile(content);
+    await this.cleanupOldFiles();
+  }
+  async ensureDir() {
+    try {
+      const Bun = globalThis.Bun;
+      const Deno = globalThis.Deno;
+      if (Bun) {
+        Bun.mkdir(this.baseDir, { recursive: true });
+      } else if (Deno) {
+        await Deno.mkdir(this.baseDir, { recursive: true });
+      } else {
+        const fs = await import('fs/promises');
+        await fs.mkdir(this.baseDir, { recursive: true });
+      }
+    } catch (err) {
+      console.error("Failed to create log directory:", err);
+    }
+  }
+  async writeToFile(content) {
+    await this.ensureDir();
+    try {
+      const Bun = globalThis.Bun;
+      const Deno = globalThis.Deno;
+      if (Bun) {
+        Bun.write(this.currentPath, content, { flag: "a" });
+      } else if (Deno) {
+        await Deno.writeTextFile(this.currentPath, content);
+      } else {
+        const fs = await import('fs/promises');
+        await fs.writeFile(this.currentPath, content, { flag: "a" });
+      }
+    } catch (err) {
+      console.error("Failed to write to log file:", err);
+    }
+  }
+  async cleanupOldFiles() {
+    try {
+      const Bun = globalThis.Bun;
+      const Deno = globalThis.Deno;
+      let files;
+      if (Bun) {
+        const entries = Bun.readdir(this.baseDir);
+        files = entries.filter((f) => f.startsWith(this.prefix)).sort();
+      } else if (Deno) {
+        const entries = await Deno.readDir(this.baseDir);
+        files = [];
+        for await (const entry of entries) {
+          if (entry.isFile && entry.name.startsWith(this.prefix)) {
+            files.push(entry.name);
+          }
+        }
+        files.sort();
+      } else {
+        const fs = await import('fs/promises');
+        const entries = await fs.readdir(this.baseDir);
+        files = entries.filter((f) => f.startsWith(this.prefix)).sort();
+      }
+      while (files.length >= this.maxFiles) {
+        const oldest = files.shift();
+        if (oldest) {
+          const filePath = `${this.baseDir}/${oldest}`;
+          if (Bun) {
+            Bun.remove(filePath);
+          } else if (Deno) {
+            await Deno.remove(filePath);
+          } else {
+            const fs = await import('fs/promises');
+            await fs.unlink(filePath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  async close() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    const content = this.buffer.join("");
+    this.buffer = [];
+    this.size = 0;
+    this.closed = true;
+    if (content) {
+      await this.writeToFile(content);
+    }
+  }
+  notifyError(err) {
+    if (this.onError) {
+      this.onError(err);
+    }
+  }
+};
+
+// src/handler/index.ts
+function createHandler(config, namespace) {
+  if (config.type === "console") {
+    return new ConsoleHandler(config);
+  }
+  return new FileHandler(config, namespace);
+}
+var Logger = class _Logger {
+  namespace;
+  level;
+  handlers;
+  propagate;
+  parent;
+  onError;
+  constructor(options = {}) {
+    const parent = options.logger instanceof _Logger ? options.logger : void 0;
+    const isChild = !!parent;
+    if (parent && options.name) {
+      throw new Error(
+        'Cannot use "name" when creating child logger with parent. Use "scope" only.'
+      );
+    }
+    this.level = options.level ?? parent?.level ?? "info";
+    this.propagate = isChild ? false : options.propagate ?? true;
+    this.parent = parent;
+    this.onError = options.onError;
+    if (parent) {
+      if (!options.scope) {
+        throw new Error('Child logger requires "scope" option.');
+      }
+      this.namespace = `${parent.namespace}.${options.scope}`;
+    } else {
+      this.namespace = options.name ?? options.scope ?? "app";
+    }
+    if (isChild) {
+      this.handlers = parent?.handlers ?? [];
+    } else {
+      const configs = options.handlers ?? [{ type: "console" }];
+      this.handlers = configs.filter((c) => c.type !== "file" || !isWorkerd).map((config) => createHandler(config, this.namespace));
+    }
+  }
+  child(scope, options) {
+    return new _Logger({
+      ...options,
+      scope,
+      logger: this
+    });
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  log(level, args) {
+    if (!shouldLog(level, normalizeLevel(this.level))) return;
+    const lastArg = args[args.length - 1];
+    const context = args.length > 1 && typeof lastArg === "object" && !Array.isArray(lastArg) ? lastArg : void 0;
+    const messageArgs = context ? args.slice(0, -1) : args;
+    const message = messageArgs.map(String).join(" ");
+    const entry = {
+      level,
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      namespace: this.namespace,
+      message,
+      context
+    };
+    this.writeToHandlers(entry);
+    if (this.propagate && this.parent) {
+      this.parent.writeToHandlers(entry);
+    }
+  }
+  writeToHandlers(entry) {
+    for (const handler of this.handlers) {
+      try {
+        handler.write(entry);
+      } catch (err) {
+        const logError = {
+          error: err instanceof Error ? err : new Error(String(err)),
+          entry,
+          handler
+        };
+        handler.notifyError(logError);
+        if (this.onError) {
+          this.onError(logError);
+        }
+      }
+    }
+  }
+  debug(...args) {
+    this.log("debug", args);
+  }
+  info(...args) {
+    this.log("info", args);
+  }
+  warn(...args) {
+    this.log("warn", args);
+  }
+  error(...args) {
+    this.log("error", args);
+  }
+  access(message, context = {}) {
+    this.log("info", [message, context]);
+  }
+  async close() {
+    await Promise.all(this.handlers.map((h) => h.close()));
+  }
+};
+function createLogger(options) {
+  return new Logger(options);
+}
+
+export { Logger, createFormatter, createHandler, createLogger, formatters };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@rx-ted/packages-logger",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "A lightweight logging library with file & console output, designed for Cloudflare/Node/Bun/Deno.",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "rx-ted",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "logger",
+    "Bun",
+    "Node",
+    "Deno",
+    "javascript",
+    "typescript"
+  ],
+  "dependencies": {
+    "std-env": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.19",
+    "@vitest/coverage-v8": "^4.1.6",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.2",
+    "vitest": "^4.1.6"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  }
+}