@choochmeque/tauri-plugin-iap-api 0.2.1 → 0.3.1

package/dist-js/index.cjs

@@ -3,60 +3,192 @@
 var core = require('@tauri-apps/api/core');
 var event = require('@tauri-apps/api/event');
 
+/**
+ * Purchase state enumeration
+ */
 exports.PurchaseState = void 0;
 (function (PurchaseState) {
     PurchaseState[PurchaseState["PURCHASED"] = 0] = "PURCHASED";
     PurchaseState[PurchaseState["CANCELED"] = 1] = "CANCELED";
     PurchaseState[PurchaseState["PENDING"] = 2] = "PENDING";
 })(exports.PurchaseState || (exports.PurchaseState = {}));
+/**
+ * Initialize the IAP plugin.
+ * Must be called before any other IAP operations.
+ *
+ * @returns Promise resolving to initialization status
+ * @example
+ * ```typescript
+ * const result = await initialize();
+ * if (result.success) {
+ *   console.log('IAP initialized successfully');
+ * }
+ * ```
+ */
 async function initialize() {
-    return await core.invoke('plugin:iap|initialize');
+    return await core.invoke("plugin:iap|initialize");
 }
-async function getProducts(productIds, productType = 'subs') {
-    return await core.invoke('plugin:iap|get_products', {
+/**
+ * Fetch product information from the app store.
+ *
+ * @param productIds - Array of product identifiers to fetch
+ * @param productType - Type of products: "subs" for subscriptions, "inapp" for one-time purchases
+ * @returns Promise resolving to product information
+ * @example
+ * ```typescript
+ * const { products } = await getProducts(
+ *   ['com.example.premium', 'com.example.remove_ads'],
+ *   'inapp'
+ * );
+ * ```
+ */
+async function getProducts(productIds, productType = "subs") {
+    return await core.invoke("plugin:iap|get_products", {
         payload: {
             productIds,
             productType,
         },
     });
 }
-async function purchase(productId, productType = 'subs', offerToken) {
-    return await core.invoke('plugin:iap|purchase', {
+/**
+ * Initiate a purchase for the specified product.
+ *
+ * @param productId - Product identifier to purchase
+ * @param productType - Type of product: "subs" or "inapp"
+ * @param options - Optional purchase parameters (platform-specific)
+ * @returns Promise resolving to purchase transaction details
+ * @example
+ * ```typescript
+ * // Simple purchase
+ * const purchase = await purchase('com.example.premium', 'subs');
+ *
+ * // With options (iOS)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   appAccountToken: '550e8400-e29b-41d4-a716-446655440000' // Must be valid UUID
+ * });
+ *
+ * // With options (Android)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   offerToken: 'offer_token_here',
+ *   obfuscatedAccountId: 'user_account_id',
+ *   obfuscatedProfileId: 'user_profile_id'
+ * });
+ * ```
+ */
+async function purchase(productId, productType = "subs", options) {
+    return await core.invoke("plugin:iap|purchase", {
         payload: {
             productId,
             productType,
-            offerToken,
+            ...options,
         },
     });
 }
-async function restorePurchases(productType = 'subs') {
-    return await core.invoke('plugin:iap|restore_purchases', {
+/**
+ * Restore user's previous purchases.
+ *
+ * @param productType - Type of products to restore: "subs" or "inapp"
+ * @returns Promise resolving to list of restored purchases
+ * @example
+ * ```typescript
+ * const { purchases } = await restorePurchases('subs');
+ * purchases.forEach(purchase => {
+ *   console.log(`Restored: ${purchase.productId}`);
+ * });
+ * ```
+ */
+async function restorePurchases(productType = "subs") {
+    return await core.invoke("plugin:iap|restore_purchases", {
         payload: {
             productType,
         },
     });
 }
+/**
+ * Get the user's purchase history.
+ * Note: Not supported on all platforms.
+ *
+ * @returns Promise resolving to purchase history
+ * @example
+ * ```typescript
+ * const { history } = await getPurchaseHistory();
+ * history.forEach(record => {
+ *   console.log(`Purchase: ${record.productId} at ${record.purchaseTime}`);
+ * });
+ * ```
+ */
 async function getPurchaseHistory() {
-    return await core.invoke('plugin:iap|get_purchase_history');
+    return await core.invoke("plugin:iap|get_purchase_history");
 }
+/**
+ * Acknowledge a purchase (Android only).
+ * Purchases must be acknowledged within 3 days or they will be refunded.
+ * iOS automatically acknowledges purchases.
+ *
+ * @param purchaseToken - Purchase token from the transaction
+ * @returns Promise resolving to acknowledgment status
+ * @example
+ * ```typescript
+ * const result = await acknowledgePurchase(purchase.purchaseToken);
+ * if (result.success) {
+ *   console.log('Purchase acknowledged');
+ * }
+ * ```
+ */
 async function acknowledgePurchase(purchaseToken) {
-    return await core.invoke('plugin:iap|acknowledge_purchase', {
+    return await core.invoke("plugin:iap|acknowledge_purchase", {
         payload: {
             purchaseToken,
         },
     });
 }
-async function getProductStatus(productId, productType = 'subs') {
-    return await core.invoke('plugin:iap|get_product_status', {
+/**
+ * Get the current status of a product for the user.
+ * Checks if the product is owned, expired, or available for purchase.
+ *
+ * @param productId - Product identifier to check
+ * @param productType - Type of product: "subs" or "inapp"
+ * @returns Promise resolving to product status
+ * @example
+ * ```typescript
+ * const status = await getProductStatus('com.example.premium', 'subs');
+ * if (status.isOwned) {
+ *   console.log('User owns this product');
+ *   if (status.isAutoRenewing) {
+ *     console.log('Subscription is auto-renewing');
+ *   }
+ * }
+ * ```
+ */
+async function getProductStatus(productId, productType = "subs") {
+    return await core.invoke("plugin:iap|get_product_status", {
         payload: {
             productId,
             productType,
         },
     });
 }
-// Event listener for purchase updates
+/**
+ * Listen for purchase updates.
+ * This event is triggered when a purchase state changes.
+ *
+ * @param callback - Function to call when a purchase is updated
+ * @returns Cleanup function to stop listening
+ * @example
+ * ```typescript
+ * const unsubscribe = onPurchaseUpdated((purchase) => {
+ *   console.log(`Purchase updated: ${purchase.productId}`);
+ *   if (purchase.purchaseState === PurchaseState.PURCHASED) {
+ *     // Handle successful purchase
+ *   }
+ * });
+ *
+ * // Later, stop listening
+ * unsubscribe();
+ * ```
+ */
 function onPurchaseUpdated(callback) {
-    const unlisten = event.listen('purchaseUpdated', (event) => {
+    const unlisten = event.listen("purchaseUpdated", (event) => {
         callback(event.payload);
     });
     return () => {

package/dist-js/index.d.ts

@@ -1,6 +1,12 @@
+/**
+ * Response from IAP initialization
+ */
 export interface InitializeResponse {
     success: boolean;
 }
+/**
+ * Represents a pricing phase for subscription products
+ */
 export interface PricingPhase {
     formattedPrice: string;
     priceCurrencyCode: string;
@@ -9,12 +15,18 @@ export interface PricingPhase {
     billingCycleCount: number;
     recurrenceMode: number;
 }
+/**
+ * Subscription offer details including pricing phases
+ */
 export interface SubscriptionOffer {
     offerToken: string;
     basePlanId: string;
     offerId?: string;
     pricingPhases: PricingPhase[];
 }
+/**
+ * Product information from the app store
+ */
 export interface Product {
     productId: string;
     title: string;
@@ -25,9 +37,15 @@ export interface Product {
     priceAmountMicros?: number;
     subscriptionOfferDetails?: SubscriptionOffer[];
 }
+/**
+ * Response containing products fetched from the store
+ */
 export interface GetProductsResponse {
     products: Product[];
 }
+/**
+ * Purchase transaction information
+ */
 export interface Purchase {
     orderId?: string;
     packageName: string;
@@ -40,9 +58,15 @@ export interface Purchase {
     originalJson: string;
     signature: string;
 }
+/**
+ * Response containing restored purchases
+ */
 export interface RestorePurchasesResponse {
     purchases: Purchase[];
 }
+/**
+ * Historical purchase record
+ */
 export interface PurchaseHistoryRecord {
     productId: string;
     purchaseTime: number;
@@ -51,17 +75,29 @@ export interface PurchaseHistoryRecord {
     originalJson: string;
     signature: string;
 }
+/**
+ * Response containing purchase history
+ */
 export interface GetPurchaseHistoryResponse {
     history: PurchaseHistoryRecord[];
 }
+/**
+ * Response from acknowledging a purchase
+ */
 export interface AcknowledgePurchaseResponse {
     success: boolean;
 }
+/**
+ * Purchase state enumeration
+ */
 export declare enum PurchaseState {
     PURCHASED = 0,
     CANCELED = 1,
     PENDING = 2
 }
+/**
+ * Current status of a product for the user
+ */
 export interface ProductStatus {
     productId: string;
     isOwned: boolean;
@@ -72,11 +108,154 @@ export interface ProductStatus {
     isAcknowledged?: boolean;
     purchaseToken?: string;
 }
+/**
+ * Optional parameters for purchase requests
+ */
+export interface PurchaseOptions {
+    /** Offer token for subscription products (Android) */
+    offerToken?: string;
+    /** Obfuscated account identifier for fraud prevention (Android only) */
+    obfuscatedAccountId?: string;
+    /** Obfuscated profile identifier for fraud prevention (Android only) */
+    obfuscatedProfileId?: string;
+    /** App account token - must be a valid UUID string (iOS only) */
+    appAccountToken?: string;
+}
+/**
+ * Initialize the IAP plugin.
+ * Must be called before any other IAP operations.
+ *
+ * @returns Promise resolving to initialization status
+ * @example
+ * ```typescript
+ * const result = await initialize();
+ * if (result.success) {
+ *   console.log('IAP initialized successfully');
+ * }
+ * ```
+ */
 export declare function initialize(): Promise<InitializeResponse>;
-export declare function getProducts(productIds: string[], productType?: 'subs' | 'inapp'): Promise<GetProductsResponse>;
-export declare function purchase(productId: string, productType?: 'subs' | 'inapp', offerToken?: string): Promise<Purchase>;
-export declare function restorePurchases(productType?: 'subs' | 'inapp'): Promise<RestorePurchasesResponse>;
+/**
+ * Fetch product information from the app store.
+ *
+ * @param productIds - Array of product identifiers to fetch
+ * @param productType - Type of products: "subs" for subscriptions, "inapp" for one-time purchases
+ * @returns Promise resolving to product information
+ * @example
+ * ```typescript
+ * const { products } = await getProducts(
+ *   ['com.example.premium', 'com.example.remove_ads'],
+ *   'inapp'
+ * );
+ * ```
+ */
+export declare function getProducts(productIds: string[], productType?: "subs" | "inapp"): Promise<GetProductsResponse>;
+/**
+ * Initiate a purchase for the specified product.
+ *
+ * @param productId - Product identifier to purchase
+ * @param productType - Type of product: "subs" or "inapp"
+ * @param options - Optional purchase parameters (platform-specific)
+ * @returns Promise resolving to purchase transaction details
+ * @example
+ * ```typescript
+ * // Simple purchase
+ * const purchase = await purchase('com.example.premium', 'subs');
+ *
+ * // With options (iOS)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   appAccountToken: '550e8400-e29b-41d4-a716-446655440000' // Must be valid UUID
+ * });
+ *
+ * // With options (Android)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   offerToken: 'offer_token_here',
+ *   obfuscatedAccountId: 'user_account_id',
+ *   obfuscatedProfileId: 'user_profile_id'
+ * });
+ * ```
+ */
+export declare function purchase(productId: string, productType?: "subs" | "inapp", options?: PurchaseOptions): Promise<Purchase>;
+/**
+ * Restore user's previous purchases.
+ *
+ * @param productType - Type of products to restore: "subs" or "inapp"
+ * @returns Promise resolving to list of restored purchases
+ * @example
+ * ```typescript
+ * const { purchases } = await restorePurchases('subs');
+ * purchases.forEach(purchase => {
+ *   console.log(`Restored: ${purchase.productId}`);
+ * });
+ * ```
+ */
+export declare function restorePurchases(productType?: "subs" | "inapp"): Promise<RestorePurchasesResponse>;
+/**
+ * Get the user's purchase history.
+ * Note: Not supported on all platforms.
+ *
+ * @returns Promise resolving to purchase history
+ * @example
+ * ```typescript
+ * const { history } = await getPurchaseHistory();
+ * history.forEach(record => {
+ *   console.log(`Purchase: ${record.productId} at ${record.purchaseTime}`);
+ * });
+ * ```
+ */
 export declare function getPurchaseHistory(): Promise<GetPurchaseHistoryResponse>;
+/**
+ * Acknowledge a purchase (Android only).
+ * Purchases must be acknowledged within 3 days or they will be refunded.
+ * iOS automatically acknowledges purchases.
+ *
+ * @param purchaseToken - Purchase token from the transaction
+ * @returns Promise resolving to acknowledgment status
+ * @example
+ * ```typescript
+ * const result = await acknowledgePurchase(purchase.purchaseToken);
+ * if (result.success) {
+ *   console.log('Purchase acknowledged');
+ * }
+ * ```
+ */
 export declare function acknowledgePurchase(purchaseToken: string): Promise<AcknowledgePurchaseResponse>;
-export declare function getProductStatus(productId: string, productType?: 'subs' | 'inapp'): Promise<ProductStatus>;
+/**
+ * Get the current status of a product for the user.
+ * Checks if the product is owned, expired, or available for purchase.
+ *
+ * @param productId - Product identifier to check
+ * @param productType - Type of product: "subs" or "inapp"
+ * @returns Promise resolving to product status
+ * @example
+ * ```typescript
+ * const status = await getProductStatus('com.example.premium', 'subs');
+ * if (status.isOwned) {
+ *   console.log('User owns this product');
+ *   if (status.isAutoRenewing) {
+ *     console.log('Subscription is auto-renewing');
+ *   }
+ * }
+ * ```
+ */
+export declare function getProductStatus(productId: string, productType?: "subs" | "inapp"): Promise<ProductStatus>;
+/**
+ * Listen for purchase updates.
+ * This event is triggered when a purchase state changes.
+ *
+ * @param callback - Function to call when a purchase is updated
+ * @returns Cleanup function to stop listening
+ * @example
+ * ```typescript
+ * const unsubscribe = onPurchaseUpdated((purchase) => {
+ *   console.log(`Purchase updated: ${purchase.productId}`);
+ *   if (purchase.purchaseState === PurchaseState.PURCHASED) {
+ *     // Handle successful purchase
+ *   }
+ * });
+ *
+ * // Later, stop listening
+ * unsubscribe();
+ * ```
+ */
 export declare function onPurchaseUpdated(callback: (purchase: Purchase) => void): () => void;

package/dist-js/index.js

@@ -1,60 +1,192 @@
 import { invoke } from '@tauri-apps/api/core';
 import { listen } from '@tauri-apps/api/event';
 
+/**
+ * Purchase state enumeration
+ */
 var PurchaseState;
 (function (PurchaseState) {
     PurchaseState[PurchaseState["PURCHASED"] = 0] = "PURCHASED";
     PurchaseState[PurchaseState["CANCELED"] = 1] = "CANCELED";
     PurchaseState[PurchaseState["PENDING"] = 2] = "PENDING";
 })(PurchaseState || (PurchaseState = {}));
+/**
+ * Initialize the IAP plugin.
+ * Must be called before any other IAP operations.
+ *
+ * @returns Promise resolving to initialization status
+ * @example
+ * ```typescript
+ * const result = await initialize();
+ * if (result.success) {
+ *   console.log('IAP initialized successfully');
+ * }
+ * ```
+ */
 async function initialize() {
-    return await invoke('plugin:iap|initialize');
+    return await invoke("plugin:iap|initialize");
 }
-async function getProducts(productIds, productType = 'subs') {
-    return await invoke('plugin:iap|get_products', {
+/**
+ * Fetch product information from the app store.
+ *
+ * @param productIds - Array of product identifiers to fetch
+ * @param productType - Type of products: "subs" for subscriptions, "inapp" for one-time purchases
+ * @returns Promise resolving to product information
+ * @example
+ * ```typescript
+ * const { products } = await getProducts(
+ *   ['com.example.premium', 'com.example.remove_ads'],
+ *   'inapp'
+ * );
+ * ```
+ */
+async function getProducts(productIds, productType = "subs") {
+    return await invoke("plugin:iap|get_products", {
         payload: {
             productIds,
             productType,
         },
     });
 }
-async function purchase(productId, productType = 'subs', offerToken) {
-    return await invoke('plugin:iap|purchase', {
+/**
+ * Initiate a purchase for the specified product.
+ *
+ * @param productId - Product identifier to purchase
+ * @param productType - Type of product: "subs" or "inapp"
+ * @param options - Optional purchase parameters (platform-specific)
+ * @returns Promise resolving to purchase transaction details
+ * @example
+ * ```typescript
+ * // Simple purchase
+ * const purchase = await purchase('com.example.premium', 'subs');
+ *
+ * // With options (iOS)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   appAccountToken: '550e8400-e29b-41d4-a716-446655440000' // Must be valid UUID
+ * });
+ *
+ * // With options (Android)
+ * const purchase = await purchase('com.example.premium', 'subs', {
+ *   offerToken: 'offer_token_here',
+ *   obfuscatedAccountId: 'user_account_id',
+ *   obfuscatedProfileId: 'user_profile_id'
+ * });
+ * ```
+ */
+async function purchase(productId, productType = "subs", options) {
+    return await invoke("plugin:iap|purchase", {
         payload: {
             productId,
             productType,
-            offerToken,
+            ...options,
         },
     });
 }
-async function restorePurchases(productType = 'subs') {
-    return await invoke('plugin:iap|restore_purchases', {
+/**
+ * Restore user's previous purchases.
+ *
+ * @param productType - Type of products to restore: "subs" or "inapp"
+ * @returns Promise resolving to list of restored purchases
+ * @example
+ * ```typescript
+ * const { purchases } = await restorePurchases('subs');
+ * purchases.forEach(purchase => {
+ *   console.log(`Restored: ${purchase.productId}`);
+ * });
+ * ```
+ */
+async function restorePurchases(productType = "subs") {
+    return await invoke("plugin:iap|restore_purchases", {
         payload: {
             productType,
         },
     });
 }
+/**
+ * Get the user's purchase history.
+ * Note: Not supported on all platforms.
+ *
+ * @returns Promise resolving to purchase history
+ * @example
+ * ```typescript
+ * const { history } = await getPurchaseHistory();
+ * history.forEach(record => {
+ *   console.log(`Purchase: ${record.productId} at ${record.purchaseTime}`);
+ * });
+ * ```
+ */
 async function getPurchaseHistory() {
-    return await invoke('plugin:iap|get_purchase_history');
+    return await invoke("plugin:iap|get_purchase_history");
 }
+/**
+ * Acknowledge a purchase (Android only).
+ * Purchases must be acknowledged within 3 days or they will be refunded.
+ * iOS automatically acknowledges purchases.
+ *
+ * @param purchaseToken - Purchase token from the transaction
+ * @returns Promise resolving to acknowledgment status
+ * @example
+ * ```typescript
+ * const result = await acknowledgePurchase(purchase.purchaseToken);
+ * if (result.success) {
+ *   console.log('Purchase acknowledged');
+ * }
+ * ```
+ */
 async function acknowledgePurchase(purchaseToken) {
-    return await invoke('plugin:iap|acknowledge_purchase', {
+    return await invoke("plugin:iap|acknowledge_purchase", {
         payload: {
             purchaseToken,
         },
     });
 }
-async function getProductStatus(productId, productType = 'subs') {
-    return await invoke('plugin:iap|get_product_status', {
+/**
+ * Get the current status of a product for the user.
+ * Checks if the product is owned, expired, or available for purchase.
+ *
+ * @param productId - Product identifier to check
+ * @param productType - Type of product: "subs" or "inapp"
+ * @returns Promise resolving to product status
+ * @example
+ * ```typescript
+ * const status = await getProductStatus('com.example.premium', 'subs');
+ * if (status.isOwned) {
+ *   console.log('User owns this product');
+ *   if (status.isAutoRenewing) {
+ *     console.log('Subscription is auto-renewing');
+ *   }
+ * }
+ * ```
+ */
+async function getProductStatus(productId, productType = "subs") {
+    return await invoke("plugin:iap|get_product_status", {
         payload: {
             productId,
             productType,
         },
     });
 }
-// Event listener for purchase updates
+/**
+ * Listen for purchase updates.
+ * This event is triggered when a purchase state changes.
+ *
+ * @param callback - Function to call when a purchase is updated
+ * @returns Cleanup function to stop listening
+ * @example
+ * ```typescript
+ * const unsubscribe = onPurchaseUpdated((purchase) => {
+ *   console.log(`Purchase updated: ${purchase.productId}`);
+ *   if (purchase.purchaseState === PurchaseState.PURCHASED) {
+ *     // Handle successful purchase
+ *   }
+ * });
+ *
+ * // Later, stop listening
+ * unsubscribe();
+ * ```
+ */
 function onPurchaseUpdated(callback) {
-    const unlisten = listen('purchaseUpdated', (event) => {
+    const unlisten = listen("purchaseUpdated", (event) => {
         callback(event.payload);
     });
     return () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@choochmeque/tauri-plugin-iap-api",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "license": "MIT",
   "author": "You",
   "description": "A Tauri v2 plugin that enables In-App Purchases (IAP)",
@@ -39,10 +39,13 @@
     "@rollup/plugin-typescript": "^12.1.4",
     "rollup": "^4.9.6",
     "tslib": "^2.6.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "prettier": "3.6.2"
   },
   "scripts": {
     "build": "rollup -c",
-    "pretest": "pnpm build"
+    "pretest": "pnpm build",
+    "format": "prettier --write \"./**/*.{cjs,mjs,js,jsx,mts,ts,tsx,html,css,json}\"",
+    "format-check": "prettier --check \"./**/*.{cjs,mjs,js,jsx,mts,ts,tsx,html,css,json}\""
   }
 }