@amplytools/react-native-amply-sdk 0.15.0 → 0.15.2

package/dist/cjs/index.js

@@ -0,0 +1,723 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemEvents = exports.AmplyConfigError = exports.formatSystemEventLabel = exports.useAmplySystemEvents = void 0;
+exports.initialize = initialize;
+exports.setAppLanguage = setAppLanguage;
+exports.handleUrl = handleUrl;
+exports.setUserId = setUserId;
+exports.setLogLevel = setLogLevel;
+exports.getLogLevel = getLogLevel;
+exports.isInitialized = isInitialized;
+exports.track = track;
+exports.trackEvent = trackEvent;
+exports.trackGated = trackGated;
+exports.registerGate = registerGate;
+exports.getRecentEvents = getRecentEvents;
+exports.getLastCampaignTouch = getLastCampaignTouch;
+exports.getDataSetSnapshot = getDataSetSnapshot;
+exports.addDeepLinkListener = addDeepLinkListener;
+exports.addSystemEventListener = addSystemEventListener;
+exports.setCustomProperty = setCustomProperty;
+exports.setCustomProperties = setCustomProperties;
+exports.getCustomProperty = getCustomProperty;
+exports.removeCustomProperty = removeCustomProperty;
+exports.clearCustomProperties = clearCustomProperties;
+exports.removeAllListeners = removeAllListeners;
+exports.addSystemEventsListener = addSystemEventsListener;
+const nativeModule_1 = __importDefault(require("./nativeModule"));
+const systemEvents_1 = require("./systemEvents");
+var useAmplySystemEvents_1 = require("./hooks/useAmplySystemEvents");
+Object.defineProperty(exports, "useAmplySystemEvents", { enumerable: true, get: function () { return useAmplySystemEvents_1.useAmplySystemEvents; } });
+var systemEventUtils_1 = require("./systemEventUtils");
+Object.defineProperty(exports, "formatSystemEventLabel", { enumerable: true, get: function () { return systemEventUtils_1.formatSystemEventLabel; } });
+const campaignTouch_1 = require("./campaignTouch");
+const REQUIRED_KEYS = ['appId', 'apiKeyPublic', 'apiKeySecret'];
+/** Rejection raised by {@link initialize} for a config the SDK cannot start with. */
+class AmplyConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'AMP_INVALID_CONFIG';
+        this.name = 'AmplyConfigError';
+    }
+}
+exports.AmplyConfigError = AmplyConfigError;
+/** The first required key that is missing or blank, if any. */
+function missingKey(config) {
+    return REQUIRED_KEYS.find((key) => {
+        const value = config === null || config === void 0 ? void 0 : config[key];
+        return typeof value !== 'string' || value.trim().length === 0;
+    });
+}
+let deepLinkRegistered = false;
+let debugLogListenerRegistered = false;
+const deepLinkSubscriptions = new Set();
+const campaignPresenterSubscriptions = new Set();
+/**
+ * What is registered NATIVELY, keyed by gate baseUrl — at most one entry per URL, because a
+ * second `registerGate` on the same URL evicts the first rather than stacking on top of it.
+ *
+ * This used to be a `Set<string>` written the moment a native call was made, whether or not
+ * that call did anything. Three defects came out of that one optimistic write: two presenters
+ * both showing a single presentation, a withdrawal that left the native gate live, and a
+ * registration made before `initialize` being lost for the lifetime of the process.
+ */
+const gateRegistrations = new Map();
+/**
+ * Identity for a gate registration. Withdrawal cannot be keyed by URL alone: an unsubscribe
+ * handed out for a registration that has since been evicted would otherwise withdraw whatever
+ * holds that URL now, killing its replacement. A stale handle must be inert.
+ */
+let nextGateRegistrationId = 1;
+const pendingRegistrations = [];
+/** True when the native module exists AND the SDK behind it has been initialised. */
+function isSdkUp() {
+    try {
+        return (0, nativeModule_1.default)().isInitialized();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Runs [apply] now if the SDK is up, otherwise parks it until [initialize] completes.
+ * Returns a canceller so a caller that withdraws before initialisation is never replayed.
+ */
+function applyWhenSdkIsUp(apply) {
+    if (isSdkUp()) {
+        apply();
+        return () => { };
+    }
+    const pending = {
+        cancelled: false,
+        apply: () => {
+            if (!pending.cancelled) {
+                apply();
+            }
+        },
+    };
+    pendingRegistrations.push(pending);
+    return () => {
+        pending.cancelled = true;
+    };
+}
+function replayPendingRegistrations() {
+    const queued = pendingRegistrations.splice(0, pendingRegistrations.length);
+    queued.forEach(pending => {
+        try {
+            pending.apply();
+        }
+        catch (error) {
+            console.warn('[Amply] Failed to apply a registration deferred until initialize', error);
+        }
+    });
+}
+/**
+ * Withdraws the gate registered for [baseUrl], on both sides. A no-op when nothing is
+ * registered, so callers do not need to check first.
+ */
+function withdrawGate(baseUrl, onlyIfId) {
+    const registration = gateRegistrations.get(baseUrl);
+    if (!registration) {
+        return;
+    }
+    // Compare before clearing, the same rule the SDK's own listener seams follow: a caller
+    // holding a stale handle must not withdraw the registration that replaced it.
+    if (onlyIfId !== undefined && registration.id !== onlyIfId) {
+        return;
+    }
+    gateRegistrations.delete(baseUrl);
+    registration.removeSubscription();
+    try {
+        (0, nativeModule_1.default)().unregisterGate(baseUrl);
+    }
+    catch (error) {
+        console.warn('[Amply] Failed to unregister gate', baseUrl, error);
+    }
+}
+/**
+ * Format a debug log entry for console output using new format.
+ */
+function formatDebugLog(event) {
+    var _a;
+    const props = event.properties;
+    const level = ((_a = props.level) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'DEBUG';
+    const category = props.category
+        ? props.category.charAt(0).toUpperCase() + props.category.slice(1)
+        : 'Sdk';
+    const timestamp = new Date(event.timestamp).toISOString();
+    return `[${timestamp}][Amply.${category}][${level}] ${props.message || ''}`;
+}
+/**
+ * Set up debug log listener that outputs to console.
+ */
+function ensureDebugLogListener() {
+    if (debugLogListenerRegistered) {
+        return;
+    }
+    debugLogListenerRegistered = true;
+    (0, systemEvents_1.addSystemEventListenerRaw)((event) => {
+        var _a;
+        if (event.name === 'DebugLog') {
+            const formattedLog = formatDebugLog(event);
+            const props = event.properties;
+            const level = (_a = props.level) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            switch (level) {
+                case 'error':
+                    console.error(formattedLog);
+                    break;
+                case 'warn':
+                    console.warn(formattedLog);
+                    break;
+                case 'debug':
+                    console.debug(formattedLog);
+                    break;
+                default:
+                    console.log(formattedLog);
+            }
+        }
+    });
+}
+async function ensureDeepLinkRegistration() {
+    if (deepLinkRegistered) {
+        return;
+    }
+    // The flag is set inside apply(), not here: native refuses while the SDK is down, and
+    // recording that refusal as success is what stranded the listener for the whole process.
+    applyWhenSdkIsUp(() => {
+        (0, nativeModule_1.default)().registerDeepLinkListener();
+        deepLinkRegistered = true;
+    });
+}
+function trackDeepLinkSubscription(subscription) {
+    let removed = false;
+    const unsubscribe = () => {
+        var _a;
+        if (removed) {
+            return;
+        }
+        removed = true;
+        (_a = subscription === null || subscription === void 0 ? void 0 : subscription.remove) === null || _a === void 0 ? void 0 : _a.call(subscription);
+        deepLinkSubscriptions.delete(unsubscribe);
+    };
+    deepLinkSubscriptions.add(unsubscribe);
+    return unsubscribe;
+}
+async function initialize(config) {
+    // Checked here, before the native module sees anything: a missing key used to reach the
+    // native config builder, which threw across the Objective-C boundary and aborted the host
+    // app. Bad keys cost the app its Amply — never its process. The SDK stays uninitialized.
+    const missing = missingKey(config);
+    if (missing) {
+        const message = `[Amply] '${missing}' is required — Amply is not initialized. Copy it from your application's page in Amply.`;
+        console.error(message);
+        throw new AmplyConfigError(message);
+    }
+    // Set up debug log listener if debug mode is enabled
+    if (config.debug || config.logLevel) {
+        ensureDebugLogListener();
+    }
+    // Taken now, synchronously: a call made after this point is later than the config and must
+    // stay parked so it is applied after it.
+    const parked = takeParkedAppLanguage();
+    try {
+        await (0, nativeModule_1.default)().initialize(withParkedAppLanguage(config, parked));
+    }
+    catch (error) {
+        // A debug link parked for a failed start has nothing to open; replaying it later would
+        // surprise a retry that the user did not scan for.
+        parkedDebugUrl = null;
+        // Nothing reached the SDK, so the call still has to — unless a newer one replaced it.
+        if (parkedAppLanguage == null && isLatestLanguageWrite(parked)) {
+            parkedAppLanguage = parked;
+        }
+        throw error;
+    }
+    // A parked clear cannot travel in the config, where null means "leave it alone". Replayed only
+    // if nothing newer came in while initialize was in flight: the native SDK reports itself up
+    // before this promise settles, and a call made in that window has already reached it.
+    if ((parked === null || parked === void 0 ? void 0 : parked.tag) === null && !hasText(config.appLanguage) && isLatestLanguageWrite(parked)) {
+        (0, nativeModule_1.default)().setAppLanguage(null);
+    }
+    flushParkedAppLanguage();
+    flushParkedDebugUrl();
+    // Anything the host registered before this point was parked rather than lost.
+    replayPendingRegistrations();
+}
+/**
+ * A {@link setAppLanguage} call made before the SDK was up. Boxed so that a parked `null` — a
+ * request to return to automatic detection — is distinguishable from nothing parked.
+ *
+ * The native bridges buffer such calls too, but replay them AFTER building the SDK, which applies
+ * the config's `appLanguage` first. An earlier call would then overwrite a later config value,
+ * the opposite of "last write wins". Parking it here lets {@link initialize} put the two in the
+ * order they were made.
+ */
+let parkedAppLanguage = null;
+/** Bumped by every {@link setAppLanguage} call, whether it is forwarded or held. */
+let languageWriteSeq = 0;
+function isLatestLanguageWrite(write) {
+    return write != null && write.seq === languageWriteSeq;
+}
+function hasText(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function takeParkedAppLanguage() {
+    const parked = parkedAppLanguage;
+    parkedAppLanguage = null;
+    return parked;
+}
+/** The config's own appLanguage wins: initialize was called after the parked call. */
+function withParkedAppLanguage(config, parked) {
+    if (hasText(config.appLanguage) || parked == null || parked.tag === null) {
+        return config;
+    }
+    return { ...config, appLanguage: parked.tag };
+}
+function flushParkedAppLanguage() {
+    const parked = takeParkedAppLanguage();
+    if (isLatestLanguageWrite(parked)) {
+        (0, nativeModule_1.default)().setAppLanguage(parked.tag);
+    }
+}
+/**
+ * Tell Amply the language your app's UI is in, so sheets, stories and mini-apps show in the
+ * matching language and campaigns can target it. Use this when the app chooses its language
+ * itself (an in-app language picker, i18next, …) rather than following the device.
+ *
+ * Any common tag format works — `'pt_BR'`, `'pt-BR'`, `'zh-TW'`, `'fr'`, any case. A value that
+ * is not a language tag is ignored by the SDK with a warning log. The value is persisted across
+ * launches; pass `null` to return to automatic detection. The device language is never changed.
+ *
+ * Safe to call before {@link initialize}: the value is held and applied at initialization, and
+ * an `appLanguage` passed to a later `initialize` call wins over it.
+ * @param tag The language tag, or null to clear
+ */
+function setAppLanguage(tag) {
+    languageWriteSeq += 1;
+    if (isSdkUp()) {
+        (0, nativeModule_1.default)().setAppLanguage(tag);
+        return;
+    }
+    parkedAppLanguage = { tag, seq: languageWriteSeq };
+}
+/** A debug link that arrived before the SDK was up. At most one: a newer link replaces it. */
+let parkedDebugUrl = null;
+const URL_SCHEME_PREFIX = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//;
+const DEBUG_LINK_HOST = 'amply-debug';
+const DEBUG_LINK_PATH = '/campaign';
+const DEBUG_LINK_TOKEN_PARAM = 't';
+/**
+ * True for `<any scheme>://amply-debug/campaign?t=<non-empty>`. Parsed by hand, without decoding,
+ * so a malformed string is just "not a debug link" and can never throw.
+ */
+function isDebugLink(url) {
+    const scheme = URL_SCHEME_PREFIX.exec(url);
+    if (scheme == null) {
+        return false;
+    }
+    const rest = url.slice(scheme[0].length).split('#')[0];
+    const queryStart = rest.indexOf('?');
+    if (queryStart < 0) {
+        return false;
+    }
+    const target = rest.slice(0, queryStart);
+    const slash = target.indexOf('/');
+    if (slash < 0 || target.slice(0, slash) !== DEBUG_LINK_HOST) {
+        return false;
+    }
+    if (target.slice(slash).replace(/\/+$/, '') !== DEBUG_LINK_PATH) {
+        return false;
+    }
+    return rest
+        .slice(queryStart + 1)
+        .split('&')
+        .some(pair => {
+        const eq = pair.indexOf('=');
+        return eq > 0 && pair.slice(0, eq) === DEBUG_LINK_TOKEN_PARAM && eq < pair.length - 1;
+    });
+}
+function flushParkedDebugUrl() {
+    var _a, _b;
+    const url = parkedDebugUrl;
+    parkedDebugUrl = null;
+    if (url == null) {
+        return;
+    }
+    try {
+        (_b = (_a = (0, nativeModule_1.default)()).handleUrl) === null || _b === void 0 ? void 0 : _b.call(_a, url);
+    }
+    catch (error) {
+        console.warn('[Amply] Failed to replay a debug link parked until initialize', error);
+    }
+}
+/**
+ * Hand an incoming URL to Amply. Call it for every link your app is opened with — cold start
+ * and while running — before your own routing; when it returns `true` Amply recognised the
+ * link as its own and took it over, so your app should not route it.
+ *
+ * Safe to call before {@link initialize}, which is how a cold-start link arrives: an Amply debug
+ * link is held (the newest one) and opened once initialization succeeds, and `true` is returned.
+ *
+ * Synchronous. Returns `false` for any other URL, for a non-string, and when the installed
+ * native SDK predates this method; it never throws.
+ * @param url The full incoming URL
+ */
+function handleUrl(url) {
+    if (typeof url !== 'string') {
+        return false;
+    }
+    try {
+        if (!isSdkUp()) {
+            if (!isDebugLink(url)) {
+                return false;
+            }
+            parkedDebugUrl = url;
+            return true;
+        }
+        const nativeModule = (0, nativeModule_1.default)();
+        if (typeof nativeModule.handleUrl !== 'function') {
+            return false;
+        }
+        return nativeModule.handleUrl(url) === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Set the user ID for analytics. Pass null to clear.
+ * @param userId The user ID to set, or null to clear
+ */
+function setUserId(userId) {
+    (0, nativeModule_1.default)().setUserId(userId);
+}
+/**
+ * Set the log level at runtime.
+ * @param level The log level: 'none' | 'error' | 'warn' | 'info' | 'debug'
+ */
+function setLogLevel(level) {
+    if (level !== 'none') {
+        ensureDebugLogListener();
+    }
+    (0, nativeModule_1.default)().setLogLevel(level);
+}
+/**
+ * Get the current log level.
+ * @returns The current log level
+ */
+function getLogLevel() {
+    return (0, nativeModule_1.default)().getLogLevel();
+}
+function isInitialized() {
+    return (0, nativeModule_1.default)().isInitialized();
+}
+/**
+ * Records an event. Fire-and-forget: the promise resolves once the event has been handed
+ * to the native SDK, not when a campaign finishes. A campaign matched by this event runs
+ * on its own and never blocks the caller — use {@link trackGated} at a call site that has
+ * to wait for a campaign's outcome before continuing.
+ *
+ * {@link trackEvent} is the same call with positional arguments.
+ */
+async function track(payload) {
+    await (0, nativeModule_1.default)().track(payload);
+}
+/**
+ * Records an event — the positional-argument form of {@link track}, shaped like
+ * {@link trackGated} so gated and non-gated call sites read the same. Behaviour is
+ * identical to {@link track}: fire-and-forget, never blocks on a campaign.
+ *
+ * Both forms are supported; pick one and stay consistent within a codebase.
+ */
+async function trackEvent(event, properties) {
+    await (0, nativeModule_1.default)().track({ name: event, properties: properties !== null && properties !== void 0 ? properties : {} });
+}
+/**
+ * Gated track. Records the event; if a gate action matches AND a presenter is
+ * registered for its `baseUrl`, the SDK dispatches the presentation and awaits its
+ * outcome before resolving:
+ * - `{ outcome: 'proceed', reason: 'completed' }` — the presenter satisfied the gate.
+ * - `{ outcome: 'proceed', reason: 'failOpen' }` — no gate matched, not initialized,
+ *   timeout, unavailable, infra failure, or dismiss under `onAbort=proceed`.
+ * - `{ outcome: 'cancelled' }` — user dismiss under an `onAbort=cancel` gate.
+ *
+ * This NEVER rejects: any infra failure resolves to `{ outcome: 'proceed', reason:
+ * 'failOpen' }` so the caller is never stranded.
+ */
+async function trackGated(event, properties) {
+    const props = properties !== null && properties !== void 0 ? properties : {};
+    try {
+        const decision = (await (0, nativeModule_1.default)().trackGated(event, props));
+        if (decision && decision.outcome === 'cancelled') {
+            return { outcome: 'cancelled' };
+        }
+        if (decision && decision.outcome === 'proceed') {
+            const reason = decision.reason === 'completed' ? 'completed' : 'failOpen';
+            return { outcome: 'proceed', reason };
+        }
+        // Unexpected/malformed payload: fail open.
+        console.warn('[Amply] trackGated returned an unexpected decision; failing open', decision);
+        return { outcome: 'proceed', reason: 'failOpen' };
+    }
+    catch (error) {
+        // Fail open: any bridge/SDK failure must proceed, never strand the caller.
+        console.warn('[Amply] trackGated failed; proceeding (fail-open)', error);
+        return { outcome: 'proceed', reason: 'failOpen' };
+    }
+}
+function trackCampaignPresenterSubscription(subscription) {
+    let removed = false;
+    const unsubscribe = () => {
+        var _a;
+        if (removed) {
+            return;
+        }
+        removed = true;
+        (_a = subscription === null || subscription === void 0 ? void 0 : subscription.remove) === null || _a === void 0 ? void 0 : _a.call(subscription);
+        campaignPresenterSubscriptions.delete(unsubscribe);
+    };
+    campaignPresenterSubscriptions.add(unsubscribe);
+    return unsubscribe;
+}
+/**
+ * Register a gate presenter for a gate (blocking) action, keyed by its `baseUrl`.
+ * The presenter is invoked when a matching gate is dispatched; it receives the parsed
+ * query `params`, the enriched `info`, and a {@link GateResolution} it must resolve
+ * exactly once (`completed`/`dismissed`/`unavailable`). The SDK collapses multi-step
+ * ad lifecycles into the single result you report. A synchronous throw → `unavailable`
+ * (fail-open).
+ *
+ * One presenter per `baseUrl`: registering the same URL again REPLACES the previous
+ * presenter and re-applies the options, rather than adding a second one. Two presenters on
+ * one URL would both be handed the same presentation, so both would show UI and the outcome
+ * would be decided by whichever reported first.
+ *
+ * Safe to call before {@link initialize} — the registration is held and applied once the SDK
+ * is up. Withdrawing before then cancels it instead.
+ *
+ * @returns an unsubscribe function. It withdraws the NATIVE gate as well as this
+ * subscription; a gate left registered behind a departed presenter parks the next gated call
+ * on that URL for its whole fail-open timeout, silently.
+ */
+async function registerGate(baseUrl, presenter, opts) {
+    var _a, _b;
+    const onAbort = (_a = opts === null || opts === void 0 ? void 0 : opts.onAbort) !== null && _a !== void 0 ? _a : 'cancel';
+    const timeoutMs = (_b = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _b !== void 0 ? _b : 0;
+    const registrationId = nextGateRegistrationId++;
+    const attach = () => {
+        // Evict at APPLY time, not at call time. Two registrations made before `initialize` are
+        // both only queued, so a call-time eviction would find nothing in the registry to evict —
+        // and both would then attach at replay, the second overwriting the map entry while the
+        // first subscription stayed live. That is the duplicate-presenter defect on another path.
+        withdrawGate(baseUrl);
+        const nativeModule = (0, nativeModule_1.default)();
+        nativeModule.registerGate(baseUrl, onAbort, timeoutMs);
+        let subscription;
+        try {
+            subscription = nativeModule.onCampaignPresent((event) => {
+                const { url, params, info, mediationId } = event;
+                // The native side routes by baseUrl, but guard here too because every gate shares the
+                // single onCampaignPresent channel.
+                if (baseUrl && url && !url.startsWith(baseUrl)) {
+                    return;
+                }
+                let settled = false;
+                const report = (result) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    nativeModule.resolveCampaign(mediationId, result);
+                };
+                const resolution = {
+                    completed: () => report('Completed'),
+                    dismissed: () => report('Dismissed'),
+                    unavailable: () => report('Unavailable'),
+                };
+                try {
+                    presenter((params !== null && params !== void 0 ? params : {}), info, resolution);
+                }
+                catch (error) {
+                    // Presenter failure is an infra failure, never a user dismiss → Unavailable.
+                    console.warn('[Amply] gate presenter threw; reporting Unavailable (fail-open)', error);
+                    report('Unavailable');
+                }
+            });
+        }
+        catch (error) {
+            // The native gate is already registered at this point. Leaving it would be the exact
+            // defect this whole change exists to remove — a gate with no presenter behind it — and
+            // nothing would be tracked to withdraw it later, so withdraw it here.
+            console.warn('[Amply] Failed to subscribe a gate presenter; withdrawing the gate', error);
+            try {
+                nativeModule.unregisterGate(baseUrl);
+            }
+            catch (withdrawError) {
+                console.warn('[Amply] Failed to withdraw the gate after a failed subscribe', withdrawError);
+            }
+            throw error;
+        }
+        gateRegistrations.set(baseUrl, {
+            id: registrationId,
+            removeSubscription: () => { var _a; return (_a = subscription === null || subscription === void 0 ? void 0 : subscription.remove) === null || _a === void 0 ? void 0 : _a.call(subscription); },
+        });
+    };
+    const cancelPending = applyWhenSdkIsUp(attach);
+    let withdrawn = false;
+    const unsubscribe = () => {
+        if (withdrawn) {
+            return;
+        }
+        withdrawn = true;
+        cancelPending();
+        // Only if THIS registration still holds the URL — see withdrawGate.
+        withdrawGate(baseUrl, registrationId);
+        campaignPresenterSubscriptions.delete(unsubscribe);
+    };
+    campaignPresenterSubscriptions.add(unsubscribe);
+    return unsubscribe;
+}
+async function getRecentEvents(limit) {
+    return (0, nativeModule_1.default)().getRecentEvents(limit);
+}
+/**
+ * The campaign the user was most recently touched by — shown, or completed — at most `withinMs`
+ * ago, or `null` if there was none.
+ *
+ * Use it to attribute a purchase (or any conversion) in your own analytics to the campaign that
+ * preceded it, including one made from somewhere other than the campaign's link:
+ *
+ * ```ts
+ * const touch = await Amply.getLastCampaignTouch(30 * 60 * 1000);
+ * analytics.track('Purchase', {sku, amply_campaign_id: touch?.campaignId});
+ * ```
+ *
+ * One touch per campaign, the newer of a show and a completion. `withinMs` is inclusive and
+ * capped at 30 days by the SDK. Resolves `null` before {@link initialize}, while the SDK's storage
+ * is off, and if the native call fails — it rejects only for a `withinMs` that is not a finite
+ * number >= 0, which is a bug at the call site.
+ */
+async function getLastCampaignTouch(withinMs) {
+    (0, campaignTouch_1.assertValidWithinMs)(withinMs);
+    try {
+        return (0, campaignTouch_1.toCampaignTouch)(await (0, nativeModule_1.default)().getLastCampaignTouch(withinMs));
+    }
+    catch (error) {
+        // The SDK answers null for every state it can be in; a rejection here is the bridge itself
+        // failing, and an analytics lookup must never break the purchase flow that asked.
+        console.warn('[Amply] getLastCampaignTouch failed; resolving null', error);
+        return null;
+    }
+}
+async function getDataSetSnapshot(type) {
+    return (0, nativeModule_1.default)().getDataSetSnapshot(type);
+}
+async function addDeepLinkListener(listener) {
+    await ensureDeepLinkRegistration();
+    const subscription = (0, nativeModule_1.default)().onDeepLink(listener);
+    return trackDeepLinkSubscription(subscription);
+}
+async function addSystemEventListener(listener) {
+    return (0, systemEvents_1.addSystemEventListener)(listener);
+}
+/**
+ * Set a single custom property.
+ * @param key The property key (max 32 characters)
+ * @param value The property value (string max 255 characters)
+ */
+function setCustomProperty(key, value) {
+    (0, nativeModule_1.default)().setCustomProperties({ [key]: value });
+}
+/**
+ * Set multiple custom properties at once.
+ * @param properties Key-value map of properties to set
+ */
+function setCustomProperties(properties) {
+    (0, nativeModule_1.default)().setCustomProperties(properties);
+}
+/**
+ * Get a custom property value by key.
+ * @param key The property key
+ * @returns The property value, or null if not found
+ */
+async function getCustomProperty(key) {
+    var _a;
+    const result = await (0, nativeModule_1.default)().getCustomProperty(key);
+    const map = result;
+    return (_a = map.value) !== null && _a !== void 0 ? _a : null;
+}
+/**
+ * Remove a custom property by key.
+ * @param key The property key to remove
+ */
+function removeCustomProperty(key) {
+    (0, nativeModule_1.default)().removeCustomProperty(key);
+}
+/**
+ * Remove all custom properties.
+ */
+function clearCustomProperties() {
+    (0, nativeModule_1.default)().clearCustomProperties();
+}
+function removeAllListeners() {
+    deepLinkSubscriptions.forEach(unsubscribe => {
+        try {
+            unsubscribe();
+        }
+        catch (error) {
+            console.warn('[Amply] Failed to remove deep link listener', error);
+        }
+    });
+    deepLinkSubscriptions.clear();
+    campaignPresenterSubscriptions.forEach(unsubscribe => {
+        try {
+            unsubscribe();
+        }
+        catch (error) {
+            console.warn('[Amply] Failed to remove gate presenter', error);
+        }
+    });
+    campaignPresenterSubscriptions.clear();
+    // Each unsubscribe above withdraws its own gate. Anything still here was registered by a
+    // path that did not go through registerGate's tracker; withdraw it too rather than just
+    // forgetting it, which is what the old `registeredGates.clear()` did — leaving JS believing
+    // nothing was registered while the gates were still live natively.
+    Array.from(gateRegistrations.keys()).forEach(withdrawGate);
+    pendingRegistrations.length = 0;
+}
+function addSystemEventsListener(listener) {
+    return addSystemEventListener(listener);
+}
+exports.systemEvents = {
+    addListener: addSystemEventsListener,
+};
+exports.default = {
+    initialize,
+    isInitialized,
+    track,
+    trackEvent,
+    trackGated,
+    registerGate,
+    getRecentEvents,
+    getLastCampaignTouch,
+    getDataSetSnapshot,
+    addDeepLinkListener,
+    addSystemEventListener,
+    addSystemEventsListener,
+    removeAllListeners,
+    setUserId,
+    setAppLanguage,
+    handleUrl,
+    setLogLevel,
+    getLogLevel,
+    setCustomProperty,
+    setCustomProperties,
+    getCustomProperty,
+    removeCustomProperty,
+    clearCustomProperties,
+    systemEvents: exports.systemEvents,
+};
+//# sourceMappingURL=index.js.map