@blotoutio/edgetag-sdk-js 0.2.0 → 0.4.3

package/README.md

@@ -1,3 +1,3 @@
 # EdgeTag SDK Core
 
-More info on https://edgetag.io/integration/js
+More info on https://app.edgetag.io/integration/js

package/api/consent.d.ts

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

package/api/data.d.ts

@@ -0,0 +1 @@
+export declare const handleData: (data: Record<string, string>) => void;

package/api/getData.d.ts

@@ -0,0 +1 @@
+export declare const handleGetData: (keys: string[], callback: (data: Record<string, string>) => void) => void;

package/api/init.d.ts

@@ -0,0 +1,2 @@
+import { InitPreferences } from '../typings';
+export declare const handleInit: (preferences: InitPreferences) => void;

package/api/keys.d.ts

@@ -0,0 +1 @@
+export declare const handleKeys: (callback: (keys: string[]) => void) => void;

package/api/tag.d.ts

@@ -0,0 +1,2 @@
+import { Data } from '../typings';
+export declare const handleTag: (name: string, data?: Data, providers?: Data) => void;

package/api/user.d.ts

@@ -0,0 +1,2 @@
+import { UserKey } from '../typings';
+export declare const handleUser: (key: UserKey, value: string) => void;

package/common/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const isDevMode = false;
+export declare const tagStorage = "edgeTag";
+export declare const consentKey = "consent";
+export declare const providersKey = "providers";
+export declare const keyPrefix = "_worker";

package/common/init.d.ts

@@ -0,0 +1,3 @@
+import { InitPreferences } from '../typings';
+export declare const setPreferences: (preferences: InitPreferences) => boolean;
+export declare const isConsentDisabled: () => boolean;

package/common/logUtil.d.ts

@@ -0,0 +1,3 @@
+export declare const info: (data: string) => void;
+export declare const log: (data: string) => void;
+export declare const error: (data: string) => void;

package/common/storage.d.ts

@@ -0,0 +1,7 @@
+import { PersistType } from '../typings/internal';
+export declare const saveDataPerKey: (persistType: PersistType, provider: string, value: unknown, key: string) => void;
+export declare const savePerKey: (persistType: PersistType, provider: string, value: unknown, key: string) => void;
+export declare const getDataPerKey: (persistType: PersistType, provider: string, key: string) => unknown;
+export declare const saveData: (persistType: PersistType, value: unknown, key?: string) => void;
+export declare const getData: (persistType: PersistType, key?: string) => Record<string, Record<string, unknown>>;
+export declare const saveKV: (data: Record<string, string>) => void;

package/common/utils.d.ts

@@ -0,0 +1,3 @@
+import { Data } from '../typings';
+export declare const getUserAgent: () => string;
+export declare const allowTag: (providers?: Data) => boolean;

package/index.cjs

@@ -0,0 +1,547 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+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 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;
+const setPreferences = preferences => {
+  if (!preferences) {
+    return false;
+  }
+
+  if (!preferences.edgeURL) {
+    console.error('Please provide URL for EdgeTag');
+    return false;
+  }
+
+  consentDisabled = !!preferences.disableConsentCheck;
+  setUrl(preferences.edgeURL);
+  return true;
+};
+const isConsentDisabled = () => consentDisabled;
+
+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 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 handleTag = (name, data, providers) => {
+  const payload = {
+    eventName: name
+  };
+
+  if (data) {
+    payload.data = data;
+  }
+
+  if (providers) {
+    payload.providers = providers;
+  }
+
+  if (!allowTag(providers)) {
+    console.log('No consent');
+    return;
+  }
+
+  postRequest(getTagURL(), payload).catch(info);
+};
+
+const getCookieValue = key => {
+  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 handleCaptureQuery = (provider, key, persistType) => {
+  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.getItem(key);
+        break;
+      }
+
+    case 'session':
+      {
+        data = 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 = [];
+  manifest.forEach(provider => {
+    providers.push(provider.package);
+    Object.entries(provider.rules).forEach(([name, recipe]) => {
+      switch (name) {
+        case 'capture':
+          {
+            handleCapture(provider.package, recipe);
+            return;
+          }
+      }
+    });
+  });
+  savePerKey('local', tagStorage, providers, providersKey);
+};
+
+const handleInit = preferences => {
+  const success = setPreferences(preferences);
+
+  if (!success) {
+    return;
+  }
+
+  let url = `${getInitURL()}`;
+
+  if (preferences.disableConsentCheck) {
+    url = `${url}?consentDisabled=true`;
+    saveConsent({
+      all: true
+    });
+  }
+
+  getRequest(url).then(result => {
+    if (!result) {
+      console.log('init failed');
+      return;
+    }
+
+    handleManifest(result.result);
+  }).catch(info);
+};
+
+const handleUser = (key, value) => {
+  if (!key || !value) {
+    console.error('Key or Value is missing in user API.');
+    return;
+  }
+
+  saveKV({
+    [key]: value
+  });
+  postRequest(getUserURL(), {
+    key,
+    value
+  }).catch(info);
+};
+
+const handleData = data => {
+  if (!data || Object.keys(data).length === 0) {
+    console.error('Provide data for data API.');
+    return;
+  }
+
+  saveKV(data);
+  postRequest(getDataURL(), {
+    data
+  }).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) => {
+  handleTag(name, data, providers);
+};
+const consent = consent => {
+  handleConsent(consent);
+};
+const user = (key, value) => {
+  handleUser(key, value);
+};
+const data = data => {
+  handleData(data);
+};
+const getData = (keys, callback) => {
+  handleGetData(keys, callback);
+};
+const keys = callback => {
+  handleKeys(callback);
+};
+
+exports.consent = consent;
+exports.data = data;
+exports.getData = getData;
+exports.init = init;
+exports.keys = keys;
+exports.tag = tag;
+exports.user = user;

package/index.d.ts

@@ -1,16 +1,8 @@
-type Data = Record<string, any>
-
-interface InitPreferences {
-  edgeURL: string
-  disableConsentCheck?: boolean
-}
-
-interface EventOptions {
-  method?: 'beacon'
-}
-
-export declare const init: (preferences: InitPreferences) => void
-
-export declare const tag: (name: string, data?: Data) => void
-
-export declare const consent: (consent: Data) => void
+import { Data, InitPreferences, UserKey } from './typings';
+export declare const init: (preferences: InitPreferences) => void;
+export declare const tag: (name: string, data?: Data, providers?: Data) => void;
+export declare const consent: (consent: Data) => void;
+export declare const user: (key: UserKey, value: string) => void;
+export declare const data: (data: Record<string, string>) => void;
+export declare const getData: (keys: string[], callback: (data: Record<string, string>) => void) => void;
+export declare const keys: (callback: (keys: string[]) => void) => void;