@blotoutio/edgetag-sdk-js 0.5.1 → 0.6.0

package/index..esm.js

@@ -0,0 +1,569 @@
+import { v4 } from 'uuid';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const tagStorage = 'edgeTag';
+const consentKey = 'consent';
+const providersKey = 'providers';
+const keyPrefix = `_worker`;
+
+const initKey = `${keyPrefix}Store`;
+const getCookieValue = (key) => {
+    if (!document || !document.cookie) {
+        return '';
+    }
+    const name = `${key}=`;
+    const decodedCookie = decodeURIComponent(document.cookie);
+    const ca = decodedCookie.split(';');
+    for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === ' ') {
+            c = c.substring(1);
+        }
+        if (c.indexOf(name) === 0) {
+            return c.substring(name.length, c.length);
+        }
+    }
+    return '';
+};
+const saveDataPerKey = (persistType, provider, value, key) => {
+    const storage = getData$1(persistType);
+    if (!storage['data']) {
+        storage['data'] = {};
+    }
+    if (!storage['data'][provider]) {
+        storage['data'][provider] = {};
+    }
+    storage['data'][provider][key] = value;
+    saveData(persistType, storage);
+};
+const savePerKey = (persistType, provider, value, key) => {
+    const storage = getData$1(persistType);
+    if (!storage[provider]) {
+        storage[provider] = {};
+    }
+    storage[provider][key] = value;
+    saveData(persistType, storage);
+};
+const getDataPerKey = (persistType, provider, key) => {
+    const storage = getData$1(persistType);
+    if (!storage[provider]) {
+        return undefined;
+    }
+    return storage[provider][key];
+};
+const saveData = (persistType, value, key = initKey) => {
+    if (persistType === 'session') {
+        saveSession(value, key);
+        return;
+    }
+    saveLocal(value, key);
+};
+const getData$1 = (persistType, key = initKey) => {
+    if (persistType === 'session') {
+        return getSession(key);
+    }
+    return getLocal(key);
+};
+const saveKV = (data) => {
+    let currentSession = getData$1('session');
+    if (!currentSession) {
+        currentSession = {};
+    }
+    if (!currentSession['kv']) {
+        currentSession['kv'] = {};
+    }
+    currentSession['kv'] = Object.assign(Object.assign({}, currentSession['kv']), data);
+    saveData('session', currentSession);
+};
+const saveLocal = (value, key) => {
+    localStorage.setItem(key, JSON.stringify(value));
+};
+const getLocal = (key) => {
+    const data = localStorage.getItem(key);
+    if (!data) {
+        return {};
+    }
+    return JSON.parse(data) || {};
+};
+const saveSession = (value, key) => {
+    sessionStorage.setItem(key, JSON.stringify(value));
+};
+const getSession = (key) => {
+    const data = sessionStorage.getItem(key);
+    if (!data) {
+        return {};
+    }
+    return JSON.parse(data) || {};
+};
+
+let endpointUrl = '';
+const generateUrl = (path) => {
+    const endpoint = getUrl();
+    if (!endpoint) {
+        console.log('URL is not valid');
+        return '';
+    }
+    return `${endpoint}${path}`;
+};
+const getUrl = () => {
+    return endpointUrl;
+};
+const setUrl = (url) => {
+    if (url == null) {
+        return;
+    }
+    endpointUrl = url;
+};
+const getTagURL = () => {
+    return generateUrl('/tag');
+};
+const getInitURL = () => {
+    return generateUrl('/init');
+};
+const getConsentURL = () => {
+    return generateUrl('/consent');
+};
+const getUserURL = () => {
+    return generateUrl('/user');
+};
+const getDataURL = () => {
+    return generateUrl(`/data`);
+};
+const getGetDataURL = (keys) => {
+    return generateUrl(`/data?keys=${encodeURIComponent(keys.join(','))}`);
+};
+const getKeysURL = () => {
+    return generateUrl(`/keys`);
+};
+
+let consentDisabled = false;
+let providers = [];
+const setPreferences = (preferences) => {
+    if (!preferences) {
+        return false;
+    }
+    if (!preferences.edgeURL) {
+        console.error('Please provide URL for EdgeTag');
+        return false;
+    }
+    consentDisabled = !!preferences.disableConsentCheck;
+    providers = preferences.providers || [];
+    if (window && window.edgetagPackages) {
+        providers = [...window.edgetagPackages, ...providers];
+    }
+    setUrl(preferences.edgeURL);
+    return true;
+};
+const isConsentDisabled = () => consentDisabled;
+const getProvidersPackage = () => providers;
+
+const getUserAgent = () => {
+    const nav = navigator;
+    let ua = nav.userAgent;
+    ua += nav.brave ? `${ua} Brave` : '';
+    return ua;
+};
+const allowTag = (providers) => {
+    const consent = getDataPerKey('local', tagStorage, consentKey);
+    if (isConsentDisabled()) {
+        return true;
+    }
+    if (!consent) {
+        return false;
+    }
+    if (consent['all']) {
+        return true;
+    }
+    if (!providers) {
+        return (Object.values(consent).find((isAllowed) => isAllowed) || false);
+    }
+    const allProviders = (getDataPerKey('local', tagStorage, providersKey) ||
+        []);
+    for (const provider of allProviders) {
+        const tagProviderSetting = providers[provider];
+        if (tagProviderSetting ||
+            (providers['all'] === true && tagProviderSetting === undefined) ||
+            (providers['all'] === false && tagProviderSetting === true)) {
+            if (consent[provider]) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const allowProvider = (providers, providerId) => {
+    const consent = getDataPerKey('local', tagStorage, consentKey);
+    if (isConsentDisabled()) {
+        return true;
+    }
+    if (!consent) {
+        return false;
+    }
+    if (consent['all']) {
+        return true;
+    }
+    if (!providers) {
+        return consent[providerId];
+    }
+    const tagProvider = providers[providerId];
+    if (tagProvider ||
+        (providers['all'] === true && tagProvider === undefined) ||
+        (providers['all'] === false && tagProvider === true)) {
+        if (consent[providerId]) {
+            return true;
+        }
+    }
+    return false;
+};
+
+const beacon = (url, payload) => {
+    let blob;
+    if (payload) {
+        blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
+    }
+    return navigator.sendBeacon(url, blob);
+};
+const ajax = (method, url, payload) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield fetch(url, {
+        method,
+        headers: {
+            'Content-type': 'application/json; charset=utf-8',
+            Accept: 'application/json; charset=utf-8',
+        },
+        body: JSON.stringify(payload),
+        credentials: 'include',
+    })
+        .then((response) => response.json().then((data) => ({ status: response.status, body: data })))
+        .then((data) => {
+        if (data.status < 200 || data.status >= 300) {
+            // Q: do we need to retry?
+            return Promise.reject(new Error(JSON.stringify(data.body)));
+        }
+        return Promise.resolve(data.body);
+    })
+        .catch((error) => {
+        // Q: do we need to retry?
+        return Promise.reject(new Error(error));
+    });
+});
+const getStandardPayload = (payload) => {
+    const data = Object.assign({ pageUrl: window.location.href, userAgent: getUserAgent() }, (payload || {}));
+    let storage = {};
+    const session = getData$1('session');
+    if (session) {
+        storage = Object.assign(Object.assign({}, storage), session);
+    }
+    const local = getData$1('local');
+    if (local) {
+        storage = Object.assign(Object.assign({}, storage), local);
+    }
+    data.storage = storage;
+    return data;
+};
+function postRequest(url, data, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!url) {
+            return Promise.reject(new Error('URL is empty'));
+        }
+        const payload = getStandardPayload(data);
+        if (options && options.method === 'beacon') {
+            return Promise.resolve(beacon(url, payload));
+        }
+        return yield ajax('POST', url, payload);
+    });
+}
+function getRequest(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!url) {
+            return Promise.reject(new Error('URL is empty'));
+        }
+        if (options && options.method === 'beacon') {
+            return {
+                result: Promise.resolve(beacon(url)),
+            };
+        }
+        return yield ajax('GET', url);
+    });
+}
+
+const info = (data) => {
+};
+
+const saveConsent = (consent) => {
+    savePerKey('local', tagStorage, consent, consentKey);
+};
+const handleConsent = (consent) => {
+    const payload = {
+        consentString: consent,
+    };
+    saveConsent(consent);
+    postRequest(getConsentURL(), payload).catch(info);
+};
+
+const generateEventId = (name) => {
+    let time = Date.now().toString();
+    if (typeof performance !== 'undefined' &&
+        typeof performance.now === 'function') {
+        const perf = performance.now();
+        if (perf) {
+            time = perf.toFixed(4);
+        }
+    }
+    return `${btoa(name)}-${v4()}-${time}`;
+};
+
+const handleGetUserId = () => {
+    return getCookieValue('tag_user_id');
+};
+
+const manifestVariables = {};
+const addProviderVariable = (name, variables) => {
+    manifestVariables[name] = variables;
+};
+const getProviderVariables = (name) => manifestVariables[name] || {};
+
+const sendTag = ({ eventName, eventId, data, providerData, providers, options, }) => {
+    const payload = {
+        eventName,
+        eventId,
+        timestamp: Date.now(),
+        data,
+        providerData,
+    };
+    if (providers) {
+        payload.providers = providers;
+    }
+    postRequest(getTagURL(), payload, options).catch(info);
+};
+const handleTag = (eventName, data = {}, providers, options) => {
+    if (!allowTag(providers)) {
+        console.log('No consent');
+        return;
+    }
+    let eventId = data['eventId'];
+    if (!eventId) {
+        eventId = generateEventId(eventName);
+    }
+    const providerPackages = getProvidersPackage();
+    const userId = handleGetUserId();
+    const providerData = {};
+    if (providerPackages) {
+        providerPackages.forEach((pkg) => {
+            if (!allowProvider(providers, pkg.name)) {
+                return;
+            }
+            if (pkg && pkg.tag) {
+                const result = pkg.tag({
+                    userId,
+                    eventName,
+                    eventId,
+                    data,
+                    sendTag,
+                    manifestVariables: getProviderVariables(pkg.name),
+                });
+                if (result) {
+                    providerData[pkg.name] = result;
+                }
+            }
+        });
+    }
+    sendTag({
+        eventName,
+        eventId,
+        data,
+        providerData,
+        providers,
+        options,
+    });
+};
+
+const handleCaptureQuery = (provider, key, persistType) => {
+    if (!window) {
+        return;
+    }
+    const params = new URLSearchParams(window.location.search);
+    if (!params || !params.get(key)) {
+        return;
+    }
+    saveDataPerKey(persistType, provider, params.get(key), key);
+};
+const handleCaptureStorage = (provider, key, persistType, location) => {
+    let data;
+    switch (location) {
+        case 'cookie': {
+            data = getCookieValue(key);
+            break;
+        }
+        case 'local': {
+            data = sessionStorage && sessionStorage.getItem(key);
+            break;
+        }
+        case 'session': {
+            data = localStorage && localStorage.getItem(key);
+            break;
+        }
+    }
+    if (!data) {
+        return;
+    }
+    saveDataPerKey(persistType, provider, data, key);
+};
+const handleCapture = (provider, params) => {
+    params.forEach((param) => {
+        switch (param.type) {
+            case 'query': {
+                handleCaptureQuery(provider, param.key, param.persist);
+                break;
+            }
+            case 'storage': {
+                handleCaptureStorage(provider, param.key, param.persist, param.location);
+                break;
+            }
+        }
+    });
+};
+
+const handleManifest = (manifest) => {
+    const providers = [];
+    const providerPackages = getProvidersPackage();
+    const userId = handleGetUserId();
+    manifest.forEach((provider) => {
+        providers.push(provider.package);
+        addProviderVariable(provider.package, provider.variables);
+        if (provider.rules) {
+            Object.entries(provider.rules).forEach(([name, recipe]) => {
+                switch (name) {
+                    case 'capture': {
+                        handleCapture(provider.package, recipe);
+                        return;
+                    }
+                }
+            });
+        }
+        if (providerPackages) {
+            const pkg = providerPackages.find((pkg) => pkg.name === provider.package);
+            if (pkg && pkg.init) {
+                pkg.init({ userId, manifest: provider, sendTag });
+            }
+        }
+    });
+    savePerKey('local', tagStorage, providers, providersKey);
+};
+
+const handleInit = (preferences) => {
+    const success = setPreferences(preferences);
+    if (!success) {
+        return;
+    }
+    const url = new URL(getInitURL());
+    if (preferences.disableConsentCheck) {
+        url.searchParams.set('consentDisabled', 'true');
+        saveConsent({ all: true });
+    }
+    if (preferences.userId) {
+        url.searchParams.set('userId', preferences.userId);
+    }
+    getRequest(url.href)
+        .then((result) => {
+        if (!result) {
+            console.log('init failed');
+            return;
+        }
+        handleManifest(result.result);
+    })
+        .catch(info);
+};
+
+const handleUser = (key, value, options) => {
+    if (!key || !value) {
+        console.error('Key or Value is missing in user API.');
+        return;
+    }
+    saveKV({
+        [key]: value,
+    });
+    postRequest(getUserURL(), {
+        key,
+        value,
+    }, options).catch(info);
+};
+
+const handleData = (data, options) => {
+    if (!data || Object.keys(data).length === 0) {
+        console.error('Provide data for data API.');
+        return;
+    }
+    saveKV(data);
+    postRequest(getDataURL(), { data }, options).catch(info);
+};
+
+const handleGetData = (keys, callback) => {
+    if (!keys || keys.length === 0) {
+        console.error('Provide keys for get data API.');
+        return;
+    }
+    getRequest(getGetDataURL(keys))
+        .then((result) => {
+        callback((result === null || result === void 0 ? void 0 : result.result) || {});
+    })
+        .catch(info);
+};
+
+const handleKeys = (callback) => {
+    getRequest(getKeysURL())
+        .then((result) => {
+        callback((result === null || result === void 0 ? void 0 : result.result) || []);
+    })
+        .catch(info);
+};
+
+const init = (preferences) => {
+    handleInit(preferences);
+};
+const tag = (name, data, providers, options) => {
+    handleTag(name, data, providers, options);
+};
+const consent = (consent) => {
+    handleConsent(consent);
+};
+const user = (key, value, options) => {
+    handleUser(key, value, options);
+};
+const data = (data, options) => {
+    handleData(data, options);
+};
+const getData = (keys, callback) => {
+    handleGetData(keys, callback);
+};
+const keys = (callback) => {
+    handleKeys(callback);
+};
+const getUserId = () => {
+    return handleGetUserId();
+};
+
+export { consent, data, getData, getUserId, init, keys, tag, user };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotoutio/edgetag-sdk-js",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "JS SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",
@@ -8,19 +8,12 @@
   "publishConfig": {
     "access": "public"
   },
+  "main": "./index.esm.js",
+  "peerDependencies": {
+    "uuid": "*"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/blotoutio/edgetag-sdk.git"
-  },
-  "module": "./index.js",
-  "main": "./index.cjs",
-  "type": "module",
-  "types": "./index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "require": "./index.cjs"
-    }
   }
 }

package/typings/index.d.ts

@@ -1,3 +1,58 @@
+// TODO this all located in '@blotoutio/shared/utility-sdk'
+
+type PersistType = 'local' | 'session'
+
+type EventOptions = {
+  method?: 'beacon'
+}
+
+type Data = Record<string, unknown>
+
+export type SendTag = {
+  eventName: string
+  eventId: string
+  data: Data
+  providerData?: Data
+  providers?: Data
+  options?: EventOptions
+}
+
+type ManifestRule = {
+  type: string
+  key: string
+  persist: PersistType
+  location?: string
+}
+
+type Manifest = {
+  package: string
+  variables?: Record<string, string>
+  rules: Record<string, ManifestRule[]>
+}
+
+type InitParams = {
+  userId: string
+  manifest: Manifest
+  sendTag: (params: SendTag) => void
+}
+
+type TagParams = {
+  userId: string
+  eventId: string
+  eventName: string
+  data: Data
+  manifestVariables: Record<string, string>
+  sendTag: (params: SendTag) => void
+}
+
+type ProviderInit = {
+  name: string
+  init?: (params: InitParams) => void
+  tag?: (params: TagParams) => unknown
+}
+
+// end TODO
+
 type UserKey =
   | 'email'
   | 'phone'
@@ -11,16 +66,11 @@ type UserKey =
   | 'zip'
   | 'address'
 
-type Data = Record<string, unknown>
-
-interface InitPreferences {
+type InitPreferences = {
   edgeURL: string
   disableConsentCheck?: boolean
   userId?: string
-}
-
-interface EventOptions {
-  method?: 'beacon'
+  providers?: ProviderInit[]
 }
 
 export declare const init: (preferences: InitPreferences) => void
@@ -39,3 +89,5 @@ export declare const getData: (
 ) => void
 
 export declare const keys: (callback: (keys: string[]) => void) => void
+
+export declare const getUserId: () => string

package/typings/internal.d.ts

@@ -1,6 +1,4 @@
-import { Data, UserKey } from './index'
-
-type PersistType = 'local' | 'session'
+import { UserKey, Data } from './index'
 
 type Navigator = {
   userAgent: string
@@ -9,6 +7,9 @@ type Navigator = {
 
 type TagPayload = {
   eventName: string
+  eventId: string
+  timestamp: number
+  providerData?: Data
   data?: Data
   providers?: Data
 }
@@ -32,15 +33,3 @@ type PostPayload = {
   data?: Data
   storage?: Data
 }
-
-export type ManifestRule = {
-  type: string
-  key: string
-  persist: PersistType
-  location?: string
-}
-
-export type Manifest = {
-  package: string
-  rules: Record<string, ManifestRule[]>
-}

package/api/consent.d.ts

@@ -1,3 +0,0 @@
-import { Data } from '../typings';
-export declare const saveConsent: (consent: Data) => void;
-export declare const handleConsent: (consent: Data) => void;