@advenue/react-native 0.3.0

package/dist/index.js

@@ -0,0 +1,563 @@
+import { parseInstallReferrer, extractReferrerProperties, parseMetaInstallReferrer } from '@advenue/install-referrer';
+import { DEFAULT_ENDPOINT, MemoryStorage, resolveDurableDeviceId, AdvenueClient } from '@advenue/sdk-core';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../shared/src/match-token.ts
+var MATCH_TOKEN_PREFIX = "advmatch:";
+function parseMatchToken(raw) {
+  if (!raw || !raw.startsWith(MATCH_TOKEN_PREFIX)) return null;
+  const id = raw.slice(MATCH_TOKEN_PREFIX.length).trim();
+  return /^[A-Za-z0-9_-]{1,128}$/.test(id) ? id : null;
+}
+
+// ../signing/src/index.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotr(x, n) {
+  return x >>> n | x << 32 - n;
+}
+function sha256Bytes(msg) {
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const l = msg.length;
+  const bitLen = l * 8;
+  const withOne = l + 1;
+  const padTo = (56 - withOne % 64 + 64) % 64;
+  const padded = new Uint8Array(withOne + padTo + 8);
+  padded.set(msg);
+  padded[l] = 128;
+  const dv = new DataView(padded.buffer);
+  dv.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+  dv.setUint32(padded.length - 4, bitLen >>> 0);
+  const w = new Uint32Array(64);
+  for (let i = 0; i < padded.length; i += 64) {
+    for (let t = 0; t < 16; t++) w[t] = dv.getUint32(i + t * 4);
+    for (let t = 16; t < 64; t++) {
+      const w15 = w[t - 15];
+      const w2 = w[t - 2];
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let a = h[0];
+    let b = h[1];
+    let c = h[2];
+    let d = h[3];
+    let e = h[4];
+    let f = h[5];
+    let g = h[6];
+    let hh = h[7];
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[t] + w[t] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const odv = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) odv.setUint32(i * 4, h[i]);
+  return out;
+}
+function toHex(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, "0");
+  return s;
+}
+var enc = new TextEncoder();
+function sha256Hex(message) {
+  return toHex(sha256Bytes(enc.encode(message)));
+}
+
+// src/deep-links.ts
+function parseDirectLink(url) {
+  let deepLinkValue = "";
+  let params;
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname.replace(/^\/+/, "");
+    const isHttp = parsed.protocol === "http:" || parsed.protocol === "https:";
+    deepLinkValue = isHttp ? path : [parsed.host, path].filter(Boolean).join("/");
+    for (const [k, v] of parsed.searchParams.entries()) {
+      params ??= {};
+      params[k] = v;
+    }
+  } catch {
+    deepLinkValue = url;
+  }
+  return {
+    deepLinkValue,
+    ...params ? { params } : {},
+    url,
+    isDeferred: false,
+    isFirstLaunch: false
+  };
+}
+function setupDeepLinks(setup) {
+  const listener = setup.addUrlListener((url) => setup.onDeepLink(parseDirectLink(url)));
+  const ready = (async () => {
+    const initial = await setup.getInitialURL();
+    if (initial) {
+      setup.onDeepLink(parseDirectLink(initial));
+      return;
+    }
+    const deferred = await setup.resolveDeferred();
+    if (deferred?.deepLinkValue) {
+      setup.onDeepLink(deferred);
+    }
+  })();
+  return { remove: () => listener.remove(), ready };
+}
+
+// src/mmkv-storage.ts
+function createMMKVStorage(mmkv) {
+  return {
+    getItem: (key) => mmkv.getString(key) ?? null,
+    setItem: (key, value) => mmkv.set(key, value),
+    removeItem: (key) => mmkv.delete(key)
+  };
+}
+
+// src/native.ts
+function getIosNative() {
+  try {
+    return __require("@advenue/sdk-ios").AdvenueIos;
+  } catch {
+    return null;
+  }
+}
+function getAndroidNative() {
+  try {
+    return __require("@advenue/sdk-android").AdvenueAndroid;
+  } catch {
+    return null;
+  }
+}
+function getAppState() {
+  try {
+    return __require("react-native").AppState;
+  } catch {
+    return null;
+  }
+}
+function getLinking() {
+  try {
+    return __require("react-native").Linking;
+  } catch {
+    return null;
+  }
+}
+
+// src/secure-store.ts
+function createSecureStore(secureStore2) {
+  return {
+    getItemAsync: async (key) => await secureStore2.getItemAsync(key) ?? null,
+    setItemAsync: (key, value) => secureStore2.setItemAsync(key, value)
+  };
+}
+
+// src/index.ts
+async function resolveAdvertisingId() {
+  const client = active();
+  const consent = client.getConsentData();
+  if (client.getRequireConsent() && consent == null) {
+    client.setAdvertisingId({});
+    return;
+  }
+  if (consent?.isUserSubjectToGDPR === true && consent.hasConsentForDataUsage !== true) {
+    client.setAdvertisingId({});
+    return;
+  }
+  const ios = getIosNative();
+  if (ios) {
+    const idfa = ios.getTrackingAuthorizationStatus() === "authorized" ? await ios.getAdvertisingId() : null;
+    const vendorId = typeof ios.getIdentifierForVendor === "function" ? ios.getIdentifierForVendor() : null;
+    client.setAdvertisingId({ ...idfa ? { idfa } : {}, ...vendorId ? { vendorId } : {} });
+    return;
+  }
+  const android = getAndroidNative();
+  if (android && typeof android.getAdvertisingId === "function") {
+    const r = await android.getAdvertisingId();
+    const vendorId = typeof android.getAppSetId === "function" ? await android.getAppSetId() : null;
+    const adFields = r ? r.limitAdTracking ? { limitAdTracking: true } : { gaid: r.id } : {};
+    client.setAdvertisingId({ ...adFields, ...vendorId ? { vendorId } : {} });
+    return;
+  }
+  client.setAdvertisingId({});
+}
+function collectDeviceInfo(natives) {
+  try {
+    if (natives.platform === "android" && natives.android?.getDeviceInfo) {
+      return natives.android.getDeviceInfo();
+    }
+    if (natives.platform === "ios" && natives.ios?.getDeviceInfo) {
+      return natives.ios.getDeviceInfo();
+    }
+  } catch {
+  }
+  return {};
+}
+async function resolveClipboardMatch() {
+  const client = active();
+  if (client.getRequireConsent() && !client.getTrackingConsent()) return null;
+  const ios = getIosNative();
+  if (!ios || typeof ios.getPasteboardMatchToken !== "function") {
+    return null;
+  }
+  const matchId = parseMatchToken(ios.getPasteboardMatchToken());
+  if (!matchId) return null;
+  return client.exchangeClipboardMatch(matchId);
+}
+function applyAppState(client, status) {
+  if (status === "active") {
+    client.notifyAppActive();
+  } else if (status === "background") {
+    client.notifyAppBackground();
+  }
+}
+var instance = null;
+var appStateSub = null;
+var deepLinkSub = null;
+var secureStore = null;
+var installFlagStore = null;
+var INSTALL_SENT_KEY = "advenue.install_sent";
+var installInFlight = false;
+var configuredAppId = null;
+var configuredApiKey = null;
+var configuredEndpoint = DEFAULT_ENDPOINT;
+function active() {
+  if (!instance) {
+    throw new Error("Advenue.initialize() must be called before tracking events.");
+  }
+  return instance;
+}
+function reportError(context, cause) {
+  instance?.report(context, cause);
+}
+var Advenue = {
+  async initialize(config) {
+    const { mmkv, secureStore: secureMod, onDeepLink, appId, ...rest } = config;
+    configuredAppId = appId ?? null;
+    configuredApiKey = config.apiKey;
+    configuredEndpoint = config.endpoint ?? DEFAULT_ENDPOINT;
+    appStateSub?.remove();
+    appStateSub = null;
+    deepLinkSub?.remove();
+    deepLinkSub = null;
+    instance?.shutdown();
+    const storage = mmkv ? createMMKVStorage(mmkv) : new MemoryStorage();
+    installFlagStore = storage;
+    secureStore = secureMod ? createSecureStore(secureMod) : null;
+    const deviceId = rest.deviceId ?? await resolveDurableDeviceId(storage, secureStore ?? void 0);
+    instance = new AdvenueClient({ ...rest, deviceId, storage });
+    void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+    const deviceInfo = collectDeviceInfo({
+      platform: rest.platform,
+      ios: getIosNative(),
+      android: getAndroidNative()
+    });
+    if (Object.keys(deviceInfo).length > 0) instance.setDeviceInfo(deviceInfo);
+    if (!config.disableAutoSessions) {
+      const appState = getAppState();
+      if (appState) {
+        appStateSub?.remove();
+        let seenBackground = false;
+        const handler = (status) => {
+          if (!instance) return;
+          if (status === "background") {
+            seenBackground = true;
+            applyAppState(instance, status);
+          } else if (status === "active") {
+            if (!seenBackground) return;
+            seenBackground = false;
+            applyAppState(instance, status);
+            void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+          }
+        };
+        appStateSub = appState.addEventListener("change", handler);
+        instance.notifyAppActive();
+      } else {
+        instance.notifyAppActive();
+      }
+    }
+    if (onDeepLink) {
+      const linking = getLinking();
+      if (linking) {
+        const client = instance;
+        deepLinkSub = setupDeepLinks({
+          getInitialURL: () => linking.getInitialURL(),
+          addUrlListener: (handler) => linking.addEventListener("url", (e) => handler(e.url)),
+          // Deferred waterfall: clipboard (deterministic) first, then the
+          // server-side conversion poll (IDFA / probabilistic).
+          resolveDeferred: async () => await resolveClipboardMatch() ?? client.resolveDeferredDeepLink(),
+          onDeepLink
+        });
+      }
+    }
+    return instance;
+  },
+  track: (name, properties, opts) => active().track(name, properties, opts),
+  /**
+   * Shows the iOS ATT prompt (resolves 'authorized' immediately on Android/web,
+   * where ATT doesn't exist) and forwards the result to the consent gate.
+   */
+  async requestTrackingAuthorization() {
+    const ios = getIosNative();
+    const status = ios ? await ios.requestTrackingAuthorization() : "authorized";
+    active().setTrackingConsent(status === "authorized");
+    void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+    return status;
+  },
+  /**
+   * Tracks the install event enriched with native attribution data: Play +
+   * Meta install referrers on Android, SKAdNetwork registration on iOS.
+   * Safe to call on every launch — when a `secureStore` is wired it fires at
+   * most once per device (reinstall-resilient on iOS via Keychain; Android
+   * re-fires after a reinstall, which is unavoidable post-GAID).
+   */
+  async trackInstall(properties) {
+    const client = active();
+    let sent = installFlagStore?.getItem(INSTALL_SENT_KEY) === "1";
+    if (!sent && secureStore) {
+      try {
+        sent = await secureStore.getItemAsync(INSTALL_SENT_KEY) === "1";
+      } catch (err) {
+        reportError("install.guardRead", err);
+      }
+    }
+    if (sent) {
+      return;
+    }
+    if (installInFlight) {
+      return;
+    }
+    installInFlight = true;
+    const opts = {};
+    const props = { ...properties };
+    const android = getAndroidNative();
+    if (android) {
+      try {
+        const result = await android.getInstallReferrer();
+        if (result) {
+          const parsed = parseInstallReferrer(result.referrer);
+          if (parsed.network) opts.network = parsed.network;
+          if (parsed.campaign) opts.campaign = parsed.campaign;
+          if (parsed.gclid) props.gclid = parsed.gclid;
+          if (parsed.fbclid) props.fbclid = parsed.fbclid;
+          Object.assign(props, extractReferrerProperties(result));
+        }
+      } catch (err) {
+        reportError("enrich.installReferrer", err);
+      }
+      try {
+        const meta = await android.getMetaInstallReferrer();
+        const parsedMeta = meta ? parseMetaInstallReferrer(meta) : null;
+        if (parsedMeta) {
+          props.metaInstallReferrer = parsedMeta.raw;
+          if (parsedMeta.encryptedData) props.metaReferrerData = parsedMeta.encryptedData;
+          if (parsedMeta.nonce) props.metaReferrerNonce = parsedMeta.nonce;
+          if (!opts.network && parsedMeta.isClickThrough) {
+            opts.network = "meta";
+            if (parsedMeta.campaign) opts.campaign = parsedMeta.campaign;
+          }
+        }
+      } catch (err) {
+        reportError("enrich.metaReferrer", err);
+      }
+    }
+    const ios = getIosNative();
+    if (ios) {
+      try {
+        ios.registerAppForAttribution();
+      } catch (err) {
+        reportError("enrich.skanRegister", err);
+      }
+      try {
+        const asaToken = await ios.getAttributionToken();
+        if (asaToken) {
+          opts.adservicesToken = asaToken;
+        }
+      } catch (err) {
+        reportError("enrich.adservicesToken", err);
+      }
+    }
+    await resolveAdvertisingId();
+    const trackOpts = { type: "install", ...opts };
+    if (configuredAppId && android && typeof android.getIntegrityToken === "function") {
+      try {
+        const deviceId = client.getDeviceId();
+        const requestHash = sha256Hex(`${configuredAppId}:${deviceId}`);
+        const token = await android.getIntegrityToken(requestHash);
+        if (token) {
+          trackOpts.attestationToken = token;
+          trackOpts.attestationType = "play-integrity";
+        }
+      } catch (err) {
+        reportError("attest.playIntegrity", err);
+      }
+    }
+    if (configuredAppId && configuredApiKey && ios && typeof ios.attestKey === "function") {
+      try {
+        const deviceId = client.getDeviceId();
+        const challengeUrl = `${configuredEndpoint}/v1/attest/challenge?deviceId=${encodeURIComponent(deviceId)}`;
+        const challengeRes = await fetch(challengeUrl, {
+          headers: { "x-api-key": configuredApiKey }
+        });
+        if (!challengeRes.ok) throw new Error(`challenge HTTP ${challengeRes.status}`);
+        const { challenge } = await challengeRes.json();
+        const { keyId, attestationObject } = await ios.attestKey(challenge);
+        trackOpts.attestationToken = attestationObject;
+        trackOpts.attestationType = "app-attest";
+        trackOpts.attestationKeyId = keyId;
+        trackOpts.attestationChallenge = challenge;
+      } catch (err) {
+        reportError("attest.appAttest", err);
+      }
+    }
+    if (ios && typeof ios.getDeviceCheckToken === "function") {
+      try {
+        const token = await ios.getDeviceCheckToken();
+        if (token) {
+          trackOpts.deviceCheckToken = token;
+        }
+      } catch (err) {
+        reportError("attest.deviceCheck", err);
+      }
+    }
+    client.track("install", props, trackOpts);
+    try {
+      installFlagStore?.setItem(INSTALL_SENT_KEY, "1");
+    } catch (err) {
+      reportError("install.flagPersist", err);
+    }
+    if (secureStore) {
+      try {
+        await secureStore.setItemAsync(INSTALL_SENT_KEY, "1");
+      } catch (err) {
+        reportError("install.flagPersistSecure", err);
+      }
+    }
+  },
+  setTrackingConsent: (granted) => active().setTrackingConsent(granted),
+  getTrackingConsent: () => active().getTrackingConsent(),
+  /** GDPR/CCPA erasure: stop tracking and wipe local identifiers/queue. */
+  forgetMe: () => active().forgetMe(),
+  setConsentData(consent) {
+    active().setConsentData(consent);
+    void resolveAdvertisingId().catch((err) => reportError("enrich.advertisingId", err));
+  },
+  getConsentData: () => active().getConsentData(),
+  flush: () => active().flush(),
+  getDeviceId: () => active().getDeviceId(),
+  shutdown() {
+    appStateSub?.remove();
+    appStateSub = null;
+    deepLinkSub?.remove();
+    deepLinkSub = null;
+    instance?.shutdown();
+    instance = null;
+    secureStore = null;
+    installInFlight = false;
+    configuredAppId = null;
+    configuredApiKey = null;
+    configuredEndpoint = DEFAULT_ENDPOINT;
+  }
+};
+
+export { Advenue, applyAppState, collectDeviceInfo, createMMKVStorage, createSecureStore, getAndroidNative, getIosNative, parseDirectLink, resolveAdvertisingId, resolveClipboardMatch };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@advenue/react-native",
+  "version": "0.3.0",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugin": "./plugin/index.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "plugin",
+    "!**/*.test.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@advenue/install-referrer": "0.1.0",
+    "@advenue/sdk-core": "0.2.0"
+  },
+  "peerDependencies": {
+    "@advenue/sdk-android": "*",
+    "@advenue/sdk-ios": "*",
+    "@expo/config-plugins": ">=8",
+    "expo-secure-store": ">=12",
+    "react": ">=18.2",
+    "react-native": ">=0.74",
+    "react-native-mmkv": ">=3"
+  },
+  "peerDependenciesMeta": {
+    "@expo/config-plugins": {
+      "optional": true
+    },
+    "@advenue/sdk-android": {
+      "optional": true
+    },
+    "@advenue/sdk-ios": {
+      "optional": true
+    },
+    "expo-secure-store": {
+      "optional": true
+    },
+    "react-native-mmkv": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8",
+    "@advenue/sdk-android": "0.2.0",
+    "@advenue/sdk-ios": "0.2.0",
+    "@advenue/shared": "0.0.0",
+    "@advenue/signing": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/plugin/index.js

@@ -0,0 +1,40 @@
+// @ts-check
+// Expo config plugin: wires the native association config that makes Advenue
+// deep links resolve on device. iOS gets the Associated Domains entitlement
+// (Universal Links); Android gets an autoVerify intent filter (App Links). The
+// backend already serves the matching apple-app-site-association / assetlinks.json.
+//
+// Usage (app.json / app.config.js):
+//   ["@advenue/react-native/plugin", { "domains": ["go.advenue.io"] }]
+//
+// @expo/config-plugins is resolved from the consuming app's Expo install.
+const { withEntitlementsPlist, withAndroidManifest } = require('@expo/config-plugins');
+const { addAssociatedDomains, addAppLinksIntentFilter } = require('./links');
+
+/**
+ * @param {any} config
+ * @param {{ domains?: string[] } | undefined} props
+ */
+function withAdvenueLinks(config, props) {
+  const domains = props?.domains ?? [];
+  if (domains.length === 0) {
+    throw new Error(
+      '@advenue/react-native/plugin: provide at least one link domain, e.g. { "domains": ["go.advenue.io"] }',
+    );
+  }
+
+  let result = withEntitlementsPlist(config, (cfg) => {
+    cfg.modResults = addAssociatedDomains(cfg.modResults, domains);
+    return cfg;
+  });
+
+  result = withAndroidManifest(result, (cfg) => {
+    cfg.modResults = addAppLinksIntentFilter(cfg.modResults, domains);
+    return cfg;
+  });
+
+  return result;
+}
+
+module.exports = withAdvenueLinks;
+module.exports.default = withAdvenueLinks;