capybara-game-sdk 0.0.0

package/dist/index.js

@@ -0,0 +1,698 @@
+'use strict';
+
+var react = require('react');
+
+// src/AuthModule.ts
+var AuthModule = class {
+  constructor(bridge) {
+    this.bridge = bridge;
+    this.currentUser = null;
+    this.authChangeListeners = /* @__PURE__ */ new Set();
+    this.initialize();
+  }
+  async initialize() {
+    this.currentUser = await this.bridge.getCurrentUser();
+    this.bridge.on("auth_changed", (user) => {
+      this.currentUser = user;
+      this.notifyAuthChange();
+    });
+  }
+  notifyAuthChange() {
+    this.authChangeListeners.forEach((listener) => {
+      try {
+        listener(this.currentUser);
+      } catch (error) {
+        console.error("Error in auth change listener:", error);
+      }
+    });
+  }
+  /**
+   * Get the currently authenticated user
+   */
+  async getCurrentUser() {
+    if (!this.currentUser) {
+      this.currentUser = await this.bridge.getCurrentUser();
+    }
+    return this.currentUser;
+  }
+  /**
+   * Get bearer token for the authenticated user
+   */
+  async getBearerToken() {
+    return await this.bridge.getBearerToken();
+  }
+  /**
+   * Request user authentication (triggers parent app UI)
+   */
+  async requestLogin() {
+    await this.bridge.requestLogin();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    this.currentUser = await this.bridge.getCurrentUser();
+    this.notifyAuthChange();
+  }
+  /**
+   * Logout the current user
+   */
+  async logout() {
+    await this.bridge.logout();
+    this.currentUser = null;
+    this.notifyAuthChange();
+  }
+  /**
+   * Listen for authentication state changes
+   */
+  onAuthChange(callback) {
+    this.authChangeListeners.add(callback);
+    callback(this.currentUser);
+    return () => {
+      this.authChangeListeners.delete(callback);
+    };
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return this.currentUser !== null;
+  }
+};
+
+// src/ParentBridge.ts
+var ParentBridge = class {
+  constructor(allowedOrigins = ["*"]) {
+    this.messageHandlers = /* @__PURE__ */ new Map();
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.requestIdCounter = 0;
+    this.allowedOrigins = new Set(allowedOrigins);
+    this.setupMessageListener();
+  }
+  setupMessageListener() {
+    window.addEventListener("message", (event) => {
+      if (this.allowedOrigins.size > 0 && !this.allowedOrigins.has("*") && !this.allowedOrigins.has(event.origin)) {
+        console.warn(
+          "Rejected message from unauthorized origin:",
+          event.origin
+        );
+        return;
+      }
+      const message = event.data;
+      if (!message || typeof message !== "object" || !message.type) {
+        return;
+      }
+      const requestId = message.requestId;
+      if (requestId && this.pendingRequests.has(requestId)) {
+        const { resolve, reject } = this.pendingRequests.get(requestId);
+        this.pendingRequests.delete(requestId);
+        if (message.error) {
+          reject(new Error(message.error));
+        } else {
+          resolve(message.data);
+        }
+        return;
+      }
+      const handler = this.messageHandlers.get(message.type);
+      if (handler) {
+        handler(message.data);
+      }
+    });
+  }
+  /**
+   * Send a message to parent and wait for response
+   */
+  sendRequest(type, data) {
+    return new Promise((resolve, reject) => {
+      const requestId = `req_${this.requestIdCounter++}_${Date.now()}`;
+      this.pendingRequests.set(requestId, { resolve, reject });
+      const message = {
+        type,
+        data,
+        requestId
+      };
+      window.parent.postMessage(message, "*");
+      setTimeout(() => {
+        if (this.pendingRequests.has(requestId)) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Request timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  /**
+   * Send a message to parent without expecting a response
+   */
+  sendMessage(type, data) {
+    const message = {
+      type,
+      data
+    };
+    window.parent.postMessage(message, "*");
+  }
+  /**
+   * Listen for messages from parent
+   */
+  on(type, handler) {
+    this.messageHandlers.set(type, handler);
+  }
+  /**
+   * Remove message listener
+   */
+  off(type) {
+    this.messageHandlers.delete(type);
+  }
+  /**
+   * Get current authenticated user
+   */
+  async getCurrentUser() {
+    try {
+      return await this.sendRequest("get_user");
+    } catch (error) {
+      console.error("Failed to get current user:", error);
+      return null;
+    }
+  }
+  /**
+   * Request user to login (triggers parent app UI)
+   */
+  async requestLogin() {
+    return this.sendRequest("request_login");
+  }
+  /**
+   * Logout current user
+   */
+  async logout() {
+    return this.sendRequest("logout");
+  }
+  /**
+   * Get bearer token for authenticated user
+   */
+  async getBearerToken() {
+    try {
+      return await this.sendRequest("get_bearer_token");
+    } catch (error) {
+      console.error("Failed to get bearer token:", error);
+      return null;
+    }
+  }
+  /**
+   * Get user's credit balance
+   */
+  async getBalance() {
+    return this.sendRequest("get_balance");
+  }
+  /**
+   * Charge credits from user's balance
+   */
+  async chargeCredits(amount, description) {
+    return this.sendRequest("charge_credits", {
+      amount,
+      description
+    });
+  }
+  /**
+   * Notify parent that SDK is ready
+   */
+  notifyReady() {
+    this.sendMessage("ready");
+  }
+};
+
+// src/PaymentsModule.ts
+var PaymentsModule = class {
+  constructor(bridge, auth, devMode) {
+    this.bridge = bridge;
+    this.auth = auth;
+    this.devMode = devMode;
+    this.currentBalance = { credits: 0 };
+    this.balanceChangeListeners = /* @__PURE__ */ new Set();
+    this.transactions = [];
+    this.initialize();
+  }
+  async initialize() {
+    if (this.auth.isAuthenticated()) {
+      await this.refreshBalance();
+    }
+    this.auth.onAuthChange(async (user) => {
+      if (user) {
+        await this.refreshBalance();
+      } else {
+        this.currentBalance = { credits: 0 };
+        this.notifyBalanceChange();
+      }
+    });
+    this.bridge.on("balance_updated", (balance) => {
+      this.currentBalance = balance;
+      this.notifyBalanceChange();
+    });
+  }
+  async refreshBalance() {
+    try {
+      this.currentBalance = await this.bridge.getBalance();
+      this.notifyBalanceChange();
+    } catch (error) {
+      console.error("Failed to refresh balance:", error);
+    }
+  }
+  notifyBalanceChange() {
+    this.balanceChangeListeners.forEach((listener) => {
+      try {
+        listener(this.currentBalance);
+      } catch (error) {
+        console.error("Error in balance change listener:", error);
+      }
+    });
+  }
+  /**
+   * Get the current credit balance
+   */
+  async getBalance() {
+    if (!this.auth.isAuthenticated()) {
+      throw new Error("User must be authenticated to check balance");
+    }
+    if (this.devMode) {
+      return { credits: 999999 };
+    }
+    await this.refreshBalance();
+    return this.currentBalance;
+  }
+  /**
+   * Charge credits from the user's balance
+   * In dev mode, this is a no-op (free)
+   */
+  async charge(amount, description) {
+    if (!this.auth.isAuthenticated()) {
+      throw new Error("User must be authenticated to make payments");
+    }
+    if (amount <= 0) {
+      throw new Error("Amount must be greater than 0");
+    }
+    if (this.devMode) {
+      console.warn(
+        `Dev mode: Charging ${amount} credits for "${description}" - no actual charge applied.`
+      );
+      return {
+        success: true,
+        newBalance: 999999
+      };
+    }
+    try {
+      const result = await this.bridge.chargeCredits(amount, description);
+      if (result.success) {
+        this.currentBalance = { credits: result.newBalance };
+        this.notifyBalanceChange();
+        this.transactions.push({
+          amount: -amount,
+          description,
+          timestamp: Date.now()
+        });
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        newBalance: this.currentBalance.credits,
+        error: error instanceof Error ? error.message : "Failed to charge credits"
+      };
+    }
+  }
+  /**
+   * Listen for balance changes
+   */
+  onBalanceChange(callback) {
+    this.balanceChangeListeners.add(callback);
+    callback(this.currentBalance);
+    return () => {
+      this.balanceChangeListeners.delete(callback);
+    };
+  }
+  /**
+   * Get transaction history
+   * Note: This only includes transactions made during the current session
+   * For full history, the parent app should provide an API
+   */
+  async getHistory() {
+    return [...this.transactions];
+  }
+  /**
+   * Gift credits to another user (requires server-side implementation)
+   */
+  async giftCredits(userId, amount, description) {
+    throw new Error("Gift credits not yet implemented");
+  }
+  /**
+   * Set development mode
+   */
+  setDevMode(enabled) {
+    this.devMode = enabled;
+  }
+};
+
+// src/GameSDK.ts
+var _GameSDK = class _GameSDK {
+  constructor(config) {
+    this.config = config;
+    this.gameId = config.gameId;
+    this.bridge = new ParentBridge();
+    this.auth = new AuthModule(this.bridge);
+    this.payments = new PaymentsModule(
+      this.bridge,
+      this.auth,
+      config.devMode || false
+    );
+    this.bridge.notifyReady();
+    if (config.onReady) {
+      setTimeout(config.onReady, 0);
+    }
+  }
+  /**
+   * Initialize the Game SDK
+   */
+  static async init(config) {
+    if (_GameSDK.instance) {
+      console.warn("GameSDK already initialized. Returning existing instance.");
+      return _GameSDK.instance;
+    }
+    if (!config.gameId) {
+      throw new Error("gameId is required");
+    }
+    _GameSDK.instance = new _GameSDK(config);
+    return _GameSDK.instance;
+  }
+  /**
+   * Get the current SDK instance
+   */
+  static getInstance() {
+    if (!_GameSDK.instance) {
+      throw new Error("GameSDK not initialized. Call GameSDK.init() first.");
+    }
+    return _GameSDK.instance;
+  }
+  /**
+   * Set development mode
+   */
+  setDevMode(enabled) {
+    this.config.devMode = enabled;
+    this.payments.setDevMode(enabled);
+  }
+  /**
+   * Get SDK configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Clean up SDK resources
+   */
+  async destroy() {
+    _GameSDK.instance = null;
+  }
+};
+_GameSDK.instance = null;
+var GameSDK = _GameSDK;
+
+// src/ApiClient.ts
+var API_BASE_URL = "https://api.gamesdk.com";
+var ApiClient = class {
+  constructor(auth) {
+    this.auth = auth;
+  }
+  async getHeaders() {
+    const token = await this.auth.getBearerToken();
+    return {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    };
+  }
+  async makeRequest(endpoint, options = {}) {
+    const url = `${API_BASE_URL}${endpoint}`;
+    const headers = await this.getHeaders();
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...headers,
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `API request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Save game data to the server
+   */
+  async saveGameData(gameId, data) {
+    await this.makeRequest("/api/storage/save", {
+      method: "POST",
+      body: JSON.stringify({ gameId, data })
+    });
+  }
+  /**
+   * Load game data from the server
+   */
+  async loadGameData(gameId) {
+    try {
+      const result = await this.makeRequest(
+        "/api/storage/load",
+        {
+          method: "GET"
+        }
+      );
+      return result.data;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("404")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Clear game data from the server
+   */
+  async clearGameData(gameId) {
+    await this.makeRequest("/api/storage/clear", {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Check if game data exists on the server
+   */
+  async gameDataExists(gameId) {
+    try {
+      await this.makeRequest("/api/storage/exists", {
+        method: "GET"
+      });
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("404")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get the size of stored game data
+   */
+  async getGameDataSize(gameId) {
+    const result = await this.makeRequest(
+      "/api/storage/size",
+      {
+        method: "GET"
+      }
+    );
+    return result.size;
+  }
+};
+
+// src/StorageModule.ts
+var StorageModule = class {
+  constructor(gameId, auth) {
+    this.auth = auth;
+    this.gameId = gameId;
+    this.apiClient = new ApiClient(auth);
+  }
+  /**
+   * Save data to storage
+   * Data is automatically scoped to current user and game
+   * Maximum size: 5MB
+   */
+  async save(data) {
+    try {
+      const serialized = JSON.stringify(data);
+      const sizeInBytes = new Blob([serialized]).size;
+      if (sizeInBytes > 5 * 1024 * 1024) {
+        throw new Error("Storage limit exceeded: Maximum 5MB allowed");
+      }
+      await this.apiClient.saveGameData(this.gameId, data);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error("Failed to save data to storage");
+    }
+  }
+  /**
+   * Load data from storage
+   * Returns null if no data exists
+   */
+  async load() {
+    try {
+      return await this.apiClient.loadGameData(this.gameId);
+    } catch (error) {
+      console.error("Failed to load data from storage:", error);
+      return null;
+    }
+  }
+  /**
+   * Clear all stored data for current user and game
+   */
+  async clear() {
+    try {
+      await this.apiClient.clearGameData(this.gameId);
+    } catch (error) {
+      console.error("Failed to clear storage:", error);
+    }
+  }
+  /**
+   * Check if data exists in storage
+   */
+  async exists() {
+    return this.apiClient.gameDataExists(this.gameId);
+  }
+  /**
+   * Get the size of stored data in bytes
+   */
+  async getSize() {
+    try {
+      return await this.apiClient.getGameDataSize(this.gameId);
+    } catch (error) {
+      return 0;
+    }
+  }
+};
+function useGameSDK(config) {
+  const [sdk, setSDK] = react.useState(null);
+  const [isReady, setIsReady] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    let mounted = true;
+    const initSDK = async () => {
+      try {
+        const configWithReady = {
+          ...config,
+          onReady: () => {
+            if (mounted) {
+              setIsReady(true);
+              config.onReady?.();
+            }
+          }
+        };
+        const instance = await GameSDK.init(configWithReady);
+        if (mounted) {
+          setSDK(instance);
+        }
+      } catch (err) {
+        if (mounted) {
+          setError(
+            err instanceof Error ? err : new Error("Failed to initialize SDK")
+          );
+        }
+      }
+    };
+    initSDK();
+    return () => {
+      mounted = false;
+    };
+  }, [config.gameId]);
+  return { sdk, isReady, error };
+}
+function useAuth() {
+  const sdk = GameSDK.getInstance();
+  const [user, setUser] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(true);
+  react.useEffect(() => {
+    let mounted = true;
+    const loadUser = async () => {
+      const currentUser = await sdk.auth.getCurrentUser();
+      if (mounted) {
+        setUser(currentUser);
+        setIsLoading(false);
+      }
+    };
+    loadUser();
+    const unsubscribe = sdk.auth.onAuthChange((newUser) => {
+      if (mounted) {
+        setUser(newUser);
+      }
+    });
+    return () => {
+      mounted = false;
+      unsubscribe();
+    };
+  }, [sdk]);
+  const login = react.useCallback(async () => {
+    await sdk.auth.requestLogin();
+  }, [sdk]);
+  const logout = react.useCallback(async () => {
+    await sdk.auth.logout();
+  }, [sdk]);
+  return {
+    user,
+    isLoading,
+    isAuthenticated: !!user,
+    login,
+    logout
+  };
+}
+function useCredits() {
+  const sdk = GameSDK.getInstance();
+  const [balance, setBalance] = react.useState({ credits: 0 });
+  const [isLoading, setIsLoading] = react.useState(true);
+  react.useEffect(() => {
+    let mounted = true;
+    const loadBalance = async () => {
+      try {
+        const currentBalance = await sdk.payments.getBalance();
+        if (mounted) {
+          setBalance(currentBalance);
+          setIsLoading(false);
+        }
+      } catch (error) {
+        if (mounted) {
+          setIsLoading(false);
+        }
+      }
+    };
+    loadBalance();
+    const unsubscribe = sdk.payments.onBalanceChange((newBalance) => {
+      if (mounted) {
+        setBalance(newBalance);
+      }
+    });
+    return () => {
+      mounted = false;
+      unsubscribe();
+    };
+  }, [sdk]);
+  const charge = react.useCallback(
+    async (amount, description) => {
+      return await sdk.payments.charge(amount, description);
+    },
+    [sdk]
+  );
+  return {
+    balance: balance.credits,
+    isLoading,
+    charge
+  };
+}
+
+exports.AuthModule = AuthModule;
+exports.GameSDK = GameSDK;
+exports.PaymentsModule = PaymentsModule;
+exports.StorageModule = StorageModule;
+exports.useAuth = useAuth;
+exports.useCredits = useCredits;
+exports.useGameSDK = useGameSDK;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map