@linkforty/mobile-sdk-react-native 1.0.0

package/dist/LinkFortySDK.js

@@ -0,0 +1,258 @@
+/**
+ * LinkFortySDK - Main SDK class for LinkForty deep linking and attribution
+ */
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { FingerprintCollector } from './FingerprintCollector';
+import { DeepLinkHandler } from './DeepLinkHandler';
+const STORAGE_KEYS = {
+    INSTALL_ID: '@linkforty:install_id',
+    INSTALL_DATA: '@linkforty:install_data',
+    FIRST_LAUNCH: '@linkforty:first_launch',
+};
+export class LinkFortySDK {
+    config = null;
+    deepLinkHandler = null;
+    deferredDeepLinkCallback = null;
+    installId = null;
+    initialized = false;
+    /**
+     * Initialize the SDK
+     */
+    async init(config) {
+        if (this.initialized) {
+            console.warn('LinkForty SDK already initialized');
+            return;
+        }
+        this.config = config;
+        if (config.debug) {
+            console.log('[LinkForty] Initializing SDK with config:', config);
+        }
+        // Check if this is first launch
+        const isFirstLaunch = await this.isFirstLaunch();
+        if (isFirstLaunch) {
+            // Report install and get deferred deep link
+            await this.reportInstall();
+        }
+        else {
+            // Load cached install data
+            await this.loadInstallData();
+        }
+        // Initialize deep link handler for direct deep links
+        this.deepLinkHandler = new DeepLinkHandler();
+        this.initialized = true;
+        if (config.debug) {
+            console.log('[LinkForty] SDK initialized successfully');
+        }
+    }
+    /**
+     * Get install attribution data (deferred deep link)
+     */
+    async getInstallData() {
+        const cached = await AsyncStorage.getItem(STORAGE_KEYS.INSTALL_DATA);
+        if (cached) {
+            return JSON.parse(cached);
+        }
+        return null;
+    }
+    /**
+     * Register callback for deferred deep links (new installs)
+     */
+    onDeferredDeepLink(callback) {
+        this.deferredDeepLinkCallback = callback;
+        // If we already have install data, call the callback immediately
+        this.getInstallData().then((data) => {
+            if (data && this.deferredDeepLinkCallback) {
+                this.deferredDeepLinkCallback(data);
+            }
+        });
+    }
+    /**
+     * Register callback for direct deep links (existing users)
+     */
+    onDeepLink(callback) {
+        if (!this.config) {
+            throw new Error('SDK not initialized. Call init() first.');
+        }
+        if (!this.deepLinkHandler) {
+            this.deepLinkHandler = new DeepLinkHandler();
+        }
+        this.deepLinkHandler.initialize(this.config.baseUrl, callback);
+    }
+    /**
+     * Track in-app event
+     */
+    async trackEvent(name, properties) {
+        if (!this.config) {
+            throw new Error('SDK not initialized. Call init() first.');
+        }
+        if (!this.installId) {
+            console.warn('[LinkForty] Cannot track event: No install ID available');
+            return;
+        }
+        // Backend expects: { installId, eventName, eventData, timestamp }
+        const requestBody = {
+            installId: this.installId,
+            eventName: name,
+            eventData: properties || {},
+            timestamp: new Date().toISOString(),
+        };
+        try {
+            const response = await this.apiRequest('/api/sdk/v1/event', {
+                method: 'POST',
+                body: JSON.stringify(requestBody),
+            });
+            if (this.config.debug) {
+                console.log('[LinkForty] Event tracked:', name, response);
+            }
+        }
+        catch (error) {
+            console.error('[LinkForty] Failed to track event:', error);
+        }
+    }
+    /**
+     * Get install ID
+     */
+    async getInstallId() {
+        if (this.installId) {
+            return this.installId;
+        }
+        const cached = await AsyncStorage.getItem(STORAGE_KEYS.INSTALL_ID);
+        if (cached) {
+            this.installId = cached;
+        }
+        return this.installId;
+    }
+    /**
+     * Clear all cached data (for testing)
+     */
+    async clearData() {
+        await AsyncStorage.multiRemove([
+            STORAGE_KEYS.INSTALL_ID,
+            STORAGE_KEYS.INSTALL_DATA,
+            STORAGE_KEYS.FIRST_LAUNCH,
+        ]);
+        this.installId = null;
+        if (this.config?.debug) {
+            console.log('[LinkForty] All data cleared');
+        }
+    }
+    /**
+     * Check if this is the first app launch
+     */
+    async isFirstLaunch() {
+        const firstLaunchFlag = await AsyncStorage.getItem(STORAGE_KEYS.FIRST_LAUNCH);
+        if (!firstLaunchFlag) {
+            await AsyncStorage.setItem(STORAGE_KEYS.FIRST_LAUNCH, 'true');
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Report app installation to LinkForty backend
+     */
+    async reportInstall() {
+        if (!this.config) {
+            return;
+        }
+        try {
+            // Collect device fingerprint
+            const fingerprint = await FingerprintCollector.collect();
+            if (this.config.debug) {
+                console.log('[LinkForty] Reporting install with fingerprint:', fingerprint);
+            }
+            // Parse screen resolution (e.g., "1080x1920" -> [1080, 1920])
+            const [screenWidth, screenHeight] = fingerprint.screenResolution
+                .split('x')
+                .map(Number);
+            // Convert attribution window from days to hours
+            const attributionWindowHours = (this.config.attributionWindow || 7) * 24;
+            // Call install endpoint with flattened structure matching backend contract
+            const response = await this.apiRequest('/api/sdk/v1/install', {
+                method: 'POST',
+                body: JSON.stringify({
+                    userAgent: fingerprint.userAgent,
+                    timezone: fingerprint.timezone,
+                    language: fingerprint.language,
+                    screenWidth,
+                    screenHeight,
+                    platform: fingerprint.platform,
+                    platformVersion: fingerprint.osVersion,
+                    deviceId: undefined, // Optional: Can add IDFA/GAID if available
+                    attributionWindowHours,
+                }),
+            });
+            if (this.config.debug) {
+                console.log('[LinkForty] Install response:', response);
+            }
+            // Store install ID
+            if (response.installId) {
+                this.installId = response.installId;
+                await AsyncStorage.setItem(STORAGE_KEYS.INSTALL_ID, response.installId);
+            }
+            // If attributed, store deep link data
+            if (response.attributed && response.deepLinkData) {
+                await AsyncStorage.setItem(STORAGE_KEYS.INSTALL_DATA, JSON.stringify(response.deepLinkData));
+                // Call deferred deep link callback if registered
+                if (this.deferredDeepLinkCallback) {
+                    this.deferredDeepLinkCallback(response.deepLinkData);
+                }
+                if (this.config.debug) {
+                    console.log('[LinkForty] Install attributed with confidence:', response.confidenceScore);
+                    console.log('[LinkForty] Matched factors:', response.matchedFactors);
+                }
+            }
+            else {
+                if (this.config.debug) {
+                    console.log('[LinkForty] Install not attributed (organic install)');
+                }
+                // Call callback with null to indicate organic install
+                if (this.deferredDeepLinkCallback) {
+                    this.deferredDeepLinkCallback(null);
+                }
+            }
+        }
+        catch (error) {
+            console.error('[LinkForty] Failed to report install:', error);
+            // Call callback with null on error
+            if (this.deferredDeepLinkCallback) {
+                this.deferredDeepLinkCallback(null);
+            }
+        }
+    }
+    /**
+     * Load cached install data
+     */
+    async loadInstallData() {
+        this.installId = await AsyncStorage.getItem(STORAGE_KEYS.INSTALL_ID);
+    }
+    /**
+     * Make API request to LinkForty backend
+     */
+    async apiRequest(endpoint, options = {}) {
+        if (!this.config) {
+            throw new Error('SDK not initialized');
+        }
+        const url = `${this.config.baseUrl}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Add API key if provided
+        if (this.config.apiKey) {
+            headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                ...headers,
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: 'Network error' }));
+            throw new Error(error.message || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+}
+// Export singleton instance
+export default new LinkFortySDK();

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * LinkForty React Native SDK
+ *
+ * Deep linking and mobile attribution for React Native apps
+ *
+ * @packageDocumentation
+ */
+export { default } from './LinkFortySDK';
+export { LinkFortySDK } from './LinkFortySDK';
+export { FingerprintCollector } from './FingerprintCollector';
+export { DeepLinkHandler } from './DeepLinkHandler';
+export type { LinkFortyConfig, DeviceFingerprint, DeepLinkData, InstallAttributionResponse, EventData, DeferredDeepLinkCallback, DeepLinkCallback, } from './types';
+//# 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;;;;;;GAMG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAGzC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,0BAA0B,EAC1B,SAAS,EACT,wBAAwB,EACxB,gBAAgB,GACjB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * LinkForty React Native SDK
+ *
+ * Deep linking and mobile attribution for React Native apps
+ *
+ * @packageDocumentation
+ */
+// Export singleton SDK instance as default
+export { default } from './LinkFortySDK';
+// Export classes
+export { LinkFortySDK } from './LinkFortySDK';
+export { FingerprintCollector } from './FingerprintCollector';
+export { DeepLinkHandler } from './DeepLinkHandler';

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * LinkForty React Native SDK Type Definitions
+ */
+/**
+ * Configuration options for initializing the LinkForty SDK
+ */
+export interface LinkFortyConfig {
+    /** Base URL of your LinkForty instance (e.g., 'https://go.yourdomain.com') */
+    baseUrl: string;
+    /** Optional API key for Cloud authentication */
+    apiKey?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom attribution window in days (default: 7) */
+    attributionWindow?: number;
+}
+/**
+ * Device fingerprint data collected for attribution matching
+ */
+export interface DeviceFingerprint {
+    /** IP address (server-side) */
+    ip?: string;
+    /** User agent string */
+    userAgent: string;
+    /** Device timezone */
+    timezone: string;
+    /** Device language */
+    language: string;
+    /** Screen resolution (width x height) */
+    screenResolution: string;
+    /** Device platform (ios/android) */
+    platform: string;
+    /** Device model */
+    deviceModel?: string;
+    /** OS version */
+    osVersion?: string;
+    /** App version */
+    appVersion?: string;
+}
+/**
+ * Deep link data containing URLs and parameters
+ */
+export interface DeepLinkData {
+    /** Short code that was clicked */
+    shortCode: string;
+    /** iOS app URL */
+    iosUrl?: string;
+    /** Android app URL */
+    androidUrl?: string;
+    /** Web fallback URL */
+    webUrl?: string;
+    /** UTM parameters */
+    utmParameters?: {
+        source?: string;
+        medium?: string;
+        campaign?: string;
+        term?: string;
+        content?: string;
+    };
+    /** Custom query parameters */
+    customParameters?: Record<string, string>;
+    /** Click timestamp */
+    clickedAt?: string;
+    /** Link ID */
+    linkId?: string;
+}
+/**
+ * Response from install attribution endpoint
+ * Matches backend contract from /api/sdk/v1/install
+ */
+export interface InstallAttributionResponse {
+    /** Install event UUID */
+    installId: string;
+    /** Whether attribution was successful */
+    attributed: boolean;
+    /** Attribution confidence score (0-100) */
+    confidenceScore: number;
+    /** Array of matched fingerprint factors (e.g., ['ip', 'user_agent', 'timezone', 'language', 'screen']) */
+    matchedFactors: string[];
+    /** Deep link data if attributed (contains shortCode, URLs, UTM params, confidence, etc.) */
+    deepLinkData: DeepLinkData | Record<string, never>;
+}
+/**
+ * Event data for tracking in-app events
+ */
+export interface EventData {
+    /** Event name (e.g., 'purchase', 'signup', 'add_to_cart') */
+    name: string;
+    /** Event properties */
+    properties?: Record<string, any>;
+    /** Revenue amount (for conversion events) */
+    revenue?: number;
+    /** Currency code (e.g., 'USD') */
+    currency?: string;
+    /** Install ID for attribution */
+    installId?: string;
+}
+/**
+ * Callback function for deferred deep links
+ */
+export type DeferredDeepLinkCallback = (deepLinkData: DeepLinkData | null) => void;
+/**
+ * Callback function for direct deep links
+ */
+export type DeepLinkCallback = (url: string, deepLinkData: DeepLinkData | null) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,wBAAwB;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,gBAAgB,EAAE,MAAM,CAAC;IACzB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sBAAsB;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uBAAuB;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qBAAqB;IACrB,aAAa,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,8BAA8B;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,sBAAsB;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,UAAU,EAAE,OAAO,CAAC;IACpB,2CAA2C;IAC3C,eAAe,EAAE,MAAM,CAAC;IACxB,0GAA0G;IAC1G,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,4FAA4F;IAC5F,YAAY,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CACpD;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC;AAEnF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI,KAAK,IAAI,CAAC"}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * LinkForty React Native SDK Type Definitions
+ */
+export {};

package/examples/AdvancedHooks.tsx

@@ -0,0 +1,230 @@
+/**
+ * Advanced Hooks Example
+ *
+ * This example shows how to create custom React hooks for
+ * LinkForty SDK integration with TypeScript.
+ */
+
+import { useEffect, useState, useCallback } from 'react';
+import LinkForty from '@linkforty/react-native-sdk';
+import type { DeepLinkData } from '@linkforty/react-native-sdk';
+
+/**
+ * Custom hook for managing LinkForty SDK initialization
+ */
+export function useLinkForty(config: {
+  baseUrl: string;
+  apiKey?: string;
+  debug?: boolean;
+}) {
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const init = async () => {
+      try {
+        await LinkForty.init(config);
+        setIsInitialized(true);
+      } catch (err) {
+        setError(err as Error);
+      }
+    };
+
+    init();
+  }, [config.baseUrl, config.apiKey]);
+
+  return { isInitialized, error };
+}
+
+/**
+ * Custom hook for handling install attribution (deferred deep links)
+ */
+export function useInstallAttribution(
+  onAttribution?: (data: DeepLinkData) => void
+) {
+  const [installData, setInstallData] = useState<DeepLinkData | null>(null);
+  const [isOrganic, setIsOrganic] = useState<boolean | null>(null);
+
+  useEffect(() => {
+    LinkForty.onDeferredDeepLink((data) => {
+      if (data) {
+        setInstallData(data);
+        setIsOrganic(false);
+        onAttribution?.(data);
+      } else {
+        setIsOrganic(true);
+      }
+    });
+  }, [onAttribution]);
+
+  return { installData, isOrganic };
+}
+
+/**
+ * Custom hook for handling deep links
+ */
+export function useDeepLink(
+  onDeepLink?: (url: string, data: DeepLinkData | null) => void
+) {
+  const [currentDeepLink, setCurrentDeepLink] = useState<{
+    url: string;
+    data: DeepLinkData | null;
+  } | null>(null);
+
+  useEffect(() => {
+    LinkForty.onDeepLink((url, data) => {
+      setCurrentDeepLink({ url, data });
+      onDeepLink?.(url, data);
+    });
+  }, [onDeepLink]);
+
+  return currentDeepLink;
+}
+
+/**
+ * Custom hook for tracking events with error handling
+ */
+export function useEventTracking() {
+  const [isTracking, setIsTracking] = useState(false);
+  const [lastError, setLastError] = useState<Error | null>(null);
+
+  const trackEvent = useCallback(
+    async (name: string, properties?: Record<string, any>) => {
+      setIsTracking(true);
+      setLastError(null);
+
+      try {
+        await LinkForty.trackEvent(name, properties);
+      } catch (error) {
+        setLastError(error as Error);
+        throw error;
+      } finally {
+        setIsTracking(false);
+      }
+    },
+    []
+  );
+
+  return { trackEvent, isTracking, lastError };
+}
+
+/**
+ * Example: Using the hooks in a component
+ */
+export default function ExampleComponent() {
+  // Initialize SDK
+  const { isInitialized, error } = useLinkForty({
+    baseUrl: 'https://go.yourdomain.com',
+    debug: __DEV__,
+  });
+
+  // Handle install attribution
+  const { installData, isOrganic } = useInstallAttribution((data) => {
+    console.log('User came from:', data.utmParameters?.source);
+  });
+
+  // Handle deep links
+  const deepLink = useDeepLink((url, data) => {
+    console.log('Deep link opened:', url);
+    // Navigate to specific screen
+  });
+
+  // Event tracking
+  const { trackEvent, isTracking } = useEventTracking();
+
+  // Track screen view
+  useEffect(() => {
+    if (isInitialized) {
+      trackEvent('screen_view', {
+        screen_name: 'Home',
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }, [isInitialized]);
+
+  const handlePurchase = async () => {
+    try {
+      await trackEvent('purchase', {
+        amount: 99.99,
+        currency: 'USD',
+        product_id: 'premium_plan',
+      });
+      alert('Purchase tracked!');
+    } catch (error) {
+      console.error('Failed to track purchase:', error);
+    }
+  };
+
+  if (error) {
+    return <Text>SDK initialization failed: {error.message}</Text>;
+  }
+
+  if (!isInitialized) {
+    return <Text>Initializing LinkForty SDK...</Text>;
+  }
+
+  return (
+    <View>
+      <Text>SDK Initialized!</Text>
+
+      {isOrganic !== null && (
+        <Text>
+          Install Type: {isOrganic ? 'Organic' : 'Attributed'}
+        </Text>
+      )}
+
+      {installData && (
+        <View>
+          <Text>Source: {installData.utmParameters?.source}</Text>
+          <Text>Campaign: {installData.utmParameters?.campaign}</Text>
+        </View>
+      )}
+
+      {deepLink && (
+        <Text>Current Deep Link: {deepLink.url}</Text>
+      )}
+
+      <Button
+        title={isTracking ? 'Tracking...' : 'Track Purchase'}
+        onPress={handlePurchase}
+        disabled={isTracking}
+      />
+    </View>
+  );
+}
+
+/**
+ * TypeScript Utility Types
+ */
+
+// Extract UTM parameters with defaults
+export function getUTMParameters(data: DeepLinkData | null) {
+  return {
+    source: data?.utmParameters?.source || 'unknown',
+    medium: data?.utmParameters?.medium || 'unknown',
+    campaign: data?.utmParameters?.campaign || 'none',
+    term: data?.utmParameters?.term,
+    content: data?.utmParameters?.content,
+  };
+}
+
+// Check if install is attributed to a specific campaign
+export function isFromCampaign(
+  data: DeepLinkData | null,
+  campaignName: string
+): boolean {
+  return data?.utmParameters?.campaign === campaignName;
+}
+
+// Get install age in days
+export async function getInstallAge(): Promise<number | null> {
+  const installData = await LinkForty.getInstallData();
+  if (!installData?.clickedAt) return null;
+
+  const clickDate = new Date(installData.clickedAt);
+  const now = new Date();
+  const diffTime = Math.abs(now.getTime() - clickDate.getTime());
+  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+
+  return diffDays;
+}