@wave-av/sdk 2.0.1 → 2.0.2

package/dist/client.js

@@ -0,0 +1,311 @@
+"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/client.ts
+var client_exports = {};
+__export(client_exports, {
+  RateLimitError: () => RateLimitError,
+  WaveClient: () => WaveClient,
+  WaveError: () => WaveError,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(client_exports);
+var import_eventemitter3 = require("eventemitter3");
+
+// src/telemetry.ts
+var resolvedTracer = null;
+var telemetryEnabled = false;
+function initTelemetry(config) {
+  if (!config.enabled) {
+    telemetryEnabled = false;
+    resolvedTracer = null;
+    return;
+  }
+  try {
+    const otelApi = require("@opentelemetry/api");
+    const serviceName = config.serviceName ?? "@wave/sdk";
+    resolvedTracer = otelApi.trace.getTracer(serviceName, "2.0.0");
+    telemetryEnabled = true;
+  } catch {
+    telemetryEnabled = false;
+    resolvedTracer = null;
+  }
+}
+
+// src/client.ts
+var WaveError = class extends Error {
+  code;
+  statusCode;
+  requestId;
+  details;
+  retryable;
+  constructor(message, code, statusCode, requestId, details) {
+    super(message);
+    this.name = "WaveError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.details = details;
+    this.retryable = this.isRetryable(statusCode, code);
+  }
+};
+var RateLimitError = class extends WaveError {
+  retryAfter;
+  constructor(message, retryAfter, requestId) {
+    super(message, "RATE_LIMITED", 429, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var WaveClient = class extends import_eventemitter3.EventEmitter {
+  config;
+  constructor(config) {
+    super();
+    if (!config.apiKey) {
+      throw new Error("WAVE SDK: apiKey is required");
+    }
+    this.config = {
+      apiKey: config.apiKey,
+      organizationId: config.organizationId || "",
+      baseUrl: config.baseUrl || "https://api.wave.online",
+      timeout: config.timeout || 3e4,
+      maxRetries: config.maxRetries ?? 3,
+      debug: config.debug || false,
+      customHeaders: config.customHeaders || {},
+      telemetry: config.telemetry
+    };
+    if (config.telemetry) {
+      initTelemetry(config.telemetry);
+    }
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, options) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  /**
+   * Make a POST request
+   */
+  async post(path, body, options) {
+    return this.request(path, {
+      ...options,
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Make a PUT request
+   */
+  async put(path, body, options) {
+    return this.request(path, {
+      ...options,
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Make a PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request(path, {
+      ...options,
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path, options) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+  /**
+   * Make an API request with retry logic
+   */
+  async request(path, options = {}) {
+    const { params, noRetry, timeout: requestTimeout, ...fetchOptions } = options;
+    let url = `${this.config.baseUrl}${path}`;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          searchParams.set(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    return this.executeWithRetry(
+      url,
+      {
+        ...fetchOptions,
+        headers: this.buildHeaders(fetchOptions.headers)
+      },
+      noRetry ? 0 : this.config.maxRetries,
+      requestTimeout || this.config.timeout
+    );
+  }
+  /**
+   * Execute request with exponential backoff retry
+   */
+  async executeWithRetry(url, options, maxRetries, timeout) {
+    const method = options.method || "GET";
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        this.emit("request.start", url, method);
+        const startTime = Date.now();
+        const response = await this.fetchWithTimeout(url, options, timeout);
+        const duration = Date.now() - startTime;
+        if (response.status === 429) {
+          const retryAfter = this.parseRetryAfter(response);
+          this.emit("rate_limit.hit", retryAfter);
+          if (attempt < maxRetries) {
+            this.emit("request.retry", url, method, attempt + 1, retryAfter);
+            await this.sleep(retryAfter);
+            continue;
+          }
+          throw new RateLimitError(
+            "Rate limit exceeded",
+            retryAfter,
+            response.headers.get("x-request-id") || void 0
+          );
+        }
+        if (!response.ok) {
+          const error = await this.parseErrorResponse(response);
+          if (error.retryable && attempt < maxRetries) {
+            const delay = this.calculateBackoff(attempt);
+            this.emit("request.retry", url, method, attempt + 1, delay);
+            await this.sleep(delay);
+            continue;
+          }
+          throw error;
+        }
+        this.emit("request.success", url, method, duration);
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          return response.json();
+        }
+        return {};
+      } catch (error) {
+        lastError = error;
+        if (error instanceof WaveError && !error.retryable) {
+          throw error;
+        }
+        if (error instanceof TypeError || error instanceof Error && error.name === "AbortError") {
+          if (attempt < maxRetries) {
+            const delay = this.calculateBackoff(attempt);
+            this.emit("request.retry", url, method, attempt + 1, delay);
+            await this.sleep(delay);
+            continue;
+          }
+        }
+        this.emit("request.error", url, method, error);
+      }
+    }
+    throw lastError || new WaveError("Request failed after retries", "UNKNOWN_ERROR", 0);
+  }
+  /**
+   * Fetch with timeout
+   */
+  async fetchWithTimeout(url, options, timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Build request headers
+   */
+  buildHeaders(additionalHeaders) {
+    const headers = {
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "User-Agent": `wave-sdk-typescript/1.0.0`,
+      ...this.config.customHeaders
+    };
+    if (this.config.organizationId) {
+      headers["X-Organization-Id"] = this.config.organizationId;
+    }
+    if (additionalHeaders) {
+      if (additionalHeaders instanceof Headers) {
+        additionalHeaders.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(additionalHeaders)) {
+        additionalHeaders.forEach(([key, value]) => {
+          headers[key] = value;
+        });
+      } else {
+        Object.assign(headers, additionalHeaders);
+      }
+    }
+    return headers;
+  }
+  /**
+   * Parse error response
+   */
+  /**
+   * Parse Retry-After header
+   */
+  /**
+   * Calculate exponential backoff delay
+   */
+  calculateBackoff(attempt) {
+    const baseDelay = 1e3;
+    const maxDelay = 3e4;
+    const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+    return delay + Math.random() * delay * 0.25;
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Log debug message
+   */
+  log(message, ...args) {
+    if (this.config.debug) {
+      console.log(`[WaveSDK] ${message}`, ...args);
+    }
+  }
+};
+function createClient(config) {
+  return new WaveClient(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RateLimitError,
+  WaveClient,
+  WaveError,
+  createClient
+});

package/dist/client.mjs

@@ -0,0 +1,14 @@
+import {
+  RateLimitError,
+  WaveClient,
+  WaveError,
+  createClient
+} from "./chunk-H2YYTNUH.mjs";
+import "./chunk-YEK26SSO.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  RateLimitError,
+  WaveClient,
+  WaveError,
+  createClient
+};

package/dist/clips-types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/clips-types.ts
+var clips_types_exports = {};
+module.exports = __toCommonJS(clips_types_exports);

package/dist/clips.js

@@ -0,0 +1,198 @@
+"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/clips.ts
+var clips_exports = {};
+__export(clips_exports, {
+  ClipsAPI: () => ClipsAPI,
+  createClipsAPI: () => createClipsAPI
+});
+module.exports = __toCommonJS(clips_exports);
+var ClipsAPI = class {
+  client;
+  basePath = "/v1/clips";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new clip
+   *
+   * Requires: clips:create permission
+   */
+  async create(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Get a clip by ID
+   *
+   * Requires: clips:read permission
+   */
+  async get(clipId) {
+    return this.client.get(`${this.basePath}/${clipId}`);
+  }
+  /**
+   * Update a clip
+   *
+   * Requires: clips:update permission
+   */
+  async update(clipId, request) {
+    return this.client.patch(`${this.basePath}/${clipId}`, request);
+  }
+  /**
+   * Remove a clip
+   *
+   * Requires: clips:remove permission (server-side RBAC enforced)
+   */
+  async remove(clipId) {
+    await this.client.delete(`${this.basePath}/${clipId}`);
+  }
+  /**
+   * List clips with optional filters
+   *
+   * Requires: clips:read permission
+   */
+  async list(params) {
+    const queryParams = {
+      limit: params?.limit,
+      offset: params?.offset,
+      cursor: params?.cursor,
+      status: params?.status,
+      source_type: params?.source_type,
+      source_id: params?.source_id,
+      created_after: params?.created_after,
+      created_before: params?.created_before,
+      order_by: params?.order_by,
+      order: params?.order
+    };
+    if (params?.tags?.length) {
+      queryParams["tags"] = params.tags.join(",");
+    }
+    return this.client.get(this.basePath, {
+      params: queryParams
+    });
+  }
+  /**
+   * Export a clip to a different format
+   *
+   * Requires: clips:export permission
+   */
+  async exportClip(clipId, request) {
+    return this.client.post(
+      `${this.basePath}/${clipId}/export`,
+      request
+    );
+  }
+  /**
+   * Get export job status
+   *
+   * Requires: clips:read permission
+   */
+  async getExport(clipId, exportId) {
+    return this.client.get(
+      `${this.basePath}/${clipId}/exports/${exportId}`
+    );
+  }
+  /**
+   * List all exports for a clip
+   *
+   * Requires: clips:read permission
+   */
+  async listExports(clipId, params) {
+    return this.client.get(
+      `${this.basePath}/${clipId}/exports`,
+      { params }
+    );
+  }
+  /**
+   * Detect highlights in source content
+   *
+   * Requires: clips:analyze permission
+   */
+  async detectHighlights(sourceType, sourceId, options) {
+    return this.client.post(
+      `${this.basePath}/highlights/detect`,
+      {
+        source_type: sourceType,
+        source_id: sourceId,
+        ...options
+      }
+    );
+  }
+  /**
+   * Generate clips from detected highlights
+   *
+   * Requires: clips:create permission
+   */
+  async createFromHighlights(sourceType, sourceId, options) {
+    return this.client.post(`${this.basePath}/highlights/create`, {
+      source_type: sourceType,
+      source_id: sourceId,
+      ...options
+    });
+  }
+  /**
+   * Wait for a clip to be ready
+   */
+  async waitForReady(clipId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 3e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const clip = await this.get(clipId);
+      if (options?.onProgress) {
+        options.onProgress(clip);
+      }
+      if (clip.status === "ready") {
+        return clip;
+      }
+      if (clip.status === "failed") {
+        throw new Error(`Clip processing failed: ${clip.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Clip processing timed out after ${timeout}ms`);
+  }
+  /**
+   * Wait for an export to be ready
+   */
+  async waitForExport(clipId, exportId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 3e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const exportJob = await this.getExport(clipId, exportId);
+      if (exportJob.status === "ready") {
+        return exportJob;
+      }
+      if (exportJob.status === "failed") {
+        throw new Error(`Export failed: ${exportJob.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Export timed out after ${timeout}ms`);
+  }
+};
+function createClipsAPI(client) {
+  return new ClipsAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClipsAPI,
+  createClipsAPI
+});

package/dist/clips.mjs

@@ -0,0 +1,9 @@
+import {
+  ClipsAPI,
+  createClipsAPI
+} from "./chunk-AI64YR5W.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  ClipsAPI,
+  createClipsAPI
+};

package/dist/cloud-switcher.js

@@ -0,0 +1,80 @@
+"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/cloud-switcher.ts
+var cloud_switcher_exports = {};
+__export(cloud_switcher_exports, {
+  CloudSwitcherAPI: () => CloudSwitcherAPI,
+  createCloudSwitcherAPI: () => createCloudSwitcherAPI
+});
+module.exports = __toCommonJS(cloud_switcher_exports);
+var CloudSwitcherAPI = class {
+  client;
+  basePath = "/v1/switcher";
+  constructor(client) {
+    this.client = client;
+  }
+  async create(options) {
+    return this.client.post(this.basePath, options);
+  }
+  async get(switcherId) {
+    return this.client.get(`${this.basePath}/${switcherId}`);
+  }
+  async list() {
+    return this.client.get(this.basePath);
+  }
+  async remove(switcherId) {
+    await this.client.delete(`${this.basePath}/${switcherId}`);
+  }
+  async addSource(switcherId, options) {
+    return this.client.post(`${this.basePath}/${switcherId}/sources`, options);
+  }
+  async removeSource(switcherId, sourceId) {
+    await this.client.delete(`${this.basePath}/${switcherId}/sources/${sourceId}`);
+  }
+  async switchTo(switcherId, sourceId) {
+    await this.client.post(`${this.basePath}/${switcherId}/control`, { type: "switch", sourceId });
+  }
+  async transition(switcherId, options) {
+    await this.client.post(`${this.basePath}/${switcherId}/control`, { type: "transition", config: options });
+  }
+  async addOutput(switcherId, options) {
+    return this.client.post(`${this.basePath}/${switcherId}/outputs`, options);
+  }
+  async startStreaming(switcherId, outputId) {
+    await this.client.post(`${this.basePath}/${switcherId}/outputs/${outputId}/start`, {});
+  }
+  async stopStreaming(switcherId, outputId) {
+    await this.client.post(`${this.basePath}/${switcherId}/outputs/${outputId}/stop`, {});
+  }
+  async startRecording(switcherId) {
+    await this.client.post(`${this.basePath}/${switcherId}/record/start`, {});
+  }
+  async stopRecording(switcherId) {
+    await this.client.post(`${this.basePath}/${switcherId}/record/stop`, {});
+  }
+};
+function createCloudSwitcherAPI(client) {
+  return new CloudSwitcherAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CloudSwitcherAPI,
+  createCloudSwitcherAPI
+});

package/dist/cloud-switcher.mjs

@@ -0,0 +1,56 @@
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/cloud-switcher.ts
+var CloudSwitcherAPI = class {
+  client;
+  basePath = "/v1/switcher";
+  constructor(client) {
+    this.client = client;
+  }
+  async create(options) {
+    return this.client.post(this.basePath, options);
+  }
+  async get(switcherId) {
+    return this.client.get(`${this.basePath}/${switcherId}`);
+  }
+  async list() {
+    return this.client.get(this.basePath);
+  }
+  async remove(switcherId) {
+    await this.client.delete(`${this.basePath}/${switcherId}`);
+  }
+  async addSource(switcherId, options) {
+    return this.client.post(`${this.basePath}/${switcherId}/sources`, options);
+  }
+  async removeSource(switcherId, sourceId) {
+    await this.client.delete(`${this.basePath}/${switcherId}/sources/${sourceId}`);
+  }
+  async switchTo(switcherId, sourceId) {
+    await this.client.post(`${this.basePath}/${switcherId}/control`, { type: "switch", sourceId });
+  }
+  async transition(switcherId, options) {
+    await this.client.post(`${this.basePath}/${switcherId}/control`, { type: "transition", config: options });
+  }
+  async addOutput(switcherId, options) {
+    return this.client.post(`${this.basePath}/${switcherId}/outputs`, options);
+  }
+  async startStreaming(switcherId, outputId) {
+    await this.client.post(`${this.basePath}/${switcherId}/outputs/${outputId}/start`, {});
+  }
+  async stopStreaming(switcherId, outputId) {
+    await this.client.post(`${this.basePath}/${switcherId}/outputs/${outputId}/stop`, {});
+  }
+  async startRecording(switcherId) {
+    await this.client.post(`${this.basePath}/${switcherId}/record/start`, {});
+  }
+  async stopRecording(switcherId) {
+    await this.client.post(`${this.basePath}/${switcherId}/record/stop`, {});
+  }
+};
+function createCloudSwitcherAPI(client) {
+  return new CloudSwitcherAPI(client);
+}
+export {
+  CloudSwitcherAPI,
+  createCloudSwitcherAPI
+};