@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-5V6HOU72.js

@@ -0,0 +1,319 @@
+// src/runtime/protocols/MQTTClient.ts
+var MQTTClient = class _MQTTClient {
+  config;
+  state = "disconnected";
+  subscriptions = /* @__PURE__ */ new Map();
+  messageQueue = [];
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  eventHandlers = /* @__PURE__ */ new Map();
+  // Simulated connection for environments without real MQTT
+  simulatedMode = false;
+  constructor(config) {
+    this.config = {
+      version: "5.0",
+      keepAlive: 60,
+      cleanSession: true,
+      reconnect: {
+        enabled: true,
+        maxAttempts: 10,
+        baseDelay: 1e3,
+        maxDelay: 3e4
+      },
+      ...config,
+      clientId: config.clientId || this.generateClientId()
+    };
+  }
+  // ===========================================================================
+  // CONNECTION MANAGEMENT
+  // ===========================================================================
+  /**
+   * Connect to the MQTT broker
+   */
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.state = "connecting";
+    this.emit("connect");
+    try {
+      await this.simulateConnect();
+      this.state = "connected";
+      this.reconnectAttempts = 0;
+      this.flushMessageQueue();
+    } catch (error) {
+      this.state = "disconnected";
+      this.emit("error", error);
+      if (this.config.reconnect?.enabled) {
+        this.scheduleReconnect();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from the MQTT broker
+   */
+  async disconnect() {
+    if (this.state === "disconnected" || this.state === "closed") {
+      return;
+    }
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.state = "closed";
+    this.emit("disconnect", "client_disconnect");
+    this.subscriptions.clear();
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.state === "connected";
+  }
+  // ===========================================================================
+  // PUBLISH / SUBSCRIBE
+  // ===========================================================================
+  /**
+   * Publish a message to a topic
+   */
+  async publish(topic, payload, options = {}) {
+    const { qos = 0, retain = false, properties } = options;
+    const serializedPayload = typeof payload === "object" && !(payload instanceof Buffer) ? JSON.stringify(payload) : payload;
+    if (this.state !== "connected") {
+      this.messageQueue.push({ topic, payload: serializedPayload, options });
+      return;
+    }
+    await this.simulatePublish(topic, serializedPayload, { qos, retain, properties });
+  }
+  /**
+   * Subscribe to a topic pattern
+   */
+  async subscribe(topicOrSubscription, handler) {
+    const subscription = typeof topicOrSubscription === "string" ? { topic: topicOrSubscription, qos: 0 } : topicOrSubscription;
+    const { topic } = subscription;
+    if (!this.subscriptions.has(topic)) {
+      this.subscriptions.set(topic, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(topic).add(handler);
+    if (this.state === "connected") {
+      await this.simulateSubscribe(subscription);
+    }
+  }
+  /**
+   * Unsubscribe from a topic
+   */
+  async unsubscribe(topic, handler) {
+    const handlers = this.subscriptions.get(topic);
+    if (!handlers) return;
+    if (handler) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.subscriptions.delete(topic);
+      }
+    } else {
+      this.subscriptions.delete(topic);
+    }
+    if (this.state === "connected" && !this.subscriptions.has(topic)) {
+      await this.simulateUnsubscribe(topic);
+    }
+  }
+  /**
+   * Get active subscriptions
+   */
+  getSubscriptions() {
+    return Array.from(this.subscriptions.keys());
+  }
+  // ===========================================================================
+  // EVENT HANDLING
+  // ===========================================================================
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`Error in MQTT event handler for ${event}:`, error);
+        }
+      }
+    }
+  }
+  // ===========================================================================
+  // TOPIC MATCHING
+  // ===========================================================================
+  /**
+   * Check if a topic matches a subscription pattern
+   * Supports + (single-level) and # (multi-level) wildcards
+   */
+  static matchTopic(pattern, topic) {
+    const patternParts = pattern.split("/");
+    const topicParts = topic.split("/");
+    for (let i = 0; i < patternParts.length; i++) {
+      const patternPart = patternParts[i];
+      if (patternPart === "#") {
+        return true;
+      }
+      if (i >= topicParts.length) {
+        return false;
+      }
+      if (patternPart !== "+" && patternPart !== topicParts[i]) {
+        return false;
+      }
+    }
+    return patternParts.length === topicParts.length;
+  }
+  // ===========================================================================
+  // MESSAGE PARSING
+  // ===========================================================================
+  /**
+   * Parse message payload based on content type
+   */
+  static parsePayload(message) {
+    const contentType = message.properties?.contentType || "";
+    const payloadStr = message.payload instanceof Buffer ? message.payload.toString("utf-8") : String(message.payload);
+    if (contentType.includes("json") || payloadStr.startsWith("{") || payloadStr.startsWith("[")) {
+      try {
+        return JSON.parse(payloadStr);
+      } catch {
+        return payloadStr;
+      }
+    }
+    const num = Number(payloadStr);
+    if (!isNaN(num)) {
+      return num;
+    }
+    return payloadStr;
+  }
+  // ===========================================================================
+  // PRIVATE METHODS
+  // ===========================================================================
+  generateClientId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `holoscript_${timestamp}_${random}`;
+  }
+  async simulateConnect() {
+    this.simulatedMode = true;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  async simulatePublish(topic, payload, options) {
+    const message = {
+      topic,
+      payload,
+      qos: options.qos || 0,
+      retain: options.retain || false,
+      properties: options.properties
+    };
+    this.deliverMessage(topic, message);
+  }
+  async simulateSubscribe(_subscription) {
+  }
+  async simulateUnsubscribe(_topic) {
+  }
+  deliverMessage(topic, message) {
+    for (const [pattern, handlers] of this.subscriptions) {
+      if (_MQTTClient.matchTopic(pattern, topic)) {
+        for (const handler of handlers) {
+          try {
+            handler(message);
+          } catch (error) {
+            console.error("Error in MQTT message handler:", error);
+          }
+        }
+      }
+    }
+    this.emit("message", topic, message);
+  }
+  scheduleReconnect() {
+    const config = this.config.reconnect;
+    if (this.reconnectAttempts >= (config.maxAttempts || 10)) {
+      this.state = "disconnected";
+      this.emit("error", new Error("Max reconnect attempts reached"));
+      return;
+    }
+    this.state = "reconnecting";
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      (config.baseDelay || 1e3) * Math.pow(2, this.reconnectAttempts - 1),
+      config.maxDelay || 3e4
+    );
+    this.emit("reconnect", this.reconnectAttempts);
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  flushMessageQueue() {
+    while (this.messageQueue.length > 0) {
+      const { topic, payload, options } = this.messageQueue.shift();
+      this.publish(topic, payload, options).catch((error) => {
+        console.error("Error publishing queued message:", error);
+      });
+    }
+  }
+  /**
+   * Inject a message for testing purposes
+   */
+  _injectMessage(topic, payload) {
+    const serializedPayload = typeof payload === "object" && !(payload instanceof Buffer) ? JSON.stringify(payload) : payload;
+    const message = {
+      topic,
+      payload: serializedPayload,
+      qos: 0,
+      retain: false
+    };
+    this.deliverMessage(topic, message);
+  }
+};
+function createMQTTClient(config) {
+  return new MQTTClient(config);
+}
+var clientRegistry = /* @__PURE__ */ new Map();
+function registerMQTTClient(name, client) {
+  clientRegistry.set(name, client);
+}
+function getMQTTClient(name) {
+  return clientRegistry.get(name);
+}
+function unregisterMQTTClient(name) {
+  const client = clientRegistry.get(name);
+  if (client) {
+    client.disconnect();
+    clientRegistry.delete(name);
+  }
+}
+
+export {
+  MQTTClient,
+  createMQTTClient,
+  registerMQTTClient,
+  getMQTTClient,
+  unregisterMQTTClient
+};