@choochmeque/tauri-plugin-iap-api 0.8.2 → 0.9.1

package/README.md

@@ -46,7 +46,7 @@ Add the plugin to your Tauri project's `Cargo.toml`:
 
 ```toml
 [dependencies]
-tauri-plugin-iap = "0.8"
+tauri-plugin-iap = "0.9"
 ```
 
 Configure the plugin permissions in your `capabilities/default.json`:
@@ -112,6 +112,7 @@ import {
   purchase,
   restorePurchases,
   acknowledgePurchase,
+  consumePurchase,
   getProductStatus,
   onPurchaseUpdated,
   PurchaseState
@@ -161,9 +162,14 @@ const upgraded = await purchase('premium_subscription', 'subs', {
 // Restore purchases (specify product type)
 const restored = await restorePurchases('subs');
 
-// Acknowledge a purchase (Android only, iOS auto-acknowledges)
+// Acknowledge a non-consumable purchase (subscriptions, durables).
+// No-op on iOS/macOS — StoreKit auto-finishes transactions.
 await acknowledgePurchase(purchaseResult.purchaseToken);
 
+// Consume a consumable purchase (credits, coins) so it can be re-bought.
+// No-op on iOS/macOS — StoreKit auto-allows re-purchase.
+await consumePurchase(purchaseResult.purchaseToken);
+
 // Listen for purchase updates
 const listener = await onPurchaseUpdated((purchase) => {
   console.log('Purchase updated:', purchase);
@@ -173,6 +179,49 @@ const listener = await onPurchaseUpdated((purchase) => {
 await listener.unregister();
 ```
 
+### Rust
+
+```rust
+use tauri_plugin_iap::{IapExt, PurchaseRequest, PurchaseStateValue, Result};
+
+
+// Get available products
+let products = app.iap()
+    .get_products(
+        vec!["subscription_id_1".into(), "subscription_id_2".into()],
+        "subs".into(),
+    )
+    .await?;
+
+// Check if user owns a specific product
+let status = app.iap()
+    .get_product_status("subscription_id_1".into(), "subs".into())
+    .await?;
+if status.is_owned && status.purchase_state == Some(PurchaseStateValue::Purchased) {
+    println!("User has active subscription");
+    if status.is_auto_renewing == Some(true) {
+        println!("Subscription will auto-renew");
+    }
+}
+
+// Purchase a subscription or in-app product
+// Simple purchase (will use first available offer on Android if not specified)
+let purchase_result = app.iap()
+    .purchase(PurchaseRequest {
+        product_id: "subscription_id_1".into(),
+        product_type: "subs".into(),
+        options: None,
+    })
+    .await?;
+
+// Restore purchases (specify product type)
+let restored = app.iap().restore_purchases("subs".into()).await?;
+
+// Acknowledge a non-consumable purchase (subscriptions, durables).
+// No-op on iOS/macOS — StoreKit auto-finishes transactions.
+app.iap().acknowledge_purchase(purchase_result.purchase_token).await?;
+```
+
 ## Platform Setup
 
 ### iOS Setup
@@ -276,7 +325,10 @@ Queries and returns all active purchases.
 Returns the complete purchase history.
 
 ### `acknowledgePurchase(purchaseToken: string)`
-Acknowledges a purchase (required on Android within 3 days, no-op on iOS).
+Acknowledges a non-consumable purchase (subscriptions, durables). On Android this is required within 3 days or Google auto-refunds the purchase. No-op on iOS, macOS, and Windows. Use `consumePurchase` instead for consumables.
+
+### `consumePurchase(purchaseToken: string)`
+Consumes a consumable purchase (credits, coins, gems) so it can be purchased again. On Android calls `BillingClient.consumeAsync()`; on Windows calls `StoreContext.ReportConsumableFulfillmentAsync` with quantity 1. No-op on iOS and macOS — StoreKit auto-allows re-purchase. Never call both `acknowledgePurchase` and `consumePurchase` for the same purchase token.
 
 ### `getProductStatus(productId: string, productType: 'subs' | 'inapp' = 'subs')`
 Checks the ownership and subscription status of a specific product.
@@ -351,6 +403,28 @@ Listens for purchase state changes.
 3. App must be code-signed to use StoreKit
 4. Clear purchase history in System Settings > App Store > Sandbox Account
 
+## Troubleshooting
+
+<details>
+<summary><code>dyld: Library not loaded: @rpath/libswift_Concurrency.dylib</code></summary>
+
+This error occurs when `MACOSX_DEPLOYMENT_TARGET` is below 13.0. Tauri defaults to 11.0 in debug mode.
+
+**Option 1:** Add `.cargo/config.toml` to your project:
+
+```toml
+[env]
+MACOSX_DEPLOYMENT_TARGET = "13.0"
+```
+
+**Option 2:** Set the environment variable when running:
+
+```bash
+MACOSX_DEPLOYMENT_TARGET="13.0" pnpm tauri dev
+```
+
+</details>
+
 ## License
 
 [MIT](LICENSE)

package/dist-js/index.cjs

@@ -138,22 +138,54 @@ async function getPurchaseHistory() {
     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.
+ * Acknowledge a non-consumable purchase (subscriptions, durable products).
+ *
+ * On Android this calls `BillingClient.acknowledgePurchase()` and is required
+ * within 3 days of purchase or Google will auto-refund. On iOS, macOS, and
+ * Windows this is a no-op — those stores handle acknowledgment automatically.
+ *
+ * For consumable products (credits, coins, gems) call {@link consumePurchase}
+ * instead. Never call both for the same purchase token.
  *
  * @param purchaseToken - Purchase token from the transaction
- * @returns Promise resolving to acknowledgment status
+ * @throws Rejects if acknowledgment fails (e.g., Android billing client error)
  * @example
  * ```typescript
- * const result = await acknowledgePurchase(purchase.purchaseToken);
- * if (result.success) {
- *   console.log('Purchase acknowledged');
- * }
+ * await acknowledgePurchase(purchase.purchaseToken);
  * ```
  */
 async function acknowledgePurchase(purchaseToken) {
-    return await core.invoke("plugin:iap|acknowledge_purchase", {
+    await core.invoke("plugin:iap|acknowledge_purchase", {
+        payload: {
+            purchaseToken,
+        },
+    });
+}
+/**
+ * Consume a purchased consumable product so it can be purchased again.
+ *
+ * On Android this calls `BillingClient.consumeAsync()`, which acknowledges the
+ * purchase and removes ownership from the user's account. On Windows this calls
+ * `StoreContext.ReportConsumableFulfillmentAsync` with quantity 1. On iOS and
+ * macOS this is a no-op — StoreKit auto-allows re-purchase once `purchase()`
+ * has finished the transaction.
+ *
+ * Use this for consumables (credits, coins, gems). For non-consumables and
+ * subscriptions call {@link acknowledgePurchase} instead. Never call both for
+ * the same purchase token.
+ *
+ * @param purchaseToken - Purchase token from the transaction
+ * @throws Rejects if consumption fails (e.g., Android billing client error,
+ *   Windows network/server error, or invalid token on Windows)
+ * @example
+ * ```typescript
+ * const result = await purchase('credits_100', 'inapp');
+ * await consumePurchase(result.purchaseToken);
+ * // user can now buy credits_100 again
+ * ```
+ */
+async function consumePurchase(purchaseToken) {
+    await core.invoke("plugin:iap|consume_purchase", {
         payload: {
             purchaseToken,
         },
@@ -209,6 +241,7 @@ async function onPurchaseUpdated(callback) {
 }
 
 exports.acknowledgePurchase = acknowledgePurchase;
+exports.consumePurchase = consumePurchase;
 exports.getProductStatus = getProductStatus;
 exports.getProducts = getProducts;
 exports.getPurchaseHistory = getPurchaseHistory;

package/dist-js/index.d.ts

@@ -104,12 +104,6 @@ export interface PurchaseHistoryRecord {
 export interface GetPurchaseHistoryResponse {
     history: PurchaseHistoryRecord[];
 }
-/**
- * Response from acknowledging a purchase
- */
-export interface AcknowledgePurchaseResponse {
-    success: boolean;
-}
 /**
  * Purchase state enumeration
  */
@@ -259,21 +253,47 @@ export declare function restorePurchases(productType?: "subs" | "inapp"): Promis
  */
 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.
+ * Acknowledge a non-consumable purchase (subscriptions, durable products).
+ *
+ * On Android this calls `BillingClient.acknowledgePurchase()` and is required
+ * within 3 days of purchase or Google will auto-refund. On iOS, macOS, and
+ * Windows this is a no-op — those stores handle acknowledgment automatically.
+ *
+ * For consumable products (credits, coins, gems) call {@link consumePurchase}
+ * instead. Never call both for the same purchase token.
  *
  * @param purchaseToken - Purchase token from the transaction
- * @returns Promise resolving to acknowledgment status
+ * @throws Rejects if acknowledgment fails (e.g., Android billing client error)
  * @example
  * ```typescript
- * const result = await acknowledgePurchase(purchase.purchaseToken);
- * if (result.success) {
- *   console.log('Purchase acknowledged');
- * }
+ * await acknowledgePurchase(purchase.purchaseToken);
+ * ```
+ */
+export declare function acknowledgePurchase(purchaseToken: string): Promise<void>;
+/**
+ * Consume a purchased consumable product so it can be purchased again.
+ *
+ * On Android this calls `BillingClient.consumeAsync()`, which acknowledges the
+ * purchase and removes ownership from the user's account. On Windows this calls
+ * `StoreContext.ReportConsumableFulfillmentAsync` with quantity 1. On iOS and
+ * macOS this is a no-op — StoreKit auto-allows re-purchase once `purchase()`
+ * has finished the transaction.
+ *
+ * Use this for consumables (credits, coins, gems). For non-consumables and
+ * subscriptions call {@link acknowledgePurchase} instead. Never call both for
+ * the same purchase token.
+ *
+ * @param purchaseToken - Purchase token from the transaction
+ * @throws Rejects if consumption fails (e.g., Android billing client error,
+ *   Windows network/server error, or invalid token on Windows)
+ * @example
+ * ```typescript
+ * const result = await purchase('credits_100', 'inapp');
+ * await consumePurchase(result.purchaseToken);
+ * // user can now buy credits_100 again
  * ```
  */
-export declare function acknowledgePurchase(purchaseToken: string): Promise<AcknowledgePurchaseResponse>;
+export declare function consumePurchase(purchaseToken: string): Promise<void>;
 /**
  * Get the current status of a product for the user.
  * Checks if the product is owned, expired, or available for purchase.

package/dist-js/index.js

@@ -136,22 +136,54 @@ async function getPurchaseHistory() {
     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.
+ * Acknowledge a non-consumable purchase (subscriptions, durable products).
+ *
+ * On Android this calls `BillingClient.acknowledgePurchase()` and is required
+ * within 3 days of purchase or Google will auto-refund. On iOS, macOS, and
+ * Windows this is a no-op — those stores handle acknowledgment automatically.
+ *
+ * For consumable products (credits, coins, gems) call {@link consumePurchase}
+ * instead. Never call both for the same purchase token.
  *
  * @param purchaseToken - Purchase token from the transaction
- * @returns Promise resolving to acknowledgment status
+ * @throws Rejects if acknowledgment fails (e.g., Android billing client error)
  * @example
  * ```typescript
- * const result = await acknowledgePurchase(purchase.purchaseToken);
- * if (result.success) {
- *   console.log('Purchase acknowledged');
- * }
+ * await acknowledgePurchase(purchase.purchaseToken);
  * ```
  */
 async function acknowledgePurchase(purchaseToken) {
-    return await invoke("plugin:iap|acknowledge_purchase", {
+    await invoke("plugin:iap|acknowledge_purchase", {
+        payload: {
+            purchaseToken,
+        },
+    });
+}
+/**
+ * Consume a purchased consumable product so it can be purchased again.
+ *
+ * On Android this calls `BillingClient.consumeAsync()`, which acknowledges the
+ * purchase and removes ownership from the user's account. On Windows this calls
+ * `StoreContext.ReportConsumableFulfillmentAsync` with quantity 1. On iOS and
+ * macOS this is a no-op — StoreKit auto-allows re-purchase once `purchase()`
+ * has finished the transaction.
+ *
+ * Use this for consumables (credits, coins, gems). For non-consumables and
+ * subscriptions call {@link acknowledgePurchase} instead. Never call both for
+ * the same purchase token.
+ *
+ * @param purchaseToken - Purchase token from the transaction
+ * @throws Rejects if consumption fails (e.g., Android billing client error,
+ *   Windows network/server error, or invalid token on Windows)
+ * @example
+ * ```typescript
+ * const result = await purchase('credits_100', 'inapp');
+ * await consumePurchase(result.purchaseToken);
+ * // user can now buy credits_100 again
+ * ```
+ */
+async function consumePurchase(purchaseToken) {
+    await invoke("plugin:iap|consume_purchase", {
         payload: {
             purchaseToken,
         },
@@ -206,4 +238,4 @@ async function onPurchaseUpdated(callback) {
     return await addPluginListener("iap", "purchaseUpdated", callback);
 }
 
-export { PurchaseState, SubscriptionReplacementMode, acknowledgePurchase, getProductStatus, getProducts, getPurchaseHistory, initialize, onPurchaseUpdated, purchase, restorePurchases };
+export { PurchaseState, SubscriptionReplacementMode, acknowledgePurchase, consumePurchase, getProductStatus, getProducts, getPurchaseHistory, initialize, onPurchaseUpdated, purchase, restorePurchases };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@choochmeque/tauri-plugin-iap-api",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "license": "MIT",
   "author": "You",
   "description": "A Tauri v2 plugin that enables In-App Purchases (IAP)",
@@ -40,10 +40,10 @@
     "@vitest/coverage-v8": "^4.0.13",
     "@vitest/ui": "^4.0.13",
     "happy-dom": "^20.0.10",
-    "prettier": "3.8.1",
+    "prettier": "3.8.3",
     "rollup": "^4.9.6",
     "tslib": "^2.6.2",
-    "typescript": "^5.3.3",
+    "typescript": "^6.0.2",
     "vitest": "^4.0.13"
   },
   "scripts": {