@xframework/logtape 0.4.0

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+
+> @xframework/logtape@0.4.0 build /home/runner/work/x/x/packages/@xframework/logtape
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.3.5
+CLI Using tsup config: /home/runner/work/x/x/packages/@xframework/logtape/tsup.config.ts
+CLI Target: esnext
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+CJS dist/index.cjs     1.37 KB
+CJS dist/index.cjs.map 676.00 B
+CJS ⚡️ Build success in 36ms
+ESM dist/index.js     346.00 B
+ESM dist/index.js.map 640.00 B
+ESM ⚡️ Build success in 34ms
+DTS Build start
+DTS ⚡️ Build success in 4163ms
+DTS dist/index.d.cts 247.00 B
+DTS dist/index.d.ts  247.00 B

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @xframework/logtape
+
+## 0.4.0
+
+### Minor Changes
+
+- 98dd8e4: redesign
+
+### Patch Changes
+
+- Updated dependencies [98dd8e4]
+  - @xframework/x@0.4.0

package/dist/index.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LogTapeAdapter: () => LogTapeAdapter
+});
+module.exports = __toCommonJS(index_exports);
+var import_adapter = require("@xframework/x/adapter");
+var import_logtape = require("@logtape/logtape");
+var LogTapeAdapter = class extends import_adapter.SyncAdapter {
+  logger;
+  constructor() {
+    super();
+    this.logger = (0, import_logtape.getLogger)();
+  }
+  export() {
+    return this.logger;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogTapeAdapter
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { SyncAdapter } from \"@xframework/x/adapter\";\nimport type { Logger } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\n\nexport class LogTapeAdapter extends SyncAdapter<Logger> {\n  public logger: Logger;\n\n  constructor() {\n    super();\n    this.logger = getLogger();\n  }\n\n  export(): Logger {\n    return this.logger;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA4B;AAE5B,qBAA0B;AAEnB,IAAM,iBAAN,cAA6B,2BAAoB;AAAA,EAC/C;AAAA,EAEP,cAAc;AACZ,UAAM;AACN,SAAK,aAAS,0BAAU;AAAA,EAC1B;AAAA,EAEA,SAAiB;AACf,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,10 @@
+import { SyncAdapter } from '@xframework/x/adapter';
+import { Logger } from '@logtape/logtape';
+
+declare class LogTapeAdapter extends SyncAdapter<Logger> {
+    logger: Logger;
+    constructor();
+    export(): Logger;
+}
+
+export { LogTapeAdapter };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { SyncAdapter } from '@xframework/x/adapter';
+import { Logger } from '@logtape/logtape';
+
+declare class LogTapeAdapter extends SyncAdapter<Logger> {
+    logger: Logger;
+    constructor();
+    export(): Logger;
+}
+
+export { LogTapeAdapter };

package/dist/index.js

@@ -0,0 +1,17 @@
+// src/index.ts
+import { SyncAdapter } from "@xframework/x/adapter";
+import { getLogger } from "@logtape/logtape";
+var LogTapeAdapter = class extends SyncAdapter {
+  logger;
+  constructor() {
+    super();
+    this.logger = getLogger();
+  }
+  export() {
+    return this.logger;
+  }
+};
+export {
+  LogTapeAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { SyncAdapter } from \"@xframework/x/adapter\";\nimport type { Logger } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\n\nexport class LogTapeAdapter extends SyncAdapter<Logger> {\n  public logger: Logger;\n\n  constructor() {\n    super();\n    this.logger = getLogger();\n  }\n\n  export(): Logger {\n    return this.logger;\n  }\n}\n"],"mappings":";AAAA,SAAS,mBAAmB;AAE5B,SAAS,iBAAiB;AAEnB,IAAM,iBAAN,cAA6B,YAAoB;AAAA,EAC/C;AAAA,EAEP,cAAc;AACZ,UAAM;AACN,SAAK,SAAS,UAAU;AAAA,EAC1B;AAAA,EAEA,SAAiB;AACf,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@xframework/logtape",
+  "version": "0.4.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@xframework/x": "0.4.0"
+  },
+  "peerDependencies": {
+    "@logtape/logtape": ">=0.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}

package/src/__tests__/index.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { LogTapeAdapter } from "../index";
+import { configure, getConsoleSink, getLogger } from "@logtape/logtape";
+import { createX } from "@xframework/x";
+
+describe("LogTapeAdapter", () => {
+  beforeEach(async () => {
+    await configure({
+      reset: true,
+      sinks: {
+        console: getConsoleSink(),
+      },
+      loggers: [
+        {
+          category: [],
+          sinks: ["console"],
+          lowestLevel: "debug",
+        },
+      ],
+    });
+  });
+
+  afterEach(async () => {
+    await configure({
+      reset: true,
+      sinks: {},
+      loggers: [],
+    });
+  });
+
+  it("should properly initialize and export logger instance", () => {
+    const adapter = new LogTapeAdapter();
+    const logger = adapter.logger;
+
+    expect(logger).toBeDefined();
+    expect(Array.isArray(logger.category)).toBe(true);
+    expect(logger.category).toHaveLength(0);
+    expect(logger.parent).toBe(null);
+    expect(typeof logger.debug).toBe("function");
+    expect(typeof logger.info).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.error).toBe("function");
+    expect(typeof logger.fatal).toBe("function");
+  });
+
+  it("should export logger with getLogger function", () => {
+    const adapter = new LogTapeAdapter();
+    const logger = adapter.logger;
+
+    expect(logger).toBeDefined();
+    const categoryLogger = getLogger(["test-category"]);
+    expect(categoryLogger.category).toEqual(["test-category"]);
+  });
+
+  it("should integrate with X framework", () => {
+    const adapter = new LogTapeAdapter();
+    const x = createX()
+      .syncAdapter("logger", () => adapter)
+      .build();
+
+    expect(x._.adapters.logger).toBeInstanceOf(LogTapeAdapter);
+    expect(x.logger).toBeDefined();
+    expect(typeof x.logger.debug).toBe("function");
+    expect(typeof x.logger.info).toBe("function");
+    expect(typeof x.logger.warn).toBe("function");
+    expect(typeof x.logger.error).toBe("function");
+    expect(typeof x.logger.fatal).toBe("function");
+  });
+
+  it("should properly log messages", () => {
+    const logger = getLogger([]);
+
+    expect(() => {
+      logger.debug("Debug message", { level: "debug" });
+      logger.info("Info message", { level: "info" });
+      logger.warn("Warning message", { level: "warn" });
+      logger.error("Error message", { level: "error" });
+      logger.fatal("Fatal message", { level: "fatal" });
+    }).not.toThrow();
+  });
+
+  it("should support getting new logger instances", () => {
+    const newLogger = getLogger(["test-category"]);
+    expect(newLogger).toBeDefined();
+    expect(newLogger.category).toEqual(["test-category"]);
+  });
+
+  it("should support child loggers with categories", () => {
+    const componentLogger = getLogger(["component"]);
+    expect(componentLogger).toBeDefined();
+    expect(componentLogger.category).toEqual(["component"]);
+
+    const childLogger = getLogger(["component", "test"]);
+    expect(childLogger).toBeDefined();
+    expect(childLogger.category).toEqual(["component", "test"]);
+    // Logtape maintains parent relationships
+    expect(childLogger.parent).toBeDefined();
+    expect(childLogger.parent?.category).toEqual(["component"]);
+  });
+
+  it("should support with method for adding context", () => {
+    const logger = getLogger([]);
+    const loggerWithContext = logger.with({ requestId: "123" });
+    expect(loggerWithContext).toBeDefined();
+    expect(() => {
+      loggerWithContext.info("Test message with context");
+    }).not.toThrow();
+  });
+
+  it("should respect log levels", async () => {
+    const logger = getLogger([]);
+
+    // Configure logger to only show info and above
+    await configure({
+      reset: true,
+      sinks: {
+        console: getConsoleSink(),
+      },
+      loggers: [
+        {
+          category: [],
+          sinks: ["console"],
+          lowestLevel: "info",
+        },
+      ],
+    });
+
+    expect(() => {
+      logger.debug("This debug message should be filtered");
+      logger.info("This info message should go through");
+      logger.warn("This warning message should go through");
+      logger.error("This error message should go through");
+      logger.fatal("This fatal message should go through");
+    }).not.toThrow();
+  });
+
+  it("should handle nested child loggers", () => {
+    const level1 = getLogger(["level1"]);
+    const level2 = getLogger(["level1", "level2"]);
+    const level3 = getLogger(["level1", "level2", "level3"]);
+
+    expect(level1.category).toEqual(["level1"]);
+    expect(level2.category).toEqual(["level1", "level2"]);
+    expect(level3.category).toEqual(["level1", "level2", "level3"]);
+
+    // Logtape maintains parent relationships
+    expect(level1.parent).toBeDefined();
+    expect(level1.parent?.category).toEqual([]);
+    expect(level2.parent).toBeDefined();
+    expect(level2.parent?.category).toEqual(["level1"]);
+    expect(level3.parent).toBeDefined();
+    expect(level3.parent?.category).toEqual(["level1", "level2"]);
+  });
+});

package/src/index.ts

@@ -0,0 +1,16 @@
+import { SyncAdapter } from "@xframework/x/adapter";
+import type { Logger } from "@logtape/logtape";
+import { getLogger } from "@logtape/logtape";
+
+export class LogTapeAdapter extends SyncAdapter<Logger> {
+  public logger: Logger;
+
+  constructor() {
+    super();
+    this.logger = getLogger();
+  }
+
+  export(): Logger {
+    return this.logger;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "lib": ["ESNext", "DOM"]
+  },
+  "include": ["src", "tsup.config.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,3 @@
+import { tsupConfig } from "../../../utils/tsup.config";
+
+export default tsupConfig;