@dicty/payment

Dicty Payment Plugin for Capacitor apps

Overview

@dicty/payment bridges Capacitor projects to native Apple in-app purchases and Google Pay flows. It ships with TypeScript definitions, a React context provider, and native shims for iOS, Android, and the web fallback.

Installation

npm install @dicty/payment
npx cap sync

After syncing, open Android Studio/Xcode to let Gradle/CocoaPods refresh native dependencies.

Usage

import { Payment } from '@dicty/payment';

const available = await Payment.isAppleInAppPurchaseAvailable();
if (available) {
  const { products } = await Payment.getAppleInAppPurchaseProducts({ id: ['premium_monthly'] });
  await Payment.buyAppleInAppPurchase({ id: products[0].id });
}

For React apps, wrap your tree with the provider:

import { PaymentPluginProvider } from '@dicty/payment/react';

<PaymentPluginProvider>{children}</PaymentPluginProvider>;

Development

• npm run build cleans, regenerates docs, compiles TypeScript, and bundles output via Rollup.
• npm run verify runs iOS, Android, and web checks; execute before publishing changes.
• npm run fmt formats TypeScript, Java, and Swift sources; npm run lint performs the read-only equivalent.

API

• isAppleInAppPurchaseAvailable()
• getAppleInAppPurchaseProducts(...)
• buyAppleInAppPurchase(...)
• restoreAppleInAppPurchase()
• getAppleInAppPurchaseReceipt()
• isGooglePayAvailable()
• handleGooglePay(...)
• Type Aliases

isAppleInAppPurchaseAvailable()

isAppleInAppPurchaseAvailable() => Promise<void>

Check if Apple In-App Purchases are available on this device

getAppleInAppPurchaseProducts(...)

getAppleInAppPurchaseProducts(opts: GetAppleInAppPurchaseProductsOptions) => Promise<GetAppleInAppPurchaseProductsResult>

Get Apple In-App Purchase products by their identifiers

| Param | Type | | ---------- | ----------------------------------------------------------------------------------------------------- | | opts | GetAppleInAppPurchaseProductsOptions |

Returns: Promise<GetAppleInAppPurchaseProductsResult>

buyAppleInAppPurchase(...)

buyAppleInAppPurchase(opts: BuyAppleInAppPurchaseOptions) => Promise<BuyAppleInAppPurchaseResult>

Purchase an Apple In-App Purchase product

| Param | Type | | ---------- | ------------------------------------------------------------------------------------- | | opts | BuyAppleInAppPurchaseOptions |

Returns: Promise<BuyAppleInAppPurchaseResult>

restoreAppleInAppPurchase()

restoreAppleInAppPurchase() => Promise<RestoreAppleInAppPurchaseResult>

Restore Apple In-App Purchase transactions

Returns: Promise<BuyAppleInAppPurchaseResult>

getAppleInAppPurchaseReceipt()

getAppleInAppPurchaseReceipt() => Promise<GetAppleInAppPurchaseReceiptResult>

Get Apple In-App Purchase receipt data

Returns: Promise<GetAppleInAppPurchaseReceiptResult>

isGooglePayAvailable()

isGooglePayAvailable() => Promise<void>

Check if Google Pay is available on this device

handleGooglePay(...)

handleGooglePay(opts: GooglePayOptions) => Promise<GooglePayResult>

Handle Google Pay payment flow

| Param | Type | | ---------- | ------------------------------------------------------------- | | opts | GooglePayOptions |

Returns: Promise<GooglePayResult>

Type Aliases

GetAppleInAppPurchaseProductsResult

{ products: AppleInAppPurchaseProduct[]; }

AppleInAppPurchaseProduct

{ id: string; title: string; description: string; price: number; localizedPrice: string; subscriptionPeriod?: { value: number; unit: AppleSubscriptionPeriodUnit; }; }

AppleSubscriptionPeriodUnit

(typeof AppleSubscriptionPeriodUnit)[keyof typeof AppleSubscriptionPeriodUnit]

GetAppleInAppPurchaseProductsOptions

{ id: string[]; }

BuyAppleInAppPurchaseResult

CompletedAppleInAppPurchaseResult | RestoredAppleInAppPurchaseResult | FailedAppleInAppPurchaseResult | CancelledAppleInAppPurchaseResult

CompletedAppleInAppPurchaseResult

{ status: typeof AppleInAppPurchaseStatus.Completed; productIdentifier: string; transactionIdentifier: string; }

RestoredAppleInAppPurchaseResult

{ status: typeof AppleInAppPurchaseStatus.Restored; } & Omit<CompletedAppleInAppPurchaseResult, 'status'>

Omit

Construct a type with the properties of T except for those in type K.

Pick<T, Exclude<keyof T, K>>

Pick

From T, pick a set of properties whose keys are in the union K

{ [P in K]: T[P]; }

Exclude

Exclude from T those types that are assignable to U

T extends U ? never : T

FailedAppleInAppPurchaseResult

{ status: typeof AppleInAppPurchaseStatus.Failed; productIdentifier?: string; transactionIdentifier?: string; }

CancelledAppleInAppPurchaseResult

{ status: typeof AppleInAppPurchaseStatus.Cancelled; } & Omit<FailedAppleInAppPurchaseResult, 'status'>

BuyAppleInAppPurchaseOptions

{ id: string; }

RestoreAppleInAppPurchaseResult

BuyAppleInAppPurchaseResult

GetAppleInAppPurchaseReceiptResult

{ receiptData: string; }

GooglePayResult

{ result: GooglePayResults; }

GooglePayResults

(typeof GooglePayResults)[keyof typeof GooglePayResults]

GooglePayOptions

{ clientSecret: string; }