@jay-framework/editor-client 0.6.7 → 0.6.9

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "@jay-framework/editor-client",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
+    ".": "./dist/index.js"
   },
   "files": [
     "dist",
@@ -27,14 +24,14 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/editor-protocol": "^0.6.7",
+    "@jay-framework/editor-protocol": "^0.6.9",
     "get-port": "^7.0.0",
     "socket.io-client": "^4.7.4",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.6.7",
-    "@jay-framework/jay-cli": "^0.6.7",
+    "@jay-framework/dev-environment": "^0.6.9",
+    "@jay-framework/jay-cli": "^0.6.9",
     "@types/node": "^22.15.21",
     "@types/uuid": "^9.0.7",
     "rimraf": "^5.0.5",

package/dist/index.cjs

@@ -1,275 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const socket_ioClient = require("socket.io-client");
-const uuid = require("uuid");
-const editorProtocol = require("@jay-framework/editor-protocol");
-class ConnectionManager {
-  constructor(options = {}) {
-    __publicField(this, "socket", null);
-    __publicField(this, "connectionState", "disconnected");
-    __publicField(this, "portRange");
-    __publicField(this, "scanTimeout");
-    __publicField(this, "retryAttempts");
-    __publicField(this, "editorId");
-    __publicField(this, "autoReconnect");
-    __publicField(this, "reconnectDelay");
-    __publicField(this, "reconnectTimer", null);
-    __publicField(this, "isManualDisconnect", false);
-    __publicField(this, "isConnecting", false);
-    __publicField(this, "pendingRequests", /* @__PURE__ */ new Map());
-    __publicField(this, "stateChangeCallbacks", /* @__PURE__ */ new Set());
-    this.portRange = options.portRange || [3101, 3200];
-    this.scanTimeout = options.scanTimeout || 5e3;
-    this.retryAttempts = options.retryAttempts || 3;
-    this.editorId = options.editorId || uuid.v4();
-    this.autoReconnect = options.autoReconnect || true;
-    this.reconnectDelay = options.reconnectDelay || 1e3;
-  }
-  async connect() {
-    if (this.connectionState === "connected" || this.isConnecting) {
-      return;
-    }
-    this.isManualDisconnect = false;
-    this.isConnecting = true;
-    this.updateConnectionState("connecting");
-    try {
-      const serverPort = await this.discoverServer();
-      await this.establishConnection(serverPort);
-      this.updateConnectionState("connected");
-    } catch (error) {
-      this.updateConnectionState("error");
-      throw error;
-    } finally {
-      this.isConnecting = false;
-    }
-  }
-  async disconnect() {
-    this.isManualDisconnect = true;
-    this.isConnecting = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.socket) {
-      this.socket.disconnect();
-      this.socket = null;
-    }
-    this.updateConnectionState("disconnected");
-  }
-  getConnectionState() {
-    return this.connectionState;
-  }
-  onConnectionStateChange(callback) {
-    this.stateChangeCallbacks.add(callback);
-    return () => {
-      this.stateChangeCallbacks.delete(callback);
-    };
-  }
-  async sendMessage(message) {
-    if (this.connectionState !== "connected") {
-      throw new Error("Not connected to editor server");
-    }
-    if (!this.socket) {
-      throw new Error("Not connected to editor server - Socket not available");
-    }
-    return new Promise((resolve, reject) => {
-      const protocolMessage = editorProtocol.createProtocolMessage(message);
-      this.pendingRequests.set(protocolMessage.id, { resolve, reject });
-      setTimeout(() => {
-        if (this.pendingRequests.has(protocolMessage.id)) {
-          this.pendingRequests.delete(protocolMessage.id);
-          reject(new Error("Request timeout"));
-        }
-      }, this.scanTimeout);
-      this.socket.emit("protocol-message", protocolMessage);
-    });
-  }
-  updateConnectionState(newState) {
-    if (this.connectionState !== newState) {
-      this.connectionState;
-      this.connectionState = newState;
-      this.stateChangeCallbacks.forEach((callback) => {
-        try {
-          callback(newState);
-        } catch (error) {
-          console.error("Error in connection state callback:", error);
-        }
-      });
-      if (newState === "disconnected" && this.autoReconnect && !this.isManualDisconnect) {
-        this.scheduleReconnect();
-      }
-    }
-  }
-  scheduleReconnect() {
-    if (this.isManualDisconnect || this.reconnectTimer) {
-      return;
-    }
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.attemptReconnect();
-    }, this.reconnectDelay);
-  }
-  async discoverServer() {
-    const [startPort, endPort] = this.portRange;
-    const ports = Array.from({ length: endPort - startPort + 1 }, (_, i) => startPort + i);
-    const errors = [];
-    for (let attempt = 0; attempt < this.retryAttempts; attempt++) {
-      for (const port of ports) {
-        try {
-          const response = await this.checkPort(port);
-          if (response) {
-            return port;
-          }
-        } catch (error) {
-          errors.push(`tried port ${port} with error ${error?.message}`);
-        }
-      }
-      if (attempt < this.retryAttempts - 1) {
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-      }
-    }
-    throw new Error(
-      `No editor server found in port range ${startPort}-${endPort}:
-${errors.join("\n")}`
-    );
-  }
-  async checkPort(port) {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`Port ${port} timeout`));
-      }, this.scanTimeout);
-      const controller = new AbortController();
-      fetch(`http://localhost:${port}/editor-connect?id=${this.editorId}`, {
-        signal: controller.signal
-      }).then((response) => {
-        clearTimeout(timeout);
-        if (response.ok) {
-          return response.json();
-        }
-        throw new Error(`HTTP ${response.status}`);
-      }).then((data) => {
-        if (data.status === "init" || data.id === this.editorId && data.status === "match") {
-          resolve(data);
-        } else {
-          if (data.id)
-            reject(
-              new Error(
-                `failed to match on editorId ${this.editorId} !== port's ${data.id}`
-              )
-            );
-          else
-            reject(new Error(`failed to match on editorId ${this.editorId}`));
-        }
-      }).catch((error) => {
-        clearTimeout(timeout);
-        reject(error);
-      });
-    });
-  }
-  async establishConnection(port) {
-    return new Promise((resolve, reject) => {
-      this.socket = socket_ioClient.io(`http://localhost:${port}`, {
-        timeout: this.scanTimeout,
-        forceNew: true
-      });
-      this.socket.on("connect", () => {
-        console.log("Connected to editor server");
-        this.setupSocketHandlers();
-        resolve();
-      });
-      this.socket.on("connect_error", (error) => {
-        console.error("Connection error:", error);
-        reject(error);
-      });
-      this.socket.on("disconnect", () => {
-        console.log("Disconnected from editor server");
-        this.updateConnectionState("disconnected");
-      });
-    });
-  }
-  setupSocketHandlers() {
-    if (!this.socket)
-      return;
-    this.socket.on("protocol-response", (response) => {
-      const pendingRequest = this.pendingRequests.get(response.id);
-      if (pendingRequest) {
-        this.pendingRequests.delete(response.id);
-        if (response.payload.success) {
-          pendingRequest.resolve(response.payload);
-        } else {
-          pendingRequest.reject(new Error(response.payload.error || "Unknown error"));
-        }
-      }
-    });
-  }
-  async attemptReconnect() {
-    if (this.isManualDisconnect || this.isConnecting) {
-      return;
-    }
-    console.log("Attempting to reconnect...");
-    try {
-      await this.connect();
-      console.log("Reconnected successfully");
-    } catch (error) {
-      console.error("Reconnection failed:", error);
-      this.scheduleReconnect();
-    }
-  }
-}
-function createConnectionManager(options) {
-  return new ConnectionManager(options);
-}
-class EditorClient {
-  constructor(connectionManager) {
-    __publicField(this, "connectionManager");
-    this.connectionManager = connectionManager;
-  }
-  // Connection management - delegate to ConnectionManager
-  async connect() {
-    return this.connectionManager.connect();
-  }
-  async disconnect() {
-    return this.connectionManager.disconnect();
-  }
-  getConnectionState() {
-    return this.connectionManager.getConnectionState();
-  }
-  onConnectionStateChange(callback) {
-    return this.connectionManager.onConnectionStateChange(callback);
-  }
-  // EditorProtocol implementation - delegate to ConnectionManager
-  async publish(params) {
-    return this.connectionManager.sendMessage(params);
-  }
-  async saveImage(params) {
-    return this.connectionManager.sendMessage(params);
-  }
-  async hasImage(params) {
-    return this.connectionManager.sendMessage(params);
-  }
-  async send(params) {
-    return this.connectionManager.sendMessage(params);
-  }
-  // Get access to the underlying connection manager if needed
-  getConnectionManager() {
-    return this.connectionManager;
-  }
-}
-function createEditorClient(options) {
-  const connectionManager = new ConnectionManager(options);
-  return new EditorClient(connectionManager);
-}
-function createEditorClientWithConnectionManager(connectionManager) {
-  return new EditorClient(connectionManager);
-}
-exports.ConnectionManager = ConnectionManager;
-exports.EditorClient = EditorClient;
-exports.createConnectionManager = createConnectionManager;
-exports.createEditorClient = createEditorClient;
-exports.createEditorClientWithConnectionManager = createEditorClientWithConnectionManager;