@thestatic-tv/dcl-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,490 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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");
+  }
+};
+export {
+  GuideModule,
+  HeartbeatModule,
+  InteractionsModule,
+  KEY_TYPE_CHANNEL,
+  KEY_TYPE_SCENE,
+  SessionModule,
+  StaticTVClient
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@thestatic-tv/dcl-sdk",
+  "version": "1.0.0",
+  "description": "Connect your Decentraland scene to thestatic.tv - full channel lineup, metrics tracking, and interactions",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "decentraland",
+    "dcl",
+    "sdk",
+    "streaming",
+    "thestatic",
+    "metaverse",
+    "video",
+    "live-streaming"
+  ],
+  "author": "TheStatic.tv",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thestatic-tv/dcl-sdk"
+  },
+  "homepage": "https://thestatic.tv",
+  "bugs": {
+    "url": "https://github.com/thestatic-tv/dcl-sdk/issues"
+  },
+  "peerDependencies": {
+    "@dcl/sdk": ">=7.0.0"
+  },
+  "devDependencies": {
+    "@dcl/sdk": "^7.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}