rn-prodeeplinks 0.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024
+
+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,330 @@
+# rn-prodeeplinks
+
+**PAID PACKAGE** - Secure deep linking package for React Native with license key validation and device fingerprinting.
+
+> ⚠️ **License Required**: This package requires a valid license key purchased from our portal. Without a license key, the package will not function.
+
+> ℹ️ **Versioning**: Current version is 0.0.1 (in-progress). It will move to 1.x after stable.
+
+## Features
+
+- 🔐 **License Key Protection** - Secure license key validation
+- 🔗 **Deep Link Management** - Server-side deep link URL management
+- 🛡️ **Code Protection** - Built-in protection against code extraction
+- ⚡ **Retry Mechanism** - Automatic retry with exponential backoff
+- 📊 **TypeScript Support** - Full TypeScript definitions included
+
+## Getting Started
+
+### Step 1: Purchase License Key
+
+Before using this package, you must purchase a license key from our portal. The license key will be provided after successful payment.
+
+### Step 2: Installation
+
+```bash
+npm install rn-prodeeplinks
+```
+
+### Step 3: Install Peer Dependencies
+
+This package requires the following peer dependencies:
+
+```bash
+npm install react-native-device-info @react-native-community/netinfo
+```
+
+## Usage
+### Deep Link Resolution Flow
+- First checks React Native Linking for an initial URL (if app opened via deep link).
+- If none, calls fingerprint-based API to resolve server-managed deep link.
+- If neither returns a URL, returns null.
+
+### Basic Usage
+
+```typescript
+import { init, getDeepLink } from 'rn-prodeeplinks';
+
+// Step 1: Initialize with your license key (obtained from our portal after payment)
+const initResult = await init({
+  licenseKey: 'your-license-key-from-portal' // REQUIRED: Purchase from our portal
+});
+
+if (!initResult.success) {
+  console.error('Initialization failed:', initResult.error);
+  return;
+}
+
+// Step 2: Get deep link URL (Linking-first, then API, else null)
+const result = await getDeepLink();
+
+if (result.success && result.url) {
+  // Use the URL for deep linking
+  console.log('Deep link URL:', result.url);
+  // Use Linking.openURL(result.url) or your preferred method
+} else {
+  // Either API error or flow returned null
+  console.log('No deep link available or error:', result.error);
+}
+```
+
+### Using Callback
+
+```typescript
+import { init, getDeepLink } from 'rn-prodeeplinks';
+
+// Initialize once
+await init({ licenseKey: 'your-license-key-here' });
+
+// Get deep link with callback
+getDeepLink((url) => {
+  console.log('Deep link URL:', url);
+  // Handle the deep link URL
+});
+```
+
+### Complete Example
+
+```typescript
+import { init, getDeepLink, isReady } from 'rn-prodeeplinks';
+import { Linking } from 'react-native';
+
+async function setupDeepLink() {
+  // Initialize with license key
+  const initResult = await init({
+    licenseKey: 'your-license-key-here'
+  });
+
+  if (!initResult.success) {
+    console.error('Failed to initialize:', initResult.error);
+    return;
+  }
+
+  // Check if ready
+  if (isReady()) {
+    // Get deep link
+    const result = await getDeepLink();
+    
+    if (result.success && result.url) {
+      // Open the deep link
+      await Linking.openURL(result.url);
+    } else {
+      // If null, there is no deep link to process
+      console.log('Deep link unavailable:', result.error);
+    }
+  }
+}
+```
+
+### Advanced Usage (Class-based - Optional)
+
+For advanced users who prefer class-based approach:
+
+```typescript
+import { ProDeepLink } from 'rn-prodeeplinks';
+
+const deepLink = new ProDeepLink({
+  licenseKey: 'your-license-key-here'
+});
+
+const result = await deepLink.getDeepLinkUrl();
+```
+
+## API Reference
+
+### Functions
+
+#### `init(config: InitConfig): Promise<{ success: boolean; error?: string }>`
+
+Initializes the package with your license key. This must be called before using `getDeepLink()`.
+
+**Parameters:**
+- `config.licenseKey` (string, required): Your license key from the portal
+
+**Returns:**
+```typescript
+{
+  success: boolean;
+  error?: string;
+}
+```
+
+**Example:**
+```typescript
+const result = await init({ licenseKey: 'your-license-key' });
+```
+
+#### `getDeepLink(callback?: (url: string) => void): Promise<DeepLinkResponse>`
+
+Fetches the deep link URL from the server.
+
+**Parameters:**
+- `callback` (optional): Callback function that receives the deep link URL when successful
+
+**Returns:**
+```typescript
+{
+  success: boolean;
+  url?: string | null;
+  message?: string;
+  error?: string;
+}
+```
+
+**Example:**
+```typescript
+// Using promise
+const result = await getDeepLink();
+
+// Using callback
+getDeepLink((url) => {
+  console.log('Deep link:', url);
+});
+```
+
+#### `isReady(): boolean`
+
+Checks if the package has been initialized with a license key.
+
+**Returns:** `boolean`
+
+#### `reset(): void`
+
+Resets/clears the stored license key. Useful for testing or logout scenarios.
+
+### ProDeepLink Class (Advanced - Optional)
+
+For users who prefer class-based approach:
+
+#### Constructor
+
+```typescript
+new ProDeepLink(config: InitConfig)
+```
+
+**Config Options:**
+- `licenseKey` (string, required): Your license key
+
+#### Methods
+
+##### `getDeepLinkUrl(): Promise<DeepLinkResponse>`
+
+Fetches the deep link URL from the server.
+
+## Security Features
+
+1. **License Key Protection** - Secure license key validation and obfuscation
+2. **Server-Side Validation** - All license validation happens on our secure server
+3. **Secure API Endpoint** - All communication happens through our encrypted API endpoint
+4. **Code Protection** - Built-in measures to prevent code extraction
+
+## License Key
+
+### Obtaining a License Key
+
+License keys are **NOT FREE**. You must:
+1. Visit our payment portal
+2. Complete the purchase process
+3. Receive your unique license key via email/portal
+4. Use the license key to initialize this package
+
+### License Validation
+
+- License keys are validated on **every API call** to our server
+- Invalid or expired license keys will result in API errors
+- License keys cannot be shared or reused without authorization
+
+### Custom License Validate API (Optional)
+For environments with a custom auth API, the license validate endpoint is:
+
+POST {{base_url}}{{api_prefix}}/custom-deep-link/license/validate
+
+Example (Postman):
+
+```
+POST '{{base_url}}{{api_prefix}}/custom-deep-link/license/validate'
+  --header 'Content-Type: application/json'
+  --body '{
+    "licenseKey": "{{license_key}}",
+    "domain": "acme.com",
+    "ipAddress": "103.21.149.10"
+  }'
+```
+
+This package exposes a helper to call this endpoint if needed. It does not interfere with the main deep link resolution flow.
+
+## Error Handling
+
+The package handles various error scenarios:
+
+- Invalid license key
+- Network timeouts
+- API errors
+
+All errors are returned in the `DeepLinkResponse` object with descriptive error messages.
+
+## TypeScript Support
+
+Full TypeScript definitions are included. Import types as needed:
+
+```typescript
+import { InitConfig, DeepLinkResponse } from 'rn-prodeeplinks';
+```
+
+**Available Types:**
+- `InitConfig` - Configuration for initialization
+- `DeepLinkResponse` - Response from getDeepLink()
+
+## Troubleshooting
+
+### License Key Errors
+
+If you receive license key errors:
+1. Ensure you've called `init()` before using `getDeepLink()`
+2. Check that the license key is valid on our portal
+3. Verify the license key hasn't expired
+4. Make sure you're using the correct license key
+
+### Network Errors
+
+If you encounter network errors:
+1. Check your internet connection
+2. Verify you have proper network permissions
+3. Check if our API endpoint is accessible from your network
+4. Try again after a few moments (automatic retry is built-in)
+
+### Initialization Errors
+
+If initialization fails:
+1. Make sure you're calling `init()` before `getDeepLink()`
+2. Verify the license key is correct
+3. Check that `isReady()` returns `true` before making API calls
+
+## Payment & Licensing
+
+This is a **paid package**. To use this package:
+
+1. **Purchase**: Visit our payment portal and purchase a license
+2. **Get License Key**: Receive your unique license key after payment
+3. **Use Package**: Initialize the package with your license key using `init()`
+4. **Server Validation**: Our server validates the license key on each request
+
+### Important Notes
+
+- ❌ **No license key = Package will not work**
+- ❌ **Invalid license key = API calls will fail**
+- ❌ **Expired license key = Access denied**
+- ❌ **Not initialized = getDeepLink() will fail**
+- ✅ **Valid license key + init() = Full access to all features**
+- ✅ **API endpoint = Managed by us (no setup required)**
+
+## Support
+
+For support regarding:
+- **License keys**: Contact our payment portal support
+- **Technical issues**: Check the documentation or contact technical support
+- **Payment issues**: Contact billing support
+
+## License
+
+This package is proprietary software. Unauthorized copying, distribution, or use without a valid license key is prohibited and may result in legal action.

package/lib/api.d.ts

@@ -0,0 +1,24 @@
+import { DeepLinkResponse, DeviceFingerprint, FingerprintMatchPayload, CustomDeepLinkAnalyticsEvent, LicenseValidationApiResponse, FingerprintMatchResponse } from './types';
+/**
+ * Call API to get deep link URL
+ * This function sends device fingerprint and license key to server
+ */
+export declare function fetchDeepLinkUrl(licenseKey: string, fingerprint: DeviceFingerprint, apiEndpoint?: string, timeout?: number): Promise<DeepLinkResponse>;
+/**
+ * Retry mechanism for API calls
+ */
+export declare function fetchDeepLinkUrlWithRetry(licenseKey: string, fingerprint: DeviceFingerprint, retryAttempts?: number, apiEndpoint?: string, timeout?: number): Promise<DeepLinkResponse>;
+export declare function validateLicenseCustom(licenseKey: string, opts?: {
+    baseUrl?: string;
+    apiPrefix?: string;
+    domain?: string;
+    ipAddress?: string;
+}): Promise<LicenseValidationApiResponse>;
+export declare function validateLicenseInit(licenseKey: string): Promise<{
+    success: boolean;
+    error?: string;
+    status?: number;
+    data?: LicenseValidationApiResponse;
+}>;
+export declare function matchFingerprintCustom(payload: FingerprintMatchPayload, baseUrl?: string): Promise<FingerprintMatchResponse>;
+export declare function trackCustomDeepLinkEvent(event: CustomDeepLinkAnalyticsEvent): Promise<any>;

package/lib/api.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDeepLinkUrl = fetchDeepLinkUrl;
+exports.fetchDeepLinkUrlWithRetry = fetchDeepLinkUrlWithRetry;
+exports.validateLicenseCustom = validateLicenseCustom;
+exports.validateLicenseInit = validateLicenseInit;
+exports.matchFingerprintCustom = matchFingerprintCustom;
+exports.trackCustomDeepLinkEvent = trackCustomDeepLinkEvent;
+const license_1 = require("./license");
+const DEFAULT_API_ENDPOINT = 'https://api.prodeeplink.com/v1/deeplink';
+const CUSTOM_API_BASE_URL = 'https://api.prodeeplinks.com';
+const ANALYTICS_ENDPOINT = 'https://s.finprim.com/custom-deep-link/track/event';
+/**
+ * Call API to get deep link URL
+ * This function sends device fingerprint and license key to server
+ */
+async function fetchDeepLinkUrl(licenseKey, fingerprint, apiEndpoint, timeout = 10000) {
+    const endpoint = apiEndpoint || DEFAULT_API_ENDPOINT;
+    try {
+        // Validate license key format first
+        const validation = (0, license_1.validateLicenseKeyFormat)(licenseKey);
+        if (!validation.isValid) {
+            return {
+                success: false,
+                error: validation.message || 'Invalid license key',
+            };
+        }
+        const PACKAGE_NAME = 'react-native-pro-deeplink';
+        const PACKAGE_VERSION = '0.0.1';
+        const payload = {
+            licenseKey,
+            fingerprint: fingerprint,
+            packageName: PACKAGE_NAME,
+            packageVersion: PACKAGE_VERSION,
+            timestamp: Date.now(),
+        };
+        // Make API call with timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const PACKAGE_NAME = 'react-native-pro-deeplink';
+            const PACKAGE_VERSION = '0.0.1';
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Package-Name': PACKAGE_NAME,
+                    'X-Package-Version': PACKAGE_VERSION,
+                },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                return {
+                    success: false,
+                    error: errorData.message || `API error: ${response.status}`,
+                };
+            }
+            const data = await response.json();
+            if (data.success && data.url) {
+                return {
+                    success: true,
+                    url: data.url,
+                    message: data.message,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: data.message || 'No URL returned from API',
+                };
+            }
+        }
+        catch (fetchError) {
+            clearTimeout(timeoutId);
+            if (fetchError.name === 'AbortError') {
+                return {
+                    success: false,
+                    error: 'Request timeout',
+                };
+            }
+            throw fetchError;
+        }
+    }
+    catch (error) {
+        console.error('Error fetching deep link URL:', error);
+        return {
+            success: false,
+            error: error.message || 'Failed to fetch deep link URL',
+        };
+    }
+}
+/**
+ * Retry mechanism for API calls
+ */
+async function fetchDeepLinkUrlWithRetry(licenseKey, fingerprint, retryAttempts = 3, apiEndpoint, timeout = 10000) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= retryAttempts; attempt++) {
+        const result = await fetchDeepLinkUrl(licenseKey, fingerprint, apiEndpoint, timeout);
+        if (result.success) {
+            return result;
+        }
+        lastError = result;
+        // Don't retry on license validation errors
+        if (result.error?.includes('license') || result.error?.includes('Invalid')) {
+            return result;
+        }
+        // Wait before retry (exponential backoff)
+        if (attempt < retryAttempts) {
+            await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+        }
+    }
+    return lastError || {
+        success: false,
+        error: 'Failed after retries',
+    };
+}
+async function validateLicenseCustom(licenseKey, opts) {
+    try {
+        const base = (opts?.baseUrl || '').trim();
+        const prefix = (opts?.apiPrefix || '').trim();
+        const endpoint = `${base}${prefix}/custom-deep-link/license/validate`;
+        const body = {
+            licenseKey,
+            domain: opts?.domain || '',
+            ipAddress: opts?.ipAddress || '',
+        };
+        const res = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const json = (await res.json().catch(() => ({})));
+        return json;
+    }
+    catch (e) {
+        return { success: false, error: e?.message || 'License validate failed' };
+    }
+}
+async function validateLicenseInit(licenseKey) {
+    try {
+        const endpoint = `${CUSTOM_API_BASE_URL}/custom-deep-link/license/validate`;
+        const res = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-license-key': licenseKey,
+            },
+            body: JSON.stringify({ licenseKey }),
+        });
+        const data = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            const message = data?.message || data?.error || 'License validation failed';
+            return { success: false, error: message, status: res.status, data };
+        }
+        if (!data.success || !data.valid) {
+            const message = data?.message || data?.error || 'License is not valid';
+            return { success: false, error: message, status: res.status, data };
+        }
+        return { success: true, status: res.status, data };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: e?.message || 'License validation request failed',
+        };
+    }
+}
+async function matchFingerprintCustom(payload, baseUrl) {
+    try {
+        const base = (baseUrl || CUSTOM_API_BASE_URL).trim().replace(/\/+$/, '');
+        const endpoint = `${base}/custom-deep-link/fingerprint/match`;
+        const res = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        const data = (await res.json().catch(() => ({})));
+        return data;
+    }
+    catch (e) {
+        return {
+            matched: false,
+            matchConfidence: 0,
+            ...(e ? { error: e?.message || 'Fingerprint match failed' } : {}),
+        };
+    }
+}
+async function trackCustomDeepLinkEvent(event) {
+    try {
+        const res = await fetch(ANALYTICS_ENDPOINT, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(event),
+        });
+        const data = await res.json().catch(() => ({}));
+        return data;
+    }
+    catch (e) {
+        return { success: false, error: e?.message || 'Analytics event tracking failed' };
+    }
+}

package/lib/fingerprint.d.ts

@@ -0,0 +1,6 @@
+import { DeviceFingerprint } from './types';
+/**
+ * Generate device fingerprint for deep link matching
+ * Collects all device information required for fingerprint matching
+ */
+export declare function generateDeviceFingerprint(): Promise<DeviceFingerprint>;

package/lib/fingerprint.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDeviceFingerprint = generateDeviceFingerprint;
+const react_native_device_info_1 = __importDefault(require("react-native-device-info"));
+const react_native_1 = require("react-native");
+const netinfo_1 = __importDefault(require("@react-native-community/netinfo"));
+/**
+ * Generate device fingerprint for deep link matching
+ * Collects all device information required for fingerprint matching
+ */
+async function generateDeviceFingerprint() {
+    try {
+        const { width, height } = react_native_1.Dimensions.get('window');
+        const screenResolution = `${width}x${height}`;
+        // Get device info
+        const deviceId = await react_native_device_info_1.default.getUniqueId();
+        const deviceModel = react_native_device_info_1.default.getModel();
+        const manufacturer = react_native_1.Platform.OS === 'android' ? await react_native_device_info_1.default.getManufacturer() : 'Apple';
+        const osVersion = react_native_device_info_1.default.getSystemVersion();
+        const appVersion = react_native_device_info_1.default.getVersion();
+        const buildNumber = react_native_device_info_1.default.getBuildNumber();
+        const isSimulator = await react_native_device_info_1.default.isEmulator();
+        const isRooted = react_native_1.Platform.OS === 'android'
+            ? (await (react_native_device_info_1.default.isDeviceRooted?.() ?? false))
+            : false;
+        // Get locale info
+        const locale = react_native_device_info_1.default.getDeviceLocale?.() || Intl.DateTimeFormat().resolvedOptions().locale;
+        const language = (locale || '').split('-')[0] || 'en';
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        // Get network info
+        const netInfo = await netinfo_1.default.fetch();
+        const connectionType = netInfo.type;
+        const carrier = react_native_1.Platform.OS === 'ios' ? await react_native_device_info_1.default.getCarrier() : undefined;
+        // Get IP address (if available)
+        let ipAddress;
+        try {
+            // Prefer device info API if available
+            ipAddress = await (react_native_device_info_1.default.getIpAddress?.() ?? undefined);
+            // Fallback to network info if not available
+            if (!ipAddress && netInfo.details && 'ipAddress' in netInfo.details) {
+                ipAddress = netInfo.details.ipAddress;
+            }
+        }
+        catch (error) {
+            console.warn('Could not get IP address:', error);
+        }
+        const fingerprint = {
+            platform: react_native_1.Platform.OS,
+            osVersion,
+            deviceId,
+            deviceModel,
+            manufacturer,
+            screenResolution,
+            screenWidth: width,
+            screenHeight: height,
+            timezone,
+            language,
+            locale,
+            appVersion: `${appVersion} (${buildNumber})`,
+            carrier,
+            connectionType: connectionType || undefined,
+            isSimulator,
+            isRooted,
+            ipAddress,
+        };
+        return fingerprint;
+    }
+    catch (error) {
+        console.error('Error generating device fingerprint:', error);
+        // Return minimal fingerprint on error
+        const { width, height } = react_native_1.Dimensions.get('window');
+        return {
+            platform: react_native_1.Platform.OS,
+            osVersion: react_native_1.Platform.Version.toString(),
+            deviceId: 'unknown',
+            deviceModel: 'unknown',
+            screenResolution: `${width}x${height}`,
+            screenWidth: width,
+            screenHeight: height,
+            appVersion: 'unknown',
+        };
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,68 @@
+import { InitConfig, DeepLinkResponse } from './types';
+/**
+ * Initialize the deep link package with license key
+ * This must be called before using getDeepLink()
+ *
+ * @param config - Configuration object containing license key
+ * @returns Object with success status and optional error message
+ *
+ * @example
+ * ```typescript
+ * import { init } from 'rn-prodeeplinks';
+ *
+ * const result = await init({ licenseKey: 'your-license-key-here' });
+ * if (result.success) {
+ *   console.log('Initialized successfully');
+ * }
+ * ```
+ */
+export declare function init(config: InitConfig): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Get deep link URL from server
+ * This function automatically handles device fingerprinting internally
+ *
+ * @param callback - Optional callback function that receives the deep link URL
+ * @returns Promise with deep link response
+ *
+ * @example
+ * ```typescript
+ * import { getDeepLink } from 'rn-prodeeplinks';
+ *
+ * // Using promise
+ * const result = await getDeepLink();
+ * if (result.success && result.url) {
+ *   console.log('Deep link:', result.url);
+ * }
+ *
+ * // Using callback
+ * getDeepLink((url) => {
+ *   console.log('Deep link:', url);
+ * });
+ * ```
+ */
+export declare function getDeepLink(callback?: (url: string) => void): Promise<DeepLinkResponse>;
+/**
+ * Check if the package is initialized
+ */
+export declare function isReady(): boolean;
+/**
+ * Reset/clear the stored license key
+ * Useful for testing or logout scenarios
+ */
+export declare function reset(): void;
+export type { InitConfig, DeepLinkResponse } from './types';
+export declare class ProDeepLink {
+    private licenseKey;
+    constructor(config: InitConfig);
+    getDeepLinkUrl(): Promise<DeepLinkResponse>;
+}
+declare const _default: {
+    init: typeof init;
+    getDeepLink: typeof getDeepLink;
+    isReady: typeof isReady;
+    reset: typeof reset;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProDeepLink = void 0;
+exports.init = init;
+exports.getDeepLink = getDeepLink;
+exports.isReady = isReady;
+exports.reset = reset;
+const fingerprint_1 = require("./fingerprint");
+const api_1 = require("./api");
+const license_1 = require("./license");
+const react_native_1 = require("react-native");
+// Global state to store license key and configuration
+let storedLicenseKey = null;
+let isInitialized = false;
+// Hardcoded API endpoint - user doesn't need to know about this
+const DEFAULT_API_ENDPOINT = 'https://api.prodeeplink.com/v1/deeplink';
+/**
+ * Initialize the deep link package with license key
+ * This must be called before using getDeepLink()
+ *
+ * @param config - Configuration object containing license key
+ * @returns Object with success status and optional error message
+ *
+ * @example
+ * ```typescript
+ * import { init } from 'rn-prodeeplinks';
+ *
+ * const result = await init({ licenseKey: 'your-license-key-here' });
+ * if (result.success) {
+ *   console.log('Initialized successfully');
+ * }
+ * ```
+ */
+async function init(config) {
+    try {
+        const validation = (0, license_1.validateLicenseKeyFormat)(config.licenseKey);
+        if (!validation.isValid) {
+            return {
+                success: false,
+                error: validation.message || 'Invalid license key',
+            };
+        }
+        const remoteValidation = await (0, api_1.validateLicenseInit)(config.licenseKey);
+        if (!remoteValidation.success) {
+            return {
+                success: false,
+                error: remoteValidation.error || 'License validation failed',
+            };
+        }
+        storedLicenseKey = config.licenseKey;
+        isInitialized = true;
+        return {
+            success: true,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to initialize',
+        };
+    }
+}
+/**
+ * Get deep link URL from server
+ * This function automatically handles device fingerprinting internally
+ *
+ * @param callback - Optional callback function that receives the deep link URL
+ * @returns Promise with deep link response
+ *
+ * @example
+ * ```typescript
+ * import { getDeepLink } from 'rn-prodeeplinks';
+ *
+ * // Using promise
+ * const result = await getDeepLink();
+ * if (result.success && result.url) {
+ *   console.log('Deep link:', result.url);
+ * }
+ *
+ * // Using callback
+ * getDeepLink((url) => {
+ *   console.log('Deep link:', url);
+ * });
+ * ```
+ */
+async function getDeepLink(callback) {
+    // Check if initialized
+    if (!isInitialized || !storedLicenseKey) {
+        return {
+            success: false,
+            error: 'Please call init() first with your license key',
+        };
+    }
+    try {
+        // First: try to read deep link via Linking (if app opened by URL)
+        const initialUrl = await react_native_1.Linking.getInitialURL();
+        if (initialUrl) {
+            if (callback)
+                callback(initialUrl);
+            return { success: true, url: initialUrl };
+        }
+        // Generate device fingerprint internally (user doesn't need to know about this)
+        const fingerprint = await (0, fingerprint_1.generateDeviceFingerprint)();
+        // Fetch deep link URL from API with retry mechanism
+        const result = await (0, api_1.fetchDeepLinkUrlWithRetry)(storedLicenseKey, fingerprint, 3, // retry attempts
+        DEFAULT_API_ENDPOINT);
+        // Call callback if provided and result is successful
+        if (callback && result.success && result.url) {
+            callback(result.url);
+        }
+        // If API didn't return a usable URL, return null as per requirements
+        if (!result.success || !result.url) {
+            return { success: true, url: null, message: 'No deep link available' };
+        }
+        return result;
+    }
+    catch (error) {
+        console.error('Error in getDeepLink:', error);
+        return {
+            success: false,
+            error: error.message || 'Unknown error occurred',
+        };
+    }
+}
+/**
+ * Check if the package is initialized
+ */
+function isReady() {
+    return isInitialized && storedLicenseKey !== null;
+}
+/**
+ * Reset/clear the stored license key
+ * Useful for testing or logout scenarios
+ */
+function reset() {
+    storedLicenseKey = null;
+    isInitialized = false;
+}
+// Keep backward compatibility - export class for advanced users (optional)
+class ProDeepLink {
+    constructor(config) {
+        const validation = (0, license_1.validateLicenseKeyFormat)(config.licenseKey);
+        if (!validation.isValid) {
+            throw new Error(validation.message || 'Invalid license key');
+        }
+        this.licenseKey = config.licenseKey;
+    }
+    async getDeepLinkUrl() {
+        const remoteValidation = await (0, api_1.validateLicenseInit)(this.licenseKey);
+        if (!remoteValidation.success) {
+            return {
+                success: false,
+                error: remoteValidation.error || 'License validation failed',
+            };
+        }
+        const fingerprint = await (0, fingerprint_1.generateDeviceFingerprint)();
+        return await (0, api_1.fetchDeepLinkUrlWithRetry)(this.licenseKey, fingerprint, 3, DEFAULT_API_ENDPOINT);
+    }
+}
+exports.ProDeepLink = ProDeepLink;
+// Export default
+exports.default = { init, getDeepLink, isReady, reset };

package/lib/license.d.ts

@@ -0,0 +1,2 @@
+import { LicenseValidationResult } from './types';
+export declare function validateLicenseKeyFormat(licenseKey: string): LicenseValidationResult;

package/lib/license.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLicenseKeyFormat = validateLicenseKeyFormat;
+function validateLicenseKeyFormat(licenseKey) {
+    if (!licenseKey || typeof licenseKey !== 'string' || !licenseKey.trim()) {
+        return {
+            isValid: false,
+            message: 'License key is required',
+        };
+    }
+    return {
+        isValid: true,
+    };
+}

package/lib/types.d.ts

@@ -0,0 +1,158 @@
+export interface DeviceFingerprint {
+    platform: 'ios' | 'android';
+    osVersion: string;
+    deviceId: string;
+    deviceModel: string;
+    manufacturer?: string;
+    screenResolution: string;
+    screenWidth: number;
+    screenHeight: number;
+    timezone?: string;
+    language?: string;
+    locale?: string;
+    appVersion: string;
+    carrier?: string;
+    connectionType?: string;
+    isSimulator?: boolean;
+    isRooted?: boolean;
+    ipAddress?: string;
+}
+export interface InitConfig {
+    licenseKey: string;
+    apiBaseUrl?: string;
+    apiPrefix?: string;
+    domain?: string;
+}
+export interface DeepLinkConfig {
+    licenseKey: string;
+    apiEndpoint: string;
+    timeout?: number;
+    retryAttempts?: number;
+}
+export interface DeepLinkResponse {
+    success: boolean;
+    url?: string | null;
+    message?: string;
+    error?: string;
+}
+export interface LicenseValidationResult {
+    isValid: boolean;
+    message?: string;
+}
+export interface FingerprintBasicPayload {
+    userAgent: string;
+    language: string;
+    platform: string;
+    screenResolution: string;
+    timezone: string;
+    timezoneOffset: number;
+}
+export interface FingerprintNetworkPayload {
+    ipAddress: string;
+    connectionType: string;
+}
+export interface FingerprintDevicePayload {
+    deviceModel: string;
+    osVersion: string;
+    appVersion: string;
+}
+export interface FingerprintMatchPayload {
+    basic: FingerprintBasicPayload;
+    network: FingerprintNetworkPayload;
+    device: FingerprintDevicePayload;
+    userId?: string;
+}
+export interface CustomDeepLinkAnalyticsDeviceInfo {
+    userAgent?: string;
+    language?: string;
+    screenResolution?: string;
+    platform?: string;
+    [key: string]: any;
+}
+export interface CustomDeepLinkAnalyticsEvent {
+    licenseKey: string;
+    eventType: string;
+    eventName: string;
+    category?: string;
+    action?: string;
+    label?: string;
+    value?: number;
+    properties?: {
+        [key: string]: any;
+    };
+    sessionId?: string;
+    userId?: string;
+    pageUrl?: string;
+    pageTitle?: string;
+    deviceInfo?: CustomDeepLinkAnalyticsDeviceInfo;
+    [key: string]: any;
+}
+export interface LicenseFeatures {
+    maxLinksPerMonth: number;
+    maxDomains: number;
+    analyticsLevel: string;
+    customBranding: boolean;
+    webhookSupport: boolean;
+    whiteLabel: boolean;
+    apiAccess: boolean;
+    rateLimitPerMinute: number;
+    [key: string]: any;
+}
+export interface LicenseUsageCurrentMonth {
+    linksCreated: number;
+    clicks: number;
+    apiCalls: number;
+    lastReset: string;
+    [key: string]: any;
+}
+export interface LicenseUsage {
+    totalLinksCreated: number;
+    totalClicks: number;
+    totalApiCalls: number;
+    currentMonth: LicenseUsageCurrentMonth;
+    [key: string]: any;
+}
+export interface LicenseData {
+    tier: string;
+    features: LicenseFeatures;
+    validUntil: string;
+    usage: LicenseUsage;
+    [key: string]: any;
+}
+export interface LicenseValidationApiResponse {
+    success: boolean;
+    valid?: boolean;
+    data?: LicenseData;
+    [key: string]: any;
+}
+export interface FingerprintMatchInstallInfo {
+    _id: string;
+    linkId: string;
+    installedAt: string;
+    timeToInstall: number;
+    [key: string]: any;
+}
+export interface DeepLinkContextMetadata {
+    title?: string;
+    description?: string;
+    imageUrl?: string;
+    [key: string]: any;
+}
+export interface DeepLinkContext {
+    action: string;
+    resourceId?: string;
+    params?: {
+        [key: string]: any;
+    };
+    metadata?: DeepLinkContextMetadata;
+    campaign?: string;
+    source?: string;
+    [key: string]: any;
+}
+export interface FingerprintMatchResponse {
+    matched: boolean;
+    matchConfidence?: number;
+    install?: FingerprintMatchInstallInfo;
+    deepLinkContext?: DeepLinkContext;
+    [key: string]: any;
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "rn-prodeeplinks",
+  "version": "0.0.1",
+  "description": "Secure deep linking package with license key validation and device fingerprinting for React Native",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "react-native",
+    "deeplink",
+    "deep-link",
+    "device-fingerprint",
+    "license",
+    "secure",
+    "authentication"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "react-native": ">=0.60.0",
+    "react-native-device-info": "^10.0.0",
+    "@react-native-community/netinfo": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/react-native": "^0.72.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/2ndGenTech/rn-prodeeplinks.git"
+  }
+}