@blotoutio/edgetag-sdk-browser 0.35.2 → 0.36.0

package/index.js

@@ -336,7 +336,7 @@
             referrer: getReferrer(),
             search: getSearch(),
             locale: getLocale(),
-            sdkVersion: "0.35.2" ,
+            sdkVersion: "0.36.0" ,
             ...(payload || {}),
         };
         let storage = {};
@@ -423,31 +423,6 @@
         return generateUrl(`/keys`);
     };
 
-    let memoryConsent;
-    const saveConsent = (consent) => {
-        setConsent(consent);
-        savePerKey('local', tagStorage, consent, consentKey);
-    };
-    const handleConsent = (consent, options) => {
-        const payload = {
-            consentString: consent,
-        };
-        saveConsent(consent);
-        if (!(options === null || options === void 0 ? void 0 : options.localSave)) {
-            postRequest(getConsentURL(), payload).catch(error);
-        }
-    };
-    const setConsent = (newConsent) => {
-        memoryConsent = newConsent;
-    };
-    const getConsent$1 = () => {
-        const storageConsent = getDataPerKey('local', tagStorage, consentKey);
-        if (storageConsent) {
-            return storageConsent;
-        }
-        return memoryConsent;
-    };
-
     const isBool = (v) => typeof v == 'boolean';
     const isRecord = (v) => !!v && typeof v == 'object' && !Array.isArray(v);
     /**
@@ -475,6 +450,25 @@
         }
         return allowed;
     };
+    /**
+     * This function validates user consent for a given provider type, not based on tagName.
+     */
+    const hasUserConsentForProvider = (consent, provider) => {
+        if (!isRecord(consent)) {
+            return false;
+        }
+        let allowed = isBool(consent.all) ? consent.all : false;
+        if (provider in consent) {
+            const providerSpecific = consent[provider];
+            if (isBool(providerSpecific)) {
+                allowed = providerSpecific;
+            }
+            else if (isRecord(providerSpecific)) {
+                return Object.keys(providerSpecific).some((instance) => providerSpecific[instance] === true);
+            }
+        }
+        return allowed;
+    };
     /**
      * This function validates provider allowance for a given provider and tag name.
      * It should not be used to validate `UserConsent`.
@@ -674,6 +668,18 @@
         return false;
     };
 
+    const handleGetData = (keys, callback) => {
+        if (!keys || keys.length === 0) {
+            error('Provide keys for get data API.');
+            return;
+        }
+        getRequest(getGetDataURL(keys))
+            .then((result) => {
+            callback((result === null || result === void 0 ? void 0 : result.result) || {});
+        })
+            .catch(error);
+    };
+
     const handleData = (data, providers, options) => {
         if (!data || Object.keys(data).length === 0) {
             error('Provide data for data API.');
@@ -712,7 +718,72 @@
         postRequest(getDataURL(), { data, providers }, options).catch(error);
     };
 
+    let memoryConsent;
+    const saveConsent = (consent) => {
+        setConsent(consent);
+        savePerKey('local', tagStorage, consent, consentKey);
+    };
+    const handleConsent = (consent, options) => {
+        const payload = {
+            consentString: consent,
+        };
+        saveConsent(consent);
+        if (!(options === null || options === void 0 ? void 0 : options.localSave)) {
+            postRequest(getConsentURL(), payload).catch(error);
+        }
+        const userId = handleGetUserId();
+        const providerPackages = getProvidersPackage();
+        const executionContext = new Map();
+        /* Calling Init for all provider instances based on consent check */
+        for (const pkg of Object.values(providerPackages)) {
+            if (!pkg || !pkg.name || !pkg.init) {
+                continue;
+            }
+            const variables = getProviderVariables(pkg.name);
+            const providerVariables = Object.entries(variables);
+            for (const [tagName, variablesSet] of providerVariables) {
+                const hasConsent = hasUserConsent(consent, pkg.name, tagName);
+                if (!hasConsent) {
+                    continue;
+                }
+                pkg.init({
+                    userId,
+                    manifest: {
+                        tagName,
+                        variables: variablesSet,
+                        package: pkg.name,
+                    },
+                    sendTag,
+                    sendEdgeData: handleData,
+                    getEdgeData: handleGetData,
+                    keyName: `${keyPrefix}Store`,
+                    executionContext,
+                });
+            }
+        }
+        /* Calling Consent for all providers, not on instance level */
+        for (const pkg of Object.values(providerPackages)) {
+            if (!pkg || !pkg.name || !pkg.consent) {
+                continue;
+            }
+            /* Returns True if any one instance of given provider has consent */
+            const hasConsent = hasUserConsentForProvider(consent, pkg.name);
+            pkg.consent({ hasConsent });
+        }
+    };
+    const setConsent = (newConsent) => {
+        memoryConsent = newConsent;
+    };
+    const getConsent$1 = () => {
+        const storageConsent = getDataPerKey('local', tagStorage, consentKey);
+        if (storageConsent) {
+            return storageConsent;
+        }
+        return memoryConsent;
+    };
+
     const cacheKey = `${keyPrefix}Cache`;
+    const identity = (v) => v;
     const saveDataToEdge = (key, value, provider) => {
         if (!value) {
             return;
@@ -728,7 +799,7 @@
         }
         handleData({ [`${provider}::${key}`]: value });
     };
-    const handleCaptureQuery = (provider, key, persistType) => {
+    const handleCaptureQuery = (provider, key, persistType, map) => {
         try {
             if (!window) {
                 return;
@@ -741,7 +812,7 @@
         if (!params || !params.get(key)) {
             return;
         }
-        const data = params.get(key);
+        const data = (map !== null && map !== void 0 ? map : identity)(params.get(key));
         if (!data) {
             return;
         }
@@ -766,82 +837,74 @@
         }
         saveData(persistType === 'edge' ? 'local' : persistType, cache, cacheKey);
     };
-    const handleCaptureStorage = (provider, key, persistType, location) => {
+    const handleCaptureStorage = (provider, key, persistType, location, map) => {
         let data;
         try {
             switch (location) {
                 case 'cookie': {
-                    data = getCookieValue(key);
+                    data = (map !== null && map !== void 0 ? map : identity)(getCookieValue(key));
                     break;
                 }
                 case 'local': {
-                    data = localStorage.getItem(key);
+                    data = (map !== null && map !== void 0 ? map : identity)(localStorage.getItem(key));
                     break;
                 }
                 case 'session': {
-                    data = sessionStorage.getItem(key);
+                    data = (map !== null && map !== void 0 ? map : identity)(sessionStorage.getItem(key));
                 }
             }
         }
         catch {
             return;
         }
-        const cachedValue = getFromCache(persistType, provider, key);
-        saveToCache(persistType, provider, key, data);
         if (!data) {
             return;
         }
+        const cachedKey = `${handleGetUserId()}/${key}`;
+        const cachedValue = getFromCache(persistType, provider, cachedKey);
         if (persistType === 'edge' && cachedValue !== data) {
             saveDataToEdge(key, data, provider);
+            saveToCache(persistType, provider, cachedKey, data);
             return;
         }
         saveDataPerKey(persistType, provider, data, key);
     };
-    const handleCapture = (provider, params) => {
+    const handleCapture = (provider, params, capture) => {
         params.forEach((param) => {
             switch (param.type) {
                 case 'query': {
-                    handleCaptureQuery(provider, param.key, param.persist);
+                    handleCaptureQuery(provider, param.key, param.persist, capture === null || capture === void 0 ? void 0 : capture.bind(null, param));
                     break;
                 }
                 case 'storage': {
-                    handleCaptureStorage(provider, param.key, param.persist, param.location);
+                    handleCaptureStorage(provider, param.key, param.persist, param.location, capture === null || capture === void 0 ? void 0 : capture.bind(null, param));
                     break;
                 }
             }
         });
     };
 
-    const handleGetData = (keys, callback) => {
-        if (!keys || keys.length === 0) {
-            error('Provide keys for get data API.');
-            return;
-        }
-        getRequest(getGetDataURL(keys))
-            .then((result) => {
-            callback((result === null || result === void 0 ? void 0 : result.result) || {});
-        })
-            .catch(error);
-    };
-
-    const handleManifest = (manifest) => {
+    const handleManifest = (manifest, consent) => {
         const providerPackages = getProvidersPackage();
         const userId = handleGetUserId();
+        const executionContext = new Map();
         manifest.forEach((provider) => {
             addConfiguredTag(provider.package, provider.tagName);
             addProviderVariable(provider.package, provider.variables, provider.tagName);
+            const pkg = providerPackages[provider.package];
             if (provider.rules) {
                 Object.entries(provider.rules).forEach(([name, recipe]) => {
                     switch (name) {
                         case 'capture': {
-                            handleCapture(provider.package, recipe);
+                            handleCapture(provider.package, recipe, pkg === null || pkg === void 0 ? void 0 : pkg.capture);
                             return;
                         }
                     }
                 });
             }
-            const pkg = providerPackages[provider.package];
-            if (pkg && pkg.name && pkg.init) {
+            /* this defines if the consent is given for a specific instance of a provider */
+            const hasConsent = hasUserConsent(consent, pkg.name, provider.tagName);
+            if (pkg && pkg.name && pkg.init && hasConsent) {
                 pkg.init({
                     userId,
                     manifest: provider,
@@ -849,6 +912,7 @@
                     sendEdgeData: handleData,
                     getEdgeData: handleGetData,
                     keyName: `${keyPrefix}Store`,
+                    executionContext,
                 });
             }
         });
@@ -886,7 +950,7 @@
             if (result.consent && !consent) {
                 saveConsent(result.consent);
             }
-            handleManifest(result.result);
+            handleManifest(result.result, consent || result.consent);
         })
             .catch(error);
     };

package/package.json

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