@blotoutio/edgetag-sdk-js 0.2.0 → 0.4.3

package/index.js

@@ -1,3 +1,537 @@
-'use strict'
+/******************************************************************************
+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());
+    });
+}
 
-module.exports = require('./cjs/index.js')
+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);
+};
+
+export { consent, data, getData, init, keys, tag, user };

package/jest.config.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    displayName: string;
+    preset: string;
+    transform: {
+        '^.+\\.[tj]sx?$': string;
+    };
+    moduleFileExtensions: string[];
+    coverageDirectory: string;
+};
+export default _default;

package/manifest/capture.d.ts

@@ -0,0 +1,2 @@
+import { ManifestRule } from '../typings/internal';
+export declare const handleCapture: (provider: string, params: ManifestRule[]) => void;

package/manifest/index.d.ts

@@ -0,0 +1,2 @@
+import { Manifest } from '../typings/internal';
+export declare const handleManifest: (manifest: Manifest[]) => void;

package/network/endPoint.d.ts

@@ -0,0 +1,9 @@
+export declare const getUrl: () => string;
+export declare const setUrl: (url?: string) => void;
+export declare const getTagURL: () => string;
+export declare const getInitURL: () => string;
+export declare const getConsentURL: () => string;
+export declare const getUserURL: () => string;
+export declare const getDataURL: () => string;
+export declare const getGetDataURL: (keys: string[]) => string;
+export declare const getKeysURL: () => string;

package/network/utils.d.ts

@@ -0,0 +1,3 @@
+import { EventOptions } from '../typings';
+export declare function postRequest<Payload, Response>(url: string, data?: Payload, options?: EventOptions): Promise<unknown>;
+export declare function getRequest<Response>(url: string, options?: EventOptions): Promise<Response>;

package/package.json

@@ -1,35 +1,26 @@
 {
   "name": "@blotoutio/edgetag-sdk-js",
-  "version": "0.2.0",
+  "version": "0.4.3",
   "description": "JS SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",
   "homepage": "https://github.com/blotoutio/edgetag-sdk",
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/blotoutio/edgetag-sdk.git"
   },
-  "files": [
-    "cjs",
-    "esm",
-    "index.js",
-    "package.json",
-    "README.md",
-    "index.d.ts"
-  ],
-  "types": "index.d.ts",
-  "main": "index.js",
-  "module": "esm/index.js",
-  "scripts": {
-    "prepublish": "npm run build",
-    "build": "rollup --config",
-    "lint": "prettier --check .",
-    "start": "rollup --config --w"
-  },
-  "dependencies": {
-    "uuid": "^8.3.0"
-  },
-  "publishConfig": {
-    "access": "public"
+  "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

@@ -0,0 +1,40 @@
+type UserKey =
+  | 'email'
+  | 'phone'
+  | 'firstName'
+  | 'lastName'
+  | 'gender'
+  | 'dateOfBirth'
+  | 'country'
+  | 'state'
+  | 'city'
+  | 'zip'
+  | 'address'
+
+type Data = Record<string, unknown>
+
+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
+
+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

package/typings/internal.d.ts

@@ -0,0 +1,46 @@
+import { Data, UserKey } from './index'
+
+type PersistType = 'local' | 'session'
+
+type Navigator = {
+  userAgent: string
+  brave: unknown
+}
+
+type TagPayload = {
+  eventName: string
+  data?: Data
+  providers?: Data
+}
+
+type ConsentPayload = {
+  consentString: Data
+}
+
+type UserPayload = {
+  key: UserKey
+  value: string
+}
+
+type DataPayload = {
+  data: Record<string, string>
+}
+
+type PostPayload = {
+  pageUrl: string
+  userAgent: string
+  data?: Data
+  storage?: Data
+}
+
+export type ManifestRule = {
+  type: string
+  key: string
+  persist: PersistType
+  location?: string
+}
+
+export type Manifest = {
+  package: string
+  rules: Record<string, ManifestRule[]>
+}