// Private VCS (recommended):
"repositories": {
    "nativephp-stripe": {
        "type": "vcs",
        "url": "[email protected]:CodyPChristian/nativephp-stripe.git"
    }
}
 
// …or a local path package (monorepo / during development):
"repositories": {
    "nativephp-stripe": { "type": "path", "url": "packages/nativephp-stripe" }
}

composer require codypchristian/nativephp-stripe:^0.2

php artisan native:plugin:register codypchristian/nativephp-stripe

public function plugins(): array
{
    return [
        \CodyPChristian\NativeStripe\StripeServiceProvider::class,
    ];
}

php artisan native:install --force

php artisan native:plugin:list

php artisan vendor:publish --tag=nativephp-stripe-config

STRIPE_PUBLISHABLE_KEY=pk_live_xxx

// config/services.php
'stripe' => [
    'publishable_key' => env('STRIPE_PUBLISHABLE_KEY'),
],

Stripe::paymentSheet($clientSecret, config('services.stripe.publishable_key'), $intentType);

# config/nativephp-stripe.php reads these
STRIPE_MERCHANT_DISPLAY_NAME="Acme Store"
 
# Apple Pay (iOS)
STRIPE_APPLE_PAY_MERCHANT_ID=merchant.com.acme.app
STRIPE_APPLE_PAY_COUNTRY=US
 
# Google Pay (Android)
STRIPE_GOOGLE_PAY_ENABLED=true
STRIPE_GOOGLE_PAY_ENV=production          # or "test"
STRIPE_GOOGLE_PAY_COUNTRY=US
STRIPE_GOOGLE_PAY_CURRENCY=usd            # optional for PaymentIntent, REQUIRED for SetupIntent

Stripe::paymentSheet($secret, $key, $intentType)
    ->applePay('merchant.com.acme.app', 'US')      // overrides / sets Apple Pay
    ->googlePay('US', 'production', 'usd')          // overrides / sets Google Pay
    ->customer($stripeCustomerId, $ephemeralKey)    // shows this customer's saved cards
    ->merchantDisplayName('Acme')                   // overrides the sheet title
    ->allowDelayedPaymentMethods(false)
    ->completed(fn () => /* ... */)
    ->start();

// server returns: { client_secret, intent_type, customer_id, ephemeral_key }
Stripe::paymentSheet($secret, $key, $intentType)
    ->customer($customerId, $ephemeralKey)
    ->completed(fn () => /* ... */)
    ->start();

Stripe::paymentSheet($secret, $publishableKey, $intentType)
    ->stripeAccount('acct_...')   // platform pk, scoped to the connected account
    ->completed(fn () => /* ... */)
    ->start();

STRIPE_CONNECT_ACCOUNT=acct_...

use CodyPChristian\NativeStripe\Facades\Stripe;

Stripe::paymentSheet(
    string  $clientSecret,          // "pi_..._secret_..." or "seti_..._secret_..."
    ?string $publishableKey = null, // "pk_..." — REQUIRED on device
    string  $intentType = 'payment' // 'payment' (charge) | 'setup' (store card)
): \CodyPChristian\NativeStripe\PendingPaymentSheet

Stripe::paymentSheet(
    clientSecret:   $clientSecret,
    publishableKey: config('services.stripe.publishable_key'),
    intentType:     $intentType, // 'payment' | 'setup'
)
    ->completed(fn ()    => /* card charged (payment) / stored (setup) */)
    ->canceled(fn ()    => /* user dismissed the sheet, nothing charged */)
    ->failed(fn ($event) => /* declined / SDK / config error: $event->error */)
    ->start();

Stripe::paymentSheet($secret, $key, $intentType)
    ->completed(fn () => /* ... */)
    ->failed(fn ($event) => report($event->error))
    ->start();

use Native\Mobile\Attributes\OnNative;
use CodyPChristian\NativeStripe\Events\PaymentSheet\Completed;
 
#[OnNative(Completed::class)]
public function onPaid(?string $id = null): void
{
    // $id correlates to the presentation's builder id.
}

<?php
 
namespace App\NativeComponents\Checkout;
 
use App\Services\Api\CheckoutApi;   // your own API client
use Native\Mobile\Edge\NativeComponent;
use CodyPChristian\NativeStripe\Facades\Stripe;
 
class Checkout extends NativeComponent
{
    public string $error = '';
    public bool $paying = false;
 
    public function pay(): void
    {
        $this->error = '';
        $this->paying = true;
 
        // 1. Ask the server to place the order. It returns either a finalized
        //    order (offline / $0 / card already on file) or a Stripe secret.
        $res = app(CheckoutApi::class)->place();
 
        $payment      = is_array($res['payment'] ?? null) ? $res['payment'] : null;
        $clientSecret = $payment['client_secret'] ?? null;
        // Branch on the SERVER's field, never on the pi_/seti_ prefix.
        $intentType   = $payment['intent_type'] ?? 'payment';
        $orderId      = $res['order']['id'] ?? null;
 
        // No payment block => the server already finalized it.
        if ($clientSecret === null) {
            $this->navigate("/receipt/{$orderId}");
            return;
        }
 
        $failMsg = $intentType === 'setup'
            ? 'Card setup was not completed.'
            : 'Payment was not completed.';
 
        // 2. Present the native sheet. Wallets come from config/nativephp-stripe.php;
        //    saved cards need the server's ephemeral key, so pass it per call.
        $sheet = Stripe::paymentSheet(
            clientSecret:   $clientSecret,
            publishableKey: config('services.stripe.publishable_key'),
            intentType:     $intentType,
        );
 
        if (! empty($payment['customer_id']) && ! empty($payment['ephemeral_key'])) {
            $sheet->customer($payment['customer_id'], $payment['ephemeral_key']);
        }
 
        $sheet
            ->completed(function () use ($orderId) {
                // UI signal only — the webhook finalizes the order server-side.
                $this->navigate("/receipt/{$orderId}");
            })
            ->canceled(function () use ($failMsg) {
                $this->error  = $failMsg;
                $this->paying = false;
            })
            ->failed(function ($event) use ($failMsg) {
                $this->error  = $event->error ?? $failMsg;
                $this->paying = false;
            })
            ->start();
    }
}

class StripePayments
{
    private const FACADE = \CodyPChristian\NativeStripe\Facades\Stripe::class;
 
    public function isAvailable(): bool
    {
        // NOTE: class_exists is true on desktop too (it's a Composer class), so
        // this only tells you the package is installed — not that native code is
        // in the build. On desktop, present() below will no-op via start()==false.
        return class_exists(self::FACADE);
    }
 
    /** $onResult(bool $success, ?string $error) fires exactly once. */
    public function present(string $clientSecret, callable $onResult, string $intentType = 'payment'): bool
    {
        if (! $this->isAvailable()) {
            $onResult(false, 'Payments are unavailable on this device.');
            return false;
        }
 
        $fail = $intentType === 'setup' ? 'Card setup was not completed.' : 'Payment was not completed.';
 
        self::FACADE::paymentSheet(
            clientSecret:   $clientSecret,
            publishableKey: config('services.stripe.publishable_key'),
            intentType:     $intentType,
        )
            ->completed(fn ()    => $onResult(true, null))
            ->canceled(fn ()    => $onResult(false, $fail))
            ->failed(fn ($event) => $onResult(false, $event->error ?? $fail))
            ->start();
 
        return true;
    }
}

import { stripe } from '@/vendor/stripe'; // wherever you copied resources/js/stripe.js
 
// Register outcome listeners once.
const offCompleted = stripe.onCompleted((p) => console.log('paid', p.id));
const offCanceled = stripe.onCanceled(() => {});
const offFailed    = stripe.onFailed((p) => console.error(p.error));
 
// Present the sheet. Wallets / saved cards are optional and map to the same
// config the PHP builder uses.
await stripe.presentPaymentSheet({
    clientSecret,                 // 'pi_..._secret_...' or 'seti_..._secret_...'
    publishableKey,               // 'pk_...'
    intentType: 'payment',        // or 'setup'
    id: 'order-123',              // optional correlation id, echoed on events
    applePay: { merchantId: 'merchant.com.acme.app', merchantCountryCode: 'US' },
    googlePay: { countryCode: 'US', environment: 'production', currencyCode: 'usd' },
    customer: { id: 'cus_123', ephemeralKeySecret: 'ek_...' }, // saved cards
});