joopjs 2.0.0

package/dist/api/index.mjs

@@ -0,0 +1,1332 @@
+// src/models/error.models.ts
+var JoopHttpError = class extends Error {
+  constructor(statusCode, statusText, body) {
+    super(`HTTP ${statusCode}: ${statusText}`);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "JoopHttpError";
+  }
+  statusCode;
+  statusText;
+  body;
+};
+var JoopEncryptionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JoopEncryptionError";
+  }
+};
+
+// src/api/http/http-client.ts
+var JoopHttpClient = class {
+  async request(method, url, options = {}) {
+    const { headers = {}, body, timeout } = options;
+    let signal = options.signal;
+    let timeoutId;
+    if (timeout && !signal) {
+      const controller = new AbortController();
+      signal = controller.signal;
+      timeoutId = setTimeout(() => controller.abort(), timeout);
+    }
+    const isFormData = body instanceof FormData;
+    const fetchInit = {
+      method,
+      signal,
+      headers: isFormData ? headers : { "Content-Type": "application/json", ...headers },
+      body: body === void 0 || body === null ? void 0 : isFormData ? body : JSON.stringify(body)
+    };
+    try {
+      const res = await fetch(url, fetchInit);
+      if (!res.ok) {
+        let errorBody;
+        try {
+          errorBody = await res.json();
+        } catch {
+        }
+        throw new JoopHttpError(res.status, res.statusText, errorBody);
+      }
+      const text = await res.text();
+      return text ? JSON.parse(text) : void 0;
+    } finally {
+      if (timeoutId !== void 0) clearTimeout(timeoutId);
+    }
+  }
+  get(url, options) {
+    return this.request("GET" /* Get */, url, options);
+  }
+  post(url, body, options) {
+    return this.request("POST" /* Post */, url, { ...options, body });
+  }
+  put(url, body, options) {
+    return this.request("PUT" /* Put */, url, { ...options, body });
+  }
+  patch(url, body, options) {
+    return this.request("PATCH" /* Patch */, url, { ...options, body });
+  }
+  delete(url, options) {
+    return this.request("DELETE" /* Delete */, url, options);
+  }
+  /** Upload files with progress via XMLHttpRequest (fetch does not expose upload progress). */
+  uploadWithProgress(url, formData, onProgress, headers = {}) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open("POST", url);
+      Object.entries(headers).forEach(([k, v]) => xhr.setRequestHeader(k, v));
+      xhr.upload.onprogress = (e) => {
+        if (e.lengthComputable) onProgress(Math.round(e.loaded / e.total * 100));
+      };
+      xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve(xhr.responseText ? JSON.parse(xhr.responseText) : void 0);
+        } else {
+          reject(new JoopHttpError(xhr.status, xhr.statusText));
+        }
+      };
+      xhr.onerror = () => reject(new JoopHttpError(0, "Network error"));
+      xhr.send(formData);
+    });
+  }
+};
+
+// src/events/index.ts
+var JoopSubject = class {
+  _listeners = [];
+  subscribe(listener) {
+    this._listeners.push(listener);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== listener);
+    };
+  }
+  next(value) {
+    for (const listener of this._listeners) {
+      listener(value);
+    }
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopBehaviorSubject = class extends JoopSubject {
+  _value;
+  constructor(initialValue) {
+    super();
+    this._value = initialValue;
+  }
+  getValue() {
+    return this._value;
+  }
+  next(value) {
+    this._value = value;
+    super.next(value);
+  }
+  subscribe(listener) {
+    listener(this._value);
+    return super.subscribe(listener);
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopObservable = class {
+  constructor(_subscribeFn) {
+    this._subscribeFn = _subscribeFn;
+  }
+  _subscribeFn;
+  subscribe(listener) {
+    return this._subscribeFn(listener);
+  }
+  /** Returns the current value without subscribing (only meaningful for BehaviorSubject-backed observables). */
+  getOnce() {
+    let result;
+    const unsub = this.subscribe((v) => {
+      result = v;
+    });
+    unsub();
+    return result;
+  }
+};
+
+// src/constants/index.ts
+var DECRYPTION_FAILED = "Response decryption failed";
+
+// src/utilities/common.utility.ts
+function removeTrailingSlash(url) {
+  return url?.endsWith("/") ? url.slice(0, -1) : url;
+}
+function objectToQueryString(obj) {
+  return Object.entries(obj).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+}
+
+// src/api/request.service.ts
+var JoopRequestService = class {
+  constructor(_http, _config, _profile, _aes) {
+    this._http = _http;
+    this._config = _config;
+    this._profile = _profile;
+    this._aes = _aes;
+  }
+  _http;
+  _config;
+  _profile;
+  _aes;
+  _loading$ = new JoopBehaviorSubject({ active: false, count: 0 });
+  _requestCount = 0;
+  /** Observable loading state — subscribe in any framework to drive a spinner. */
+  loading$() {
+    return this._loading$.asObservable();
+  }
+  isLoading() {
+    return this._loading$.getValue().active;
+  }
+  /**
+   * Send a service request to the configured base URL.
+   * @param serviceId  Service/endpoint identifier appended to the base URL
+   * @param data       Request payload
+   * @param options    Loader, error, method overrides
+   */
+  async send(serviceId, data = {}, options = {}) {
+    const { useLoader = true, method = "POST" /* Post */, headers = {} } = options;
+    if (useLoader) this._incrementLoader();
+    try {
+      const url = this._buildUrl(serviceId);
+      const body = await this._prepareBody(data);
+      const fetchOpts = {
+        headers,
+        timeout: this._config.requestTimeout
+      };
+      let response;
+      if (method === "GET" /* Get */) {
+        const qs = objectToQueryString(body);
+        response = await this._http.get(`${url}?${qs}`, fetchOpts);
+      } else {
+        response = await this._http.post(url, body, fetchOpts);
+      }
+      return await this._handleResponse(response);
+    } finally {
+      if (useLoader) this._decrementLoader();
+    }
+  }
+  /** Upload a file with progress. */
+  async upload(serviceId, formData, onProgress) {
+    const url = this._buildUrl(serviceId);
+    this._incrementLoader();
+    try {
+      const res = await this._http.uploadWithProgress(url, formData, onProgress);
+      return await this._handleResponse(res);
+    } finally {
+      this._decrementLoader();
+    }
+  }
+  _buildUrl(serviceId) {
+    const base = removeTrailingSlash(this._config.baseUrl);
+    return `${base}/${serviceId}`;
+  }
+  async _prepareBody(data) {
+    if (!this._aes.isE2EEnabled(this._profile.isInitialRequest)) {
+      return data;
+    }
+    const serialized = objectToQueryString(data);
+    const encrypted = await this._aes.processEncryption(serialized, this._profile.pageToken);
+    return encrypted;
+  }
+  async _handleResponse(response) {
+    if (response?.encrypted && response?.encryptedData) {
+      try {
+        const decrypted = await this._aes.decryptResponse(response.encryptedData);
+        return JSON.parse(decrypted);
+      } catch {
+        throw new JoopEncryptionError(DECRYPTION_FAILED);
+      }
+    }
+    return response;
+  }
+  _incrementLoader() {
+    this._requestCount++;
+    this._loading$.next({ active: true, count: this._requestCount });
+  }
+  _decrementLoader() {
+    this._requestCount = Math.max(0, this._requestCount - 1);
+    this._loading$.next({ active: this._requestCount > 0, count: this._requestCount });
+  }
+};
+function isHttpError(err, status) {
+  return err instanceof JoopHttpError && (status === void 0 || err.statusCode === status);
+}
+
+// src/api/http/interceptor.ts
+var JoopInterceptorPipeline = class {
+  _req = [];
+  _res = [];
+  _err = [];
+  addRequestInterceptor(fn) {
+    this._req.push(fn);
+    return () => {
+      this._req = this._req.filter((i) => i !== fn);
+    };
+  }
+  addResponseInterceptor(fn) {
+    this._res.push(fn);
+    return () => {
+      this._res = this._res.filter((i) => i !== fn);
+    };
+  }
+  addErrorInterceptor(fn) {
+    this._err.push(fn);
+    return () => {
+      this._err = this._err.filter((i) => i !== fn);
+    };
+  }
+  async processRequest(req) {
+    let cur = req;
+    for (const fn of this._req) cur = await fn(cur);
+    return cur;
+  }
+  async processResponse(res) {
+    let cur = res;
+    for (const fn of this._res) cur = await fn(cur);
+    return cur;
+  }
+  async processError(err) {
+    let cur = err;
+    for (const fn of this._err) cur = await fn(cur);
+    return cur;
+  }
+  clear() {
+    this._req = [];
+    this._res = [];
+    this._err = [];
+  }
+};
+
+// src/api/http/retry.ts
+var DEFAULTS = {
+  maxAttempts: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 3e4,
+  jitter: true
+};
+async function withRetry(fn, config = {}) {
+  const cfg = { ...DEFAULTS, ...config };
+  let lastError;
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt === cfg.maxAttempts) break;
+      if (cfg.retryOn && !cfg.retryOn(err, attempt)) break;
+      await _sleep(_calcDelay(attempt, cfg));
+    }
+  }
+  throw lastError;
+}
+function _calcDelay(attempt, cfg) {
+  const exp = Math.min(cfg.baseDelayMs * Math.pow(2, attempt - 1), cfg.maxDelayMs);
+  return cfg.jitter ? Math.floor(Math.random() * exp) : exp;
+}
+function _sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/api/http/circuit-breaker.ts
+var JoopCircuitBreakerOpenError = class extends Error {
+  nextAttemptAt;
+  constructor(name, nextAttemptAt) {
+    super(`Circuit "${name}" is OPEN. Retry after ${new Date(nextAttemptAt).toISOString()}`);
+    this.name = "JoopCircuitBreakerOpenError";
+    this.nextAttemptAt = nextAttemptAt;
+  }
+};
+var JoopCircuitBreaker = class {
+  _name;
+  failureThreshold;
+  successThreshold;
+  timeoutMs;
+  volumeThreshold;
+  onStateChangeFn;
+  _state = "closed";
+  _failures = 0;
+  _successes = 0;
+  _totalCalls = 0;
+  _lastFailureAt;
+  _openedAt;
+  constructor(nameOrConfig, config = {}) {
+    const merged = typeof nameOrConfig === "string" ? { name: nameOrConfig, ...config } : { ...nameOrConfig, ...config };
+    this._name = merged.name ?? "default";
+    this.failureThreshold = merged.failureThreshold ?? 5;
+    this.successThreshold = merged.successThreshold ?? 2;
+    this.timeoutMs = merged.timeoutMs ?? 3e4;
+    this.volumeThreshold = merged.volumeThreshold ?? 1;
+    this.onStateChangeFn = merged.onStateChange;
+  }
+  get state() {
+    return this._state;
+  }
+  get name() {
+    return this._name;
+  }
+  setState(to) {
+    if (to === this._state) return;
+    const from = this._state;
+    this._state = to;
+    if (to === "open") this._openedAt = Date.now();
+    this.onStateChangeFn?.(from, to, this._name);
+  }
+  recordSuccess() {
+    this._successes++;
+    this._failures = 0;
+    if (this._state === "half-open" && this._successes >= this.successThreshold) {
+      this._successes = 0;
+      this.setState("closed");
+    }
+  }
+  recordFailure() {
+    this._failures++;
+    this._lastFailureAt = Date.now();
+    this._successes = 0;
+    if (this._state === "half-open") {
+      this.setState("open");
+    } else if (this._state === "closed" && this._totalCalls >= this.volumeThreshold && this._failures >= this.failureThreshold) {
+      this.setState("open");
+    }
+  }
+  canAttempt() {
+    if (this._state !== "open") return true;
+    if (Date.now() - (this._openedAt ?? 0) >= this.timeoutMs) {
+      this.setState("half-open");
+      this._successes = 0;
+      return true;
+    }
+    return false;
+  }
+  /** Primary execution method — throws JoopCircuitBreakerOpenError when open. */
+  async execute(fn) {
+    if (!this.canAttempt()) {
+      throw new JoopCircuitBreakerOpenError(this._name, (this._openedAt ?? 0) + this.timeoutMs);
+    }
+    this._totalCalls++;
+    try {
+      const result = await fn();
+      this.recordSuccess();
+      return result;
+    } catch (err) {
+      this.recordFailure();
+      throw err;
+    }
+  }
+  /** Alias kept for back-compat with original `call()` interface. */
+  async call(fn) {
+    return this.execute(fn);
+  }
+  async executeWithFallback(fn, fallback) {
+    try {
+      return await this.execute(fn);
+    } catch {
+      return fallback();
+    }
+  }
+  getState() {
+    return this._state;
+  }
+  getStats() {
+    return {
+      state: this._state,
+      failures: this._failures,
+      successes: this._successes,
+      totalCalls: this._totalCalls,
+      lastFailureAt: this._lastFailureAt,
+      openedAt: this._openedAt,
+      nextAttemptAt: this._openedAt ? this._openedAt + this.timeoutMs : void 0
+    };
+  }
+  reset() {
+    this._state = "closed";
+    this._failures = 0;
+    this._successes = 0;
+    this._totalCalls = 0;
+    this._lastFailureAt = void 0;
+    this._openedAt = void 0;
+  }
+  forceOpen() {
+    this.setState("open");
+  }
+  forceClose() {
+    this._failures = 0;
+    this.setState("closed");
+  }
+};
+
+// src/api/http/offline-queue.service.ts
+var JoopOfflineQueue = class {
+  _queue = [];
+  _online = typeof navigator !== "undefined" ? navigator.onLine : true;
+  _draining = false;
+  constructor() {
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", () => this._onOnline());
+      window.addEventListener("offline", () => {
+        this._online = false;
+      });
+    }
+  }
+  isOnline() {
+    return this._online;
+  }
+  queueLength() {
+    return this._queue.length;
+  }
+  enqueue(fn) {
+    return new Promise((resolve, reject) => {
+      this._queue.push({
+        id: crypto.randomUUID(),
+        fn,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      });
+    });
+  }
+  async drainNow() {
+    if (this._draining) return;
+    this._draining = true;
+    while (this._queue.length > 0) {
+      const entry = this._queue.shift();
+      try {
+        entry.resolve(await entry.fn());
+      } catch (err) {
+        entry.reject(err);
+      }
+    }
+    this._draining = false;
+  }
+  clear() {
+    this._queue.forEach((e) => e.reject(new Error("Queue cleared")));
+    this._queue = [];
+  }
+  _onOnline() {
+    this._online = true;
+    this.drainNow().catch(() => {
+    });
+  }
+};
+
+// src/api/http/polling.service.ts
+var JoopPollingService = class {
+  _timers = /* @__PURE__ */ new Map();
+  _subjects = /* @__PURE__ */ new Map();
+  start(id, config) {
+    this.stop(id);
+    const subject = new JoopSubject();
+    this._subjects.set(id, subject);
+    const run = async () => {
+      try {
+        const result = await config.fn();
+        subject.next(result);
+        if (config.stopWhen?.(result)) this.stop(id);
+      } catch (err) {
+        config.onError?.(err);
+      }
+    };
+    if (config.immediate) run();
+    this._timers.set(id, setInterval(run, config.intervalMs));
+    return subject;
+  }
+  stop(id) {
+    const timer = this._timers.get(id);
+    if (timer) {
+      clearInterval(timer);
+      this._timers.delete(id);
+    }
+    this._subjects.delete(id);
+  }
+  stopAll() {
+    [...this._timers.keys()].forEach((id) => this.stop(id));
+  }
+  isPolling(id) {
+    return this._timers.has(id);
+  }
+};
+
+// src/api/http/file-saver.service.ts
+var IOS_WEBVIEW_MIME = {
+  xls: "data:application/xls;base64,",
+  csv: "data:text/xml;base64,",
+  pdf: "data:application/pdf;base64,",
+  xlsx: "data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,",
+  doc: "data:application/msword;base64,",
+  docx: "data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64,"
+};
+var MIME_TYPES = {
+  txt: "text/plain",
+  pdf: "application/pdf",
+  csv: "text/csv",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif"
+};
+var JoopFileSaverService = class {
+  isIosWebView(handlerName = "mxDownloadPdf") {
+    return !!window?.["webkit"]?.["messageHandlers"]?.[handlerName];
+  }
+  async download(url, options = {}) {
+    const res = await fetch(url, {
+      method: options.method ?? "GET",
+      headers: options.headers,
+      body: options.body
+    });
+    if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+    const blob = await res.blob();
+    const fileName = this._fileNameFromHeaders(res.headers) ?? "download";
+    if (options.iosHandlerName && this.isIosWebView(options.iosHandlerName)) {
+      await this._sendToIos(blob, fileName, options.iosHandlerName);
+    } else {
+      this.saveBlob(blob, fileName);
+    }
+  }
+  saveBlob(blob, fileName) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = fileName;
+    a.style.display = "none";
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    setTimeout(() => URL.revokeObjectURL(url), 5e3);
+  }
+  blobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  getMimeType(fileName) {
+    const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
+    return MIME_TYPES[ext] ?? "application/octet-stream";
+  }
+  typedBlob(blob, fileName) {
+    return new Blob([blob], { type: this.getMimeType(fileName) });
+  }
+  async _sendToIos(blob, fileName, handlerName) {
+    const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
+    const prefix = IOS_WEBVIEW_MIME[ext] ?? "";
+    const base64 = await this.blobToBase64(blob);
+    const parts = base64.split("base64,");
+    const payload = prefix + (parts.length > 1 ? parts[1] : parts[0]);
+    window["webkit"]["messageHandlers"][handlerName].postMessage(payload);
+  }
+  _fileNameFromHeaders(headers) {
+    const cd = headers.get("Content-Disposition") ?? "";
+    const match = /filename=([^;]+)/i.exec(cd);
+    return match ? match[1].trim().replace(/['"]/g, "") : null;
+  }
+};
+
+// src/api/response-mapper.ts
+var SCOPE_PREFIXES = {
+  M: "M",
+  O: "O",
+  N: "N",
+  S: "S"
+};
+var JoopResponseMapper = class {
+  /** Normalize a v6 or v7+ raw API response into a typed mapped response */
+  map(raw) {
+    const v7 = this._isV7(raw) ? raw : this._convertV6ToV7(raw);
+    const components = v7.components ?? {};
+    const componentList = Object.entries(components).map(([key, value]) => ({
+      key,
+      value,
+      scope: this.extractScope(key),
+      dataKey: this.extractDataKey(key)
+    }));
+    return {
+      scrid: v7.scrid ?? "",
+      segments: v7.segments ?? "",
+      mxenc: v7.mxenc ?? "",
+      mxencres: v7.mxencres ?? "",
+      components,
+      componentList,
+      errorCode: v7.errorCode,
+      errorDesc: v7.errorDesc,
+      hasError: !!(v7.errorCode && v7.errorCode !== "0" && v7.errorCode !== "")
+    };
+  }
+  /** Extract scope prefix from a component key (first char: M/O/N/S) */
+  extractScope(key) {
+    const first = key.charAt(0).toUpperCase();
+    return SCOPE_PREFIXES[first] ?? "M";
+  }
+  /** Extract data key portion (everything after the first character) */
+  extractDataKey(key) {
+    return key.length > 1 ? key.slice(1) : key;
+  }
+  /**
+   * Build a property map from component list — groups by scope prefix.
+   * e.g. "MUserName" → { scope: 'M', dataKey: 'UserName', value: '...' }
+   */
+  buildScopedMap(response) {
+    const result = {};
+    for (const comp of response.componentList) {
+      if (!result[comp.scope]) result[comp.scope] = {};
+      result[comp.scope][comp.dataKey] = comp.value;
+    }
+    return result;
+  }
+  /** Get a single component value from a mapped response */
+  getComponent(response, key) {
+    return response.components[key] ?? null;
+  }
+  /** Check if the raw payload looks like a v7+ response (has 'components' key) */
+  _isV7(raw) {
+    return "components" in raw && raw.components != null;
+  }
+  _convertV6ToV7(raw) {
+    const components = {};
+    for (const item of raw.compDet ?? []) {
+      if (item.compKey) components[item.compKey] = item.compValue ?? "";
+    }
+    return {
+      scrid: raw.scrid ?? raw.scrId,
+      segments: raw.segments,
+      mxenc: raw.mxenc,
+      mxencres: raw.mxencres,
+      components,
+      errorCode: raw.errorCode,
+      errorDesc: raw.errorDesc
+    };
+  }
+};
+
+// src/api/export.service.ts
+var JoopExportService = class {
+  /** Convert an array of objects to a CSV string */
+  toCsv(data, options = {}) {
+    if (!data.length) return "";
+    const {
+      delimiter = ",",
+      headers,
+      includeHeaders = true,
+      bom = false,
+      nullValue = ""
+    } = options;
+    const cols = headers ?? Object.keys(data[0]);
+    const escape = (v) => {
+      const s = v == null ? nullValue : String(v);
+      return s.includes(delimiter) || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}"` : s;
+    };
+    const rows = [];
+    if (includeHeaders) rows.push(cols.map(escape).join(delimiter));
+    for (const row of data) rows.push(cols.map((k) => escape(row[k])).join(delimiter));
+    const csv = rows.join("\r\n");
+    return bom ? "\uFEFF" + csv : csv;
+  }
+  /** Trigger browser download of a CSV string */
+  downloadCsv(data, filename, options = {}) {
+    const csv = this.toCsv(data, options);
+    this._download(csv, filename.endsWith(".csv") ? filename : `${filename}.csv`, "text/csv;charset=utf-8;");
+  }
+  /** Download Excel-compatible CSV (with BOM so Excel reads UTF-8 correctly) */
+  downloadExcel(data, filename, options = {}) {
+    const csv = this.toCsv(data, { ...options, bom: true, delimiter: "," });
+    this._download(csv, filename.endsWith(".csv") ? filename : `${filename}.csv`, "text/csv;charset=utf-8;");
+  }
+  /** Convert data to a JSON string and download */
+  downloadJson(data, filename, indent = 2) {
+    const json = JSON.stringify(data, null, indent);
+    this._download(json, filename.endsWith(".json") ? filename : `${filename}.json`, "application/json");
+  }
+  /** Download a plain-text file */
+  downloadText(content, filename) {
+    this._download(content, filename, "text/plain;charset=utf-8;");
+  }
+  /** Convert a 2D array (table) to CSV */
+  tableToCsv(rows, headers, delimiter = ",") {
+    const esc = (v) => {
+      const s = v == null ? "" : String(v);
+      return s.includes(delimiter) || s.includes('"') ? `"${s.replace(/"/g, '""')}"` : s;
+    };
+    const lines = [];
+    if (headers) lines.push(headers.map(esc).join(delimiter));
+    for (const row of rows) lines.push(row.map(esc).join(delimiter));
+    return lines.join("\r\n");
+  }
+  _download(content, filename, mimeType) {
+    const blob = new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    a.style.display = "none";
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    setTimeout(() => URL.revokeObjectURL(url), 5e3);
+  }
+};
+
+// src/api/webhook-verifier.ts
+var JoopWebhookVerifier = class _JoopWebhookVerifier {
+  _provider = "generic";
+  for(provider) {
+    const clone = new _JoopWebhookVerifier();
+    clone._provider = provider;
+    return clone;
+  }
+  async verify(payload, signature, secret, opts = {}) {
+    switch (this._provider) {
+      case "stripe":
+        return this.verifyStripe(payload, signature, secret, opts);
+      case "github":
+        return this.verifyGitHub(payload, signature, secret, opts);
+      default:
+        return this.verifyGeneric(payload, signature, secret, opts);
+    }
+  }
+  /** Stripe: `Stripe-Signature: t=...,v1=...` */
+  async verifyStripe(payload, header, secret, opts = {}) {
+    const parts = Object.fromEntries(header.split(",").map((p) => p.split("=")));
+    const t = parts["t"];
+    const v1 = parts["v1"];
+    if (!t || !v1) return false;
+    if (!this.verifyTimestamp(parseInt(t, 10), opts.toleranceSeconds ?? 300)) return false;
+    const signed = `${t}.${payload}`;
+    const expected = await _hmac("SHA-256", secret, signed);
+    return _safeEqual(expected, v1);
+  }
+  /** GitHub: `X-Hub-Signature-256: sha256=...` */
+  async verifyGitHub(payload, header, secret, opts = {}) {
+    const prefix = "sha256=";
+    if (!header.startsWith(prefix)) return false;
+    const provided = header.slice(prefix.length);
+    const expected = await _hmac("SHA-256", secret, payload);
+    return _safeEqual(expected, provided);
+  }
+  /** Generic HMAC verification. signature is a hex string. */
+  async verifyGeneric(payload, signature, secret, opts = {}) {
+    const algo = opts.algorithm ?? "SHA-256";
+    const expected = await _hmac(algo, secret, payload);
+    return _safeEqual(expected, signature);
+  }
+  /** Returns true if the timestamp is within tolerance of now */
+  verifyTimestamp(timestamp, toleranceSeconds = 300) {
+    const diff = Math.abs(Math.floor(Date.now() / 1e3) - timestamp);
+    return diff <= toleranceSeconds;
+  }
+  /** Compute the expected HMAC for a payload (for testing) */
+  async sign(payload, secret, algo = "SHA-256") {
+    return _hmac(algo, secret, payload);
+  }
+};
+async function _hmac(algorithm, secret, payload) {
+  const enc = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(secret),
+    { name: "HMAC", hash: algorithm },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, enc.encode(payload));
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function _safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+
+// src/platform/platform.ts
+var _webStorage = (store) => ({
+  getItem: (k) => store.getItem(k),
+  setItem: (k, v) => store.setItem(k, v),
+  removeItem: (k) => store.removeItem(k),
+  clear: () => store.clear()
+});
+var _MemStorageImpl = class {
+  _m = /* @__PURE__ */ new Map();
+  getItem(k) {
+    return this._m.get(k) ?? null;
+  }
+  setItem(k, v) {
+    this._m.set(k, v);
+  }
+  removeItem(k) {
+    this._m.delete(k);
+  }
+  clear() {
+    this._m.clear();
+  }
+};
+function _detect() {
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") return "react-native";
+  const _proc = globalThis["process"];
+  if (typeof window === "undefined" && _proc?.versions?.node) return "node";
+  if (typeof window !== "undefined") return "web";
+  return "unknown";
+}
+var JoopPlatform = class {
+  static _type = _detect();
+  static _adapter = {};
+  static _memStorage = null;
+  /**
+   * Call once at app startup to configure adapters for your platform.
+   *
+   * Web (default — no call needed):
+   *   JoopPlatform.init();
+   *
+   * React Native with react-native-mmkv:
+   *   import { MMKV } from 'react-native-mmkv';
+   *   const mmkv = new MMKV();
+   *   JoopPlatform.init({ adapter: { storage: mmkv } });
+   *
+   * React Native with custom compression (fflate):
+   *   import { gzip, ungzip } from 'fflate';
+   *   JoopPlatform.init({
+   *     adapter: {
+   *       compression: {
+   *         compress: (d, fmt) => new Promise((res, rej) => gzip(d, (e, r) => e ? rej(e) : res(r))),
+   *         decompress: (d, fmt) => new Promise((res, rej) => ungzip(d, (e, r) => e ? rej(e) : res(r))),
+   *       },
+   *     },
+   *   });
+   */
+  static init(config = {}) {
+    if (config.platform) this._type = config.platform;
+    this._adapter = { ...this._adapter, ...config.adapter ?? {} };
+  }
+  /** Current detected or overridden platform type */
+  static get type() {
+    return this._type;
+  }
+  static is(type) {
+    return this._type === type;
+  }
+  static isMobile() {
+    return this._type === "react-native";
+  }
+  static isWeb() {
+    return this._type === "web";
+  }
+  static isNode() {
+    return this._type === "node";
+  }
+  /** Raw adapter config registered via init() */
+  static getAdapter() {
+    return this._adapter;
+  }
+  /**
+   * Returns the best available storage adapter:
+   *   1. Custom adapter registered via init()
+   *   2. localStorage (web)
+   *   3. In-memory fallback (Node / RN without adapter)
+   */
+  static getStorage() {
+    if (this._adapter.storage) return this._adapter.storage;
+    if (typeof localStorage !== "undefined") return _webStorage(localStorage);
+    if (!this._memStorage) this._memStorage = new _MemStorageImpl();
+    return this._memStorage;
+  }
+  /**
+   * Returns the best available session-scoped storage:
+   *   1. Custom adapter registered via init()
+   *   2. sessionStorage (web)
+   *   3. Shared in-memory fallback
+   */
+  static getSessionStorage() {
+    if (this._adapter.storage) return this._adapter.storage;
+    if (typeof sessionStorage !== "undefined") return _webStorage(sessionStorage);
+    if (!this._memStorage) this._memStorage = new _MemStorageImpl();
+    return this._memStorage;
+  }
+  /** What APIs are available in the current environment */
+  static capabilities() {
+    return {
+      compression: typeof CompressionStream !== "undefined" || !!this._adapter.compression,
+      workers: typeof Worker !== "undefined" || !!this._adapter.worker,
+      cryptoSubtle: !!(typeof globalThis !== "undefined" && globalThis.crypto?.subtle),
+      persistentStorage: typeof localStorage !== "undefined" || !!this._adapter.storage,
+      dom: typeof document !== "undefined",
+      serviceWorker: typeof navigator !== "undefined" && "serviceWorker" in navigator
+    };
+  }
+  /** Reset to auto-detected defaults — useful between tests */
+  static _reset() {
+    this._type = _detect();
+    this._adapter = {};
+    this._memStorage = null;
+  }
+};
+
+// src/api/idempotency.service.ts
+var JoopIdempotencyService = class {
+  _storage;
+  _ttlMs;
+  _prefix;
+  /** Internal key registry used for clearAll() and gc() (avoids requiring Storage.length/key()) */
+  _keys = /* @__PURE__ */ new Set();
+  constructor(config = {}) {
+    this._ttlMs = config.ttlMs ?? 24 * 60 * 60 * 1e3;
+    this._prefix = config.prefix ?? "joop_idem_";
+    this._storage = config.storage ?? JoopPlatform.getStorage();
+  }
+  /**
+   * Generate and store an idempotency key for the given operation.
+   * Returns an existing (non-expired) key if one already exists.
+   */
+  generate(operationKey) {
+    const storageKey = this._prefix + operationKey;
+    const existing = this.get(operationKey);
+    if (existing) {
+      this._keys.add(storageKey);
+      return existing;
+    }
+    const key = _generateKey();
+    const entry = { key, createdAt: Date.now(), expiresAt: Date.now() + this._ttlMs };
+    this._storage.setItem(storageKey, JSON.stringify(entry));
+    this._keys.add(storageKey);
+    return key;
+  }
+  /** Get the stored key for an operation, or null if expired/not found */
+  get(operationKey) {
+    const storageKey = this._prefix + operationKey;
+    const raw = this._storage.getItem(storageKey);
+    if (!raw) return null;
+    try {
+      const entry = JSON.parse(raw);
+      if (Date.now() > entry.expiresAt) {
+        this._storage.removeItem(storageKey);
+        this._keys.delete(storageKey);
+        return null;
+      }
+      return entry.key;
+    } catch {
+      return null;
+    }
+  }
+  /** Remove the key for an operation (e.g. after successful completion) */
+  clear(operationKey) {
+    const storageKey = this._prefix + operationKey;
+    this._storage.removeItem(storageKey);
+    this._keys.delete(storageKey);
+  }
+  /** Clear all idempotency keys managed by this instance */
+  clearAll() {
+    for (const k of this._keys) this._storage.removeItem(k);
+    this._keys.clear();
+  }
+  /**
+   * Wrap a fetch-based function with automatic idempotency key injection.
+   * Clears the key on success; keeps it on failure so retries reuse the same key.
+   */
+  async wrap(operationKey, fn) {
+    const key = this.generate(operationKey);
+    try {
+      const result = await fn(key);
+      this.clear(operationKey);
+      return result;
+    } catch (e) {
+      throw e;
+    }
+  }
+  /** Remove all expired entries */
+  gc() {
+    const now = Date.now();
+    for (const k of [...this._keys]) {
+      const raw = this._storage.getItem(k);
+      if (!raw) {
+        this._keys.delete(k);
+        continue;
+      }
+      try {
+        const e = JSON.parse(raw);
+        if (now > e.expiresAt) {
+          this._storage.removeItem(k);
+          this._keys.delete(k);
+        }
+      } catch {
+        this._storage.removeItem(k);
+        this._keys.delete(k);
+      }
+    }
+  }
+};
+function _generateKey() {
+  const buf = new Uint8Array(16);
+  crypto.getRandomValues(buf);
+  return Array.from(buf).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/api/http/http-client-extended.ts
+var _inFlight = /* @__PURE__ */ new Map();
+var JoopHttpClientExtended = class _JoopHttpClientExtended extends JoopHttpClient {
+  // ── Parallel requests ───────────────────────────────────────────────────────
+  /** Fire multiple GETs at once, collect all results (never throws). */
+  async getAll(urls, options) {
+    return Promise.all(
+      urls.map(async (url, index) => {
+        const t0 = Date.now();
+        try {
+          const data = await this.get(url, options);
+          return { index, url, data, ok: true, ms: Date.now() - t0 };
+        } catch (e) {
+          return { index, url, error: e, ok: false, ms: Date.now() - t0 };
+        }
+      })
+    );
+  }
+  /** Post to multiple URLs in parallel (fire-and-collect). */
+  async postAll(requests) {
+    return Promise.all(
+      requests.map(async (req, index) => {
+        const t0 = Date.now();
+        try {
+          const data = await this.post(req.url, req.body, req.options);
+          return { index, url: req.url, data, ok: true, ms: Date.now() - t0 };
+        } catch (e) {
+          return { index, url: req.url, error: e, ok: false, ms: Date.now() - t0 };
+        }
+      })
+    );
+  }
+  /** Race multiple GET requests — resolves with the first successful response. */
+  async race(urls, options) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const errors = [];
+      urls.forEach((url) => {
+        const t0 = Date.now();
+        this.get(url, options).then((data) => {
+          if (!settled) {
+            settled = true;
+            resolve({ data, url, ms: Date.now() - t0 });
+          }
+        }).catch((err) => {
+          errors.push(err);
+          if (errors.length === urls.length) reject(errors[0]);
+        });
+      });
+    });
+  }
+  /** Sequential requests — each result fed to a mapper for the next URL. */
+  async chain(steps, options) {
+    const results = [];
+    let prev;
+    for (const step of steps) {
+      const { url, body, method = "GET" } = step(prev);
+      prev = method === "POST" ? await this.post(url, body, options) : await this.get(url, options);
+      results.push(prev);
+    }
+    return results;
+  }
+  // ── Deduplication ─────────────────────────────────────────────────────────
+  /** GET with request deduplication — concurrent identical URLs share one network call. */
+  getDedup(url, options) {
+    const key = url + JSON.stringify(options?.headers ?? {});
+    if (_inFlight.has(key)) return _inFlight.get(key);
+    const promise = this.get(url, options).finally(() => _inFlight.delete(key));
+    _inFlight.set(key, promise);
+    return promise;
+  }
+  // ── Retry wrapper ─────────────────────────────────────────────────────────
+  /** GET with automatic retry on failure. */
+  getWithRetry(url, retry, options) {
+    return withRetry(() => this.get(url, options), retry);
+  }
+  postWithRetry(url, body, retry, options) {
+    return withRetry(() => this.post(url, body, options), retry);
+  }
+  // ── Request queue ──────────────────────────────────────────────────────────
+  createQueue(config = { concurrency: 4 }) {
+    return new JoopRequestQueue(config);
+  }
+  // ── Typed response helpers ────────────────────────────────────────────────
+  /** GET that throws if the response does not pass a validator. */
+  async getValidated(url, validate, options) {
+    const data = await this.get(url, options);
+    if (!validate(data)) throw new TypeError(`JoopHttp: response from ${url} failed type validation`);
+    return data;
+  }
+  /** GET with fallback value on error (never throws). */
+  async getSafe(url, fallback, options) {
+    try {
+      return await this.get(url, options);
+    } catch {
+      return fallback;
+    }
+  }
+  /** POST with fallback on error. */
+  async postSafe(url, body, fallback, options) {
+    try {
+      return await this.post(url, body, options);
+    } catch {
+      return fallback;
+    }
+  }
+  // ── Timeout helper ────────────────────────────────────────────────────────
+  /** Set a default timeout on all subsequent requests. */
+  withTimeout(ms) {
+    const child = new _JoopHttpClientExtended();
+    const orig = child.request.bind(child);
+    child.request = (method, url, opts = {}) => orig(method, url, { timeout: ms, ...opts });
+    return child;
+  }
+  // ── Sync-style callback wrapper ───────────────────────────────────────────
+  /** "Sync-style" GET — callback-based wrapper (JS is single-threaded; true sync fetch doesn't exist).
+   *  Use only in contexts where you cannot use async/await (e.g., legacy callbacks). */
+  getCallback(url, onSuccess, onError, options) {
+    this.get(url, options).then(onSuccess).catch(onError);
+  }
+  /** Batch multiple operations with concurrency limit. */
+  async batch(items, fn, concurrency = 4) {
+    const results = [];
+    for (let i = 0; i < items.length; i += concurrency) {
+      const slice = items.slice(i, i + concurrency);
+      const batch = await Promise.all(
+        slice.map(async (item, idx) => {
+          try {
+            const result = await fn(item, i + idx);
+            return { item, result, ok: true };
+          } catch (e) {
+            return { item, error: e, ok: false };
+          }
+        })
+      );
+      results.push(...batch);
+    }
+    return results;
+  }
+};
+var JoopRequestQueue = class {
+  _queue = [];
+  _running = 0;
+  _config;
+  constructor(config) {
+    this._config = { concurrency: config.concurrency ?? 4, onDrain: config.onDrain };
+  }
+  enqueue(fn) {
+    return new Promise((resolve, reject) => {
+      this._queue.push({ fn, resolve, reject });
+      this._tick();
+    });
+  }
+  get size() {
+    return this._queue.length;
+  }
+  get inflight() {
+    return this._running;
+  }
+  _tick() {
+    while (this._running < this._config.concurrency && this._queue.length > 0) {
+      const entry = this._queue.shift();
+      this._running++;
+      entry.fn().then(entry.resolve, entry.reject).finally(() => {
+        this._running--;
+        this._tick();
+        if (this._running === 0 && this._queue.length === 0) this._config.onDrain?.();
+      });
+    }
+  }
+};
+
+// src/api/http/interceptors.ts
+function bearerAuthInterceptor(getToken) {
+  return (req) => {
+    const token = getToken();
+    if (token) {
+      return { ...req, headers: { ...req.headers, Authorization: `Bearer ${token}` } };
+    }
+    return req;
+  };
+}
+function loggingRequestInterceptor(opts = {}) {
+  const log = opts.logger ?? console;
+  return (req) => {
+    if (opts.logRequest !== false) {
+      log.log(`[JoopHTTP] \u279C ${req.method} ${req.url}`, req.body ? { body: req.body } : "");
+    }
+    return req;
+  };
+}
+function loggingResponseInterceptor(opts = {}) {
+  const log = opts.logger ?? console;
+  return (res) => {
+    if (opts.logResponse !== false) {
+      log.log(`[JoopHTTP] \u2713 ${res.status}`, res.data);
+    }
+    return res;
+  };
+}
+function loggingErrorInterceptor(opts = {}) {
+  const log = opts.logger ?? console;
+  return (err) => {
+    if (opts.logErrors !== false) {
+      const e = err;
+      log.error(`[JoopHTTP] \u2717 ${e?.status ?? 0} ${e?.message}`, err);
+    }
+    return err;
+  };
+}
+function correlationInterceptor(getCorrelationId) {
+  const getId = getCorrelationId ?? (() => crypto.randomUUID?.() ?? Math.random().toString(36).slice(2));
+  return (req) => ({
+    ...req,
+    headers: {
+      ...req.headers,
+      "X-Correlation-ID": getId(),
+      "X-Request-ID": getId()
+    }
+  });
+}
+function baseUrlInterceptor(baseUrl) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return (req) => ({
+    ...req,
+    url: req.url.startsWith("http") ? req.url : `${base}${req.url.startsWith("/") ? "" : "/"}${req.url}`
+  });
+}
+function retryErrorInterceptor(opts = {}) {
+  const maxRetries = opts.maxRetries ?? 2;
+  const retryOn = opts.retryOn ?? [429, 502, 503, 504];
+  return (err) => {
+    const e = err;
+    const shouldRetry = retryOn.includes(e?.status ?? 0);
+    return Object.assign(e ?? {}, { _joopShouldRetry: shouldRetry, _joopMaxRetries: maxRetries });
+  };
+}
+var _cache = /* @__PURE__ */ new Map();
+function cacheResponseInterceptor(opts = {}) {
+  const ttl = opts.ttlMs ?? 6e4;
+  const methods = (opts.methods ?? ["GET"]).map((m) => m.toUpperCase());
+  return (res) => {
+    if (methods.includes(res._requestMethod?.toUpperCase() ?? "GET")) {
+      _cache.set(res._requestUrl ?? "", { data: res.data, expiresAt: Date.now() + ttl });
+    }
+    return res;
+  };
+}
+function cacheRequestInterceptor() {
+  return (req) => {
+    const cached = _cache.get(req.url);
+    if (cached && cached.expiresAt > Date.now()) {
+      return Object.assign(req, { _cacheHit: true, _cachedData: cached.data });
+    }
+    return req;
+  };
+}
+function clearCache(url) {
+  url ? _cache.delete(url) : _cache.clear();
+}
+
+export { JoopCircuitBreaker, JoopExportService, JoopFileSaverService, JoopHttpClient, JoopHttpClientExtended, JoopIdempotencyService, JoopInterceptorPipeline, JoopOfflineQueue, JoopPollingService, JoopRequestQueue, JoopRequestService, JoopResponseMapper, JoopWebhookVerifier, baseUrlInterceptor, bearerAuthInterceptor, cacheRequestInterceptor, cacheResponseInterceptor, clearCache, correlationInterceptor, isHttpError, loggingErrorInterceptor, loggingRequestInterceptor, loggingResponseInterceptor, retryErrorInterceptor, withRetry };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map