deep-link-expo 1.0.0

package/dist/deeplink/deep-link-handler.js

@@ -0,0 +1,150 @@
+import * as Linking from 'expo-linking';
+import { parseDeepLinkUrl, parseUrlString, buildQueryString } from './url-parser';
+import { logger } from '../logger';
+export class DeepLinkHandler {
+    baseUrl;
+    network;
+    fingerprint;
+    linkPathPrefix;
+    deferredCallbacks = [];
+    deepLinkCallbacks = [];
+    deferredDelivered = false;
+    cachedDeferredData = null;
+    subscription = null;
+    constructor(baseUrl, network, fingerprint, linkPathPrefix) {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.network = network;
+        this.fingerprint = fingerprint;
+        this.linkPathPrefix = linkPathPrefix?.replace(/^\/+|\/+$/g, '') || undefined;
+    }
+    /**
+     * Start listening for deep links via expo-linking.
+     */
+    startListening() {
+        this.subscription = Linking.addEventListener('url', (event) => {
+            this.handleUrl(event.url);
+        });
+        // Check if app was opened via deep link
+        Linking.getInitialURL()
+            .then((url) => {
+            if (url) {
+                this.handleUrl(url);
+            }
+        })
+            .catch((e) => {
+            logger.warn('Failed to get initial URL:', e);
+        });
+    }
+    /**
+     * Manually pass a deep link URL.
+     */
+    handleDeepLink(url) {
+        this.handleUrl(url);
+    }
+    /**
+     * Register a deferred deep link callback.
+     * If data was already delivered, calls back immediately.
+     */
+    onDeferredDeepLink(callback) {
+        this.deferredCallbacks.push(callback);
+        if (this.deferredDelivered) {
+            callback(this.cachedDeferredData);
+        }
+    }
+    /**
+     * Register a direct deep link callback. Multiple callbacks supported.
+     */
+    onDeepLink(callback) {
+        this.deepLinkCallbacks.push(callback);
+    }
+    /**
+     * Deliver deferred deep link data (called by SDK after install attribution).
+     */
+    deliverDeferredDeepLink(data) {
+        this.cachedDeferredData = data;
+        this.deferredDelivered = true;
+        logger.log('Delivering deferred deep link:', data?.shortCode ?? 'organic');
+        for (const cb of this.deferredCallbacks) {
+            cb(data);
+        }
+    }
+    clearCallbacks() {
+        this.deferredCallbacks = [];
+        this.deepLinkCallbacks = [];
+        this.deferredDelivered = false;
+        this.cachedDeferredData = null;
+    }
+    cleanup() {
+        this.subscription?.remove();
+        this.subscription = null;
+        this.clearCallbacks();
+    }
+    handleUrl(url) {
+        if (!url || this.deepLinkCallbacks.length === 0)
+            return;
+        logger.log('Handling deep link:', url);
+        // Parse locally first as fallback
+        const localData = parseDeepLinkUrl(url, this.baseUrl);
+        // If this is a LinkForty URL, try server-side resolution
+        if (localData && url.startsWith(this.baseUrl)) {
+            this.resolveUrl(url)
+                .then((resolvedData) => {
+                const data = resolvedData ?? localData;
+                for (const cb of this.deepLinkCallbacks)
+                    cb(url, data);
+            })
+                .catch(() => {
+                for (const cb of this.deepLinkCallbacks)
+                    cb(url, localData);
+            });
+        }
+        else {
+            for (const cb of this.deepLinkCallbacks)
+                cb(url, localData);
+        }
+    }
+    async resolveUrl(url) {
+        const parsed = parseUrlString(url);
+        if (!parsed)
+            return null;
+        const pathSegments = parsed.pathname.split('/').filter(Boolean);
+        if (pathSegments.length === 0)
+            return null;
+        let resolvePath;
+        if (this.linkPathPrefix && pathSegments[0] === this.linkPathPrefix && pathSegments[1]) {
+            resolvePath = `/api/sdk/v1/resolve/${pathSegments[0]}/${pathSegments[1]}`;
+        }
+        else if (pathSegments.length >= 2) {
+            resolvePath = `/api/sdk/v1/resolve/${pathSegments[0]}/${pathSegments[1]}`;
+        }
+        else if (this.linkPathPrefix) {
+            resolvePath = `/api/sdk/v1/resolve/${this.linkPathPrefix}/${pathSegments[0]}`;
+        }
+        else {
+            resolvePath = `/api/sdk/v1/resolve/${pathSegments[0]}`;
+        }
+        // Collect fingerprint for click attribution
+        try {
+            const fp = this.fingerprint.collect(168);
+            const fpParams = {
+                fp_tz: fp.timezone,
+                fp_lang: fp.language,
+                fp_sw: String(fp.screenWidth),
+                fp_sh: String(fp.screenHeight),
+                fp_platform: fp.platform,
+                fp_pv: fp.platformVersion,
+            };
+            resolvePath += `?${buildQueryString(fpParams)}`;
+        }
+        catch (e) {
+            logger.warn('Fingerprint collection failed, resolving without fingerprint:', e);
+        }
+        try {
+            return await this.network.request(resolvePath);
+        }
+        catch (e) {
+            logger.warn('Server-side resolution failed:', e);
+            return null;
+        }
+    }
+}

package/dist/deeplink/url-parser.d.ts

@@ -0,0 +1,13 @@
+import type { DeepLinkData } from '../models/deep-link-data';
+interface ParsedUrl {
+    pathname: string;
+    searchParams: Map<string, string>;
+}
+/**
+ * Hermes-safe URL parsing (URL.pathname may throw "not implemented" in Hermes).
+ */
+export declare function parseUrlString(url: string): ParsedUrl | null;
+export declare function buildQueryString(params: Record<string, string>): string;
+export declare function parseDeepLinkUrl(url: string, baseUrl?: string): DeepLinkData | null;
+export {};
+//# sourceMappingURL=url-parser.d.ts.map

package/dist/deeplink/url-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-parser.d.ts","sourceRoot":"","sources":["../../src/deeplink/url-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAmC5D;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAIvE;AAID,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAuCnF"}

package/dist/deeplink/url-parser.js

@@ -0,0 +1,92 @@
+/**
+ * Hermes-safe URL parsing (URL.pathname may throw "not implemented" in Hermes).
+ */
+export function parseUrlString(url) {
+    try {
+        const protocolEnd = url.indexOf('://');
+        if (protocolEnd === -1)
+            return null;
+        const afterProtocol = url.substring(protocolEnd + 3);
+        const pathStart = afterProtocol.indexOf('/');
+        const pathAndQuery = pathStart === -1 ? '/' : afterProtocol.substring(pathStart);
+        const hashIndex = pathAndQuery.indexOf('#');
+        const withoutHash = hashIndex === -1 ? pathAndQuery : pathAndQuery.substring(0, hashIndex);
+        const queryStart = withoutHash.indexOf('?');
+        const pathname = queryStart === -1 ? withoutHash : withoutHash.substring(0, queryStart);
+        const queryString = queryStart === -1 ? '' : withoutHash.substring(queryStart + 1);
+        const searchParams = new Map();
+        if (queryString) {
+            for (const pair of queryString.split('&')) {
+                const eqIndex = pair.indexOf('=');
+                if (eqIndex === -1) {
+                    searchParams.set(decodeURIComponent(pair), '');
+                }
+                else {
+                    searchParams.set(decodeURIComponent(pair.substring(0, eqIndex)), decodeURIComponent(pair.substring(eqIndex + 1)));
+                }
+            }
+        }
+        return { pathname, searchParams };
+    }
+    catch {
+        return null;
+    }
+}
+export function buildQueryString(params) {
+    return Object.entries(params)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .join('&');
+}
+const UTM_KEYS = new Set(['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content']);
+export function parseDeepLinkUrl(url, baseUrl) {
+    // If baseUrl is set, only parse URLs matching it
+    if (baseUrl && !url.startsWith(baseUrl)) {
+        return null;
+    }
+    const parsed = parseUrlString(url);
+    if (!parsed)
+        return null;
+    const pathSegments = parsed.pathname.split('/').filter(Boolean);
+    const shortCode = pathSegments[pathSegments.length - 1];
+    if (!shortCode)
+        return null;
+    // Extract UTM parameters
+    const utmParameters = {};
+    let hasUtm = false;
+    for (const [key, value] of parsed.searchParams) {
+        if (key === 'utm_source') {
+            utmParameters.source = value;
+            hasUtm = true;
+        }
+        else if (key === 'utm_medium') {
+            utmParameters.medium = value;
+            hasUtm = true;
+        }
+        else if (key === 'utm_campaign') {
+            utmParameters.campaign = value;
+            hasUtm = true;
+        }
+        else if (key === 'utm_term') {
+            utmParameters.term = value;
+            hasUtm = true;
+        }
+        else if (key === 'utm_content') {
+            utmParameters.content = value;
+            hasUtm = true;
+        }
+    }
+    // Extract custom (non-UTM) parameters
+    const customParameters = {};
+    let hasCustom = false;
+    for (const [key, value] of parsed.searchParams) {
+        if (!UTM_KEYS.has(key)) {
+            customParameters[key] = value;
+            hasCustom = true;
+        }
+    }
+    return {
+        shortCode,
+        utmParameters: hasUtm ? utmParameters : undefined,
+        customParameters: hasCustom ? customParameters : undefined,
+    };
+}

package/dist/errors/linkforty-error.d.ts

@@ -0,0 +1,26 @@
+export declare enum LinkFortyErrorCode {
+    NOT_INITIALIZED = "NOT_INITIALIZED",
+    ALREADY_INITIALIZED = "ALREADY_INITIALIZED",
+    INVALID_CONFIGURATION = "INVALID_CONFIGURATION",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    INVALID_RESPONSE = "INVALID_RESPONSE",
+    DECODING_ERROR = "DECODING_ERROR",
+    INVALID_EVENT_DATA = "INVALID_EVENT_DATA",
+    INVALID_DEEP_LINK_URL = "INVALID_DEEP_LINK_URL",
+    MISSING_API_KEY = "MISSING_API_KEY"
+}
+export declare class LinkFortyError extends Error {
+    readonly code: LinkFortyErrorCode;
+    readonly cause?: Error;
+    constructor(code: LinkFortyErrorCode, message: string, cause?: Error);
+    static notInitialized(): LinkFortyError;
+    static alreadyInitialized(): LinkFortyError;
+    static invalidConfiguration(detail: string): LinkFortyError;
+    static networkError(cause: Error): LinkFortyError;
+    static invalidResponse(statusCode: number, message?: string): LinkFortyError;
+    static decodingError(cause: Error): LinkFortyError;
+    static invalidEventData(detail: string): LinkFortyError;
+    static invalidDeepLinkUrl(detail: string): LinkFortyError;
+    static missingApiKey(): LinkFortyError;
+}
+//# sourceMappingURL=linkforty-error.d.ts.map

package/dist/errors/linkforty-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkforty-error.d.ts","sourceRoot":"","sources":["../../src/errors/linkforty-error.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,eAAe,oBAAoB;IACnC,mBAAmB,wBAAwB;IAC3C,qBAAqB,0BAA0B;IAC/C,aAAa,kBAAkB;IAC/B,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,kBAAkB,uBAAuB;IACzC,qBAAqB,0BAA0B;IAC/C,eAAe,oBAAoB;CACpC;AAED,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;gBAEX,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;IAOpE,MAAM,CAAC,cAAc,IAAI,cAAc;IAOvC,MAAM,CAAC,kBAAkB,IAAI,cAAc;IAO3C,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc;IAO3D,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc;IAQjD,MAAM,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,cAAc;IAQ5E,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc;IAQlD,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc;IAOvD,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc;IAOzD,MAAM,CAAC,aAAa,IAAI,cAAc;CAMvC"}

package/dist/errors/linkforty-error.js

@@ -0,0 +1,50 @@
+export var LinkFortyErrorCode;
+(function (LinkFortyErrorCode) {
+    LinkFortyErrorCode["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+    LinkFortyErrorCode["ALREADY_INITIALIZED"] = "ALREADY_INITIALIZED";
+    LinkFortyErrorCode["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
+    LinkFortyErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+    LinkFortyErrorCode["INVALID_RESPONSE"] = "INVALID_RESPONSE";
+    LinkFortyErrorCode["DECODING_ERROR"] = "DECODING_ERROR";
+    LinkFortyErrorCode["INVALID_EVENT_DATA"] = "INVALID_EVENT_DATA";
+    LinkFortyErrorCode["INVALID_DEEP_LINK_URL"] = "INVALID_DEEP_LINK_URL";
+    LinkFortyErrorCode["MISSING_API_KEY"] = "MISSING_API_KEY";
+})(LinkFortyErrorCode || (LinkFortyErrorCode = {}));
+export class LinkFortyError extends Error {
+    code;
+    cause;
+    constructor(code, message, cause) {
+        super(message);
+        this.name = 'LinkFortyError';
+        this.code = code;
+        this.cause = cause;
+    }
+    static notInitialized() {
+        return new LinkFortyError(LinkFortyErrorCode.NOT_INITIALIZED, 'LinkForty SDK is not initialized. Call initialize() first.');
+    }
+    static alreadyInitialized() {
+        return new LinkFortyError(LinkFortyErrorCode.ALREADY_INITIALIZED, 'LinkForty SDK has already been initialized.');
+    }
+    static invalidConfiguration(detail) {
+        return new LinkFortyError(LinkFortyErrorCode.INVALID_CONFIGURATION, `Invalid configuration: ${detail}`);
+    }
+    static networkError(cause) {
+        return new LinkFortyError(LinkFortyErrorCode.NETWORK_ERROR, `Network error: ${cause.message}`, cause);
+    }
+    static invalidResponse(statusCode, message) {
+        const detail = message ? `: ${message}` : '';
+        return new LinkFortyError(LinkFortyErrorCode.INVALID_RESPONSE, `Invalid server response (status: ${statusCode})${detail}`);
+    }
+    static decodingError(cause) {
+        return new LinkFortyError(LinkFortyErrorCode.DECODING_ERROR, `Failed to decode response: ${cause.message}`, cause);
+    }
+    static invalidEventData(detail) {
+        return new LinkFortyError(LinkFortyErrorCode.INVALID_EVENT_DATA, `Invalid event data: ${detail}`);
+    }
+    static invalidDeepLinkUrl(detail) {
+        return new LinkFortyError(LinkFortyErrorCode.INVALID_DEEP_LINK_URL, `Invalid deep link URL: ${detail}`);
+    }
+    static missingApiKey() {
+        return new LinkFortyError(LinkFortyErrorCode.MISSING_API_KEY, 'API key is required for this operation. Provide an apiKey in the config.');
+    }
+}

package/dist/events/event-queue.d.ts

@@ -0,0 +1,14 @@
+import type { EventRequest } from '../models/event-request';
+export declare class EventQueue {
+    private queue;
+    private loaded;
+    load(): Promise<void>;
+    enqueue(event: EventRequest): Promise<boolean>;
+    dequeue(): Promise<EventRequest | null>;
+    peek(): Promise<EventRequest[]>;
+    clear(): Promise<void>;
+    get count(): number;
+    get isEmpty(): boolean;
+    private persist;
+}
+//# sourceMappingURL=event-queue.d.ts.map

package/dist/events/event-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-queue.d.ts","sourceRoot":"","sources":["../../src/events/event-queue.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAM5D,qBAAa,UAAU;IACrB,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,MAAM,CAAS;IAEjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAcrB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAY9C,OAAO,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAQvC,IAAI,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAK/B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;YAEa,OAAO;CAOtB"}

package/dist/events/event-queue.js

@@ -0,0 +1,68 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { STORAGE_KEYS } from '../storage/storage-keys';
+import { logger } from '../logger';
+const MAX_QUEUE_SIZE = 100;
+export class EventQueue {
+    queue = [];
+    loaded = false;
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const json = await AsyncStorage.getItem(STORAGE_KEYS.EVENT_QUEUE);
+            if (json) {
+                this.queue = JSON.parse(json);
+            }
+        }
+        catch (e) {
+            logger.error('Failed to load event queue:', e);
+            this.queue = [];
+        }
+        this.loaded = true;
+    }
+    async enqueue(event) {
+        await this.load();
+        if (this.queue.length >= MAX_QUEUE_SIZE) {
+            logger.log('Event queue full, dropping event:', event.eventName);
+            return false;
+        }
+        this.queue.push(event);
+        await this.persist();
+        logger.log(`Event queued: ${event.eventName} (queue size: ${this.queue.length})`);
+        return true;
+    }
+    async dequeue() {
+        await this.load();
+        if (this.queue.length === 0)
+            return null;
+        const event = this.queue.shift();
+        await this.persist();
+        return event;
+    }
+    async peek() {
+        await this.load();
+        return [...this.queue];
+    }
+    async clear() {
+        const size = this.queue.length;
+        this.queue = [];
+        await this.persist();
+        if (size > 0) {
+            logger.log(`Event queue cleared (${size} events removed)`);
+        }
+    }
+    get count() {
+        return this.queue.length;
+    }
+    get isEmpty() {
+        return this.queue.length === 0;
+    }
+    async persist() {
+        try {
+            await AsyncStorage.setItem(STORAGE_KEYS.EVENT_QUEUE, JSON.stringify(this.queue));
+        }
+        catch (e) {
+            logger.error('Failed to persist event queue:', e);
+        }
+    }
+}

package/dist/events/event-tracker.d.ts

@@ -0,0 +1,18 @@
+import type { NetworkManagerProtocol } from '../network/network-manager';
+import type { StorageManagerProtocol } from '../storage/storage-manager';
+import type { AttributionContext } from '../attribution/attribution-context';
+import { EventQueue } from './event-queue';
+export declare class EventTracker {
+    private readonly network;
+    private readonly storage;
+    private readonly queue;
+    private readonly attribution?;
+    constructor(network: NetworkManagerProtocol, storage: StorageManagerProtocol, queue?: EventQueue, attribution?: AttributionContext);
+    trackEvent(name: string, properties?: Record<string, unknown>): Promise<void>;
+    trackRevenue(amount: number, currency: string, properties?: Record<string, unknown>): Promise<void>;
+    flushQueue(): Promise<void>;
+    clearQueue(): Promise<void>;
+    get queuedEventCount(): number;
+    private sendEvent;
+}
+//# sourceMappingURL=event-tracker.d.ts.map

package/dist/events/event-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-tracker.d.ts","sourceRoot":"","sources":["../../src/events/event-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAEzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAqB;gBAGhD,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,sBAAsB,EAC/B,KAAK,CAAC,EAAE,UAAU,EAClB,WAAW,CAAC,EAAE,kBAAkB;IAQ5B,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAsC7E,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,OAAO,CAAC,IAAI,CAAC;IAcV,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB3B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,IAAI,gBAAgB,IAAI,MAAM,CAE7B;YAEa,SAAS;CAMxB"}

package/dist/events/event-tracker.js

@@ -0,0 +1,92 @@
+import { EventQueue } from './event-queue';
+import { LinkFortyError } from '../errors/linkforty-error';
+import { logger } from '../logger';
+import { SDK_NAME, SDK_VERSION } from '../version';
+export class EventTracker {
+    network;
+    storage;
+    queue;
+    attribution;
+    constructor(network, storage, queue, attribution) {
+        this.network = network;
+        this.storage = storage;
+        this.queue = queue ?? new EventQueue();
+        this.attribution = attribution;
+    }
+    async trackEvent(name, properties) {
+        if (!name || !name.trim()) {
+            throw LinkFortyError.invalidEventData('Event name cannot be empty');
+        }
+        const installId = await this.storage.getInstallId();
+        if (!installId) {
+            throw LinkFortyError.notInitialized();
+        }
+        // Stamp the event with the active last-click attribution + session so it can
+        // be credited to the originating deep link. Stamped at event time, so a
+        // queued event keeps its point-in-time attribution.
+        const event = {
+            installId,
+            eventName: name,
+            eventData: properties ?? {},
+            timestamp: new Date().toISOString(),
+            ...this.attribution?.getStamp(),
+            // SDK identity for health/version diagnostics (SIT-235)
+            sdkName: SDK_NAME,
+            sdkVersion: SDK_VERSION,
+        };
+        try {
+            await this.sendEvent(event);
+            logger.log('Event tracked:', name);
+            // If send succeeds, try to flush queued events
+            await this.flushQueue();
+        }
+        catch (e) {
+            // Queue the event on failure
+            await this.queue.enqueue(event);
+            logger.log('Event queued due to error:', e);
+            throw e;
+        }
+    }
+    async trackRevenue(amount, currency, properties) {
+        if (amount < 0) {
+            throw LinkFortyError.invalidEventData('Revenue amount must be non-negative');
+        }
+        const eventProperties = {
+            ...properties,
+            revenue: amount,
+            currency,
+        };
+        await this.trackEvent('revenue', eventProperties);
+    }
+    async flushQueue() {
+        await this.queue.load();
+        logger.log(`Flushing event queue (${this.queue.count} events)`);
+        while (!this.queue.isEmpty) {
+            const event = await this.queue.dequeue();
+            if (!event)
+                break;
+            try {
+                await this.sendEvent(event);
+                logger.log('Queued event sent:', event.eventName);
+            }
+            catch (e) {
+                // Re-queue the event and stop flushing
+                await this.queue.enqueue(event);
+                logger.log('Failed to send queued event:', e);
+                return;
+            }
+        }
+    }
+    async clearQueue() {
+        await this.queue.clear();
+    }
+    get queuedEventCount() {
+        return this.queue.count;
+    }
+    async sendEvent(event) {
+        await this.network.request('/api/sdk/v1/event', {
+            method: 'POST',
+            body: JSON.stringify(event),
+        });
+    }
+}

package/dist/fingerprint/fingerprint-collector.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceFingerprint } from '../models/device-fingerprint';
+export interface FingerprintCollectorProtocol {
+    collect(attributionWindowHours: number, deviceId?: string): DeviceFingerprint;
+}
+export declare class FingerprintCollector implements FingerprintCollectorProtocol {
+    collect(attributionWindowHours: number, deviceId?: string): DeviceFingerprint;
+}
+//# sourceMappingURL=fingerprint-collector.d.ts.map

package/dist/fingerprint/fingerprint-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint-collector.d.ts","sourceRoot":"","sources":["../../src/fingerprint/fingerprint-collector.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,MAAM,WAAW,4BAA4B;IAC3C,OAAO,CAAC,sBAAsB,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAC;CAC/E;AAED,qBAAa,oBAAqB,YAAW,4BAA4B;IACvE,OAAO,CAAC,sBAAsB,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,iBAAiB;CAuB9E"}

package/dist/fingerprint/fingerprint-collector.js

@@ -0,0 +1,27 @@
+import * as Device from 'expo-device';
+import * as Application from 'expo-application';
+import { getLocales, getCalendars } from 'expo-localization';
+import { Platform, Dimensions } from 'react-native';
+export class FingerprintCollector {
+    collect(attributionWindowHours, deviceId) {
+        const { width, height } = Dimensions.get('window');
+        const locales = getLocales();
+        const calendars = getCalendars();
+        const appName = Application.applicationName ?? 'App';
+        const appVersion = Application.nativeApplicationVersion ?? '1.0.0';
+        const platform = Platform.OS;
+        const platformVersion = Device.osVersion ?? '0';
+        return {
+            userAgent: `${appName}/${appVersion} ${platform}/${platformVersion}`,
+            timezone: calendars[0]?.timeZone ?? 'UTC',
+            language: locales[0]?.languageTag ?? 'en-US',
+            screenWidth: Math.round(width),
+            screenHeight: Math.round(height),
+            platform,
+            platformVersion,
+            appVersion,
+            deviceId,
+            attributionWindowHours,
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { default } from './linkforty-sdk';
+export { default as DeepLink } from './linkforty-sdk';
+export { LinkFortySDK } from './linkforty-sdk';
+export { LinkFortyError, LinkFortyErrorCode } from './errors/linkforty-error';
+export type { LinkFortyConfig, AutoTrackNavigationOptions, NavigationRouteLike, NavigationContainerRefLike, } from './models/config';
+export type { DeepLinkData } from './models/deep-link-data';
+export type { InstallAttributionResponse } from './models/install-response';
+export type { UTMParameters } from './models/utm-parameters';
+export type { DeviceFingerprint } from './models/device-fingerprint';
+export type { CreateLinkOptions } from './models/create-link-options';
+export type { CreateLinkResult } from './models/create-link-result';
+export type { EventRequest } from './models/event-request';
+export type { ActiveAttribution, AttributionStamp } from './models/attribution';
+export { AttributionContext } from './attribution/attribution-context';
+export { NavigationTracker, sanitizeScreenParams } from './navigation/navigation-tracker';
+export type { ScreenEventEmitter, NavigationTrackerOptions, } from './navigation/navigation-tracker';
+export type { DeferredDeepLinkCallback, DeepLinkCallback } from './deeplink/deep-link-handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9E,YAAY,EACV,eAAe,EACf,0BAA0B,EAC1B,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,YAAY,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,YAAY,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,YAAY,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAC1F,YAAY,EACV,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AAEzC,YAAY,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { default } from './linkforty-sdk';
+export { default as DeepLink } from './linkforty-sdk';
+export { LinkFortySDK } from './linkforty-sdk';
+export { LinkFortyError, LinkFortyErrorCode } from './errors/linkforty-error';
+export { AttributionContext } from './attribution/attribution-context';
+export { NavigationTracker, sanitizeScreenParams } from './navigation/navigation-tracker';