@mpgd/adapter-capacitor 0.4.12 → 0.6.0

package/dist/app-events.js

@@ -0,0 +1,332 @@
+import { App } from '@capacitor/app';
+const maxWarmUrlsBeforeInitial = 32;
+// Covers a near-simultaneous duplicate from getLaunchUrl and appUrlOpen, not a later tap.
+const coldUrlDedupeWindowMs = 2_000;
+function defaultVisibility() {
+    return typeof document === 'undefined' ? null : document;
+}
+/**
+ * Owns only handles it registers. Disposing during an awaited addListener
+ * removes the eventual handle without touching another gateway's listeners.
+ */
+export function createCapacitorAppEvents(input) {
+    const app = input.app ?? App;
+    const visibility = input.visibility === undefined ? defaultVisibility() : input.visibility;
+    const pauseCallbacks = new Set();
+    const resumeCallbacks = new Set();
+    const gameUrlCallbacks = new Set();
+    const oauthCallbacks = new Set();
+    const backHandlers = [];
+    const handles = [];
+    const warmUrlsBeforeInitial = new Set();
+    let disposed = false;
+    let initialResolved = false;
+    let appActive = true;
+    let visibilityActive = visibility?.hidden !== true;
+    let currentActive = true;
+    let transitionVersion = 0;
+    let stateEvents = 0;
+    let externalActivities = 0;
+    let backInProgress = false;
+    let startFailureReported = false;
+    let recentColdUrl;
+    let recentColdUntil = 0;
+    let startPromise;
+    let backPromise;
+    let initialPromise;
+    const reportError = (error) => {
+        try {
+            if (input.onError !== undefined) {
+                input.onError(error);
+            }
+            else {
+                console.error('Capacitor app event failed.', error);
+            }
+        }
+        catch {
+            // Reporting must not replace the original listener or registration error.
+        }
+    };
+    function emit(callbacks, version) {
+        for (const callback of [...callbacks]) {
+            // A callback can open or close external UI and reenter reconcile().
+            // Never continue an older resume/pause emission after that transition.
+            if (disposed || version !== transitionVersion) {
+                return;
+            }
+            try {
+                callback();
+            }
+            catch (error) {
+                reportError(error);
+            }
+        }
+    }
+    function reconcile() {
+        if (disposed) {
+            return;
+        }
+        const active = appActive && visibilityActive && externalActivities === 0;
+        if (active === currentActive) {
+            return;
+        }
+        currentActive = active;
+        transitionVersion += 1;
+        emit(active ? resumeCallbacks : pauseCallbacks, transitionVersion);
+    }
+    function classify(url) {
+        try {
+            const kind = input.classifyIncomingUrl?.(url);
+            return kind === 'game' || kind === 'oauth' ? kind : null;
+        }
+        catch (error) {
+            reportError(error);
+            return null;
+        }
+    }
+    function dispatchWarmUrl(url) {
+        if (disposed || url.trim() === '') {
+            return;
+        }
+        if (url === recentColdUrl && Date.now() <= recentColdUntil) {
+            // Capacitor can deliver the same launch through getLaunchUrl and
+            // appUrlOpen. Suppress only that immediate duplicate, not a later tap.
+            recentColdUrl = undefined;
+            return;
+        }
+        const kind = classify(url);
+        if (kind === null) {
+            return;
+        }
+        const callbacks = kind === 'game' ? gameUrlCallbacks : oauthCallbacks;
+        if (!initialResolved && callbacks.size > 0) {
+            // Keep enough recent entries to suppress a cold/warm duplicate without
+            // retaining an unbounded history when the host never requests cold URLs.
+            if (warmUrlsBeforeInitial.size >= maxWarmUrlsBeforeInitial) {
+                const oldest = warmUrlsBeforeInitial.values().next().value;
+                if (oldest !== undefined) {
+                    warmUrlsBeforeInitial.delete(oldest);
+                }
+            }
+            warmUrlsBeforeInitial.add(url);
+        }
+        const event = { url, source: 'warm' };
+        for (const callback of [...callbacks]) {
+            try {
+                callback(event);
+            }
+            catch (error) {
+                reportError(error);
+            }
+        }
+    }
+    async function own(registration) {
+        const handle = await registration;
+        if (disposed) {
+            await handle.remove();
+        }
+        else {
+            handles.push(handle);
+        }
+    }
+    function onVisibilityChange() {
+        visibilityActive = visibility?.hidden !== true;
+        reconcile();
+    }
+    function start() {
+        if (disposed) {
+            return Promise.reject(new Error('Capacitor app events are disposed.'));
+        }
+        if (startPromise !== undefined) {
+            return startPromise;
+        }
+        visibility?.addEventListener('visibilitychange', onVisibilityChange);
+        onVisibilityChange();
+        const beforeRead = stateEvents;
+        startPromise = Promise.all([
+            own(app.addListener('appStateChange', ({ isActive }) => {
+                stateEvents += 1;
+                appActive = isActive;
+                reconcile();
+            })),
+            own(app.addListener('appUrlOpen', ({ url }) => dispatchWarmUrl(url))),
+            app.getState().then(({ isActive }) => {
+                if (!disposed && stateEvents === beforeRead) {
+                    appActive = isActive;
+                    reconcile();
+                }
+            }),
+        ]).then(() => undefined);
+        return startPromise;
+    }
+    function startForSubscription() {
+        void start().catch((error) => {
+            if (startFailureReported) {
+                return;
+            }
+            startFailureReported = true;
+            reportError(error);
+        });
+    }
+    async function dispatchBack(event) {
+        for (const handler of [...backHandlers].reverse()) {
+            try {
+                if (await handler(event)) {
+                    return;
+                }
+                if (disposed) {
+                    return;
+                }
+            }
+            catch (error) {
+                reportError(error);
+            }
+        }
+        if (disposed) {
+            return;
+        }
+        if (event.canGoBack) {
+            if (input.historyBack !== undefined) {
+                input.historyBack();
+            }
+            else if (typeof history !== 'undefined') {
+                history.back();
+            }
+        }
+        else {
+            await app.exitApp();
+        }
+    }
+    function startBackListener() {
+        if (input.target !== 'android' || backPromise !== undefined || disposed) {
+            return;
+        }
+        backPromise = own(app.addListener('backButton', (event) => {
+            if (backInProgress || disposed) {
+                return;
+            }
+            backInProgress = true;
+            void dispatchBack(event).catch(reportError).finally(() => {
+                backInProgress = false;
+            });
+        }));
+        void backPromise.catch(reportError);
+    }
+    function subscribe(callbacks, callback) {
+        if (disposed) {
+            return () => { };
+        }
+        callbacks.add(callback);
+        startForSubscription();
+        return () => {
+            callbacks.delete(callback);
+        };
+    }
+    function getInitial() {
+        if (initialPromise !== undefined) {
+            return initialPromise;
+        }
+        startForSubscription();
+        initialPromise = app.getLaunchUrl().then((launch) => {
+            initialResolved = true;
+            const url = launch?.url;
+            const seenWarm = url === undefined ? false : warmUrlsBeforeInitial.has(url);
+            warmUrlsBeforeInitial.clear();
+            if (disposed || url === undefined || url.trim() === '' || seenWarm) {
+                return null;
+            }
+            const kind = classify(url);
+            if (kind === null) {
+                return null;
+            }
+            recentColdUrl = url;
+            recentColdUntil = Date.now() + coldUrlDedupeWindowMs;
+            return { kind, event: { url, source: 'cold' } };
+        }, (error) => {
+            initialResolved = true;
+            warmUrlsBeforeInitial.clear();
+            throw error;
+        });
+        return initialPromise;
+    }
+    async function dispose() {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        visibility?.removeEventListener('visibilitychange', onVisibilityChange);
+        pauseCallbacks.clear();
+        resumeCallbacks.clear();
+        gameUrlCallbacks.clear();
+        oauthCallbacks.clear();
+        backHandlers.length = 0;
+        warmUrlsBeforeInitial.clear();
+        recentColdUrl = undefined;
+        // Pending registrations remove themselves in own() if they later resolve.
+        // Teardown must not hang on an SDK registration that never does.
+        await Promise.allSettled(handles.splice(0).map((handle) => handle.remove()));
+    }
+    return {
+        onPause(callback) {
+            // start() may synchronously emit the first pause while subscribing.
+            const alreadyPaused = !disposed && currentActive === false;
+            const unsubscribe = subscribe(pauseCallbacks, callback);
+            if (alreadyPaused) {
+                try {
+                    callback();
+                }
+                catch (error) {
+                    reportError(error);
+                }
+            }
+            return unsubscribe;
+        },
+        onResume(callback) {
+            return subscribe(resumeCallbacks, callback);
+        },
+        onBackButton(handler) {
+            if (disposed || input.target !== 'android') {
+                return () => { };
+            }
+            backHandlers.push(handler);
+            startBackListener();
+            return () => {
+                const index = backHandlers.indexOf(handler);
+                if (index >= 0) {
+                    backHandlers.splice(index, 1);
+                }
+            };
+        },
+        onGameUrlOpen(callback) {
+            return subscribe(gameUrlCallbacks, callback);
+        },
+        onOAuthRedirect(callback) {
+            return subscribe(oauthCallbacks, callback);
+        },
+        async getInitialGameUrl() {
+            const initial = await getInitial();
+            return initial?.kind === 'game' ? initial.event : null;
+        },
+        async getInitialOAuthRedirect() {
+            const initial = await getInitial();
+            return initial?.kind === 'oauth' ? initial.event : null;
+        },
+        beginExternalActivity() {
+            if (disposed) {
+                return () => { };
+            }
+            externalActivities += 1;
+            reconcile();
+            let released = false;
+            return () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                externalActivities -= 1;
+                reconcile();
+            };
+        },
+        dispose,
+    };
+}

package/dist/app-store-server.d.ts

@@ -0,0 +1,12 @@
+import { type AppStoreEnvironment, type AppStoreSignedTransactionVerifier } from '@mpgd/game-services/app-store-verifier';
+export interface CreateAppleSignedTransactionVerifierOptions {
+  /** DER-encoded Apple root certificates, supplied by the server operator. */
+  readonly rootCertificates: readonly Uint8Array[];
+  readonly environment: AppStoreEnvironment;
+  readonly bundleId: string;
+  /** Required by Apple's verifier in production. */
+  readonly appAppleId?: number;
+  readonly enableOnlineChecks?: boolean;
+}
+/** Verify the App Store JWS before exposing any decoded purchase fields. */
+export declare function createAppleSignedTransactionVerifier(options: CreateAppleSignedTransactionVerifierOptions): AppStoreSignedTransactionVerifier;

package/dist/app-store-server.js

@@ -0,0 +1,119 @@
+import { Environment, SignedDataVerifier, VerificationException, VerificationStatus, } from '@apple/app-store-server-library';
+import { AppStoreDependencyUnavailableError, } from '@mpgd/game-services/app-store-verifier';
+/** Verify the App Store JWS before exposing any decoded purchase fields. */
+export function createAppleSignedTransactionVerifier(options) {
+    if (!Array.isArray(options.rootCertificates)
+        || options.rootCertificates.length === 0
+        || options.rootCertificates.some((certificate) => !(certificate instanceof Uint8Array)
+            || certificate.length === 0)) {
+        throw new TypeError('Apple root certificates are required.');
+    }
+    if (options.environment !== 'Production' && options.environment !== 'Sandbox') {
+        throw new TypeError('App Store environment must be Production or Sandbox.');
+    }
+    if (options.bundleId.trim() === '') {
+        throw new TypeError('App Store bundle ID is required.');
+    }
+    if (options.environment === 'Production'
+        && (!Number.isSafeInteger(options.appAppleId) || (options.appAppleId ?? 0) <= 0)) {
+        throw new TypeError('Production App Store verification requires appAppleId.');
+    }
+    if (options.environment === 'Production' && options.enableOnlineChecks === false) {
+        throw new TypeError('Production App Store verification requires online certificate checks.');
+    }
+    const verifier = new SignedDataVerifier(options.rootCertificates.map((certificate) => Buffer.from(certificate)), options.enableOnlineChecks ?? true, options.environment === 'Production' ? Environment.PRODUCTION : Environment.SANDBOX, options.bundleId, options.appAppleId);
+    return {
+        async verifyAndDecode(input) {
+            if (input.environment !== options.environment || input.bundleId !== options.bundleId) {
+                return { status: 'rejected', reason: 'APP_STORE_VERIFIER_SCOPE_MISMATCH' };
+            }
+            if (typeof input.signedTransaction !== 'string'
+                || input.signedTransaction.length === 0
+                || input.signedTransaction.length > 512 * 1024) {
+                return { status: 'rejected', reason: 'APP_STORE_SIGNED_TRANSACTION_INVALID' };
+            }
+            input.signal.throwIfAborted();
+            let decoded;
+            try {
+                decoded = await waitForVerification(verifier.verifyAndDecodeTransaction(input.signedTransaction), input.signal);
+                input.signal.throwIfAborted();
+            }
+            catch (error) {
+                if (input.signal.aborted) {
+                    throw input.signal.reason;
+                }
+                if (error instanceof VerificationException) {
+                    if (error.status === VerificationStatus.RETRYABLE_VERIFICATION_FAILURE) {
+                        throw new AppStoreDependencyUnavailableError('Apple signature checks are temporarily unavailable.', error);
+                    }
+                    return { status: 'rejected', reason: 'APP_STORE_SIGNATURE_INVALID' };
+                }
+                // Only Apple's explicit retryable status is a transient dependency
+                // failure. Unexpected adapter/library faults must reach the caller.
+                throw error;
+            }
+            const payload = decodeOneTimeTransaction(decoded);
+            return payload === undefined
+                ? { status: 'rejected', reason: 'APP_STORE_SIGNED_TRANSACTION_INVALID' }
+                : { status: 'verified', payload };
+        },
+    };
+}
+async function waitForVerification(operation, signal) {
+    signal.throwIfAborted();
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason ?? new Error('Verification was aborted.'));
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+        }
+    });
+    try {
+        return await Promise.race([operation, aborted]);
+    }
+    finally {
+        if (onAbort !== undefined) {
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
+}
+function decodeOneTimeTransaction(decoded) {
+    if (!nonEmpty(decoded.transactionId)
+        || !nonEmpty(decoded.originalTransactionId)
+        || !nonEmpty(decoded.bundleId)
+        || !nonEmpty(decoded.productId)
+        || !validTimestamp(decoded.purchaseDate)
+        || !validTimestamp(decoded.signedDate)
+        || (decoded.environment !== 'Production' && decoded.environment !== 'Sandbox')
+        || (decoded.type !== 'Consumable' && decoded.type !== 'Non-Consumable')
+        || (decoded.quantity !== undefined
+            && (!Number.isSafeInteger(decoded.quantity) || decoded.quantity <= 0))
+        || (decoded.appAccountToken !== undefined && !nonEmpty(decoded.appAccountToken))
+        || (decoded.revocationDate !== undefined && !validTimestamp(decoded.revocationDate))
+        || (decoded.expiresDate !== undefined && !validTimestamp(decoded.expiresDate))
+        || (decoded.isUpgraded !== undefined && typeof decoded.isUpgraded !== 'boolean')) {
+        return undefined;
+    }
+    return {
+        transactionId: decoded.transactionId,
+        originalTransactionId: decoded.originalTransactionId,
+        bundleId: decoded.bundleId,
+        productId: decoded.productId,
+        purchaseDate: decoded.purchaseDate,
+        signedDate: decoded.signedDate,
+        environment: decoded.environment,
+        type: decoded.type,
+        ...(decoded.quantity === undefined ? {} : { quantity: decoded.quantity }),
+        ...(decoded.appAccountToken === undefined ? {} : { appAccountToken: decoded.appAccountToken }),
+        ...(decoded.revocationDate === undefined ? {} : { revocationDate: decoded.revocationDate }),
+        ...(decoded.expiresDate === undefined ? {} : { expiresDate: decoded.expiresDate }),
+        ...(decoded.isUpgraded === undefined ? {} : { isUpgraded: decoded.isUpgraded }),
+    };
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function validTimestamp(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}

package/dist/index.d.ts

@@ -1,11 +1,20 @@
-import { type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
-import { type PlatformGateway, type PlatformTarget } from '@mpgd/platform';
-export interface NativeBridge {
-  request(input: BridgeRequest): Promise<BridgeResponse>;
-}
+import { type PlatformGateway, type PlatformTarget, type ViewportAdapter } from '@mpgd/platform';
+import { type CapacitorAppEventsApi, type CapacitorIncomingUrlKind, type CapacitorVisibilitySource } from './app-events.js';
+import { type CapacitorServiceProvider, type NativeBridge } from './providers.js';
+export { createCapacitorProviderRegistry, type CapacitorServiceProvider, type NativeBridge, } from './providers.js';
+export { createCapacitorAppEvents, type CapacitorAppEventsApi, type CapacitorIncomingUrlKind, type CapacitorVisibilitySource, } from './app-events.js';
+export { CapacitorNativeHttpError, createCapacitorNativeJsonTransport, type CapacitorJsonRequest, type CapacitorJsonResponse, type CapacitorNativeHttpErrorCode, type CapacitorNativeJsonTransport, type CreateCapacitorNativeJsonTransportInput, } from './native-http.js';
+export { createCapacitorViewport, type CapacitorViewportBaseState, type CapacitorOccupiedSurfaceInput, type CapacitorViewportController, type CapacitorViewportHost, } from './viewport.js';
 export declare function createCapacitorPlatformGateway(input: {
   readonly target: Extract<PlatformTarget, 'android' | 'ios'>;
   readonly appVersion: string;
   readonly buildId: string;
   readonly bridge?: NativeBridge;
+  readonly providers?: readonly CapacitorServiceProvider[];
+  readonly app?: CapacitorAppEventsApi;
+  readonly visibility?: CapacitorVisibilitySource | null;
+  readonly classifyIncomingUrl?: (url: string) => CapacitorIncomingUrlKind | null;
+  readonly historyBack?: () => void;
+  readonly onAppEventError?: (error: unknown) => void;
+  readonly viewport?: ViewportAdapter;
 }): PlatformGateway;