@moxxy/cli 0.0.2 → 0.0.3

package/dist/chunk-6DZX6EAA.mjs

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-C46NSEKG.mjs

@@ -0,0 +1,211 @@
+// ../integration-base/dist/index.mjs
+var IntegrationError = class extends Error {
+  constructor(message, integration, code, cause) {
+    super(message);
+    this.integration = integration;
+    this.code = code;
+    this.cause = cause;
+    this.name = "IntegrationError";
+  }
+};
+var IntegrationConnectionError = class extends IntegrationError {
+  constructor(message, integration, cause) {
+    super(message, integration, "CONNECTION_ERROR", cause);
+    this.name = "IntegrationConnectionError";
+  }
+};
+var IntegrationConfigError = class extends IntegrationError {
+  constructor(message, integration, cause) {
+    super(message, integration, "CONFIG_ERROR", cause);
+    this.name = "IntegrationConfigError";
+  }
+};
+var IntegrationNotFoundError = class extends IntegrationError {
+  constructor(integration) {
+    super(`Integration "${integration}" not found`, integration, "NOT_FOUND");
+    this.name = "IntegrationNotFoundError";
+  }
+};
+var BaseIntegration = class {
+  constructor(name, type) {
+    this.name = name;
+    this.type = type;
+  }
+  _status = "disconnected";
+  handlers = /* @__PURE__ */ new Map();
+  get status() {
+    return this._status;
+  }
+  async connect(config) {
+    if (this._status === "connected" || this._status === "watching") {
+      return;
+    }
+    this._status = "connecting";
+    try {
+      await this.onConnect(config);
+      this._status = "connected";
+    } catch (error) {
+      this._status = "error";
+      throw new IntegrationConnectionError(
+        `Failed to connect integration "${this.name}": ${error instanceof Error ? error.message : String(error)}`,
+        this.name,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async disconnect() {
+    if (this._status === "disconnected") {
+      return;
+    }
+    try {
+      await this.onDisconnect();
+    } finally {
+      this._status = "disconnected";
+    }
+  }
+  async watch(targets) {
+    if (this._status !== "connected" && this._status !== "watching") {
+      throw new IntegrationConnectionError(
+        `Cannot watch: integration "${this.name}" is not connected`,
+        this.name
+      );
+    }
+    await this.onWatch(targets);
+    this._status = "watching";
+  }
+  async unwatch(targets) {
+    if (this._status !== "watching") {
+      return;
+    }
+    await this.onUnwatch(targets);
+    this._status = "connected";
+  }
+  async dispose() {
+    if (this._status !== "disconnected") {
+      await this.disconnect();
+    }
+    this.handlers.clear();
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+  }
+  off(event, handler) {
+    const set = this.handlers.get(event);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+  emit(type, data) {
+    const event = {
+      type,
+      integration: this.name,
+      data,
+      timestamp: Date.now()
+    };
+    const specificHandlers = this.handlers.get(type);
+    if (specificHandlers) {
+      for (const handler of specificHandlers) {
+        handler(event);
+      }
+    }
+    const wildcardHandlers = this.handlers.get("*");
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        handler(event);
+      }
+    }
+  }
+};
+var IntegrationManager = class {
+  integrations = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  integrationListeners = /* @__PURE__ */ new Map();
+  register(integration) {
+    this.integrations.set(integration.name, integration);
+    const listener = (event) => {
+      this.emitToHandlers(event);
+    };
+    this.integrationListeners.set(integration.name, listener);
+    integration.on("*", listener);
+  }
+  unregister(name) {
+    const integration = this.integrations.get(name);
+    if (!integration) {
+      return;
+    }
+    const listener = this.integrationListeners.get(name);
+    if (listener) {
+      integration.off("*", listener);
+      this.integrationListeners.delete(name);
+    }
+    this.integrations.delete(name);
+  }
+  get(name) {
+    return this.integrations.get(name);
+  }
+  getAll() {
+    return Array.from(this.integrations.values());
+  }
+  async startAll() {
+    const promises = [];
+    for (const integration of this.integrations.values()) {
+      promises.push(integration.connect({}));
+    }
+    await Promise.all(promises);
+  }
+  async stopAll() {
+    const promises = [];
+    for (const integration of this.integrations.values()) {
+      promises.push(integration.disconnect());
+    }
+    await Promise.all(promises);
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+  }
+  off(event, handler) {
+    const set = this.handlers.get(event);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+  emitToHandlers(event) {
+    const specificHandlers = this.handlers.get(event.type);
+    if (specificHandlers) {
+      for (const handler of specificHandlers) {
+        handler(event);
+      }
+    }
+    const wildcardHandlers = this.handlers.get("*");
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        handler(event);
+      }
+    }
+  }
+};
+
+export {
+  IntegrationError,
+  IntegrationConnectionError,
+  IntegrationConfigError,
+  IntegrationNotFoundError,
+  BaseIntegration,
+  IntegrationManager
+};