@thestatic-tv/dcl-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,516 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GuideModule: () => GuideModule,
+  HeartbeatModule: () => HeartbeatModule,
+  InteractionsModule: () => InteractionsModule,
+  KEY_TYPE_CHANNEL: () => KEY_TYPE_CHANNEL,
+  KEY_TYPE_SCENE: () => KEY_TYPE_SCENE,
+  SessionModule: () => SessionModule,
+  StaticTVClient: () => StaticTVClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/http.ts
+async function request(url, options = {}) {
+  const { timeout = 1e4, ...fetchOptions } = options;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...fetchOptions,
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.error || `HTTP ${response.status}`);
+    }
+    return response.json();
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+// src/modules/guide.ts
+var GuideModule = class {
+  // 30 seconds
+  constructor(client) {
+    this.cachedChannels = null;
+    this.cacheTimestamp = 0;
+    this.cacheDuration = 3e4;
+    this.client = client;
+  }
+  /**
+   * Get all channels from thestatic.tv
+   * Results are cached for 30 seconds
+   */
+  async getChannels(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && this.cachedChannels && now - this.cacheTimestamp < this.cacheDuration) {
+      this.client.log("Returning cached channels");
+      return this.cachedChannels;
+    }
+    const response = await this.client.request("/guide");
+    this.cachedChannels = response.channels;
+    this.cacheTimestamp = now;
+    this.client.log(`Fetched ${response.channels.length} channels`);
+    return response.channels;
+  }
+  /**
+   * Get only live channels
+   */
+  async getLiveChannels(forceRefresh = false) {
+    const channels = await this.getChannels(forceRefresh);
+    return channels.filter((c) => c.isLive);
+  }
+  /**
+   * Get a specific channel by slug
+   */
+  async getChannel(slug) {
+    const channels = await this.getChannels();
+    return channels.find((c) => c.slug === slug);
+  }
+  /**
+   * Get VODs (videos on demand)
+   */
+  async getVods() {
+    const response = await this.client.request("/guide");
+    return response.vods;
+  }
+  /**
+   * Clear the channel cache
+   */
+  clearCache() {
+    this.cachedChannels = null;
+    this.cacheTimestamp = 0;
+  }
+};
+
+// src/utils/identity.ts
+function getPlayerWallet() {
+  try {
+    const { getPlayer } = require("@dcl/sdk/src/players");
+    const player = getPlayer();
+    return player?.userId ?? null;
+  } catch {
+    return null;
+  }
+}
+function getPlayerDisplayName() {
+  try {
+    const { getPlayer } = require("@dcl/sdk/src/players");
+    const player = getPlayer();
+    return player?.name ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/modules/session.ts
+var SessionModule = class {
+  constructor(client) {
+    this.sessionId = null;
+    this.heartbeatInterval = null;
+    this.isActive = false;
+    this.client = client;
+  }
+  /**
+   * Get the appropriate session endpoint based on key type
+   */
+  getEndpoint() {
+    return this.client.isLite ? "/scene-session" : "/session";
+  }
+  /**
+   * Start a new session
+   * Called automatically if autoStartSession is true
+   */
+  async startSession(metadata) {
+    if (this.isActive) {
+      this.client.log("Session already active");
+      return this.sessionId;
+    }
+    try {
+      const response = await this.client.request(this.getEndpoint(), {
+        method: "POST",
+        body: JSON.stringify({
+          action: "enter",
+          walletAddress: getPlayerWallet(),
+          dclDisplayName: getPlayerDisplayName(),
+          metadata
+        })
+      });
+      if (response.success && response.sessionId) {
+        this.sessionId = response.sessionId;
+        this.isActive = true;
+        this.startHeartbeat();
+        this.client.log(`Session started: ${this.sessionId}`);
+        return this.sessionId;
+      }
+      return null;
+    } catch (error) {
+      this.client.log(`Failed to start session: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Start the heartbeat interval
+   */
+  startHeartbeat() {
+    if (this.heartbeatInterval) return;
+    const interval = this.client.getConfig().sessionHeartbeatInterval || 3e4;
+    this.heartbeatInterval = setInterval(() => {
+      this.sendHeartbeat();
+    }, interval);
+  }
+  /**
+   * Send a session heartbeat
+   */
+  async sendHeartbeat() {
+    if (!this.sessionId || !this.isActive) return;
+    try {
+      await this.client.request(this.getEndpoint(), {
+        method: "POST",
+        body: JSON.stringify({
+          action: "heartbeat",
+          sessionId: this.sessionId
+        })
+      });
+      this.client.log("Session heartbeat sent");
+    } catch (error) {
+      this.client.log(`Session heartbeat failed: ${error}`);
+    }
+  }
+  /**
+   * End the current session
+   */
+  async endSession() {
+    if (!this.isActive) return;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.sessionId) {
+      try {
+        await this.client.request(this.getEndpoint(), {
+          method: "POST",
+          body: JSON.stringify({
+            action: "leave",
+            sessionId: this.sessionId
+          })
+        });
+        this.client.log("Session ended");
+      } catch (error) {
+        this.client.log(`Failed to end session: ${error}`);
+      }
+    }
+    this.sessionId = null;
+    this.isActive = false;
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Check if a session is currently active
+   */
+  isSessionActive() {
+    return this.isActive;
+  }
+};
+
+// src/modules/heartbeat.ts
+var HeartbeatModule = class {
+  constructor(client) {
+    this.watchInterval = null;
+    this.currentChannel = null;
+    this.isWatching = false;
+    this.client = client;
+  }
+  /**
+   * Start tracking video watching for a channel
+   * Sends heartbeats every minute while watching
+   *
+   * @param channelSlug The slug of the channel being watched
+   */
+  startWatching(channelSlug) {
+    if (this.isWatching && this.currentChannel === channelSlug) {
+      this.client.log(`Already watching ${channelSlug}`);
+      return;
+    }
+    if (this.isWatching && this.currentChannel !== channelSlug) {
+      this.stopWatching();
+    }
+    this.currentChannel = channelSlug;
+    this.isWatching = true;
+    this.sendHeartbeat();
+    const interval = this.client.getConfig().watchHeartbeatInterval || 6e4;
+    this.watchInterval = setInterval(() => {
+      this.sendHeartbeat();
+    }, interval);
+    this.client.log(`Started watching ${channelSlug}`);
+  }
+  /**
+   * Stop tracking video watching
+   */
+  stopWatching() {
+    if (!this.isWatching) return;
+    if (this.watchInterval) {
+      clearInterval(this.watchInterval);
+      this.watchInterval = null;
+    }
+    this.client.log(`Stopped watching ${this.currentChannel}`);
+    this.currentChannel = null;
+    this.isWatching = false;
+  }
+  /**
+   * Send a watching heartbeat (1 heartbeat = 1 minute watched)
+   */
+  async sendHeartbeat() {
+    if (!this.currentChannel || !this.isWatching) return;
+    try {
+      const sessionId = this.client.session.getSessionId();
+      await this.client.request("/heartbeat", {
+        method: "POST",
+        body: JSON.stringify({
+          channelSlug: this.currentChannel,
+          walletAddress: getPlayerWallet(),
+          sessionId
+        })
+      });
+      this.client.log(`Heartbeat sent for ${this.currentChannel}`);
+    } catch (error) {
+      this.client.log(`Heartbeat failed: ${error}`);
+    }
+  }
+  /**
+   * Get the currently watched channel
+   */
+  getCurrentChannel() {
+    return this.currentChannel;
+  }
+  /**
+   * Check if currently watching
+   */
+  isCurrentlyWatching() {
+    return this.isWatching;
+  }
+};
+
+// src/modules/interactions.ts
+var InteractionsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Like a channel
+   * Requires the user to be connected with a wallet
+   *
+   * @param channelSlug The slug of the channel to like
+   * @returns The interaction response or null if failed
+   */
+  async like(channelSlug) {
+    const walletAddress = getPlayerWallet();
+    if (!walletAddress) {
+      this.client.log("Cannot like: wallet not connected");
+      return null;
+    }
+    try {
+      const response = await this.client.request("/interact", {
+        method: "POST",
+        body: JSON.stringify({
+          action: "like",
+          channelSlug,
+          walletAddress
+        })
+      });
+      if (response.alreadyExists) {
+        this.client.log(`Already liked ${channelSlug}`);
+      } else {
+        this.client.log(`Liked ${channelSlug}`);
+      }
+      return response;
+    } catch (error) {
+      this.client.log(`Failed to like ${channelSlug}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Follow a channel
+   * Requires the user to be connected with a wallet
+   *
+   * @param channelSlug The slug of the channel to follow
+   * @returns The interaction response or null if failed
+   */
+  async follow(channelSlug) {
+    const walletAddress = getPlayerWallet();
+    if (!walletAddress) {
+      this.client.log("Cannot follow: wallet not connected");
+      return null;
+    }
+    try {
+      const response = await this.client.request("/interact", {
+        method: "POST",
+        body: JSON.stringify({
+          action: "follow",
+          channelSlug,
+          walletAddress
+        })
+      });
+      if (response.alreadyExists) {
+        this.client.log(`Already following ${channelSlug}`);
+      } else {
+        this.client.log(`Followed ${channelSlug}`);
+      }
+      return response;
+    } catch (error) {
+      this.client.log(`Failed to follow ${channelSlug}: ${error}`);
+      return null;
+    }
+  }
+};
+
+// src/StaticTVClient.ts
+var DEFAULT_BASE_URL = "https://thestatic.tv/api/v1/dcl";
+var KEY_TYPE_CHANNEL = "channel";
+var KEY_TYPE_SCENE = "scene";
+var StaticTVClient = class {
+  /**
+   * Create a new StaticTVClient
+   *
+   * @param config Configuration options
+   *
+   * @example
+   * ```typescript
+   * // Full access with channel key
+   * const staticTV = new StaticTVClient({
+   *   apiKey: 'dclk_your_channel_key_here',
+   *   debug: true
+   * });
+   *
+   * // Lite mode with scene key (visitors only)
+   * const staticTV = new StaticTVClient({
+   *   apiKey: 'dcls_your_scene_key_here'
+   * });
+   * ```
+   */
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("StaticTVClient: apiKey is required");
+    }
+    if (config.apiKey.startsWith("dclk_")) {
+      this._keyType = KEY_TYPE_CHANNEL;
+    } else if (config.apiKey.startsWith("dcls_")) {
+      this._keyType = KEY_TYPE_SCENE;
+    } else {
+      throw new Error("StaticTVClient: invalid apiKey format. Must start with dclk_ or dcls_");
+    }
+    this.config = {
+      autoStartSession: true,
+      sessionHeartbeatInterval: 3e4,
+      watchHeartbeatInterval: 6e4,
+      debug: false,
+      ...config
+    };
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.session = new SessionModule(this);
+    if (this._keyType === KEY_TYPE_CHANNEL) {
+      this.guide = new GuideModule(this);
+      this.heartbeat = new HeartbeatModule(this);
+      this.interactions = new InteractionsModule(this);
+    } else {
+      this.guide = null;
+      this.heartbeat = null;
+      this.interactions = null;
+    }
+    if (this.config.autoStartSession) {
+      this.session.startSession().catch((err) => {
+        this.log(`Auto-start session failed: ${err}`);
+      });
+    }
+    this.log(`StaticTVClient initialized (${this._keyType} mode)`);
+  }
+  /**
+   * Get the key type (channel or scene)
+   */
+  get keyType() {
+    return this._keyType;
+  }
+  /**
+   * Check if this is a lite (scene-only) client
+   */
+  get isLite() {
+    return this._keyType === KEY_TYPE_SCENE;
+  }
+  /**
+   * Make an authenticated API request
+   * @internal
+   */
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    return request(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "x-dcl-api-key": this.config.apiKey,
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Log a message if debug is enabled
+   * @internal
+   */
+  log(message, ...args) {
+    if (this.config.debug) {
+      console.log(`[StaticTV] ${message}`, ...args);
+    }
+  }
+  /**
+   * Get the current configuration
+   * @internal
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Cleanup when done (call before scene unload)
+   */
+  async destroy() {
+    if (this.heartbeat) {
+      this.heartbeat.stopWatching();
+    }
+    await this.session.endSession();
+    this.log("StaticTVClient destroyed");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GuideModule,
+  HeartbeatModule,
+  InteractionsModule,
+  KEY_TYPE_CHANNEL,
+  KEY_TYPE_SCENE,
+  SessionModule,
+  StaticTVClient
+});