@blotoutio/edgetag-sdk-js 0.2.0 → 0.3.0

package/index.umd.js

@@ -0,0 +1,487 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BlotoutEdgeTagSDKJS = {}));
+})(this, (function (exports) { '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());
+        });
+    }
+
+    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(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(persistType);
+
+      if (!storage[provider]) {
+        storage[provider] = {};
+      }
+
+      storage[provider][key] = value;
+      saveData(persistType, storage);
+    };
+    const getDataPerKey = (persistType, provider, key) => {
+      const storage = getData(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 = (persistType, key = initKey) => {
+      if (persistType === 'session') {
+        return getSession(key);
+      }
+
+      return getLocal(key);
+    };
+
+    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');
+    };
+
+    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('session');
+
+      if (session) {
+        storage = Object.assign(Object.assign({}, storage), session);
+      }
+
+      const local = getData('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' && navigator.sendBeacon) {
+          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' && navigator.sendBeacon) {
+          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;
+      }
+
+      const payload = {
+        key,
+        value
+      };
+      postRequest(getUserURL(), payload).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);
+    };
+
+    exports.consent = consent;
+    exports.init = init;
+    exports.tag = tag;
+    exports.user = user;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

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,6 @@
+export declare const getUrl: () => string;
+export declare const setUrl: (url?: string | undefined) => void;
+export declare const getTagURL: () => string;
+export declare const getInitURL: () => string;
+export declare const getConsentURL: () => string;
+export declare const getUserURL: () => string;

package/network/utils.d.ts

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

package/package.json

@@ -1,35 +1,18 @@
 {
   "name": "@blotoutio/edgetag-sdk-js",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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"
-  }
+  "main": "./index.umd.js",
+  "module": "./index.esm.js",
+  "typings": "./index.d.ts"
 }

package/typings/index.d.ts

@@ -0,0 +1,28 @@
+type UserKeys =
+  | 'email'
+  | 'phone'
+  | 'firstName'
+  | 'lastName'
+  | 'gender'
+  | 'dateOfBirth'
+  | 'country'
+  | 'state'
+  | 'city'
+  | 'zip'
+
+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

package/typings/internal.d.ts

@@ -0,0 +1,44 @@
+import { Data, UserKeys } from "./index";
+
+type PersistType = 'local' | 'session'
+
+interface Navigator {
+  userAgent: string
+  brave: unknown
+}
+
+interface TagRequest {
+  eventName: string
+  data?: Data
+  providers?: Data
+}
+
+interface ConsentRequest {
+  consentString: Data
+}
+
+interface UserRequest {
+  key: UserKeys
+  value: string
+}
+
+type PostData = TagRequest | ConsentRequest | UserRequest
+
+interface 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[]>
+}