deep-link-expo 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,70 @@
+## 1.6.0 (2026-06-10)
+
+* feat(sdk): report SDK name + version (SIT-235 · Expo) (#5) ([554b45d](https://github.com/LinkForty/mobile-sdk-expo/commit/554b45d)), closes [#5](https://github.com/LinkForty/mobile-sdk-expo/issues/5)
+
+## 1.5.0 (2026-06-10)
+
+* feat: port last-click attribution + autoTrackNavigation to the Expo SDK (SIT-237) (#4) ([418c160](https://github.com/LinkForty/mobile-sdk-expo/commit/418c160)), closes [#4](https://github.com/LinkForty/mobile-sdk-expo/issues/4)
+
+## 1.4.0 (2026-05-04)
+
+* feat: add appToken config option for Cloud organic-install attribution (#1) ([8261ca4](https://github.com/LinkForty/mobile-sdk-expo/commit/8261ca4)), closes [#1](https://github.com/LinkForty/mobile-sdk-expo/issues/1) [LinkForty/cloud#76](https://github.com/LinkForty/cloud/issues/76)
+* ci: drop flaky 'npm install -g npm@latest' self-upgrade step (#2) ([f1cebdd](https://github.com/LinkForty/mobile-sdk-expo/commit/f1cebdd)), closes [#2](https://github.com/LinkForty/mobile-sdk-expo/issues/2) [#1](https://github.com/LinkForty/mobile-sdk-expo/issues/1)
+* update packages ([334885e](https://github.com/LinkForty/mobile-sdk-expo/commit/334885e))
+
+## 1.3.0 (2026-04-01)
+
+* feat: add webFallbackUrl to CreateLinkOptions ([d96c7ae](https://github.com/LinkForty/mobile-sdk-expo/commit/d96c7ae))
+
+## 1.2.0 (2026-03-17)
+
+* ci: add semantic-release with OIDC trusted publishing to npm ([05c7918](https://github.com/LinkForty/mobile-sdk-expo/commit/05c7918))
+* feat: add setExternalUserId for SDK-level user attribution ([f555707](https://github.com/LinkForty/mobile-sdk-expo/commit/f555707))
+* chore: add .claude/ to gitignore ([4c6aade](https://github.com/LinkForty/mobile-sdk-expo/commit/4c6aade))
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.0] - 2026-03-03
+### Added
+- `externalUserId` option in `CreateLinkOptions` — identifies the app user creating the link, enabling per-user deduplication and share attribution
+- `deduplicated` boolean in `CreateLinkResult` — indicates when an existing link was returned instead of creating a new one (per-user deduplication)
+
+## [1.0.3] - 2026-02-27
+### Changed
+- Optimized README and npm package description for LLM discoverability
+- Added competitor positioning keywords and cross-SDK references
+- Added `firebase-dynamic-links` npm keyword
+
+## [1.0.2] - 2026-02-27
+### Fixed
+- Corrected GitHub repository, bugs, and homepage URLs in package.json
+
+## [1.0.1] - 2026-02-26
+### Added
+- `llms.txt` — LLM-optimized integration reference shipped with the published package, enabling AI coding assistants to generate accurate integration code directly from node_modules
+
+## [1.0.0] - 2026-02-16
+
+### Added
+- Initial release of the LinkForty Expo SDK
+- Initialization with config validation (HTTPS enforcement, attribution window bounds)
+- Deferred deep linking (install attribution via device fingerprinting)
+- Direct deep linking with multiple callback support
+- Server-side URL resolution with fingerprint query parameters
+- Event tracking with install ID correlation
+- Revenue tracking (`trackRevenue`)
+- Programmatic link creation (simplified + dashboard endpoints)
+- Attribution data access (`getInstallId`, `getInstallData`, `isFirstLaunch`)
+- Persistent offline event queue (AsyncStorage-backed, max 100 events, FIFO)
+- Manual queue management (`flushEvents`, `clearEventQueue`, `queuedEventCount`)
+- Data management (`clearData`, `reset`)
+- Typed error handling (`LinkFortyError` with `LinkFortyErrorCode` enum)
+- Network retry with exponential backoff (3 attempts, 1s/2s/4s, no retry on 4xx)
+- Debug logging via `debug` config flag
+- Pure Expo module dependencies (no native linking required)
+- Comprehensive Vitest test suite (119 tests)

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Parth24072001
+Copyright (c) 2026 LinkForty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# deep-link-expo
+
+Expo SDK for the [deep-link](https://github.com/Parth24072001/deep-link) self-hosted service. Add deferred deep linking, install attribution, and short-link routing to an Expo app. Pure Expo modules — no native linking required.
+
+[![npm version](https://img.shields.io/npm/v/deep-link-expo.svg)](https://www.npmjs.com/package/deep-link-expo)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Install
+
+```bash
+npx expo install deep-link-expo expo-device expo-application expo-localization expo-linking @react-native-async-storage/async-storage
+```
+
+Or with npm:
+
+```bash
+npm install deep-link-expo
+npx expo install expo-device expo-application expo-localization expo-linking @react-native-async-storage/async-storage
+```
+
+## Quick start
+
+Create an app in the dashboard, copy the four values from the overview page, then initialize once at startup:
+
+```typescript
+import DeepLink from 'deep-link-expo';
+
+const response = await DeepLink.initialize({
+  baseUrl: 'https://go.yourdomain.com',
+  linkPathPrefix: '/your-app-prefix',
+  apiKey: 'pk_live_xxxxxxxx',          // publishable key only
+  appToken: 'your-app-id',             // dashboard App ID
+  debug: __DEV__,
+  attributionWindowHours: 168,
+});
+
+if (response.attributed) {
+  console.log('Install attributed', response.deepLinkData);
+}
+
+DeepLink.onDeferredDeepLink((data) => {
+  if (data) {
+    // First open after install
+  }
+});
+
+DeepLink.onDeepLink((url, data) => {
+  // App already installed, user tapped a link
+});
+```
+
+Use the publishable key (`pk_…`) in the mobile app. Never put the secret key (`sk_…`) in the client.
+
+## What the SDK sends
+
+On install/resolve the SDK reports a device fingerprint used for deferred matching: IP (server-side), user agent, timezone, language, screen size, and platform. Tracked events include the event name plus any properties you pass. Nothing is sent to a third-party analytics vendor — only to the `baseUrl` you configure.
+
+## Features
+
+- Deferred deep linking (install attribution via device fingerprinting)
+- Direct deep linking with server-side URL resolution
+- Event tracking with an offline queue (persists across app restarts)
+- Revenue tracking
+- Programmatic link creation (publishable or secret key, depending on your server policy)
+- Pure Expo modules (`expo-device`, `expo-application`, `expo-localization`, `expo-linking`)
+
+## API
+
+```typescript
+await DeepLink.initialize(config);
+DeepLink.isInitialized;
+
+DeepLink.onDeferredDeepLink(callback);
+DeepLink.onDeepLink(callback);
+DeepLink.handleDeepLink(url);
+
+await DeepLink.trackEvent(name, properties?);
+await DeepLink.trackRevenue(amount, currency, properties?);
+await DeepLink.flushEvents();
+await DeepLink.clearEventQueue();
+DeepLink.queuedEventCount;
+
+await DeepLink.getInstallId();
+await DeepLink.getInstallData();
+await DeepLink.isFirstLaunch();
+await DeepLink.clearData();
+DeepLink.reset();
+```
+
+### Automatic screen tracking
+
+```typescript
+import { createNavigationContainerRef } from '@react-navigation/native';
+
+export const navigationRef = createNavigationContainerRef();
+
+await DeepLink.initialize({
+  baseUrl: 'https://go.yourdomain.com',
+  linkPathPrefix: '/your-app-prefix',
+  autoTrackNavigation: true,
+  navigationRef,
+});
+```
+
+Route params are off by default. To capture specific non-PII params:
+
+```typescript
+autoTrackNavigation: { captureParams: ['productId', 'category'] }
+```
+
+### Link creation
+
+```typescript
+const result = await DeepLink.createLink({
+  deepLinkParameters: { route: 'PRODUCT', id: '123' },
+  title: 'Check out this product',
+});
+console.log(result.url);
+```
+
+## Configuration
+
+| Field | Required | Default | Description |
+|---|---|---|---|
+| `baseUrl` | yes | — | Your deep-link server origin (`https://…`, HTTP only for localhost) |
+| `linkPathPrefix` | recommended | — | Per-app path from the dashboard (e.g. `/mQuDYblrf6`) |
+| `apiKey` | for link create | — | Publishable API key (`pk_…`) |
+| `appToken` | recommended | — | Dashboard App ID |
+| `debug` | no | `false` | Verbose logging |
+| `attributionWindowHours` | no | `168` | 1–2160 hours |
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Support
+
+Issues: [github.com/Parth24072001/deep-link](https://github.com/Parth24072001/deep-link/issues)

package/dist/attribution/attribution-context.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AttributionContext — last-click attribution + session tracking (SIT-237).
+ *
+ * Mirrors the React Native SDK. Every deep-link open (deferred install OR direct
+ * re-engagement) pins an active attribution context to THAT link; the newest
+ * open supersedes the previous one. Every tracked event is stamped with the
+ * active context + a session id so the backend can credit the link under a
+ * last-click + window model. The active context is persisted so a reopen without
+ * a new click still attributes to the last link; the session is in-memory (a cold
+ * start is a new session).
+ *
+ * Uses AsyncStorage directly (not StorageManager) to stay self-contained.
+ */
+import type { ActiveAttribution, AttributionStamp } from '../models/attribution';
+export declare class AttributionContext {
+    private active;
+    private sessionId;
+    private loaded;
+    constructor();
+    /** Restore the persisted active context. Idempotent; never throws. */
+    load(): Promise<void>;
+    /**
+     * Record a deep-link open. Newest open supersedes (last-click) and starts a new
+     * session. No-op when no `linkId` is known (organic open).
+     */
+    recordDeepLinkOpen(linkId?: string | null, clickId?: string | null): Promise<void>;
+    /** Fields to merge into every event payload. */
+    getStamp(): AttributionStamp;
+    getSessionId(): string;
+    getActive(): ActiveAttribution | null;
+    /** Clear the persisted context and start a fresh session. */
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=attribution-context.d.ts.map

package/dist/attribution/attribution-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribution-context.d.ts","sourceRoot":"","sources":["../../src/attribution/attribution-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAejF,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAS;;IAOvB,sEAAsE;IAChE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAa3B;;;OAGG;IACG,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBxF,gDAAgD;IAChD,QAAQ,IAAI,gBAAgB;IAS5B,YAAY,IAAI,MAAM;IAItB,SAAS,IAAI,iBAAiB,GAAG,IAAI;IAIrC,6DAA6D;IACvD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAS7B"}

package/dist/attribution/attribution-context.js

@@ -0,0 +1,98 @@
+/**
+ * AttributionContext — last-click attribution + session tracking (SIT-237).
+ *
+ * Mirrors the React Native SDK. Every deep-link open (deferred install OR direct
+ * re-engagement) pins an active attribution context to THAT link; the newest
+ * open supersedes the previous one. Every tracked event is stamped with the
+ * active context + a session id so the backend can credit the link under a
+ * last-click + window model. The active context is persisted so a reopen without
+ * a new click still attributes to the last link; the session is in-memory (a cold
+ * start is a new session).
+ *
+ * Uses AsyncStorage directly (not StorageManager) to stay self-contained.
+ */
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { STORAGE_KEYS } from '../storage/storage-keys';
+import { logger } from '../logger';
+/**
+ * RFC4122-v4-style id for session grouping. Not a security token — `Math.random`
+ * is sufficient and avoids a native crypto dependency.
+ */
+function generateSessionId() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+export class AttributionContext {
+    active = null;
+    sessionId;
+    loaded = false;
+    constructor() {
+        // Construction == cold start == a new session.
+        this.sessionId = generateSessionId();
+    }
+    /** Restore the persisted active context. Idempotent; never throws. */
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const raw = await AsyncStorage.getItem(STORAGE_KEYS.ATTRIBUTION);
+            if (raw) {
+                this.active = JSON.parse(raw);
+            }
+        }
+        catch (e) {
+            logger.warn('Failed to load attribution context:', e);
+        }
+        this.loaded = true;
+    }
+    /**
+     * Record a deep-link open. Newest open supersedes (last-click) and starts a new
+     * session. No-op when no `linkId` is known (organic open).
+     */
+    async recordDeepLinkOpen(linkId, clickId) {
+        if (!linkId)
+            return;
+        this.active = {
+            linkId,
+            clickId: clickId ?? undefined,
+            openedAt: new Date().toISOString(),
+        };
+        this.sessionId = generateSessionId();
+        try {
+            await AsyncStorage.setItem(STORAGE_KEYS.ATTRIBUTION, JSON.stringify(this.active));
+        }
+        catch (e) {
+            logger.warn('Failed to persist attribution context:', e);
+        }
+        logger.log('Attribution context set:', this.active, 'session:', this.sessionId);
+    }
+    /** Fields to merge into every event payload. */
+    getStamp() {
+        return {
+            attributedLinkId: this.active?.linkId,
+            attributedClickId: this.active?.clickId,
+            linkOpenedAt: this.active?.openedAt,
+            sessionId: this.sessionId,
+        };
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getActive() {
+        return this.active;
+    }
+    /** Clear the persisted context and start a fresh session. */
+    async clear() {
+        this.active = null;
+        this.sessionId = generateSessionId();
+        try {
+            await AsyncStorage.removeItem(STORAGE_KEYS.ATTRIBUTION);
+        }
+        catch (e) {
+            logger.warn('Failed to clear attribution context:', e);
+        }
+    }
+}

package/dist/attribution/attribution-manager.d.ts

@@ -0,0 +1,18 @@
+import type { FingerprintCollectorProtocol } from '../fingerprint/fingerprint-collector';
+import type { NetworkManagerProtocol } from '../network/network-manager';
+import type { StorageManagerProtocol } from '../storage/storage-manager';
+import type { InstallAttributionResponse } from '../models/install-response';
+import type { DeepLinkData } from '../models/deep-link-data';
+export declare class AttributionManager {
+    private readonly network;
+    private readonly storage;
+    private readonly fingerprint;
+    constructor(network: NetworkManagerProtocol, storage: StorageManagerProtocol, fingerprint: FingerprintCollectorProtocol);
+    reportInstall(attributionWindowHours: number, deviceId?: string, appToken?: string): Promise<InstallAttributionResponse>;
+    getInstallId(): Promise<string | null>;
+    getInstallData(): Promise<DeepLinkData | null>;
+    isFirstLaunch(): Promise<boolean>;
+    clearData(): Promise<void>;
+    private buildCachedResponse;
+}
+//# sourceMappingURL=attribution-manager.d.ts.map

package/dist/attribution/attribution-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribution-manager.d.ts","sourceRoot":"","sources":["../../src/attribution/attribution-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AACzF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;gBAGzD,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,4BAA4B;IAOrC,aAAa,CACjB,sBAAsB,EAAE,MAAM,EAC9B,QAAQ,CAAC,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,0BAA0B,CAAC;IAqEhC,YAAY,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAItC,cAAc,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAI9C,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;YAKlB,mBAAmB;CAYlC"}

package/dist/attribution/attribution-manager.js

@@ -0,0 +1,94 @@
+import { logger } from '../logger';
+import { SDK_NAME, SDK_VERSION } from '../version';
+export class AttributionManager {
+    network;
+    storage;
+    fingerprint;
+    constructor(network, storage, fingerprint) {
+        this.network = network;
+        this.storage = storage;
+        this.fingerprint = fingerprint;
+    }
+    async reportInstall(attributionWindowHours, deviceId, appToken) {
+        const isFirst = await this.storage.isFirstLaunch();
+        if (!isFirst) {
+            return this.buildCachedResponse();
+        }
+        const fp = this.fingerprint.collect(attributionWindowHours, deviceId);
+        logger.log('Reporting install with fingerprint:', fp);
+        let response;
+        try {
+            response = await this.network.request('/api/sdk/v1/install', {
+                method: 'POST',
+                // appToken (when provided) lets Cloud scope organic installs
+                // to the right workspace. Omitted from the body when undefined.
+                // sdkName/sdkVersion (SIT-235) identify the SDK for health diagnostics.
+                body: JSON.stringify({
+                    ...fp,
+                    ...(appToken ? { appToken } : {}),
+                    sdkName: SDK_NAME,
+                    sdkVersion: SDK_VERSION,
+                }),
+            });
+        }
+        catch (e) {
+            logger.error('Failed to report install:', e);
+            // Treat as organic on failure
+            await this.storage.setHasLaunched();
+            return {
+                installId: '',
+                attributed: false,
+                confidenceScore: 0,
+                matchedFactors: [],
+                deepLinkData: null,
+            };
+        }
+        logger.log('Install response:', response);
+        // Cache install ID
+        if (response.installId) {
+            await this.storage.saveInstallId(response.installId);
+        }
+        // Cache deep link data if attributed
+        if (response.attributed && response.deepLinkData) {
+            // Normalize deepLinkParameters -> customParameters
+            const deepLinkData = {
+                ...response.deepLinkData,
+                customParameters: response.deepLinkData
+                    .deepLinkParameters ?? response.deepLinkData.customParameters,
+            };
+            await this.storage.saveInstallData(deepLinkData);
+            logger.log('Install attributed with confidence:', response.confidenceScore);
+            // Return with normalized data
+            response = { ...response, deepLinkData };
+        }
+        else {
+            logger.log('Organic install (no attribution)');
+        }
+        await this.storage.setHasLaunched();
+        return response;
+    }
+    async getInstallId() {
+        return this.storage.getInstallId();
+    }
+    async getInstallData() {
+        return this.storage.getInstallData();
+    }
+    async isFirstLaunch() {
+        return this.storage.isFirstLaunch();
+    }
+    async clearData() {
+        await this.storage.clearAll();
+        logger.log('Attribution data cleared');
+    }
+    async buildCachedResponse() {
+        const installId = await this.storage.getInstallId();
+        const deepLinkData = await this.storage.getInstallData();
+        return {
+            installId: installId ?? '',
+            attributed: deepLinkData !== null,
+            confidenceScore: deepLinkData ? 100 : 0,
+            matchedFactors: [],
+            deepLinkData,
+        };
+    }
+}

package/dist/deeplink/deep-link-handler.d.ts

@@ -0,0 +1,43 @@
+import type { FingerprintCollectorProtocol } from '../fingerprint/fingerprint-collector';
+import type { NetworkManagerProtocol } from '../network/network-manager';
+import type { DeepLinkData } from '../models/deep-link-data';
+export type DeferredDeepLinkCallback = (deepLinkData: DeepLinkData | null) => void;
+export type DeepLinkCallback = (url: string, deepLinkData: DeepLinkData | null) => void;
+export declare class DeepLinkHandler {
+    private baseUrl;
+    private network;
+    private fingerprint;
+    private linkPathPrefix;
+    private deferredCallbacks;
+    private deepLinkCallbacks;
+    private deferredDelivered;
+    private cachedDeferredData;
+    private subscription;
+    constructor(baseUrl: string, network: NetworkManagerProtocol, fingerprint: FingerprintCollectorProtocol, linkPathPrefix?: string);
+    /**
+     * Start listening for deep links via expo-linking.
+     */
+    startListening(): void;
+    /**
+     * Manually pass a deep link URL.
+     */
+    handleDeepLink(url: string): void;
+    /**
+     * Register a deferred deep link callback.
+     * If data was already delivered, calls back immediately.
+     */
+    onDeferredDeepLink(callback: DeferredDeepLinkCallback): void;
+    /**
+     * Register a direct deep link callback. Multiple callbacks supported.
+     */
+    onDeepLink(callback: DeepLinkCallback): void;
+    /**
+     * Deliver deferred deep link data (called by SDK after install attribution).
+     */
+    deliverDeferredDeepLink(data: DeepLinkData | null): void;
+    clearCallbacks(): void;
+    cleanup(): void;
+    private handleUrl;
+    private resolveUrl;
+}
+//# sourceMappingURL=deep-link-handler.d.ts.map

package/dist/deeplink/deep-link-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-link-handler.d.ts","sourceRoot":"","sources":["../../src/deeplink/deep-link-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AACzF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D,MAAM,MAAM,wBAAwB,GAAG,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC;AACnF,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC;AAExF,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,WAAW,CAA+B;IAClD,OAAO,CAAC,cAAc,CAAqB;IAE3C,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,iBAAiB,CAA0B;IACnD,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,YAAY,CAAmC;gBAGrD,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,sBAAsB,EAC/B,WAAW,EAAE,4BAA4B,EACzC,cAAc,CAAC,EAAE,MAAM;IAQzB;;OAEG;IACH,cAAc,IAAI,IAAI;IAiBtB;;OAEG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIjC;;;OAGG;IACH,kBAAkB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI;IAQ5D;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAI5C;;OAEG;IACH,uBAAuB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI;IAUxD,cAAc,IAAI,IAAI;IAOtB,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,SAAS;YAuBH,UAAU;CAyCzB"}