z-ipc/build/adapters/index.cjs

Z-IPC is an easy-to-use, extensible and fully type-safe IPC solution for JavaScript environments.

"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/adapters/index.ts
var adapters_exports = {};
__export(adapters_exports, {
  createClusterAdapter: () => createClusterAdapter,
  createDebugLogAdapter: () => createDebugLogAdapter,
  createProxyAdapter: () => createProxyAdapter,
  createSerializedAdapter: () => createSerializedAdapter
});
module.exports = __toCommonJS(adapters_exports);

// src/core/adapter.ts
function defineAdapter(adapter) {
  return adapter;
}

// src/adapters/cluster.ts
function createClusterAdapter(adapter, ...adapters) {
  const adapterPool = [adapter, ...adapters];
  return defineAdapter({
    publish: (message) => {
      for (const adapter2 of adapterPool) {
        adapter2.publish(message);
      }
    },
    subscribe: (callback) => {
      for (const adapter2 of adapterPool) {
        adapter2.subscribe(callback);
      }
    },
    unsubscribe: (callback) => {
      for (const adapter2 of adapterPool) {
        adapter2.unsubscribe(callback);
      }
    }
  });
}

// src/adapters/debug-log.ts
function createDebugLogAdapter(adapter, name) {
  adapter.subscribe((message) => {
    console.log(`[${name}] message`, message);
  });
  return defineAdapter({
    publish: (message) => {
      console.log(`[${name}] publish`, message);
      adapter.publish(message);
    },
    subscribe: (listener) => {
      console.log(`[${name}] subscribe`);
      return adapter.subscribe(listener);
    },
    unsubscribe: (listener) => {
      console.log(`[${name}] unsubscribe`);
      return adapter.unsubscribe(listener);
    }
  });
}

// src/adapters/proxy.ts
function createProxyAdapter(source, destination) {
  source.subscribe((message) => destination.publish(message));
  return source;
}

// src/adapters/serializer.ts
function createSerializedAdapter(adapter, serializer) {
  const wrappedSubscribers = /* @__PURE__ */ new Map();
  return defineAdapter({
    publish: (message) => {
      adapter.publish(serializer.stringify(message));
    },
    subscribe: (callback) => {
      const wrappedCallback = (message) => {
        callback(serializer.parse(message));
      };
      adapter.subscribe(wrappedCallback);
      wrappedSubscribers.set(callback, wrappedCallback);
    },
    unsubscribe: (callback) => {
      const wrappedCallback = wrappedSubscribers.get(callback);
      if (!wrappedCallback) {
        return;
      }
      adapter.unsubscribe(wrappedCallback);
      wrappedSubscribers.delete(callback);
    }
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createClusterAdapter,
  createDebugLogAdapter,
  createProxyAdapter,
  createSerializedAdapter
});