@mpgd/platform 0.18.0 → 0.20.0

package/dist/capability-conformance.js

@@ -1,3 +1,4 @@
+import { deriveLegacyCommerceCapabilities } from './commerce-capabilities.js';
 export const platformCapabilityKeys = Object.freeze([
     'nativeIap',
     'nativeAds',
@@ -22,6 +23,7 @@ const allowedPlatformCapabilityKeys = Object.freeze([
 const allowedPlatformCapabilityKeySet = new Set([
     ...allowedPlatformCapabilityKeys,
     'providerAvailability',
+    'commerce',
 ]);
 const optionalPlatformCapabilityKeySet = new Set(optionalPlatformCapabilityKeys);
 const providerFeatureSet = new Set([
@@ -41,6 +43,19 @@ const providerAvailabilitySet = new Set([
     'temporarily-unavailable',
     'available',
 ]);
+// The optional commerce v2 block follows the same rules as the boolean
+// snapshot: exact keys, typed values, and a fresh object on every read.
+const commerceCapabilityBlockKeys = Object.freeze({
+    purchase: ['consumable', 'durable', 'subscription', 'quantity'],
+    catalog: ['products', 'offers', 'localizedPrice'],
+    lifecycle: ['availablePurchases', 'pending', 'restore', 'events', 'finish'],
+    authority: ['evidence', 'accountBinding'],
+});
+const commerceCapabilityEnums = Object.freeze({
+    'lifecycle.finish': ['client', 'server', 'host', 'none'],
+    'authority.evidence': ['client-token', 'host-callback', 'adapter-settled', 'server-push'],
+    'authority.accountBinding': ['required', 'optional', 'host'],
+});
 /**
  * Runs provider-neutral capability checks against real adapter gateways or
  * target-configured wrappers. Every read must return a complete boolean
@@ -116,6 +131,55 @@ function assertCapabilitySnapshot(actual, expected) {
     }
     assertProviderAvailabilityShape(actual.providerAvailability);
     assertEqual(normalizedAvailability(actual.providerAvailability), normalizedAvailability(expected.providerAvailability), 'provider availability must match the expected provider state');
+    assertCommerceCapabilityBlock(actual, expected.commerce);
+}
+function assertCommerceCapabilityBlock(snapshot, expected) {
+    const actual = snapshot.commerce;
+    if (actual === undefined) {
+        assert(expected === undefined, 'commerce capabilities must be present when the fixture expects them');
+        return;
+    }
+    assert(expected !== undefined, 'commerce capabilities must be absent when the fixture omits them');
+    assert(typeof actual === 'object' && actual !== null && !Array.isArray(actual), 'commerce capabilities must be a non-array record');
+    const block = actual;
+    const blockKeys = Object.keys(block).sort();
+    assertEqual(JSON.stringify(blockKeys), JSON.stringify([...Object.keys(commerceCapabilityBlockKeys), 'availability'].sort()), 'commerce capabilities must contain exactly purchase, catalog, lifecycle, authority, and availability');
+    for (const [group, keys] of Object.entries(commerceCapabilityBlockKeys)) {
+        const nested = block[group];
+        assert(typeof nested === 'object' && nested !== null && !Array.isArray(nested), `commerce ${group} capabilities must be a non-array record`);
+        const record = nested;
+        assertEqual(JSON.stringify(Object.keys(record).sort()), JSON.stringify([...keys].sort()), `commerce ${group} capabilities must contain exactly ${keys.join(', ')}`);
+        for (const key of keys) {
+            const path = `${group}.${key}`;
+            const allowed = commerceCapabilityEnums[path];
+            if (allowed === undefined) {
+                assertEqual(typeof record[key], 'boolean', `commerce capability ${path} must be a boolean`);
+            }
+            else {
+                assert(allowed.includes(record[key]), `commerce capability ${path} must be one of ${allowed.join(', ')}`);
+            }
+        }
+    }
+    assert(providerAvailabilitySet.has(block.availability), 'commerce availability must be a known readiness state');
+    assertEqual(normalizedCommerce(block), normalizedCommerce(expected), 'commerce capabilities must match the expected provider state');
+    const legacy = deriveLegacyCommerceCapabilities(block);
+    assertEqual(snapshot.nativeIap, legacy.nativeIap, 'nativeIap must equal the value derived from the commerce capabilities');
+    assertEqual(snapshot.subscriptionIap ?? false, legacy.subscriptionIap, 'subscriptionIap must equal the value derived from the commerce capabilities');
+}
+function normalizedCommerce(value) {
+    if (value === undefined) {
+        return 'undefined';
+    }
+    return JSON.stringify([
+        ['purchase', sortedEntries(value.purchase)],
+        ['catalog', sortedEntries(value.catalog)],
+        ['lifecycle', sortedEntries(value.lifecycle)],
+        ['authority', sortedEntries(value.authority)],
+        ['availability', value.availability],
+    ]);
+}
+function sortedEntries(value) {
+    return Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
 }
 function assertProviderAvailabilityShape(value) {
     if (value === undefined) {
@@ -133,6 +197,17 @@ function cloneExpectedCapabilities(value) {
         ...(value.providerAvailability === undefined
             ? {}
             : { providerAvailability: { ...value.providerAvailability } }),
+        ...(value.commerce === undefined
+            ? {}
+            : {
+                commerce: {
+                    purchase: { ...value.commerce.purchase },
+                    catalog: { ...value.commerce.catalog },
+                    lifecycle: { ...value.commerce.lifecycle },
+                    authority: { ...value.commerce.authority },
+                    availability: value.commerce.availability,
+                },
+            }),
     };
 }
 function normalizedAvailability(value) {
@@ -156,12 +231,39 @@ function tryMutateSnapshot(snapshot) {
             // A frozen nested readiness record already satisfies isolation.
         }
     }
+    if (snapshot.commerce !== undefined) {
+        tryMutateCommerceSnapshot(snapshot.commerce);
+    }
+}
+// Every nested block is probed: a gateway may rebuild the outer object while
+// reusing one mutable nested record across reads.
+function tryMutateCommerceSnapshot(commerce) {
+    const probes = [
+        [commerce.purchase, 'consumable', !commerce.purchase.consumable],
+        [commerce.catalog, 'products', !commerce.catalog.products],
+        [commerce.lifecycle, 'events', !commerce.lifecycle.events],
+        [
+            commerce.authority,
+            'accountBinding',
+            commerce.authority.accountBinding === 'host' ? 'optional' : 'host',
+        ],
+        [commerce, 'availability', commerce.availability === 'available' ? 'unsupported' : 'available'],
+    ];
+    for (const [target, key, next] of probes) {
+        try {
+            Reflect.set(target, key, next);
+        }
+        catch {
+            // A frozen nested commerce block already satisfies isolation.
+        }
+    }
 }
 function hasCapabilityDifference(first, second) {
     return allowedPlatformCapabilityKeys
         .some((key) => (first[key] ?? false) !== (second[key] ?? false))
         || normalizedAvailability(first.providerAvailability)
-            !== normalizedAvailability(second.providerAvailability);
+            !== normalizedAvailability(second.providerAvailability)
+        || normalizedCommerce(first.commerce) !== normalizedCommerce(second.commerce);
 }
 function assert(condition, message) {
     if (!condition) {

package/dist/commerce-capabilities.d.ts

@@ -0,0 +1,9 @@
+import type { CommerceCapabilities } from './index.js';
+export interface LegacyCommerceCapabilities {
+  readonly nativeIap: boolean;
+  readonly subscriptionIap: boolean;
+}
+/** Transition rule for the boolean `PlatformCapabilities` flags. */
+export declare function deriveLegacyCommerceCapabilities(capabilities: CommerceCapabilities): LegacyCommerceCapabilities;
+/** A fresh all-false snapshot; callers must not share or mutate a returned object. */
+export declare function createUnsupportedCommerceCapabilities(): CommerceCapabilities;

package/dist/commerce-capabilities.js

@@ -0,0 +1,24 @@
+/** Transition rule for the boolean `PlatformCapabilities` flags. */
+export function deriveLegacyCommerceCapabilities(capabilities) {
+    return {
+        nativeIap: capabilities.availability === 'available'
+            && (capabilities.purchase.consumable || capabilities.purchase.durable),
+        subscriptionIap: capabilities.purchase.subscription,
+    };
+}
+/** A fresh all-false snapshot; callers must not share or mutate a returned object. */
+export function createUnsupportedCommerceCapabilities() {
+    return {
+        purchase: { consumable: false, durable: false, subscription: false, quantity: false },
+        catalog: { products: false, offers: false, localizedPrice: false },
+        lifecycle: {
+            availablePurchases: false,
+            pending: false,
+            restore: false,
+            events: false,
+            finish: 'none',
+        },
+        authority: { evidence: 'client-token', accountBinding: 'optional' },
+        availability: 'unsupported',
+    };
+}