@coventia/softphone 0.1.0

package/dist/index.js

@@ -0,0 +1,630 @@
+import { isBrowser } from './chunk-KAXEMJ7E.js';
+export { isBrowser, isWebRtcSupported } from './chunk-KAXEMJ7E.js';
+export { CallEvent, SoftphoneEvent } from './chunk-N2N2EQQJ.js';
+import { isFatal } from './chunk-2ZSOGGPO.js';
+export { ERROR_CATALOGUE, isFatal } from './chunk-2ZSOGGPO.js';
+import { cachedTokenSource } from './chunk-MHOJHG5E.js';
+
+// src/core/emitter.ts
+var Emitter = class {
+  constructor(onListenerError) {
+    this.onListenerError = onListenerError;
+  }
+  onListenerError;
+  // A copy of the listener set is iterated on emit, so a listener that unsubscribes (or subscribes)
+  // during dispatch does not mutate the set mid-iteration.
+  #listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    const wrapped = (payload) => {
+      off();
+      listener(payload);
+    };
+    const off = this.on(event, wrapped);
+    return off;
+  }
+  off(event, listener) {
+    const set = this.#listeners.get(event);
+    if (!set) return;
+    set.delete(listener);
+    if (set.size === 0) this.#listeners.delete(event);
+  }
+  emit(event, payload) {
+    const set = this.#listeners.get(event);
+    if (!set) return;
+    for (const listener of [...set]) {
+      try {
+        listener(payload);
+      } catch (error) {
+        this.onListenerError?.(event, error);
+      }
+    }
+  }
+  /** Drop every listener. Called on teardown so a destroyed object leaks nothing. */
+  clear() {
+    this.#listeners.clear();
+  }
+};
+
+// src/core/call.ts
+var CALL_TRANSITIONS = {
+  ringing: ["answering", "ended"],
+  dialing: ["early", "active", "ended"],
+  early: ["active", "ended"],
+  answering: ["active", "ended"],
+  active: ["held", "reconnecting", "ended"],
+  held: ["active", "reconnecting", "ended"],
+  reconnecting: ["active", "held", "ended"],
+  ended: []
+};
+var INITIAL_STATES = {
+  inbound: "ringing",
+  outbound: "dialing"
+};
+function canTransition(from, to) {
+  return CALL_TRANSITIONS[from].includes(to);
+}
+function isTerminal(state) {
+  return CALL_TRANSITIONS[state].length === 0;
+}
+
+// src/core/call-impl.ts
+var CallImpl = class _CallImpl extends Emitter {
+  constructor(engineCall, onListenerError, onInternalError) {
+    super(onListenerError);
+    this.engineCall = engineCall;
+    this.onInternalError = onInternalError;
+    this.#onListenerError = onListenerError;
+    this.#state = INITIAL_STATES[engineCall.direction];
+    this.#remote = {
+      number: engineCall.remoteNumber,
+      displayName: engineCall.remoteNumber,
+      contact: null
+    };
+    this.#unsubscribe = engineCall.onEvent((event) => this.#onEngineEvent(event));
+  }
+  engineCall;
+  onInternalError;
+  #state;
+  #remote;
+  #answeredAt = null;
+  #muted = false;
+  #onHold = false;
+  #remoteStream = null;
+  #consultEngineCall = null;
+  #consultCall = null;
+  #unsubscribe;
+  #onListenerError;
+  get id() {
+    return this.engineCall.id;
+  }
+  get direction() {
+    return this.engineCall.direction;
+  }
+  get state() {
+    return this.#state;
+  }
+  get remote() {
+    return this.#remote;
+  }
+  get answeredAt() {
+    return this.#answeredAt;
+  }
+  get isMuted() {
+    return this.#muted;
+  }
+  get isOnHold() {
+    return this.#onHold;
+  }
+  get remoteStream() {
+    return this.#remoteStream;
+  }
+  // ── Raw engine signals → state machine ──────────────────────────────────────
+  #onEngineEvent(event) {
+    switch (event.type) {
+      case "progress":
+        this.#transition("early");
+        break;
+      case "accepted":
+        if (this.#answeredAt === null) this.#answeredAt = this.#now();
+        this.#transition("active");
+        this.emit("accepted" /* Accepted */, void 0);
+        break;
+      case "held":
+        this.#onHold = true;
+        if (this.#transition("held")) this.emit("held" /* Held */, { originator: event.originator });
+        break;
+      case "unheld":
+        this.#onHold = false;
+        if (this.#transition("active")) this.emit("unheld" /* Unheld */, { originator: event.originator });
+        break;
+      case "reconnecting":
+        if (this.#transition("reconnecting")) this.emit("reconnecting" /* Reconnecting */, void 0);
+        break;
+      case "reconnected":
+        if (this.#transition(this.#onHold ? "held" : "active"))
+          this.emit("reconnected" /* Reconnected */, void 0);
+        break;
+      case "ended":
+        this.#end(event.reason);
+        break;
+      case "stream":
+        this.#remoteStream = event.stream;
+        this.emit("remoteStream" /* RemoteStream */, { stream: event.stream });
+        break;
+    }
+  }
+  // ── Commands ────────────────────────────────────────────────────────────────
+  async answer() {
+    if (this.#state !== "ringing") {
+      throw this.#stateError("answer", "call/not-answerable");
+    }
+    this.#transition("answering");
+    await this.engineCall.answer();
+  }
+  async reject() {
+    if (this.#state !== "ringing") {
+      throw this.#stateError("reject", "call/not-answerable");
+    }
+    await this.engineCall.reject();
+  }
+  async hangup() {
+    if (isTerminal(this.#state)) return;
+    await this.engineCall.hangup();
+  }
+  mute(muted) {
+    if (this.#muted === muted) return;
+    this.#muted = muted;
+    this.engineCall.mute(muted);
+    this.emit("muted" /* Muted */, { muted });
+  }
+  async hold() {
+    if (this.#onHold || this.#state !== "active" && this.#state !== "reconnecting") return;
+    await this.engineCall.hold();
+  }
+  async unhold() {
+    if (!this.#onHold) return;
+    await this.engineCall.unhold();
+  }
+  sendDigits(digits) {
+    this.engineCall.sendDigits(digits);
+    this.emit("digitsSent" /* DigitsSent */, { digits });
+  }
+  async transfer(target) {
+    await this.engineCall.transfer(target);
+  }
+  async startConsult(target) {
+    await this.hold();
+    const consultEngineCall = await this.engineCall.startConsult(target);
+    this.#consultEngineCall = consultEngineCall;
+    const consult = new _CallImpl(consultEngineCall, this.#onListenerError, this.onInternalError);
+    this.#consultCall = consult;
+    return consult;
+  }
+  async completeTransfer() {
+    if (!this.#consultEngineCall) throw this.#stateError("completeTransfer", "call/unsupported");
+    await this.engineCall.completeTransfer(this.#consultEngineCall);
+  }
+  async cancelConsult() {
+    if (!this.#consultCall) return;
+    await this.#consultCall.hangup();
+    this.#consultCall = null;
+    this.#consultEngineCall = null;
+    await this.unhold();
+  }
+  // ── Internals ───────────────────────────────────────────────────────────────
+  #transition(to) {
+    const from = this.#state;
+    if (from === to) return false;
+    if (isTerminal(from)) return false;
+    if (!canTransition(from, to)) {
+      this.onInternalError?.(`illegal call transition ${from} \u2192 ${to} (SPEC \xA75.3)`);
+      return false;
+    }
+    this.#state = to;
+    this.emit("stateChanged" /* StateChanged */, { state: to, previous: from });
+    return true;
+  }
+  #end(reason) {
+    if (isTerminal(this.#state)) return;
+    const from = this.#state;
+    this.#state = "ended";
+    this.emit("stateChanged" /* StateChanged */, { state: "ended", previous: from });
+    this.emit("ended" /* Ended */, { reason });
+    this.#unsubscribe();
+    this.clear();
+  }
+  #stateError(op, _code) {
+    return new Error(`${op}() is not valid while call is '${this.#state}'`);
+  }
+  #now() {
+    return /* @__PURE__ */ new Date();
+  }
+  /** @internal — the Softphone updates caller identity once `resolveContact` resolves. */
+  setRemoteContact(contact) {
+    this.#remote = {
+      number: this.#remote.number,
+      displayName: contact.name ?? this.#remote.number,
+      contact
+    };
+    this.emit("remotePartyUpdated" /* RemotePartyUpdated */, void 0);
+  }
+};
+
+// src/core/backend.ts
+function coventiaBackend(config, tokenSource, fallbackBaseUrl) {
+  const baseUrl = config.baseUrl ?? fallbackBaseUrl;
+  if (!baseUrl) {
+    throw new Error(
+      "No base URL for the Coventia backend. Pass `coventia.baseUrl`, or a top-level `apiBase` on `createSoftphone` for it to fall back to."
+    );
+  }
+  let pending = null;
+  const load = () => {
+    pending ??= import('./sources-N4BOEDRL.js').then(
+      (m) => m.coventiaSources({ ...config, baseUrl, tokenSource })
+    );
+    return pending;
+  };
+  return {
+    contacts: async (params) => (await load()).contacts(params),
+    history: async (params) => (await load()).history(params),
+    resolveContact: async (number) => (await load()).resolveContact(number),
+    listAgents: async () => (await load()).listAgents()
+  };
+}
+
+// src/core/tabs.ts
+var LOCK_NAME = "coventia-softphone:leader";
+function isWebLocksSupported() {
+  return isBrowser() && typeof navigator.locks?.request === "function";
+}
+function webLocksTabLock(lockName = LOCK_NAME) {
+  const controller = new AbortController();
+  let releaseHold;
+  return {
+    acquireLeadership() {
+      if (!isWebLocksSupported()) return Promise.resolve();
+      return new Promise((resolveAcquired) => {
+        navigator.locks.request(lockName, { signal: controller.signal }, () => {
+          resolveAcquired();
+          return new Promise((resolveHold) => {
+            releaseHold = resolveHold;
+          });
+        }).catch(() => {
+        });
+      });
+    },
+    release() {
+      if (releaseHold) {
+        const resolve = releaseHold;
+        releaseHold = void 0;
+        resolve();
+      } else {
+        controller.abort();
+      }
+    }
+  };
+}
+
+// src/core/softphone-impl.ts
+var liveInstance = false;
+var BrowserAudioDevices = class {
+  inputs = [];
+  outputs = [];
+  currentInputId = null;
+  currentOutputId = null;
+  canSelectOutput;
+  #engine;
+  #onChange;
+  constructor(engine, onChange) {
+    this.#engine = engine;
+    this.#onChange = onChange;
+    this.canSelectOutput = isBrowser() && typeof HTMLMediaElement !== "undefined" && "setSinkId" in HTMLMediaElement.prototype;
+    if (isBrowser() && navigator.mediaDevices) {
+      void this.refresh();
+      navigator.mediaDevices.addEventListener?.("devicechange", () => void this.refresh());
+    }
+  }
+  async refresh() {
+    if (!isBrowser() || typeof navigator.mediaDevices?.enumerateDevices !== "function") return;
+    let all;
+    try {
+      all = await navigator.mediaDevices.enumerateDevices();
+    } catch {
+      return;
+    }
+    this.inputs = all.filter((d) => d.kind === "audioinput");
+    this.outputs = all.filter((d) => d.kind === "audiooutput");
+    if (this.currentInputId && !this.inputs.some((d) => d.deviceId === this.currentInputId)) {
+      this.currentInputId = null;
+    }
+    if (this.currentOutputId && !this.outputs.some((d) => d.deviceId === this.currentOutputId)) {
+      this.currentOutputId = null;
+    }
+    this.#onChange();
+  }
+  async setInput(deviceId) {
+    this.currentInputId = deviceId;
+    this.#onChange();
+    await this.#engine.setInputDevice?.(deviceId);
+  }
+  async setOutput(deviceId) {
+    this.currentOutputId = deviceId;
+    this.#onChange();
+  }
+  async setRingtoneOutput() {
+  }
+};
+var SoftphoneImpl = class extends Emitter {
+  #state = "stopped";
+  #lastError = null;
+  #activeCall = null;
+  #destroyed = false;
+  #startedHere = false;
+  #isLeader = false;
+  #engine;
+  #tabLock;
+  #resolveContact;
+  /** Contacts + history, whenever there is a Coventia backend to reach. The widget reads these. */
+  sources;
+  audio;
+  /**
+   * `tabLock` defaults to the real Web Locks implementation — not part of `SoftphoneConfig` (an
+   * internal seam, not something an integrator tunes). Tests construct this class directly with a
+   * fake for deterministic control; `createSoftphone()` never passes a third argument, so every
+   * existing test that goes through it is unaffected (`multi-tab-leader-election.md` §3.8).
+   */
+  constructor(engine, config, tabLock = webLocksTabLock()) {
+    super();
+    this.#engine = engine;
+    this.#tabLock = tabLock;
+    this.audio = new BrowserAudioDevices(
+      this.#engine,
+      () => this.emit("deviceChange" /* DeviceChange */, void 0)
+    );
+    this.sources = config.coventia || config.apiBase ? coventiaBackend(config.coventia ?? {}, cachedTokenSource(config.tokenSource), config.apiBase) : null;
+    this.#resolveContact = config.resolveContact ?? this.sources?.resolveContact;
+    this.#engine.onIncoming((engineCall) => this.#onIncoming(engineCall));
+    this.#engine.onStateChange((state) => this.#setState(state));
+    this.#engine.onError?.((error) => this.#onError(error));
+  }
+  get state() {
+    return this.#state;
+  }
+  get lastError() {
+    return this.#lastError;
+  }
+  get isLeader() {
+    return this.#isLeader;
+  }
+  get activeCall() {
+    return this.#activeCall;
+  }
+  get canPlayAudio() {
+    return true;
+  }
+  async startAudio() {
+  }
+  async start() {
+    this.#assertUsable();
+    if (this.#startedHere) return;
+    if (liveInstance) {
+      throw new Error(
+        "A Softphone is already running on this page. Construct one and share it; call destroy() before starting another. (SPEC \xA75.3 / error engine/duplicate-instance)"
+      );
+    }
+    liveInstance = true;
+    this.#startedHere = true;
+    this.#setState("starting");
+    await this.#tabLock.acquireLeadership();
+    if (this.#destroyed) return;
+    this.#setLeader(true);
+    await this.#engine.start();
+  }
+  async stop() {
+    if (!this.#startedHere) return;
+    this.#tabLock.release();
+    if (this.#isLeader) {
+      await this.#engine.stop();
+      if (this.#activeCall) await this.#activeCall.hangup().catch(() => {
+      });
+    }
+    this.#setLeader(false);
+    this.#releaseInstance();
+    this.#setState("stopped");
+  }
+  async destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+    await this.stop().catch(() => {
+    });
+    this.#setState("destroyed");
+    this.clear();
+  }
+  async call(destination, options) {
+    this.#assertUsable();
+    if (this.#state !== "online" && this.#state !== "offline" && this.#state !== "starting") {
+      throw new Error(`Cannot place a call while softphone is '${this.#state}'.`);
+    }
+    if (this.#activeCall) {
+      throw new Error("A call is already in progress. Hang up before placing another.");
+    }
+    const engineCall = await this.#engine.placeCall(destination, options);
+    return this.#adopt(engineCall);
+  }
+  // ── internals ───────────────────────────────────────────────────────────────
+  #onIncoming(engineCall) {
+    if (this.#activeCall) {
+      void engineCall.reject().catch(() => {
+      });
+      return;
+    }
+    const call = this.#adopt(engineCall);
+    this.emit("incomingCall" /* IncomingCall */, call);
+  }
+  #adopt(engineCall) {
+    const call = new CallImpl(
+      engineCall,
+      (event, error) => this.#reportListenerError("call", event, error),
+      (message) => this.#reportInternalError(message)
+    );
+    this.#activeCall = call;
+    const off = call.on("ended" /* Ended */, () => {
+      off();
+      if (this.#activeCall === call) {
+        this.#activeCall = null;
+        this.emit("activeCallChanged" /* ActiveCallChanged */, { call: null });
+      }
+    });
+    if (this.#resolveContact) {
+      void this.#resolveContact(engineCall.remoteNumber).then((contact) => {
+        if (contact && this.#activeCall === call) call.setRemoteContact(contact);
+      }).catch(() => {
+      });
+    }
+    this.emit("activeCallChanged" /* ActiveCallChanged */, { call });
+    return call;
+  }
+  #setState(state) {
+    if (state === this.#state) return;
+    const previous = this.#state;
+    this.#state = state;
+    if (state === "online") this.#lastError = null;
+    this.emit("stateChanged" /* StateChanged */, { state, previous });
+  }
+  #setLeader(isLeader) {
+    if (isLeader === this.#isLeader) return;
+    this.#isLeader = isLeader;
+    this.emit("leaderChanged" /* LeaderChanged */, { isLeader });
+  }
+  /**
+   * Re-emit an engine failure to the host, and remember it if it is fatal.
+   *
+   * Every error is emitted; only fatal ones are retained. A non-fatal error is a fact about one call
+   * — the remote party was busy — and keeping it as softphone state would make a working phone look
+   * broken to anything that renders `lastError`.
+   */
+  #onError(error) {
+    if (isFatal(error)) this.#lastError = error;
+    this.emit("error" /* Error */, error);
+  }
+  #releaseInstance() {
+    if (this.#startedHere) {
+      liveInstance = false;
+      this.#startedHere = false;
+    }
+  }
+  #assertUsable() {
+    if (this.#destroyed) {
+      throw new Error("This Softphone has been destroyed. Construct a new one. (engine/destroyed)");
+    }
+  }
+  #reportListenerError(source, event, error) {
+    console.error(`[softphone] a ${source} '${String(event)}' listener threw:`, error);
+  }
+  #reportInternalError(message) {
+    console.error(`[softphone] ${message}`);
+  }
+};
+
+// src/core/default-provider.ts
+var LazyRelay = class {
+  #listeners = /* @__PURE__ */ new Set();
+  #realOff = /* @__PURE__ */ new Map();
+  #target = null;
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    if (this.#target) this.#realOff.set(listener, this.#target.on(listener));
+    return () => {
+      this.#listeners.delete(listener);
+      this.#realOff.get(listener)?.();
+      this.#realOff.delete(listener);
+    };
+  }
+  /** Called once the real engine exists — replays every listener registered before now onto it. */
+  attach(target) {
+    this.#target = target;
+    for (const listener of this.#listeners) this.#realOff.set(listener, target.on(listener));
+  }
+};
+function defaultZadarmaEngine(config) {
+  let real = null;
+  let pending = null;
+  const incoming = new LazyRelay();
+  const stateChange = new LazyRelay();
+  const error = new LazyRelay();
+  function load() {
+    pending ??= import('./zadarma-engine-DN2SZSQ3.js').then(({ createZadarmaEngine }) => {
+      const engine = createZadarmaEngine(config);
+      incoming.attach({ on: (l) => engine.onIncoming(l) });
+      stateChange.attach({ on: (l) => engine.onStateChange(l) });
+      error.attach({ on: (l) => engine.onError?.(l) ?? (() => {
+      }) });
+      real = engine;
+      return engine;
+    }).catch((cause) => {
+      pending = null;
+      throw cause;
+    });
+    return pending;
+  }
+  return {
+    get state() {
+      return real?.state ?? "stopped";
+    },
+    async start() {
+      await (await load()).start();
+    },
+    async stop() {
+      if (real) await real.stop();
+    },
+    async placeCall(destination, options) {
+      return (await load()).placeCall(destination, options);
+    },
+    onIncoming: (listener) => incoming.subscribe(listener),
+    onStateChange: (listener) => stateChange.subscribe(listener),
+    onError: (listener) => error.subscribe(listener)
+  };
+}
+
+// src/core/create.ts
+function createSoftphone(config) {
+  return new SoftphoneImpl(resolveEngine(config), config);
+}
+function resolveEngine(config) {
+  if (config.provider !== void 0) {
+    if (isCallEngine(config.provider)) return config.provider;
+    throw new Error(
+      '`config.provider` was set but is not a valid CallEngine \u2014 it needs at least `placeCall` and `onIncoming`. Pass `createZadarmaEngine(...)` from "@coventia/softphone/zadarma", a `MockProvider` from "@coventia/softphone/testing", or omit it entirely to use the default.'
+    );
+  }
+  if (config.apiBase) {
+    return defaultZadarmaEngine({
+      apiBase: config.apiBase,
+      tokenSource: config.tokenSource,
+      organizationId: config.coventia?.organizationId
+    });
+  }
+  throw new Error(
+    'No call engine configured. Pass `config.provider` explicitly \u2014 `createZadarmaEngine({ apiBase, tokenSource })` from "@coventia/softphone/zadarma", or a `MockProvider` from "@coventia/softphone/testing" \u2014 or set `config.apiBase` so a default Zadarma engine can be built.'
+  );
+}
+function isCallEngine(value) {
+  return typeof value === "object" && value !== null && typeof value.placeCall === "function" && typeof value.onIncoming === "function";
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+
+export { CALL_TRANSITIONS, INITIAL_STATES, VERSION, canTransition, createSoftphone, isTerminal };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map