@blotoutio/edgetag-sdk-browser 0.6.3 → 0.6.5

package/index.js

@@ -101,24 +101,56 @@
         saveData('session', currentSession);
     };
     const saveLocal = (value, key) => {
-        localStorage.setItem(key, JSON.stringify(value));
+        try {
+            if (!localStorage) {
+                return;
+            }
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch (_a) {
+            console.log('Local storage not supported');
+        }
     };
     const getLocal = (key) => {
-        const data = localStorage.getItem(key);
-        if (!data) {
+        try {
+            if (!localStorage) {
+                return {};
+            }
+            const data = localStorage.getItem(key);
+            if (!data) {
+                return {};
+            }
+            return JSON.parse(data) || {};
+        }
+        catch (_a) {
             return {};
         }
-        return JSON.parse(data) || {};
     };
     const saveSession = (value, key) => {
-        sessionStorage.setItem(key, JSON.stringify(value));
+        try {
+            if (!sessionStorage) {
+                return;
+            }
+            sessionStorage.setItem(key, JSON.stringify(value));
+        }
+        catch (_a) {
+            console.log('Session storage not supported');
+        }
     };
     const getSession = (key) => {
-        const data = sessionStorage.getItem(key);
-        if (!data) {
+        try {
+            if (!sessionStorage) {
+                return {};
+            }
+            const data = sessionStorage.getItem(key);
+            if (!data) {
+                return {};
+            }
+            return JSON.parse(data) || {};
+        }
+        catch (_a) {
             return {};
         }
-        return JSON.parse(data) || {};
     };
 
     let endpointUrl = '';
@@ -228,7 +260,7 @@
         return false;
     };
     const allowProvider = (providers, providerId) => {
-        if (providers) {
+        if (providers && Object.keys(providers).length) {
             const tagProvider = providers[providerId];
             if (!(tagProvider ||
                 (providers['all'] === true && tagProvider === undefined) ||
@@ -336,14 +368,13 @@
     // Unique ID creation requires a high quality random # generator. In the browser we therefore
     // require the crypto API and do not support built-in fallback to lower quality random number
     // generators (like Math.random()).
-    var getRandomValues;
-    var rnds8 = new Uint8Array(16);
+    let getRandomValues;
+    const rnds8 = new Uint8Array(16);
     function rng() {
       // lazy load so that environments that need to polyfill have a chance to do so
       if (!getRandomValues) {
-        // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
-        // find the complete implementation of crypto (msCrypto) on IE11.
-        getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+        // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+        getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
 
         if (!getRandomValues) {
           throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
@@ -364,27 +395,16 @@
      * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
      */
 
-    var byteToHex = [];
+    const byteToHex = [];
 
-    for (var i = 0; i < 256; ++i) {
-      byteToHex.push((i + 0x100).toString(16).substr(1));
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 0x100).toString(16).slice(1));
     }
 
-    function stringify(arr) {
-      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    function unsafeStringify(arr, offset = 0) {
       // Note: Be careful editing this code!  It's been tuned for performance
       // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-      var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
-      // of the following:
-      // - One or more input array values don't map to a hex octet (leading to
-      // "undefined" in the uuid)
-      // - Invalid input values for the RFC `version` or `variant` fields
-
-      if (!validate(uuid)) {
-        throw TypeError('Stringified UUID is invalid');
-      }
-
-      return uuid;
+      return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
     }
 
     function parse(uuid) {
@@ -392,8 +412,8 @@
         throw TypeError('Invalid UUID');
       }
 
-      var v;
-      var arr = new Uint8Array(16); // Parse ########-....-....-....-............
+      let v;
+      const arr = new Uint8Array(16); // Parse ########-....-....-....-............
 
       arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
       arr[1] = v >>> 16 & 0xff;
@@ -422,19 +442,21 @@
     function stringToBytes(str) {
       str = unescape(encodeURIComponent(str)); // UTF8 escape
 
-      var bytes = [];
+      const bytes = [];
 
-      for (var i = 0; i < str.length; ++i) {
+      for (let i = 0; i < str.length; ++i) {
         bytes.push(str.charCodeAt(i));
       }
 
       return bytes;
     }
 
-    var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-    var URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
-    function v35 (name, version, hashfunc) {
+    const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+    const URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+    function v35(name, version, hashfunc) {
       function generateUUID(value, namespace, buf, offset) {
+        var _namespace;
+
         if (typeof value === 'string') {
           value = stringToBytes(value);
         }
@@ -443,14 +465,14 @@
           namespace = parse(namespace);
         }
 
-        if (namespace.length !== 16) {
+        if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
           throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
         } // Compute hash of namespace and value, Per 4.3
         // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
         // hashfunc([...namespace, ... value])`
 
 
-        var bytes = new Uint8Array(16 + value.length);
+        let bytes = new Uint8Array(16 + value.length);
         bytes.set(namespace);
         bytes.set(value, namespace.length);
         bytes = hashfunc(bytes);
@@ -460,14 +482,14 @@
         if (buf) {
           offset = offset || 0;
 
-          for (var i = 0; i < 16; ++i) {
+          for (let i = 0; i < 16; ++i) {
             buf[offset + i] = bytes[i];
           }
 
           return buf;
         }
 
-        return stringify(bytes);
+        return unsafeStringify(bytes);
       } // Function#name is not settable on some platforms (#270)
 
 
@@ -503,11 +525,11 @@
      */
     function md5(bytes) {
       if (typeof bytes === 'string') {
-        var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+        const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
 
         bytes = new Uint8Array(msg.length);
 
-        for (var i = 0; i < msg.length; ++i) {
+        for (let i = 0; i < msg.length; ++i) {
           bytes[i] = msg.charCodeAt(i);
         }
       }
@@ -520,13 +542,13 @@
 
 
     function md5ToHexEncodedArray(input) {
-      var output = [];
-      var length32 = input.length * 32;
-      var hexTab = '0123456789abcdef';
+      const output = [];
+      const length32 = input.length * 32;
+      const hexTab = '0123456789abcdef';
 
-      for (var i = 0; i < length32; i += 8) {
-        var x = input[i >> 5] >>> i % 32 & 0xff;
-        var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
+      for (let i = 0; i < length32; i += 8) {
+        const x = input[i >> 5] >>> i % 32 & 0xff;
+        const hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
         output.push(hex);
       }
 
@@ -549,16 +571,16 @@
       /* append padding */
       x[len >> 5] |= 0x80 << len % 32;
       x[getOutputLength(len) - 1] = len;
-      var a = 1732584193;
-      var b = -271733879;
-      var c = -1732584194;
-      var d = 271733878;
-
-      for (var i = 0; i < x.length; i += 16) {
-        var olda = a;
-        var oldb = b;
-        var oldc = c;
-        var oldd = d;
+      let a = 1732584193;
+      let b = -271733879;
+      let c = -1732584194;
+      let d = 271733878;
+
+      for (let i = 0; i < x.length; i += 16) {
+        const olda = a;
+        const oldb = b;
+        const oldc = c;
+        const oldd = d;
         a = md5ff(a, b, c, d, x[i], 7, -680876936);
         d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
         c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
@@ -642,10 +664,10 @@
         return [];
       }
 
-      var length8 = input.length * 8;
-      var output = new Uint32Array(getOutputLength(length8));
+      const length8 = input.length * 8;
+      const output = new Uint32Array(getOutputLength(length8));
 
-      for (var i = 0; i < length8; i += 8) {
+      for (let i = 0; i < length8; i += 8) {
         output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
       }
 
@@ -658,8 +680,8 @@
 
 
     function safeAdd(x, y) {
-      var lsw = (x & 0xffff) + (y & 0xffff);
-      var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+      const lsw = (x & 0xffff) + (y & 0xffff);
+      const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
       return msw << 16 | lsw & 0xffff;
     }
     /*
@@ -697,9 +719,18 @@
 
     v35('v3', 0x30, md5);
 
+    const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+    var native = {
+      randomUUID
+    };
+
     function v4(options, buf, offset) {
+      if (native.randomUUID && !buf && !options) {
+        return native.randomUUID();
+      }
+
       options = options || {};
-      var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+      const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
 
       rnds[6] = rnds[6] & 0x0f | 0x40;
       rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
@@ -707,14 +738,14 @@
       if (buf) {
         offset = offset || 0;
 
-        for (var i = 0; i < 16; ++i) {
+        for (let i = 0; i < 16; ++i) {
           buf[offset + i] = rnds[i];
         }
 
         return buf;
       }
 
-      return stringify(rnds);
+      return unsafeStringify(rnds);
     }
 
     // Adapted from Chris Veness' SHA1 code at
@@ -740,15 +771,15 @@
     }
 
     function sha1(bytes) {
-      var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
-      var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+      const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+      const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
 
       if (typeof bytes === 'string') {
-        var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+        const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
 
         bytes = [];
 
-        for (var i = 0; i < msg.length; ++i) {
+        for (let i = 0; i < msg.length; ++i) {
           bytes.push(msg.charCodeAt(i));
         }
       } else if (!Array.isArray(bytes)) {
@@ -757,44 +788,44 @@
       }
 
       bytes.push(0x80);
-      var l = bytes.length / 4 + 2;
-      var N = Math.ceil(l / 16);
-      var M = new Array(N);
+      const l = bytes.length / 4 + 2;
+      const N = Math.ceil(l / 16);
+      const M = new Array(N);
 
-      for (var _i = 0; _i < N; ++_i) {
-        var arr = new Uint32Array(16);
+      for (let i = 0; i < N; ++i) {
+        const arr = new Uint32Array(16);
 
-        for (var j = 0; j < 16; ++j) {
-          arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];
+        for (let j = 0; j < 16; ++j) {
+          arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3];
         }
 
-        M[_i] = arr;
+        M[i] = arr;
       }
 
       M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
       M[N - 1][14] = Math.floor(M[N - 1][14]);
       M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
 
-      for (var _i2 = 0; _i2 < N; ++_i2) {
-        var W = new Uint32Array(80);
+      for (let i = 0; i < N; ++i) {
+        const W = new Uint32Array(80);
 
-        for (var t = 0; t < 16; ++t) {
-          W[t] = M[_i2][t];
+        for (let t = 0; t < 16; ++t) {
+          W[t] = M[i][t];
         }
 
-        for (var _t = 16; _t < 80; ++_t) {
-          W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);
+        for (let t = 16; t < 80; ++t) {
+          W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
         }
 
-        var a = H[0];
-        var b = H[1];
-        var c = H[2];
-        var d = H[3];
-        var e = H[4];
+        let a = H[0];
+        let b = H[1];
+        let c = H[2];
+        let d = H[3];
+        let e = H[4];
 
-        for (var _t2 = 0; _t2 < 80; ++_t2) {
-          var s = Math.floor(_t2 / 20);
-          var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;
+        for (let t = 0; t < 80; ++t) {
+          const s = Math.floor(t / 20);
+          const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0;
           e = d;
           d = c;
           c = ROTL(b, 30) >>> 0;
@@ -863,21 +894,19 @@
         const providerData = {};
         if (providerPackages) {
             Object.values(providerPackages).forEach((pkg) => {
-                if (!allowProvider(providers, pkg.name)) {
+                if (!pkg || !pkg.tag || !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;
-                    }
+                const result = pkg.tag({
+                    userId,
+                    eventName,
+                    eventId,
+                    data,
+                    sendTag,
+                    manifestVariables: getProviderVariables(pkg.name),
+                });
+                if (result) {
+                    providerData[pkg.name] = result;
                 }
             });
         }
@@ -891,6 +920,30 @@
         });
     };
 
+    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 saveDataToEdge = (key, value, provider) => {
+        if (!value) {
+            return;
+        }
+        if (typeof value !== 'string') {
+            try {
+                value = JSON.stringify(value);
+            }
+            catch (_a) {
+                console.log('Error stringify value');
+                return;
+            }
+        }
+        handleData({ [`${provider}::${key}`]: value });
+    };
     const handleCaptureQuery = (provider, key, persistType) => {
         if (!window) {
             return;
@@ -899,7 +952,15 @@
         if (!params || !params.get(key)) {
             return;
         }
-        saveDataPerKey(persistType, provider, params.get(key), key);
+        const data = params.get(key);
+        if (!data) {
+            return;
+        }
+        if (persistType === 'edge') {
+            saveDataToEdge(key, data, provider);
+            return;
+        }
+        saveDataPerKey(persistType, provider, data, key);
     };
     const handleCaptureStorage = (provider, key, persistType, location) => {
         let data;
@@ -909,17 +970,20 @@
                 break;
             }
             case 'local': {
-                data = sessionStorage && sessionStorage.getItem(key);
+                data = getData$1('local', key);
                 break;
             }
             case 'session': {
-                data = localStorage && localStorage.getItem(key);
-                break;
+                data = getData$1('session', key);
             }
         }
         if (!data) {
             return;
         }
+        if (persistType === 'edge') {
+            saveDataToEdge(key, data, provider);
+            return;
+        }
         saveDataPerKey(persistType, provider, data, key);
     };
     const handleCapture = (provider, params) => {
@@ -1002,15 +1066,6 @@
         }, 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.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotoutio/edgetag-sdk-browser",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Browser SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",