kv-test-lib 1.0.0

package/dist/browser/browser.d.ts

@@ -0,0 +1,8 @@
+export declare const getPackageName: () => string;
+export declare const getLanguage: () => string;
+export declare const getDeviceWidth: () => number;
+export declare const getDeviceHeight: () => number;
+export declare const getDeviceOrientation: () => string;
+export declare const getBaseDomain: () => string;
+export declare const getPageName: () => string;
+export declare const getUrlParameter: (name: string) => string;

package/dist/browser/browser.js

@@ -0,0 +1,40 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+export const getPackageName = () => `com.${window.location.hostname}.web`;
+export const getLanguage = () => (navigator) ? navigator.language : "";
+export const getDeviceWidth = () => (window) ? window.screen.availWidth : 0;
+export const getDeviceHeight = () => (window) ? window.screen.availHeight : 0;
+export const getDeviceOrientation = () => (window) ? window.innerWidth < window.innerHeight
+    ? "portrait" : "landscape" : "";
+export const getBaseDomain = () => {
+    try {
+        const regexResult = window.location.host.match(/[^.]*\.[^.]*$/);
+        if (regexResult)
+            return regexResult[0];
+        return "";
+    }
+    catch (err) {
+        return window.location.host;
+    }
+};
+export const getPageName = () => {
+    let page = "";
+    if (window.location) {
+        page = window.location.pathname.substring(1);
+        page = page.replace(/\/+$/, "");
+    }
+    return page === "" ? "/" : page;
+};
+export const getUrlParameter = (name) => {
+    if (!window.location || !window.location.search) {
+        return "";
+    }
+    name = name.replace(/[[]/, "\\[").replace(/[\]]/, "\\]");
+    const regex = new RegExp("[\\?&]" + name + "=([^&#]*)");
+    const results = regex.exec(window.location.search);
+    return results === null
+        ? ""
+        : decodeURIComponent(results[1].replace(/\+/g, " "));
+};

package/dist/browser/cookies.d.ts

@@ -0,0 +1,3 @@
+export declare const setCookie: (name: string, value: string) => void;
+export declare const getCookie: (name: string) => string;
+export declare const deleteCookie: (name: string) => void;

package/dist/browser/cookies.js

@@ -0,0 +1,40 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import { getBaseDomain } from "./browser";
+export const setCookie = (name, value) => {
+    let expires = "";
+    const date = new Date();
+    date.setTime(date.getTime() + 3650 * 24 * 60 * 60 * 1000);
+    expires = `; expires=${date.toUTCString()}`;
+    document.cookie =
+        name +
+            "=" +
+            (value || "") +
+            expires +
+            "; path=/;domain=" +
+            getBaseDomain();
+};
+export const getCookie = (name) => {
+    const nameEQ = name + "=";
+    const charArray = document.cookie.split(';');
+    for (let i = 0; i < charArray.length; i++) {
+        let char = charArray[i];
+        while (char.charAt(0) === " ")
+            char = char.substring(1, char.length);
+        if (char.indexOf(nameEQ) === 0)
+            return char.substring(nameEQ.length, char.length);
+    }
+    return "";
+};
+export const deleteCookie = (name) => {
+    if (getCookie(name)) {
+        const path = "/";
+        const domain = getBaseDomain();
+        document.cookie = name + "=" +
+            ((path) ? ";path=" + path : "") +
+            ((domain) ? ";domain=" + domain : "") +
+            ";expires=Thu, 01 Jan 1970 00:00:01 GMT";
+    }
+};

package/dist/browser/persist.d.ts

@@ -0,0 +1,33 @@
+import { IdentityLink } from "../interfaces";
+import { EventJob, IdLinkJob } from "../jobqueue";
+export declare const MAX_STORED_IDLINKS = 10;
+export declare enum PersistKey {
+    LastKvinit = "com.kochava.tracker.LastKvinit",
+    EventQueue = "com.kochava.tracker.EventQueue",
+    IdLinkQueue = "com.kochava.tracker.IdLinkQueue",
+    DeviceId = "com.kochava.tracker.DeviceId",
+    InstallId = "com.kochava.tracker.InstallId",
+    FirstStartDate = "com.kochava.tracker.FirstStartDate",
+    InstallSentDate = "com.kochava.tracker.InstallSentDate",
+    KvinitSentDate = "com.kochava.tracker.KvinitSentDate",
+    SessionCount = "com.kochava.tracker.SessionCount",
+    IdentityLinks = "com.kochava.tracker.IdentityLinks",
+    OverrideAppId = "com.kochava.tracker.OverrideAppId",
+    OverrideDeviceId = "com.kochava.tracker.OverrideDeviceId",
+    OldKvid = "kv_id"
+}
+export declare const checkInstallIdChange: (inputId: string, useCookies: boolean) => boolean;
+export declare const addToPersistedEventQueue: (job: EventJob) => void;
+export declare const removeFromEventPersistedQueue: (job: EventJob) => void;
+export declare const updateOrAddPersistedIdLinkQueue: (job: IdLinkJob) => void;
+export declare const removeFromIdLinkPersistedQueue: (job: IdLinkJob) => void;
+export declare const addPersistedIdLinks: (key: string, value: string, useCookies: boolean) => void;
+export declare const checkDuplicateIdLink: (key: string, value: string) => boolean;
+export declare const getPersistedIdentityLinks: () => IdentityLink | undefined;
+export declare const readAndUpdateUTM: (appGuid: string, useCookies: boolean) => string;
+export declare const readAndUpdatePersistedValue: (key: PersistKey, useCookie: boolean) => string;
+export declare const updatePersistedValue: (key: PersistKey, value: string, useCookie: boolean) => void;
+export declare const deletePersistedValue: (item: PersistKey) => void;
+export declare const deleteAllPersisted: () => void;
+export declare const readAndUpdateDeviceId: (useCookie: boolean) => string;
+export declare const readAndUpdateSessionCount: (useCookie: boolean) => number;

package/dist/browser/persist.js

@@ -0,0 +1,195 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import * as utils from "../utils/utils";
+import { getUrlParameter } from "./browser";
+import { setCookie, getCookie, deleteCookie } from "./cookies";
+import { Log } from "../utils/log";
+export const MAX_STORED_IDLINKS = 10;
+export var PersistKey;
+(function (PersistKey) {
+    PersistKey["LastKvinit"] = "com.kochava.tracker.LastKvinit";
+    PersistKey["EventQueue"] = "com.kochava.tracker.EventQueue";
+    PersistKey["IdLinkQueue"] = "com.kochava.tracker.IdLinkQueue";
+    PersistKey["DeviceId"] = "com.kochava.tracker.DeviceId";
+    PersistKey["InstallId"] = "com.kochava.tracker.InstallId";
+    PersistKey["FirstStartDate"] = "com.kochava.tracker.FirstStartDate";
+    PersistKey["InstallSentDate"] = "com.kochava.tracker.InstallSentDate";
+    PersistKey["KvinitSentDate"] = "com.kochava.tracker.KvinitSentDate";
+    PersistKey["SessionCount"] = "com.kochava.tracker.SessionCount";
+    PersistKey["IdentityLinks"] = "com.kochava.tracker.IdentityLinks";
+    PersistKey["OverrideAppId"] = "com.kochava.tracker.OverrideAppId";
+    PersistKey["OverrideDeviceId"] = "com.kochava.tracker.OverrideDeviceId";
+    PersistKey["OldKvid"] = "kv_id";
+})(PersistKey || (PersistKey = {}));
+const storedKeys = [
+    PersistKey.LastKvinit,
+    PersistKey.EventQueue,
+    PersistKey.IdLinkQueue,
+    PersistKey.DeviceId,
+    PersistKey.InstallId,
+    PersistKey.FirstStartDate,
+    PersistKey.InstallSentDate,
+    PersistKey.KvinitSentDate,
+    PersistKey.SessionCount,
+    PersistKey.IdentityLinks,
+    PersistKey.OverrideAppId,
+    PersistKey.OverrideDeviceId,
+];
+export const checkInstallIdChange = (inputId, useCookies) => {
+    const persistedInstallId = readAndUpdatePersistedValue(PersistKey.InstallId, useCookies);
+    // if the input is empty, we don't need to change
+    if (!inputId)
+        return false;
+    // if the persistedId is empty, we will need to change
+    if (!persistedInstallId) {
+        updatePersistedValue(PersistKey.InstallId, inputId, useCookies);
+        return true;
+    }
+    // if the inputId and persistedId are the same, we dont need to change
+    if (inputId === persistedInstallId)
+        return false;
+    // at this point both inputId and persistedInstallId exist and are not equal,
+    // so we must need to change
+    updatePersistedValue(PersistKey.InstallId, inputId, useCookies);
+    return true;
+};
+export const addToPersistedEventQueue = (job) => {
+    const persistedQueueStr = localStorage.getItem(PersistKey.EventQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    persistedQueue.push(job);
+    localStorage.setItem(PersistKey.EventQueue, JSON.stringify(persistedQueue));
+};
+export const removeFromEventPersistedQueue = (job) => {
+    const persistedQueueStr = localStorage.getItem(PersistKey.EventQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    const queueWithJobRemoved = persistedQueue.filter(persistedJob => {
+        return persistedJob.id !== job.id;
+    });
+    localStorage.setItem(PersistKey.EventQueue, JSON.stringify(queueWithJobRemoved));
+};
+export const updateOrAddPersistedIdLinkQueue = (job) => {
+    const idLinkKey = Object.keys(job.idLink)[0];
+    const persistedQueueStr = localStorage.getItem(PersistKey.IdLinkQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    let updated = false;
+    for (const persistedJob of persistedQueue) {
+        const persistedKey = Object.keys(persistedJob.idLink)[0];
+        // if the key is already there, update it
+        if (idLinkKey === persistedKey) {
+            persistedJob.idLink[idLinkKey] = job.idLink[idLinkKey];
+            updated = true;
+        }
+    }
+    // if the key is new, add it
+    if (!updated)
+        persistedQueue.push(job);
+    localStorage.setItem(PersistKey.IdLinkQueue, JSON.stringify(persistedQueue));
+};
+export const removeFromIdLinkPersistedQueue = (job) => {
+    const persistedQueueStr = localStorage.getItem(PersistKey.IdLinkQueue);
+    const persistedQueue = JSON.parse(persistedQueueStr) || [];
+    const queueWithJobRemoved = persistedQueue.filter(persistedJob => {
+        return persistedJob.id !== job.id;
+    });
+    localStorage.setItem(PersistKey.IdLinkQueue, JSON.stringify(queueWithJobRemoved));
+};
+export const addPersistedIdLinks = (key, value, useCookies) => {
+    const persistedIdLinksStr = localStorage.getItem(PersistKey.IdentityLinks);
+    const persistedIdLinks = JSON.parse(persistedIdLinksStr) || {};
+    const storedSoFar = Object.keys(persistedIdLinks);
+    if (storedSoFar.length > MAX_STORED_IDLINKS) {
+        Log.debug("Maximum stored idLinks reached, most recent idLink will not be stored.");
+        return;
+    }
+    persistedIdLinks[key] = value;
+    updatePersistedValue(PersistKey.IdentityLinks, JSON.stringify(persistedIdLinks), useCookies);
+};
+export const checkDuplicateIdLink = (key, value) => {
+    const persistedIdLinksStr = localStorage.getItem(PersistKey.IdentityLinks);
+    if (persistedIdLinksStr) {
+        const persistedIdLinks = JSON.parse(persistedIdLinksStr) || {};
+        for (const persistedKey in persistedIdLinks) {
+            if (key === persistedKey && persistedIdLinks[persistedKey] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+export const getPersistedIdentityLinks = () => {
+    const persistedIdLinksStr = localStorage.getItem(PersistKey.IdentityLinks);
+    if (persistedIdLinksStr) {
+        return JSON.parse(persistedIdLinksStr);
+    }
+    return undefined;
+};
+export const readAndUpdateUTM = (appGuid, useCookies) => {
+    const storageName = appGuid + "_click";
+    const urlValue = getUrlParameter("ko_click_id");
+    const storageValue = localStorage.getItem(storageName);
+    let cookieValue = "";
+    if (useCookies)
+        cookieValue = getCookie(storageName);
+    if (urlValue) {
+        localStorage.setItem(storageName, urlValue);
+        if (useCookies)
+            setCookie(storageName, urlValue);
+    }
+    else if (storageValue) {
+        if (useCookies)
+            setCookie(storageName, urlValue);
+    }
+    return (urlValue) ? urlValue :
+        (storageValue) ? storageValue :
+            (cookieValue) ? cookieValue : "";
+};
+export const readAndUpdatePersistedValue = (key, useCookie) => {
+    const urlValue = getUrlParameter(key);
+    const storageValue = localStorage.getItem(key);
+    let cookieValue = "";
+    if (useCookie)
+        cookieValue = getCookie(key);
+    if (urlValue) {
+        updatePersistedValue(key, urlValue, useCookie);
+    }
+    else if (storageValue) {
+        updatePersistedValue(key, storageValue, useCookie);
+    }
+    else if (cookieValue) {
+        updatePersistedValue(key, storageValue, useCookie);
+    }
+    return (urlValue) ? urlValue :
+        (storageValue) ? storageValue :
+            (cookieValue) ? cookieValue : "";
+};
+export const updatePersistedValue = (key, value, useCookie) => {
+    localStorage.setItem(key, value);
+    if (useCookie)
+        setCookie(key, value);
+};
+export const deletePersistedValue = (item) => {
+    localStorage.removeItem(item);
+    deleteCookie(item);
+};
+export const deleteAllPersisted = () => storedKeys.forEach(item => deletePersistedValue(item));
+export const readAndUpdateDeviceId = (useCookie) => {
+    let storedDeviceId = readAndUpdatePersistedValue(PersistKey.DeviceId, useCookie);
+    if (!storedDeviceId) {
+        const kvId = `KB${utils.getCurrTimeSec()}T${utils.uuidv4()}`;
+        storedDeviceId = kvId.replace(/-/g, "");
+    }
+    updatePersistedValue(PersistKey.DeviceId, storedDeviceId, useCookie);
+    return storedDeviceId;
+};
+export const readAndUpdateSessionCount = (useCookie) => {
+    const storedSessionCount = readAndUpdatePersistedValue(PersistKey.SessionCount, useCookie);
+    let sessionCount = 1;
+    if (storedSessionCount) {
+        sessionCount = parseInt(storedSessionCount);
+        sessionCount++;
+    }
+    updatePersistedValue(PersistKey.SessionCount, sessionCount.toString(), useCookie);
+    return sessionCount;
+};

package/dist/http.d.ts

@@ -0,0 +1,6 @@
+import { Payload } from "./payloads/payload";
+export interface BaseResp {
+    success: string | number | boolean;
+}
+export declare const sendRequest: (payload: Payload, endpoint: string) => Promise<string>;
+export declare const wasRespSuccess: (success: string | number | boolean) => boolean;

package/dist/http.js

@@ -0,0 +1,23 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+import { Log } from "./utils/log";
+export const sendRequest = async (payload, endpoint) => {
+    try {
+        const headers = new Headers();
+        headers.append("Content-Type", "application/json");
+        Log.trace(`Request ${payload.nt_id} being sent to: `, endpoint);
+        const resp = await fetch(endpoint, {
+            method: "POST",
+            headers: headers,
+            body: JSON.stringify(payload),
+        });
+        return await resp.text();
+    }
+    catch (e) {
+        Log.error("Error in post request", e);
+        return "";
+    }
+};
+export const wasRespSuccess = (success) => success === "1" || success === 1 || success === true;

package/dist/interfaces.d.ts

@@ -0,0 +1,117 @@
+interface DefaultConfig {
+    readonly general: {
+        readonly app_id_override: string;
+        readonly device_id_override: string;
+    };
+    readonly config: {
+        readonly init_token: string;
+        readonly refresh_minimum: number;
+    };
+    readonly install: {
+        readonly resend_id: "";
+        readonly updates_enabled: true;
+    };
+    readonly networking: {
+        readonly urls: {
+            readonly init: "https://kvinit-prod.api.kochava.com/track/kvinit";
+            readonly install: "https://web-sdk.control.kochava.com/track/json/";
+            readonly event: "https://web-sdk.control.kochava.com/track/json/";
+            readonly identityLink: "https://web-sdk.control.kochava.com/v1/cpi/identityLink.php";
+        };
+        readonly retry_waterfall: [7, 30, 300, 1800];
+    };
+    readonly privacy: {
+        readonly allow_custom_ids: string[];
+        readonly deny_datapoints: string[];
+        readonly deny_event_names: string[];
+        readonly deny_identity_links: string[];
+    };
+}
+export declare const DEFAULTS: DefaultConfig;
+export interface KvConfig {
+    general: {
+        device_id_override?: string;
+        app_id_override?: string;
+    };
+    config: {
+        init_token: string;
+        refresh_minimum: number;
+    };
+    install: {
+        resend_id?: string;
+        updates_enabled: boolean;
+    };
+    networking: {
+        urls: {
+            init: string;
+            install: string;
+            identityLink: string;
+            event: string;
+        };
+        retry_waterfall: number[];
+    };
+    privacy: {
+        allow_custom_ids: string[];
+        deny_datapoints: string[];
+        deny_event_names: string[];
+        deny_identity_links: string[];
+    };
+}
+export interface KvinitResponse {
+    general?: {
+        device_id_override?: string;
+        app_id_override?: string;
+    };
+    config?: {
+        init_token?: string;
+        refresh_minimum?: number;
+    };
+    install?: {
+        resend_id?: string;
+        updates_enabled?: boolean;
+    };
+    networking?: {
+        urls?: {
+            init?: string;
+            install?: string;
+            identityLink?: string;
+            event?: string;
+        };
+        retry_waterfall?: number[];
+    };
+    privacy?: {
+        allow_custom_ids?: string[];
+        deny_datapoints?: string[];
+        deny_event_names?: string[];
+        deny_identity_links?: string[];
+    };
+    success?: string | number | boolean;
+}
+export declare type Json = {
+    [key: string]: any;
+};
+export declare type IdentityLink = {
+    [key: string]: string;
+};
+export interface Urls {
+    init: string;
+    install: string;
+    event: string;
+    identityLink: string;
+}
+export interface OverrideUrls {
+    init?: string;
+    install?: string;
+    event?: string;
+    identityLink?: string;
+}
+export interface CustomValue {
+    data: Json;
+    isDeviceId: boolean;
+}
+export interface WrapperVersion {
+    name: string;
+    version: string;
+    build_date: string;
+}
+export {};

package/dist/interfaces.js

@@ -0,0 +1,36 @@
+/*
+  Authored by Brett Barinaga on 11/17/21.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+export const DEFAULTS = {
+    general: {
+        // DO NOT DEFAULT
+        app_id_override: "",
+        // DO NOT DEFAULT
+        device_id_override: "",
+    },
+    config: {
+        init_token: "",
+        refresh_minimum: 60,
+    },
+    install: {
+        // DO NOT DEFAULT
+        resend_id: "",
+        updates_enabled: true,
+    },
+    networking: {
+        urls: {
+            init: "https://kvinit-prod.api.kochava.com/track/kvinit",
+            install: "https://web-sdk.control.kochava.com/track/json/",
+            event: "https://web-sdk.control.kochava.com/track/json/",
+            identityLink: "https://web-sdk.control.kochava.com/v1/cpi/identityLink.php"
+        },
+        retry_waterfall: [7, 30, 300, 1800],
+    },
+    privacy: {
+        allow_custom_ids: [],
+        deny_datapoints: [],
+        deny_event_names: [],
+        deny_identity_links: [],
+    },
+};

package/dist/jobqueue.d.ts

@@ -0,0 +1,35 @@
+import { IdentityLink, Json } from "./interfaces";
+import { KochavaInstance } from "./kochava";
+import { PostStartBody, PreStartBody } from "./payloads/payload";
+export interface Job {
+    id: string;
+    queuedBeforeStart: boolean;
+    preStartBody: PreStartBody;
+    postStartBody: PostStartBody;
+    retries: number;
+}
+export interface EventJob extends Job {
+    eventName: string;
+}
+export interface IdLinkJob extends Job {
+    idLink: IdentityLink;
+}
+export default class JobQueue {
+    private eventQueue;
+    idLinkQueue: IdLinkJob[];
+    private processing;
+    private stopped;
+    private paused;
+    private timeOut;
+    constructor();
+    start(instance: KochavaInstance): Promise<void>;
+    stop(): void;
+    pause(): void;
+    enqueueEvent(instance: KochavaInstance, args: [string, Json | string]): Promise<void>;
+    enqueueIdLink(instance: KochavaInstance, idLink: IdentityLink): Promise<void>;
+    dequeueJob(instance: KochavaInstance): Promise<boolean>;
+    processJob(instance: KochavaInstance, job: EventJob | IdLinkJob): Promise<boolean>;
+    attemptJob(instance: KochavaInstance, job: Job): Promise<boolean>;
+    updateEventJobs(instance: KochavaInstance): void;
+    updateIdLinkJobs(instance: KochavaInstance): void;
+}