@livx.cc/appwrap 0.29.0 → 0.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Wrap any PWA into a native app with native capabilities (appwrap runtime + @livx.cc/native-kit).",
   "license": "MIT",
   "author": "Elya Livshitz",

package/runtime/app/shell/capabilities.manifest.ts

@@ -141,6 +141,10 @@ export const MODULES: ModuleManifest[] = [
   {
     name: 'billing', group: 'billing',
     capabilities: { billing: { ios: true, android: false } },
+    // iOS-only Swift shim (AppwrapManageSubscriptions.swift) bridging StoreKit 2's Swift-async
+    // showManageSubscriptions(in:) to an @objc completion the ObjC bridge can call. Compiled into
+    // the app target only when `billing` is active (NS auto-compiles App_Resources/iOS/src/*.swift).
+    nativeSrc: 'billing',
   },
 
   // ── reviews — in-app store review prompt — opt-in, STRIPPABLE (own handler + group) ──

package/runtime/app/shell/handlers-billing.ts

@@ -1,6 +1,10 @@
 import { Utils, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
 
+// @objc Swift shim (AppwrapManageSubscriptions.swift, billing nativeSrc) — no NS types; bridges
+// StoreKit 2's Swift-async showManageSubscriptions(in:) to a completion the ObjC bridge can call.
+declare const AppwrapManageSubscriptions: { present(completion: (message: string | null) => void): void };
+
 /**
  * In-app purchases — iOS StoreKit 1 (SKPaymentQueue). StoreKit 2 (Product/Transaction)
  * is Swift-only and unreachable via the ObjC bridge, so we use the delegate-based
@@ -199,9 +203,23 @@ export function registerBillingHandlers(): void {
   });
 
   bridge.register('billing.manageSubscriptions', () => {
-    // StoreKit 2's AppStore.showManageSubscriptions is Swift-only; deep-link instead.
+    // DEFAULT: StoreKit 1 deep-link — correct for production, but leaves the app and doesn't show
+    // sandbox/TestFlight subs. The in-app sheet is the opt-in `billing.manageSubscriptionsSheet` below.
     Utils.openUrl('itms-apps://apps.apple.com/account/subscriptions');
   });
+
+  // OPT-IN (iOS 15+): StoreKit 2's in-app management sheet via the AppwrapManageSubscriptions Swift
+  // shim — shows the user's subs (incl. sandbox/TestFlight) and lets them cancel without leaving the
+  // app. Reached only when the app calls kit.billing.showManageSubscriptionsSheet(), so the default
+  // deep-link path above is untouched. Rejects on iOS <15, no scene, or a StoreKit error.
+  bridge.register('billing.manageSubscriptionsSheet', () => {
+    return new Promise<void>((resolve, reject) => {
+      AppwrapManageSubscriptions.present((message: string | null) => {
+        if (message) reject(err('NATIVE_ERROR', message));
+        else resolve();
+      });
+    });
+  });
 }
 
 function restoreTransactions(): Promise<any[]> {

package/runtime/modules-native/billing/App_Resources/iOS/src/AppwrapManageSubscriptions.swift

@@ -0,0 +1,39 @@
+import Foundation
+import StoreKit
+import UIKit
+
+// StoreKit 2's `AppStore.showManageSubscriptions(in:)` is Swift-only + async, so it can't be reached
+// from the ObjC bridge NativeScript uses. This @objc wrapper bridges the async call to a completion
+// callback (NativeScript can't await Swift async) and runs it on the main actor against the active
+// foreground UIWindowScene. Shipped via the billing module's nativeSrc → compiled into the app target
+// only when `billing` is active. iOS 15+ (StoreKit 2); the JS layer guards the deep-link fallback.
+@objc(AppwrapManageSubscriptions)
+public final class AppwrapManageSubscriptions: NSObject {
+  // completion(nil) on success; completion(message) on failure. Always invoked on the main thread
+  // so the NativeScript JS continuation (and WebView response delivery) resumes on the UI thread.
+  @objc public static func present(_ completion: @escaping (String?) -> Void) {
+    guard #available(iOS 15.0, *) else {
+      completion("StoreKit 2 manage-subscriptions sheet requires iOS 15+")
+      return
+    }
+    Task { @MainActor in
+      guard let scene = AppwrapManageSubscriptions.activeWindowScene() else {
+        completion("No active UIWindowScene to present the subscriptions sheet")
+        return
+      }
+      do {
+        try await AppStore.showManageSubscriptions(in: scene)
+        completion(nil)
+      } catch {
+        completion(error.localizedDescription)
+      }
+    }
+  }
+
+  // The foreground-active window scene (the one allowed to present UI). Falls back to any connected
+  // window scene so a not-yet-foregroundActive launch still finds a presenter.
+  @MainActor private static func activeWindowScene() -> UIWindowScene? {
+    let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+    return scenes.first { $0.activationState == .foregroundActive } ?? scenes.first
+  }
+}