wisetrack 2.0.9 → 2.1.1

package/dist/cjs/types/config/initial-config.d.ts

@@ -8,6 +8,10 @@ export interface WTInitialConfig {
      * The unique application token provided by WiseTrack Panel.
      */
     appToken: string;
+    /**
+     * The client secret provided by WiseTrack Panel.
+     */
+    clientSecret: string;
     /**
      * The version of your application.
      */
@@ -40,4 +44,8 @@ export interface WTInitialConfig {
      * Sets the log level for SDK logging.
      */
     logLevel?: WTLogLevel;
+    /**
+     * Whether to enable deepLinks controls, if specified. Defaults to `true`.
+     */
+    deeplinkEnabled?: boolean;
 }

package/dist/cjs/types/config/secure-config.d.ts

@@ -1,8 +1,19 @@
 export declare class SecureConfig {
     private static decode;
     static get CONFIG_PATH(): string;
+    static get LOCAL_BASE_URL(): string;
     static get DEBUG_BASE_URL(): string;
     static get STAGE_BASE_URL(): string;
     static get PRODUCTION_BASE_URL(): string;
+    static get NOTIFICATION_KEY(): string;
+    static get EVENTS_PATH(): string;
+    static get SESSIONS_PATH(): string;
+    static get SDK_CLICKS_PATH(): string;
+    static get PUSH_TOKENS_PATH(): string;
+    static get ATTRIBUTIONS_PATH(): string;
+    static get CLICK_MATCHES_PATH(): string;
+    static get DEFERRED_LOOKUPS_PATH(): string;
+    static get AUTH_PATH(): string;
+    static get HEARTBEATS_PATH(): string;
 }
 export default SecureConfig;

package/dist/cjs/types/config/wt-auth.d.ts

@@ -0,0 +1,7 @@
+/** @internal */
+export declare class WTAuth {
+    authToken: string;
+    wiseId: string;
+    constructor(authToken: string, wiseId: string);
+    static fromJson(json: any): WTAuth;
+}

package/dist/cjs/types/config/wt-config-endpoints.d.ts

@@ -0,0 +1,15 @@
+/** @internal */
+export declare class WTConfigEndpoints {
+    events: string;
+    sessions: string;
+    sdkClicks: string;
+    pushTokens: string;
+    attributions: string;
+    clickMatches: string;
+    deferredLookups: string;
+    heartbeats: string;
+    auth: string;
+    constructor(events: string, sessions: string, sdkClicks: string, pushTokens: string, attributions: string, clickMatches: string, deferredLookups: string, heartbeats: string, auth: string);
+    static fromJson(json: any): WTConfigEndpoints;
+    static get defaultValue(): WTConfigEndpoints;
+}

package/dist/cjs/types/config/wt-config.d.ts

@@ -1,15 +1,13 @@
+import { WTConfigEndpoints } from "./wt-config-endpoints";
 /** @internal */
 export declare class WTConfig {
-    events: string;
-    sessions: string;
-    sdkClicks: string;
-    sdkInfos: string;
-    attributions: string;
+    endpoints: WTConfigEndpoints;
     sdkEnabled: boolean;
     sdkUpdate: boolean;
     sessionInterval: string;
     subsessionInterval: string;
-    constructor(events: string, sessions: string, sdkClicks: string, sdkInfos: string, attributions: string, sdkEnabled?: boolean, sdkUpdate?: boolean, sessionInterval?: string, subsessionInterval?: string);
+    heartbeatInterval: string;
+    constructor(endpoints: WTConfigEndpoints, sdkEnabled?: boolean, sdkUpdate?: boolean, sessionInterval?: string, subsessionInterval?: string, heartbeatInterval?: string);
     static fromJson(json: any): WTConfig;
     static get defaultValue(): WTConfig;
 }

package/dist/cjs/types/wt-deferred-lookup.d.ts

@@ -0,0 +1,6 @@
+/** @internal */
+export declare class WTDeferredLookup {
+    deeplink: string;
+    constructor(deeplink: string);
+    static fromJson(json: any): WTDeferredLookup;
+}

package/dist/cjs/utils/country-finder.d.ts

@@ -1,6 +1,7 @@
 /** @internal */
 export declare class CountryFinder {
     private _country;
+    private _failedCount;
     getCountryCode(): Promise<string | null>;
     private tryAllEndpoints;
     private fetchWithTimeout;

package/dist/cjs/utils/crypto-helper.d.ts

@@ -1,4 +1,4 @@
 /** @internal */
 export declare const cryptoHelper: {
-    generateDeviceUUID(): string;
+    generateUUID(): string;
 };

package/dist/cjs/utils/lifecycle-observer.d.ts

@@ -0,0 +1,32 @@
+export type DeeplinkHandler = (uri: string, isDeferred: boolean) => void;
+declare class LifecycleOvserver {
+    private tickerDelay;
+    private isPaused;
+    private tickerJob?;
+    onStartHandler: (() => any) | null;
+    deeplinkHandler: DeeplinkHandler | null;
+    onClickMatchHandler: ((url: string) => any) | null;
+    private visibilityListener;
+    private pageHideListener;
+    private originalPushState;
+    private originalReplaceState;
+    private popstateHandler;
+    private hashchangeHandler;
+    registerListeners(): void;
+    private setupUrlChangeListener;
+    private removeUrlChangeListener;
+    unregisterListeners(): void;
+    private checkForDeepLink;
+    onDeeplinkReceived(data: {
+        uri: string;
+        isDeferred: boolean;
+    }): void;
+    private isVisibleFocused;
+    startTicking(): void;
+    stopTicking(): void;
+    pauseTicking(): void;
+    resumeTicking(): void;
+}
+/** @internal */
+export declare const lifecycleOvserver: LifecycleOvserver;
+export {};

package/dist/cjs/utils/utils.d.ts

@@ -2,4 +2,5 @@
 export declare class Utils {
     static detectWebFramework: () => string | undefined;
     static getUTMParamsString(): string;
+    static formattedDate(date: Date): string;
 }

package/dist/cjs/utils/webgl-fingerprint.d.ts

@@ -1,7 +1,7 @@
-/** @internal */
 export declare class DeviceFingerprint {
     static isWebGLSupported(): boolean;
-    static getWebGLFingerprint(): Promise<string | undefined>;
-    static getCanvasFingerprint(): Promise<string | undefined>;
+    static generateFingerprint(): Promise<string>;
+    private static getWebGLFingerprint;
+    private static getCanvasFingerprint;
     private static hashData;
 }

package/dist/esm/constants/constants.d.ts

@@ -4,7 +4,7 @@ import { WTSDKEnvironment } from "./environments";
 export declare const WTConstants: {
     readonly SDK: {
         readonly PLATFORM: "web";
-        readonly VERSION: "2.0.9";
+        readonly VERSION: "2.1.0";
     };
     readonly CONFIG: {
         readonly DEFAULT_ENVIRONMENT: WTSDKEnvironment;
@@ -13,6 +13,8 @@ export declare const WTConstants: {
         readonly LOG_LEVEL: WTLogLevel;
         readonly SESSION_INTERVAL: "1800";
         readonly SUBSESSION_INTERVAL: "300";
+        readonly HEARTBEAT_INTERVAL: "21600";
         readonly PARAMETERS_VALUE: string | undefined;
     };
+    readonly WT_DEEPLINK_PARAM: "wt_click_id";
 };

package/dist/esm/constants/endpoints.d.ts

@@ -1,11 +1,14 @@
 /** @internal */
 export declare const WTEndpoints: {
-    readonly EVENTS: "/api/v1/events";
-    readonly SESSIONS: "/api/v1/sessions";
-    readonly SDK_CLICKS: "/api/v1/sdk_clicks";
-    readonly SDK_INFOS: "/api/v1/sdk_infos";
-    readonly ATTRIBUTIONS: "/api/v1/attributions";
-    readonly APP_SETTINGS: "/api/v1/app_settings";
+    readonly EVENTS: string;
+    readonly SESSIONS: string;
+    readonly SDK_CLICKS: string;
+    readonly PUSH_TOKENS: string;
+    readonly ATTRIBUTIONS: string;
+    readonly CLICK_MATCHES: string;
+    readonly DEFERRED_LOOKUPS: string;
+    readonly HEARTBEATS: string;
+    readonly AUTH: string;
 };
 /** @internal */
 export type WTEndpoints = (typeof WTEndpoints)[keyof typeof WTEndpoints];

package/dist/esm/constants/environments.d.ts

@@ -11,6 +11,7 @@ export declare const WTUserEnvironment: {
 export type WTUserEnvironment = (typeof WTUserEnvironment)[keyof typeof WTUserEnvironment];
 /** @internal */
 export declare const WTSDKEnvironment: {
+    readonly LOCAL: "local";
     readonly DEBUG: "debug";
     readonly STAGE: "stage";
     readonly PRODUCTION: "production";
@@ -20,6 +21,5 @@ export type WTSDKEnvironment = (typeof WTSDKEnvironment)[keyof typeof WTSDKEnvir
 /** @internal */
 export declare const EnvironmentUtils: {
     readonly sdkEnvironment: WTSDKEnvironment;
-    readonly needResponseDetails: boolean;
     readonly baseUrl: string;
 };

package/dist/esm/core/caching/queue-data.d.ts

@@ -4,7 +4,6 @@ import { FieldsBuilder } from "../fields/fields-builder";
 export interface RequestRecordCreator {
     endpoint: WTEndpoints;
     fBuilder?: FieldsBuilder;
-    queueType?: "main" | "pending";
 }
 /** @internal */
 export declare class RequestRecord {

package/dist/esm/core/caching/request-queue-manager.d.ts

@@ -3,52 +3,37 @@ import { RequestRecord } from "./queue-data";
 export declare class RequestsQueueManager {
     private isInitialized;
     private isProcessing;
-    private isCurrentlyProcessing;
     private mutex;
     private processingInterval;
     private readonly PROCESSING_INTERVAL_MS;
+    private activeRequests;
     private failedRequestDelay;
     private readonly MAX_DELAY_MS;
     private readonly BACKOFF_MULTIPLIER;
     private readonly BASE_DELAY_MS;
+    private readonly MAX_CONCURRENT_REQUESTS;
     constructor();
     initialize(): Promise<void>;
     shutdown(): Promise<void>;
-    private startProcessing;
-    private stopProcessing;
-    addRequest(request: RequestRecord): Promise<void>;
-    addPendingRequest(request: RequestRecord): Promise<void>;
-    private processQueues;
-    private processMainQueue;
-    private calculateBackoffDelay;
-    private processPendingQueue;
-    private sendRequest;
-    private getMainQueue;
-    private saveMainQueue;
-    private getPendingQueue;
-    private savePendingQueue;
-    private getMainRequestsSentFlag;
-    private postRequestCheck;
     getQueueStatus(): {
-        mainQueueLength: number;
-        pendingQueueLength: number;
+        queueLength: number;
         isProcessing: boolean;
-        mainRequestsSent: boolean;
+        activeRequests: number;
         isInBackoffDelay: boolean;
         backoffEndsAt: number | null;
     };
-    /**
-     * Manually reset backoff delay (useful for testing or manual recovery)
-     */
-    resetBackoffDelay(): void;
-    /**
-     * Get current backoff delay configuration
-     */
-    getBackoffConfig(): {
-        baseDelayMs: number;
-        multiplier: number;
-        maxDelayMs: number;
-    };
+    private startProcessing;
+    private stopProcessing;
+    addRequest(request: RequestRecord): Promise<void>;
+    private processQueues;
+    private canProcessNext;
+    private processNextRequest;
+    private finishRequest;
+    private sendRequest;
+    private calculateBackoffDelay;
+    private getQueue;
+    private saveQueue;
+    private canAddRequest;
 }
 /** @internal */
 export declare const queueManager: RequestsQueueManager;

package/dist/esm/core/fields/click-match-fields-builder.d.ts

@@ -0,0 +1,7 @@
+import { FieldsBuilder } from "./fields-builder";
+/** @internal */
+export declare class ClickMatchFieldsBuilder extends FieldsBuilder {
+    deeplink: string;
+    constructor(deeplink: string);
+    build(): Promise<Record<string, any>>;
+}

package/dist/esm/core/fields/heartbeat-fields-builder.d.ts

@@ -0,0 +1,7 @@
+import { FieldsBuilder } from "./fields-builder";
+/** @internal */
+export declare class HeartbeatFieldsBuilder extends FieldsBuilder {
+    trigger: string;
+    constructor(trigger: string);
+    build(): Promise<Record<string, any>>;
+}

package/dist/esm/core/network/api-client.d.ts

@@ -1,7 +1,19 @@
 import { WTEndpoints } from "../../constants/endpoints";
 import { WTConfig } from "../../types/config/wt-config";
+import { WTDeferredLookup } from "../../types/wt-deferred-lookup";
+import { WTApiError } from "./network-error";
+import { ApiResponseWrapper } from "./network-manager";
 /** @internal */
-export declare const apiClient: {
-    doGetConfig(): Promise<WTConfig>;
-    doCallRequest(endpoint: WTEndpoints, params: Record<string, any>): Promise<boolean>;
-};
+declare class ApiClient {
+    constructor();
+    doGetConfig(): Promise<WTConfig | WTApiError>;
+    doGetAuthToken(): Promise<Boolean | WTApiError>;
+    doGetDeferredData(): Promise<WTDeferredLookup | WTApiError>;
+    doSendHeartbeat(params: Record<string, any>): Promise<Boolean>;
+    doCallRequest(endpoint: WTEndpoints, params: Record<string, any>): Promise<ApiResponseWrapper | WTApiError>;
+    private refreshTokenPromise;
+    refreshToken(): Promise<Boolean | WTApiError>;
+    get isRefreshingToken(): boolean;
+}
+export declare const apiClient: ApiClient;
+export {};

package/dist/esm/core/network/network-error.d.ts

@@ -1,17 +1,33 @@
-/** @internal */
-export declare namespace ApiError {
-    class InvalidUrl extends Error {
-        constructor(url: string);
-    }
-    class ServerError extends Error {
-        statusCode: number;
-        message: string;
-        constructor(statusCode: number, message: string);
-    }
-    class NetworkError extends Error {
-        constructor(message: string);
-    }
-    class DecodingError extends Error {
-        constructor(message: string);
-    }
+export declare abstract class WTApiError extends Error {
+    abstract readonly statusCode: number | null;
+    abstract readonly shouldRetryRequest: boolean;
+    /**
+     * Message suitable for showing to end users
+     */
+    abstract readonly localizedMessage: string;
+    protected constructor(message?: string);
+}
+export declare class ConnectionError extends WTApiError {
+    readonly statusCode: null;
+    readonly shouldRetryRequest = true;
+    readonly localizedMessage: string;
+    constructor(message?: string);
+}
+export declare class HttpError extends WTApiError {
+    readonly statusCode: number;
+    readonly shouldRetryRequest: boolean;
+    readonly localizedMessage: string;
+    constructor(statusCode: number, message?: string);
+}
+export declare class DecodingError extends WTApiError {
+    readonly statusCode: null;
+    readonly shouldRetryRequest = true;
+    readonly localizedMessage: string;
+    constructor(message?: string);
+}
+export declare class UnknownError extends WTApiError {
+    readonly statusCode: number | null;
+    readonly shouldRetryRequest = false;
+    readonly localizedMessage: string;
+    constructor(message?: string, statusCode?: number | null);
 }

package/dist/esm/core/network/network-manager.d.ts

@@ -1,3 +1,4 @@
+import { WTApiError } from "./network-error";
 import { RetryPolicy } from "./retry-policy";
 type HttpMethod = "GET" | "POST" | "PUT";
 /** @internal */
@@ -6,6 +7,7 @@ export interface RequestOptions {
     headers?: Record<string, string>;
     params?: Record<string, any>;
     retryAttempt?: number;
+    needsAuthentication?: boolean;
 }
 /** @internal */
 export interface ApiResponseWrapper {
@@ -14,8 +16,11 @@ export interface ApiResponseWrapper {
     result?: any;
 }
 /** @internal */
-export declare const networkManager: {
-    readonly retryPolicy: () => RetryPolicy;
-    readonly sendRequest: (endpoint: string, options?: RequestOptions) => Promise<ApiResponseWrapper>;
-};
+declare class NetworkManager {
+    private refreshHandler;
+    setRefreshHandler(handler: () => Promise<Boolean | WTApiError>): void;
+    retryPolicy(): RetryPolicy;
+    sendRequest(endpoint: string, options?: RequestOptions): Promise<ApiResponseWrapper | WTApiError>;
+}
+export declare const networkManager: NetworkManager;
 export {};

package/dist/esm/core/storage/storage-manager.d.ts

@@ -1,6 +1,7 @@
 import { WTSDKEnvironment } from "../../constants/environments";
 import { WTInitialConfig } from "../../types/config/initial-config";
 import { WTConfig } from "../../types/config/wt-config";
+import { WTDeferredLookup } from "../../types/wt-deferred-lookup";
 import { RequestRecord } from "../caching/queue-data";
 declare class StorageManager {
     clear(): void;
@@ -36,8 +37,8 @@ declare class StorageManager {
     set inactiveDuration(value: number);
     get inactiveTime(): number | null;
     set inactiveTime(value: number | null);
-    get activeTime(): number | null;
-    set activeTime(value: number | null);
+    get lastActiveTime(): number | null;
+    set lastActiveTime(value: number | null);
     get requestRecords(): RequestRecord[];
     set requestRecords(value: RequestRecord[]);
     get pendingRequestRecords(): RequestRecord[];
@@ -48,6 +49,26 @@ declare class StorageManager {
     set sdkEnvironment(value: string);
     get sdkVersion(): string;
     set sdkVersion(value: string);
+    get clientSessionId(): string | null;
+    set clientSessionId(value: string | null);
+    get appStartTime(): number | null;
+    set appStartTime(value: number | null);
+    get deferredLinkHandled(): boolean;
+    set deferredLinkHandled(value: boolean);
+    get unmatchedDeeplinks(): string[];
+    set unmatchedDeeplinks(value: string[]);
+    get deferredData(): WTDeferredLookup | null;
+    set deferredData(value: WTDeferredLookup | null);
+    get appDeeplink(): string | null;
+    set appDeeplink(value: string | null);
+    get wiseId(): string | null;
+    set wiseId(value: string | null);
+    get nextClientSessionId(): string | null;
+    set nextClientSessionId(value: string | null);
+    get lastSessionStart(): string | null;
+    set lastSessionStart(value: string | null);
+    get authToken(): string | null;
+    set authToken(value: string | null);
 }
 /** @internal */
 export declare const storageManager: StorageManager;

package/dist/esm/core/wisetrack.d.ts

@@ -1,5 +1,6 @@
 import { WTInitialConfig } from "../types/config/initial-config";
 import { WTEvent } from "../types/event/wt-event";
+import { DeeplinkHandler } from "../utils/lifecycle-observer";
 import { WTLogLevel } from "../utils/logger";
 /**
  * The main entry point for the WiseTrack Web SDK.
@@ -9,7 +10,8 @@ import { WTLogLevel } from "../utils/logger";
  * @example
  * ```ts
  * const initialConfig: WTInitialConfig = {
- *  appToken: appToken ?? "rMN5ZCwpOzY7",
+ *  appToken: appToken,
+ *  clientSecret: clientSecret,
  *  appFrameWork: "native",
  *  appVersion: "1.0.0",
  * };
@@ -24,7 +26,7 @@ export declare class WiseTrack {
     static get instance(): WiseTrack;
     private constructor();
     private sdkInitialized;
-    private isInitializing;
+    private initializationPromise;
     /**
      * Initializes the WiseTrack SDK with the given configuration.
      *
@@ -35,7 +37,8 @@ export declare class WiseTrack {
      * @example
      * ```ts
      * const initialConfig: WTInitialConfig = {
-     *  appToken: appToken ?? "rMN5ZCwpOzY7",
+     *  appToken: appToken,
+     *  clientSecret: clientSecret,
      *  appFrameWork: "native", // your current web app framework (native, reactjs, nextjs, ...)
      *  appVersion: "1.0.0", // your current web app version
      * };
@@ -43,6 +46,11 @@ export declare class WiseTrack {
      * ```
      */
     init(initConfig: WTInitialConfig): Promise<void>;
+    /**
+     * Performs the actual SDK initialization.
+     * Runs asynchronously without blocking the main thread.
+     */
+    private performInitialization;
     /**
      * Sets the log level for internal SDK logging.
      *
@@ -117,10 +125,24 @@ export declare class WiseTrack {
      * ```
      */
     trackEvent(event: WTEvent): Promise<void>;
-    /** @internal */
-    private getConfig;
-    /** @internal */
-    private checkSdkEnabled;
-    /** @internal */
-    private checkSdkUpdate;
+    /**
+     * Sets a callback listener for deeplink events.
+     * The callback will be invoked when a deeplink is received, providing the intent and whether it's a deferred deeplink.
+     *
+     * @param callback The callback to be invoked when a deeplink is received.
+     */
+    setOnDeeplinkListener(callback: DeeplinkHandler): void;
+    /**
+     * Retrieves the last recorded deeplink, if available.
+     *
+     * @return The last deeplink string, or null if not available.
+     */
+    getLastDeeplink(): string | null;
+    /**
+     * Retrieves the deferred deeplink from storage, if available.
+     * Deferred deeplinks are used for attribution of app installs.
+     *
+     * @return The deferred deeplink string, or null if not available.
+     */
+    getDeferredDeeplink(): string | null;
 }

package/dist/esm/core/wt-configure.d.ts

@@ -0,0 +1,18 @@
+import { WTInitialConfig } from "../types/config/initial-config";
+/** @internal */
+declare class WTConfigure {
+    configureSDK(initConfig: WTInitialConfig): Promise<void>;
+    /** @internal */
+    private getConfig;
+    /** @internal */
+    private getAuth;
+    /** @internal */
+    private deferredLookup;
+    /** @internal */
+    private checkSdkEnabled;
+    /** @internal */
+    private checkSdkUpdate;
+}
+/** @internal */
+export declare const configure: WTConfigure;
+export {};

package/dist/esm/core/wt-tracker.d.ts

@@ -1,4 +1,5 @@
 import { WTEvent } from "../types/event/wt-event";
+import { DeeplinkHandler } from "../utils/lifecycle-observer";
 /** @internal */
 declare class WTTracker {
     private isRunning;
@@ -7,17 +8,19 @@ declare class WTTracker {
     initialize(): Promise<void>;
     startTracking(): Promise<void>;
     stopTracking(): Promise<void>;
+    destroy(): Promise<void>;
     checkPushToken(token: string): Promise<void>;
     trackEvent(event: WTEvent): Promise<void>;
+    setOnDeeplinkListener(callback: DeeplinkHandler): void;
     private getCountryCode;
     private createAttribution;
     private checkFirstSession;
     private checkSdkClicks;
     private createRequest;
     private createDeviceID;
+    private checkDeepLinks;
+    private createClickMatch;
     private setActivityTimes;
-    private checkSessionIntervals;
-    private isVisibleFocused;
     private addObservers;
 }
 /** @internal */

package/dist/esm/index.d.ts

@@ -1,7 +1,9 @@
 export { WTUserEnvironment } from "./constants/environments";
 export { ResourceWrapper } from "./constants/resource-wrapper";
 export { WiseTrack } from "./core/wisetrack";
-export { WTInitialConfig } from "./types/config/initial-config";
+export type { WTInitialConfig } from "./types/config/initial-config";
 export { RevenueCurrency } from "./types/event/revenue-currency";
-export { EventParam, WTEvent } from "./types/event/wt-event";
+export type { EventParam } from "./types/event/wt-event";
+export { WTEvent } from "./types/event/wt-event";
 export { WTLogger, WTLogLevel } from "./utils/logger";
+export type { DeeplinkHandler } from "./utils/lifecycle-observer";