@agentxjs/ui 0.1.1 → 0.1.2

package/dist/index.js

@@ -4,15 +4,15 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 import * as React from "react";
 import React__default, { useState, useRef, useEffect, useCallback, forwardRef, createElement } from "react";
 import { jsxs, jsx, Fragment } from "react/jsx-runtime";
-var __defProp2 = Object.defineProperty;
-var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-var _ConsoleLogger = class _ConsoleLogger2 {
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _ConsoleLogger$1 = class _ConsoleLogger {
   constructor(name2, options = {}) {
-    __publicField2(this, "name");
-    __publicField2(this, "level");
-    __publicField2(this, "colors");
-    __publicField2(this, "timestamps");
+    __publicField$1(this, "name");
+    __publicField$1(this, "level");
+    __publicField$1(this, "colors");
+    __publicField$1(this, "timestamps");
     this.name = name2;
     this.level = options.level ?? "info";
     this.colors = options.colors ?? this.isNodeEnvironment();
@@ -70,8 +70,8 @@ var _ConsoleLogger = class _ConsoleLogger2 {
       parts.push((/* @__PURE__ */ new Date()).toISOString());
     }
     if (this.colors) {
-      const color2 = _ConsoleLogger2.COLORS[level];
-      parts.push(`${color2}${level.padEnd(5)}${_ConsoleLogger2.COLORS.RESET}`);
+      const color2 = _ConsoleLogger.COLORS[level];
+      parts.push(`${color2}${level.padEnd(5)}${_ConsoleLogger.COLORS.RESET}`);
     } else {
       parts.push(level.padEnd(5));
     }
@@ -104,16 +104,16 @@ var _ConsoleLogger = class _ConsoleLogger2 {
     return typeof process !== "undefined" && ((_a = process.versions) == null ? void 0 : _a.node) !== void 0;
   }
 };
-__publicField2(_ConsoleLogger, "COLORS", {
+__publicField$1(_ConsoleLogger$1, "COLORS", {
   DEBUG: "\x1B[36m",
   INFO: "\x1B[32m",
   WARN: "\x1B[33m",
   ERROR: "\x1B[31m",
   RESET: "\x1B[0m"
 });
-var ConsoleLogger = _ConsoleLogger;
-var externalFactory = null;
-var LoggerFactoryImpl = class {
+var ConsoleLogger$1 = _ConsoleLogger$1;
+var externalFactory$1 = null;
+var LoggerFactoryImpl$1 = class LoggerFactoryImpl {
   static getLogger(nameOrClass) {
     const name2 = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
     if (this.loggers.has(name2)) {
@@ -129,7 +129,7 @@ var LoggerFactoryImpl = class {
   static reset() {
     this.loggers.clear();
     this.config = { defaultLevel: "info" };
-    externalFactory = null;
+    externalFactory$1 = null;
   }
   static createLazyLogger(name2) {
     let realLogger = null;
@@ -153,26 +153,26 @@ var LoggerFactoryImpl = class {
     };
   }
   static createLogger(name2) {
-    if (externalFactory) {
-      return externalFactory.getLogger(name2);
+    if (externalFactory$1) {
+      return externalFactory$1.getLogger(name2);
     }
     if (this.config.defaultImplementation) {
       return this.config.defaultImplementation(name2);
     }
-    return new ConsoleLogger(name2, {
+    return new ConsoleLogger$1(name2, {
       level: this.config.defaultLevel,
       ...this.config.consoleOptions
     });
   }
 };
-__publicField2(LoggerFactoryImpl, "loggers", /* @__PURE__ */ new Map());
-__publicField2(LoggerFactoryImpl, "config", {
+__publicField$1(LoggerFactoryImpl$1, "loggers", /* @__PURE__ */ new Map());
+__publicField$1(LoggerFactoryImpl$1, "config", {
   defaultLevel: "info"
 });
-function createLogger(name2) {
-  return LoggerFactoryImpl.getLogger(name2);
+function createLogger$1(name2) {
+  return LoggerFactoryImpl$1.getLogger(name2);
 }
-const logger$2 = createLogger("ui/useAgent");
+const logger$2 = createLogger$1("ui/useAgent");
 function useAgent(agentx, imageId, options = {}) {
   const { initialMessages = [], onSend, onError, onStatusChange } = options;
   const [messages, setMessages] = useState(initialMessages);
@@ -412,9 +412,187 @@ function useAgent(agentx, imageId, options = {}) {
     agentId: agentIdState
   };
 }
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+function createLogger(name2) {
+  return LoggerFactoryImpl2.getLogger(name2);
+}
+var __defProp2, __defNormalProp2, __publicField2, _ConsoleLogger2, ConsoleLogger, externalFactory, LoggerFactoryImpl2;
+var init_dist = __esm({
+  "../common/dist/index.js"() {
+    __defProp2 = Object.defineProperty;
+    __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+    _ConsoleLogger2 = class _ConsoleLogger22 {
+      constructor(name2, options = {}) {
+        __publicField2(this, "name");
+        __publicField2(this, "level");
+        __publicField2(this, "colors");
+        __publicField2(this, "timestamps");
+        this.name = name2;
+        this.level = options.level ?? "info";
+        this.colors = options.colors ?? this.isNodeEnvironment();
+        this.timestamps = options.timestamps ?? true;
+      }
+      debug(message, context) {
+        if (this.isDebugEnabled()) {
+          this.log("DEBUG", message, context);
+        }
+      }
+      info(message, context) {
+        if (this.isInfoEnabled()) {
+          this.log("INFO", message, context);
+        }
+      }
+      warn(message, context) {
+        if (this.isWarnEnabled()) {
+          this.log("WARN", message, context);
+        }
+      }
+      error(message, context) {
+        if (this.isErrorEnabled()) {
+          if (message instanceof Error) {
+            this.log("ERROR", message.message, { ...context, stack: message.stack });
+          } else {
+            this.log("ERROR", message, context);
+          }
+        }
+      }
+      isDebugEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("debug");
+      }
+      isInfoEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("info");
+      }
+      isWarnEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("warn");
+      }
+      isErrorEnabled() {
+        return this.getLevelValue(this.level) <= this.getLevelValue("error");
+      }
+      getLevelValue(level) {
+        const levels = {
+          debug: 0,
+          info: 1,
+          warn: 2,
+          error: 3,
+          silent: 4
+        };
+        return levels[level];
+      }
+      log(level, message, context) {
+        const parts = [];
+        if (this.timestamps) {
+          parts.push((/* @__PURE__ */ new Date()).toISOString());
+        }
+        if (this.colors) {
+          const color2 = _ConsoleLogger22.COLORS[level];
+          parts.push(`${color2}${level.padEnd(5)}${_ConsoleLogger22.COLORS.RESET}`);
+        } else {
+          parts.push(level.padEnd(5));
+        }
+        parts.push(`[${this.name}]`);
+        parts.push(message);
+        const logLine = parts.join(" ");
+        const consoleMethod = this.getConsoleMethod(level);
+        if (context && Object.keys(context).length > 0) {
+          consoleMethod(logLine, context);
+        } else {
+          consoleMethod(logLine);
+        }
+      }
+      getConsoleMethod(level) {
+        switch (level) {
+          case "DEBUG":
+            return console.debug.bind(console);
+          case "INFO":
+            return console.info.bind(console);
+          case "WARN":
+            return console.warn.bind(console);
+          case "ERROR":
+            return console.error.bind(console);
+          default:
+            return console.log.bind(console);
+        }
+      }
+      isNodeEnvironment() {
+        var _a;
+        return typeof process !== "undefined" && ((_a = process.versions) == null ? void 0 : _a.node) !== void 0;
+      }
+    };
+    __publicField2(_ConsoleLogger2, "COLORS", {
+      DEBUG: "\x1B[36m",
+      INFO: "\x1B[32m",
+      WARN: "\x1B[33m",
+      ERROR: "\x1B[31m",
+      RESET: "\x1B[0m"
+    });
+    ConsoleLogger = _ConsoleLogger2;
+    externalFactory = null;
+    LoggerFactoryImpl2 = class {
+      static getLogger(nameOrClass) {
+        const name2 = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
+        if (this.loggers.has(name2)) {
+          return this.loggers.get(name2);
+        }
+        const lazyLogger = this.createLazyLogger(name2);
+        this.loggers.set(name2, lazyLogger);
+        return lazyLogger;
+      }
+      static configure(config) {
+        this.config = { ...this.config, ...config };
+      }
+      static reset() {
+        this.loggers.clear();
+        this.config = { defaultLevel: "info" };
+        externalFactory = null;
+      }
+      static createLazyLogger(name2) {
+        let realLogger = null;
+        const getRealLogger = () => {
+          if (!realLogger) {
+            realLogger = this.createLogger(name2);
+          }
+          return realLogger;
+        };
+        return {
+          name: name2,
+          level: this.config.defaultLevel || "info",
+          debug: (message, context) => getRealLogger().debug(message, context),
+          info: (message, context) => getRealLogger().info(message, context),
+          warn: (message, context) => getRealLogger().warn(message, context),
+          error: (message, context) => getRealLogger().error(message, context),
+          isDebugEnabled: () => getRealLogger().isDebugEnabled(),
+          isInfoEnabled: () => getRealLogger().isInfoEnabled(),
+          isWarnEnabled: () => getRealLogger().isWarnEnabled(),
+          isErrorEnabled: () => getRealLogger().isErrorEnabled()
+        };
+      }
+      static createLogger(name2) {
+        if (externalFactory) {
+          return externalFactory.getLogger(name2);
+        }
+        if (this.config.defaultImplementation) {
+          return this.config.defaultImplementation(name2);
+        }
+        return new ConsoleLogger(name2, {
+          level: this.config.defaultLevel,
+          ...this.config.consoleOptions
+        });
+      }
+    };
+    __publicField2(LoggerFactoryImpl2, "loggers", /* @__PURE__ */ new Map());
+    __publicField2(LoggerFactoryImpl2, "config", {
+      defaultLevel: "info"
+    });
+  }
+});
 function isRemoteConfig(config) {
   return "serverUrl" in config && typeof config.serverUrl === "string";
 }
+init_dist();
 var remoteLogger = createLogger("agentx/RemoteClient");
 var isBrowser = typeof window !== "undefined" && typeof window.WebSocket !== "undefined";
 async function createRemoteAgentX(serverUrl) {
@@ -558,7 +736,7 @@ async function createAgentX(config) {
   }
   return createRemoteAgentX(config.serverUrl);
 }
-const logger$1 = createLogger("ui/useAgentX");
+const logger$1 = createLogger$1("ui/useAgentX");
 function useAgentX(serverUrl) {
   const [agentx, setAgentx] = useState(null);
   useEffect(() => {
@@ -586,7 +764,7 @@ function useAgentX(serverUrl) {
   }, [serverUrl]);
   return agentx;
 }
-const logger = createLogger("ui/useImages");
+const logger = createLogger$1("ui/useImages");
 function useImages(agentx, options = {}) {
   const { containerId, autoLoad = true, onRun, onImagesChange } = options;
   const [images, setImages] = useState([]);