@oxyhq/core 4.0.1 → 5.1.0

package/dist/cjs/mixins/OxyServices.accounts.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OxyServicesAccountsMixin = OxyServicesAccountsMixin;
+const userIdentity_1 = require("../utils/userIdentity");
+const platform_1 = require("../utils/platform");
+const loggerUtils_1 = require("../utils/loggerUtils");
 const mixinHelpers_1 = require("./mixinHelpers");
 function OxyServicesAccountsMixin(Base) {
     return class extends Base {
@@ -43,6 +46,93 @@ function OxyServicesAccountsMixin(Base) {
                 throw this.handleError(error);
             }
         }
+        /**
+         * Switch the active session INTO a managed account.
+         *
+         * Calls `POST /accounts/:id/switch` with the signed-in operator's bearer.
+         * The server authorises the operator (must hold `account:act_as` over the
+         * target, directly or inherited — else 403; 404 if missing/archived; 403 if
+         * the target is a personal account), then mints a REAL session for the
+         * target account and returns it in the canonical login / `claimSessionByToken`
+         * shape (`{ sessionId, deviceId, expiresAt, accessToken, user, authuser }`).
+         *
+         * Unlike the removed `X-Acting-As` delegation header, the returned session
+         * IS the new identity: this plants `accessToken` as the active token —
+         * exactly like `claimSessionByToken` / `verifyChallenge` — so every
+         * subsequent request authenticates as the target account.
+         *
+         * Joining the device multi-account set (so the switch survives a reload and
+         * propagates cross-domain via `/auth/refresh-all`) requires a SECOND call, to
+         * `POST /auth/session`, made here after the token is planted. The switch route
+         * lives at `/accounts/*`, OUTSIDE the `oxy_rt_<authuser>` cookie's `Path=/auth`
+         * scope, so the server never sees the device's existing slots from it and
+         * would clobber slot 0 (destroying the operator's own session). `/auth/session`
+         * runs where those cookies ARE visible, so the server allocates a NEW slot that
+         * coexists with the operator's and returns its `authuser`. This step is
+         * web-only (native multi-account uses stored sessions, not cookies) and
+         * best-effort — a failure leaves the in-session switch intact; the switched
+         * account simply won't survive a reload until the cookie is next established.
+         *
+         * After planting, the SDK's identity-scoped GET cache is fully cleared so
+         * every cached read re-fetches as the new account. (The consuming
+         * `OxyContext` additionally invalidates its React Query cache and updates
+         * session state from the returned `user`; this clears the SDK's own HTTP
+         * cache at the source — `setTokens` deliberately preserves the warm cache for
+         * same-user silent refreshes, so the sweep here is explicit.)
+         *
+         * @param accountId - The target account's Mongo `_id`.
+         * @returns The minted session (planted) plus the device `authuser` slot.
+         */
+        async switchToAccount(accountId) {
+            try {
+                const res = await this.makeRequest('POST', `/accounts/${encodeURIComponent(accountId)}/switch`, undefined, { cache: false });
+                // Plant the freshly minted session as the ACTIVE session, mirroring
+                // `claimSessionByToken` / `verifyChallenge`: the response body carries
+                // the first access token. The device refresh cookie is established below.
+                if (res?.accessToken) {
+                    this.setTokens(res.accessToken);
+                }
+                // Register the switched session in the device's multi-account set by
+                // establishing its first-party refresh cookie. This MUST be a separate
+                // call to `POST /auth/session`: the switch route is at `/accounts/*`,
+                // outside the `oxy_rt_<authuser>` cookie's `Path=/auth` scope, so it can
+                // never read the device's existing slots and would overwrite slot 0
+                // (destroying the operator's own session). `/auth/session` runs where the
+                // cookies ARE visible, so the server allocates a NEW slot that coexists
+                // with the operator's and returns its `authuser`. Web-only; best-effort.
+                let authuser = res.authuser;
+                if ((0, platform_1.isWeb)()) {
+                    try {
+                        const established = await this.makeRequest('POST', '/auth/session', undefined, { cache: false });
+                        if (typeof established?.authuser === 'number') {
+                            authuser = established.authuser;
+                        }
+                        // /auth/session mints a fresh access token off the same session;
+                        // re-plant it so the active token matches the rotated cookie.
+                        if (established?.accessToken) {
+                            this.setTokens(established.accessToken);
+                        }
+                    }
+                    catch (error) {
+                        loggerUtils_1.logger.warn('[OxyServices] Failed to establish device refresh cookie after account switch; the switch is active in-session but may not survive a reload', { component: 'OxyServices', method: 'switchToAccount' }, error);
+                    }
+                }
+                // Identity changed → drop the entire GET response cache so no entry
+                // personalised for the previous identity is reused. Cache keys are
+                // identity-scoped, so a different identity could not READ the old
+                // entries anyway, but clearing guarantees a clean refetch as the new
+                // account and frees the prior identity's resident data.
+                this.clearCache();
+                return {
+                    ...res,
+                    ...(typeof authuser === 'number' ? { authuser } : {}),
+                    user: (0, userIdentity_1.normalizeUserIdentity)(res.user),
+                };
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
         /**
          * Create a new (non-personal) account. The caller becomes its `owner`.
          * @param data - Account configuration: kind, optional parent, and profile.

package/dist/cjs/mixins/OxyServices.assets.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OxyServicesAssetsMixin = OxyServicesAssetsMixin;
-const platform_1 = require("../utils/platform");
+const protocol_1 = require("@oxyhq/protocol");
+const loggerUtils_1 = require("../utils/loggerUtils");
+const errorUtils_1 = require("../utils/errorUtils");
+/**
+ * Maximum number of ids sent per `POST /assets/service/by-ids` request. Matches
+ * the server-side batch cap (the route rejects empty or > 100 id arrays with a
+ * 400); larger inputs are split into multiple chunked calls and merged. Mirrors
+ * `getUsersByIds`'s `USERS_BY_IDS_CHUNK_SIZE`.
+ */
+const SERVICE_ASSET_METADATA_CHUNK_SIZE = 100;
 function OxyServicesAssetsMixin(Base) {
     return class extends Base {
         constructor(...args) {
@@ -147,6 +156,63 @@ function OxyServicesAssetsMixin(Base) {
             }
             return urls;
         }
+        /**
+         * Resolve many Oxy asset ids to their content-addressed metadata in one
+         * round-trip per chunk via `POST /assets/service/by-ids` (body `{ ids }`).
+         *
+         * Returns each asset's `sha256`, `mime`, byte `size`, and `status` — built
+         * for server-to-server callers (e.g. Mention's MTN Protocol blob-ref
+         * resolution) that need the content hash for an asset id. Ids are
+         * deduplicated and validated (empty/blank ids dropped) before being split
+         * into chunks of {@link SERVICE_ASSET_METADATA_CHUNK_SIZE} (the server-side
+         * cap). The server omits unknown/deleted ids from each chunk's `data`, so
+         * the merged result may be shorter than the requested id list and the caller
+         * is expected to map by `id`.
+         *
+         * **Service-token auth (required).** `/assets/service/by-ids` is guarded by
+         * `serviceAuthMiddleware` + the `files:read` scope and is called via
+         * `makeServiceRequest`, which attaches `Authorization: Bearer <serviceToken>`
+         * (the same client that calls `POST /assets/service/cache`). The calling
+         * client MUST be service-configured (`configureServiceAuth(apiKey,
+         * apiSecret)`) before invoking this method; otherwise `getServiceToken()`
+         * throws because no credentials are available. A plain user-session request
+         * is rejected by the route's service-auth guard.
+         *
+         * Resilience: chunks are independent. A failed chunk is logged and skipped —
+         * the method returns every entry that resolved successfully rather than
+         * discarding the whole call on one chunk's failure. An empty/whitespace-only
+         * input resolves immediately with `[]` and performs no network call.
+         *
+         * Not cached at the SDK layer: it's a POST keyed on a multi-id body (low hit
+         * rate), mirroring the sibling service/POST methods which never cache.
+         */
+        async getServiceAssetMetadataByIds(ids) {
+            const uniqueIds = Array.from(new Set(ids.filter((id) => typeof id === 'string' && id.trim().length > 0)));
+            if (uniqueIds.length === 0) {
+                return [];
+            }
+            const chunks = [];
+            for (let i = 0; i < uniqueIds.length; i += SERVICE_ASSET_METADATA_CHUNK_SIZE) {
+                chunks.push(uniqueIds.slice(i, i + SERVICE_ASSET_METADATA_CHUNK_SIZE));
+            }
+            // Run chunks concurrently; a single chunk failure must not sink the rest.
+            const settled = await Promise.all(chunks.map(async (chunk) => {
+                try {
+                    const entries = await this.makeServiceRequest('POST', '/assets/service/by-ids', { ids: chunk });
+                    return Array.isArray(entries) ? entries : [];
+                }
+                catch (error) {
+                    loggerUtils_1.logger.warn('getServiceAssetMetadataByIds: chunk failed, continuing with remaining chunks', {
+                        method: 'getServiceAssetMetadataByIds',
+                        chunkSize: chunk.length,
+                        status: (0, errorUtils_1.extractErrorStatus)(error),
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    return [];
+                }
+            }));
+            return settled.flat();
+        }
         /**
          * Upload raw file data
          */
@@ -173,7 +239,7 @@ function OxyServicesAssetsMixin(Base) {
                 }
                 else if ('uri' in file && typeof file.uri === 'string') {
                     const descriptor = file;
-                    if ((0, platform_1.isReactNative)()) {
+                    if ((0, protocol_1.isReactNative)()) {
                         // React Native file descriptor — RN's FormData handles {uri, type, name} natively.
                         // It reads the file from disk during the multipart request — no in-JS Blob
                         // conversion (which would fail on Hermes for ArrayBuffer-backed Blobs).

package/dist/cjs/mixins/OxyServices.auth.js

@@ -5,7 +5,7 @@ exports.OxyServicesAuthMixin = OxyServicesAuthMixin;
 const OxyServices_errors_1 = require("../OxyServices.errors");
 const keyManager_1 = require("../crypto/keyManager");
 const signatureService_1 = require("../crypto/signatureService");
-const platformCrypto_1 = require("../utils/platformCrypto");
+const protocol_1 = require("@oxyhq/protocol");
 const loggerUtils_1 = require("../utils/loggerUtils");
 const userIdentity_1 = require("../utils/userIdentity");
 /**
@@ -61,7 +61,7 @@ function OxyServicesAuthMixin(Base) {
          * @internal
          */
         async _hashApiKey(apiKey) {
-            const nodeCrypto = await (0, platformCrypto_1.loadNodeCrypto)();
+            const nodeCrypto = await (0, protocol_1.loadNodeCrypto)();
             return nodeCrypto.createHash('sha256').update(apiKey).digest('hex');
         }
         /**
@@ -113,7 +113,7 @@ function OxyServicesAuthMixin(Base) {
             // Verify the secret on every cache hit, regardless of token freshness.
             // Constant-time compare prevents timing oracles on the stored secret.
             if (entry) {
-                const nodeCrypto = await (0, platformCrypto_1.loadNodeCrypto)();
+                const nodeCrypto = await (0, protocol_1.loadNodeCrypto)();
                 const storedSecretBuf = entry.secretBuf;
                 const lengthMatch = storedSecretBuf.length === providedSecretBuf.length;
                 // Always run timingSafeEqual on equal-length inputs to keep timing flat.

package/dist/cjs/mixins/OxyServices.civic.js

@@ -4,7 +4,7 @@ exports.parseIdPayload = parseIdPayload;
 exports.parseAttestPayload = parseAttestPayload;
 exports.verifyPublicCardAttestation = verifyPublicCardAttestation;
 exports.OxyServicesCivicMixin = OxyServicesCivicMixin;
-const canonicalJson_1 = require("../crypto/canonicalJson");
+const protocol_1 = require("@oxyhq/protocol");
 const signatureService_1 = require("../crypto/signatureService");
 const OxyServices_identity_1 = require("./OxyServices.identity");
 const mixinHelpers_1 = require("./mixinHelpers");
@@ -156,7 +156,7 @@ function parseAttestPayload(raw) {
  * key, matching the server which omits absent keys entirely) and checks the
  * `ES256K-DER-SHA256` signature against `attestation.publicKey`.
  *
- * NEVER throws: `SignatureService.verify` already swallows malformed-input
+ * NEVER throws: `verifySignature` already swallows malformed-input
  * errors and returns `false`, and an absent attestation short-circuits to
  * `false`. A pure, reusable helper (Commons can call it on a cached card).
  *
@@ -171,7 +171,7 @@ async function verifyPublicCardAttestation(card, attestation) {
     if (!signature || !publicKey) {
         return false;
     }
-    return signatureService_1.SignatureService.verify((0, canonicalJson_1.canonicalize)(card), signature, publicKey);
+    return (0, protocol_1.verifySignature)((0, protocol_1.canonicalize)(card), signature, publicKey);
 }
 function OxyServicesCivicMixin(Base) {
     return class extends Base {

package/dist/cjs/mixins/OxyServices.language.js

@@ -5,7 +5,7 @@ exports.OxyServicesLanguageMixin = OxyServicesLanguageMixin;
  * Language Methods Mixin
  */
 const languageUtils_1 = require("../utils/languageUtils");
-const platformCrypto_1 = require("../utils/platformCrypto");
+const protocol_1 = require("@oxyhq/protocol");
 const debugUtils_1 = require("../shared/utils/debugUtils");
 function OxyServicesLanguageMixin(Base) {
     return class extends Base {
@@ -22,7 +22,7 @@ function OxyServicesLanguageMixin(Base) {
                     // `loadAsyncStorage` is per-platform: the RN variant statically imports
                     // @react-native-async-storage/async-storage, the default variant throws
                     // (never called outside RN because of the `isReactNative` gate above).
-                    const asyncStorageModule = await (0, platformCrypto_1.loadAsyncStorage)();
+                    const asyncStorageModule = await (0, protocol_1.loadAsyncStorage)();
                     const storage = asyncStorageModule.default;
                     return {
                         getItem: storage.getItem.bind(storage),

package/dist/cjs/mixins/OxyServices.utility.js

@@ -8,7 +8,7 @@ exports.OxyServicesUtilityMixin = OxyServicesUtilityMixin;
  * and Express.js authentication middleware
  */
 const jwt_decode_1 = require("jwt-decode");
-const platformCrypto_1 = require("../utils/platformCrypto");
+const protocol_1 = require("@oxyhq/protocol");
 const loggerUtils_1 = require("../utils/loggerUtils");
 const mixinHelpers_1 = require("./mixinHelpers");
 /**
@@ -50,8 +50,6 @@ function OxyServicesUtilityMixin(Base) {
         // monorepo-wide refactor of the mixin pipeline.
         constructor(...args) {
             super(...args);
-            /** @internal In-memory cache for acting-as verification results (TTL: 5 min) */
-            this._actingAsCache = new Map();
             /**
              * In-memory cache for service-acting-as verification.
              * Negative results are cached for 1min to avoid hammering the verify
@@ -61,46 +59,6 @@ function OxyServicesUtilityMixin(Base) {
              */
             this._serviceActingAsCache = new Map();
         }
-        /**
-         * Verify that a user is authorized to act as an account (direct membership
-         * or inherited via an ancestor). Backed by `GET /accounts/verify-acting-as`.
-         * Results are cached in-memory for 5 minutes to avoid repeated API calls.
-         *
-         * @internal Used by the auth() middleware — not part of the public API
-         */
-        async verifyActingAs(userId, accountId) {
-            const cacheKey = `${userId}:${accountId}`;
-            const now = Date.now();
-            // Check cache
-            const cached = this._actingAsCache.get(cacheKey);
-            if (cached && cached.expiresAt > now) {
-                return cached.result;
-            }
-            // Query the API
-            try {
-                const result = await this.makeRequest('GET', '/accounts/verify-acting-as', { accountId, userId }, { cache: false, retry: false, timeout: 5000 });
-                // Cache successful result for 5 minutes
-                this._actingAsCache.set(cacheKey, {
-                    result: result && result.authorized ? result : null,
-                    expiresAt: now + 5 * 60 * 1000,
-                });
-                return result && result.authorized ? result : null;
-            }
-            catch (error) {
-                loggerUtils_1.logger.warn('[oxy.auth] verifyActingAs lookup failed — caching negative result', {
-                    component: 'auth',
-                    method: 'verifyActingAs',
-                    userId,
-                    accountId,
-                }, error);
-                // Cache negative result for 1 minute to avoid hammering on transient errors
-                this._actingAsCache.set(cacheKey, {
-                    result: null,
-                    expiresAt: now + 1 * 60 * 1000,
-                });
-                return null;
-            }
-        }
         /**
          * Verify that a service app holds an active delegation grant authorising
          * it to act on behalf of `userId`. Returns the grant (with allowed scopes)
@@ -221,47 +179,6 @@ function OxyServicesUtilityMixin(Base) {
             const oxyInstance = this;
             // Return an async middleware function
             return async (req, res, next) => {
-                // Process X-Acting-As header for managed account identity delegation.
-                // Called after successful authentication, before next(). If the header
-                // is present, verifies authorization and swaps the request identity to
-                // the managed account, preserving the original user for audit trails.
-                const processActingAs = async () => {
-                    const actingAsUserId = req.headers['x-acting-as'];
-                    if (!actingAsUserId || typeof actingAsUserId !== 'string')
-                        return true; // No header, proceed normally
-                    const currentUserId = req.userId;
-                    if (!currentUserId)
-                        return true; // No authenticated user yet — nothing to swap
-                    const verification = await oxyInstance.verifyActingAs(currentUserId, actingAsUserId);
-                    if (!verification) {
-                        const error = {
-                            error: 'ACTING_AS_UNAUTHORIZED',
-                            message: 'Not authorized to act as this account',
-                            code: 'ACTING_AS_UNAUTHORIZED',
-                            status: 403,
-                        };
-                        if (onError) {
-                            onError(error);
-                        }
-                        else {
-                            res.status(403).json(error);
-                        }
-                        return false;
-                    }
-                    // Preserve original user for audit trails
-                    req.originalUser = { id: currentUserId, ...(req.user ?? {}) };
-                    req.actingAs = { userId: actingAsUserId, role: verification.role };
-                    // Swap user identity to the managed account
-                    req.userId = actingAsUserId;
-                    req.user = { id: actingAsUserId, _id: actingAsUserId };
-                    if (debug) {
-                        loggerUtils_1.logger.debug(`[oxy.auth] Acting as ${actingAsUserId} (role=${verification.role}) original=${currentUserId}`, {
-                            component: 'auth',
-                            method: 'auth.processActingAs',
-                        });
-                    }
-                    return true;
-                };
                 try {
                     // Extract token from Authorization header.
                     // Node/Express normalizes `Authorization` to a string; we guard
@@ -343,9 +260,9 @@ function OxyServicesUtilityMixin(Base) {
                         // Signature verification uses a manual HMAC-SHA256 compare because
                         // this file ships into RN/web bundles where `jsonwebtoken` is
                         // unavailable. The middleware only ever runs on Node hosts (see
-                        // platformCrypto's doc-comment), and `loadNodeCrypto` is per-
-                        // platform: the RN variant throws so Metro never bundles a Node
-                        // built-in reference.
+                        // `@oxyhq/protocol`'s `platform/crypto` doc-comment), and
+                        // `loadNodeCrypto` is per-platform: the RN variant throws so Metro
+                        // never bundles a Node built-in reference.
                         try {
                             await verifyServiceTokenSignature(token, jwtSecret);
                             verifyServiceTokenClaims(decoded, {
@@ -554,10 +471,7 @@ function OxyServicesUtilityMixin(Base) {
                                     method: 'auth',
                                 });
                             }
-                            // Process X-Acting-As header before proceeding
-                            if (await processActingAs())
-                                return next();
-                            return;
+                            return next();
                         }
                         catch (validationError) {
                             if (debug) {
@@ -621,9 +535,7 @@ function OxyServicesUtilityMixin(Base) {
                             method: 'auth',
                         });
                     }
-                    // Process X-Acting-As header before proceeding
-                    if (await processActingAs())
-                        next();
+                    next();
                 }
                 catch (error) {
                     const handled = oxyInstance.handleError(error);
@@ -861,7 +773,7 @@ function OxyServicesUtilityMixin(Base) {
  * `ServiceTokenSignatureError` on signature mismatch — both map to 401.
  */
 async function verifyServiceTokenSignature(token, secret) {
-    const nodeCrypto = await (0, platformCrypto_1.loadNodeCrypto)();
+    const nodeCrypto = await (0, protocol_1.loadNodeCrypto)();
     const { createHmac, timingSafeEqual } = nodeCrypto;
     const parts = token.split('.');
     if (parts.length !== 3) {

package/dist/cjs/utils/cacheKey.js

@@ -4,8 +4,8 @@
  *
  * Extracted from {@link HttpService} so the identity-tag derivation is a pure,
  * independently testable function with no dependency on instance/token state.
- * The HTTP service injects the live access token and acting-as id; everything
- * here is referentially transparent given those inputs.
+ * The HTTP service injects the live access token; everything here is
+ * referentially transparent given that input.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ANON_IDENTITY = void 0;
@@ -63,25 +63,23 @@ function fnv1a32(str) {
  *
  * We use the decoded user id rather than the raw JWT so the token never lands
  * in a cache key (no token leakage through any cache-key logging, no key bloat).
- * The acting-as id is folded in because managed-account responses differ per
- * acting identity — and `X-Acting-As` already changes the server response for
- * the same bearer token.
+ * Switching into a managed account mints a REAL new session whose access token
+ * carries the target account's id, so the identity tag changes naturally on a
+ * switch — there is no separate acting-as discriminator to fold in.
  *
  * @param accessToken The current bearer access token, or `null` when anonymous.
- * @param actingAsUserId The active managed-account id, or `null`.
  */
-function computeIdentityTag(accessToken, actingAsUserId) {
-    let principal = exports.ANON_IDENTITY;
-    if (accessToken) {
-        try {
-            const decoded = (0, jwt_decode_1.jwtDecode)(accessToken);
-            principal = decoded.userId || decoded.id || `t${fnv1a32(accessToken)}`;
-        }
-        catch {
-            // Undecodable token — still partition it away from anon and from other
-            // tokens via a hash. Never silently fall back to ANON_IDENTITY.
-            principal = `t${fnv1a32(accessToken)}`;
-        }
+function computeIdentityTag(accessToken) {
+    if (!accessToken) {
+        return exports.ANON_IDENTITY;
+    }
+    try {
+        const decoded = (0, jwt_decode_1.jwtDecode)(accessToken);
+        return decoded.userId || decoded.id || `t${fnv1a32(accessToken)}`;
+    }
+    catch {
+        // Undecodable token — still partition it away from anon and from other
+        // tokens via a hash. Never silently fall back to ANON_IDENTITY.
+        return `t${fnv1a32(accessToken)}`;
     }
-    return actingAsUserId ? `${principal}~as${actingAsUserId}` : principal;
 }

package/dist/cjs/utils/deviceManager.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceManager = void 0;
-const platformCrypto_1 = require("./platformCrypto");
+const protocol_1 = require("@oxyhq/protocol");
 /**
  * Client-side device management utility
  * Handles persistent device identification across app sessions
@@ -22,7 +22,7 @@ class DeviceManager {
                 // `loadAsyncStorage` is per-platform: the RN variant statically imports
                 // @react-native-async-storage/async-storage, the default variant throws
                 // (never called outside RN because of the `isReactNative()` gate above).
-                const asyncStorageModule = await (0, platformCrypto_1.loadAsyncStorage)();
+                const asyncStorageModule = await (0, protocol_1.loadAsyncStorage)();
                 const storage = asyncStorageModule.default;
                 return {
                     getItem: storage.getItem.bind(storage),

package/dist/cjs/utils/platform.js

@@ -12,8 +12,6 @@ exports.isWeb = isWeb;
 exports.isNative = isNative;
 exports.isIOS = isIOS;
 exports.isAndroid = isAndroid;
-exports.isReactNative = isReactNative;
-exports.isNodeJS = isNodeJS;
 exports.setPlatformOS = setPlatformOS;
 /**
  * Detect the current platform without importing react-native
@@ -84,18 +82,6 @@ function isIOS() {
 function isAndroid() {
     return getPlatformOS() === 'android';
 }
-/**
- * Check if running in React Native
- */
-function isReactNative() {
-    return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-}
-/**
- * Check if running in Node.js
- */
-function isNodeJS() {
-    return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-}
 /**
  * Set the platform OS explicitly
  * Called by React Native entry point to register the platform