@blotoutio/edgetag-sdk-browser 1.28.1 → 1.30.0

package/index.js

@@ -1,7 +1,7 @@
 (function () {
     'use strict';
 
-    var api$1 = /*#__PURE__*/Object.freeze({
+    var api = /*#__PURE__*/Object.freeze({
         __proto__: null,
         get consent () { return consent; },
         get data () { return data; },
@@ -510,12 +510,17 @@
     };
 
     // eslint-disable-next-line @nx/enforce-module-boundaries
-    let edgeTagSettings;
+    const getGlobalSettings = () => {
+        var _a;
+        // settings must be globally shared in order for each tag to be able to
+        // process the correct destinations when receiving stubs/calls to process
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore extending globalThis is a pain, ignore.
+        return ((_a = globalThis.edgeTagSettings) !== null && _a !== void 0 ? _a : (globalThis.edgeTagSettings = {}));
+    };
     const initSettings = (destination, options) => {
-        if (!edgeTagSettings) {
-            edgeTagSettings = {};
-        }
-        edgeTagSettings[destination] = {
+        const settings = getGlobalSettings();
+        settings[destination] = {
             destination,
             initialized: false,
             stubs: [],
@@ -532,29 +537,27 @@
         };
     };
     const setSetting = (destination, options) => {
-        if (!edgeTagSettings) {
-            return;
-        }
+        const settings = getGlobalSettings();
         if (!destination) {
-            Object.keys(edgeTagSettings).forEach((key) => {
-                edgeTagSettings[key] = {
-                    ...edgeTagSettings[key],
+            Object.keys(settings).forEach((key) => {
+                settings[key] = {
+                    ...settings[key],
                     ...options,
                 };
             });
             return;
         }
-        edgeTagSettings[destination] = {
-            ...edgeTagSettings[destination],
+        settings[destination] = {
+            ...settings[destination],
             ...options,
         };
     };
     const getSetting = (destination, key) => {
         var _a;
-        return (_a = edgeTagSettings === null || edgeTagSettings === void 0 ? void 0 : edgeTagSettings[destination]) === null || _a === void 0 ? void 0 : _a[key];
+        return (_a = getGlobalSettings()[destination]) === null || _a === void 0 ? void 0 : _a[key];
     };
     const getInstances = () => {
-        return Object.keys(edgeTagSettings || {});
+        return Object.keys(getGlobalSettings());
     };
     const addChannel = (destination, pkg, tagName) => upsert(getSetting(destination, 'channels'), pkg, (names) => names.add(tagName), () => new Set());
     const getProviderVariables = (destination, packageId) => {
@@ -953,7 +956,7 @@
             referrer: getReferrer(destination),
             search: getSearch(destination),
             locale: getLocale(),
-            sdkVersion: "1.28.1" ,
+            sdkVersion: "1.30.0" ,
             ...(payload || {}),
         };
         let storage = {};
@@ -1059,7 +1062,7 @@
             const stubs = getSetting(destination, 'stubs');
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
-            stubs.forEach((stub) => api$1[stub.name](...(stub.arguments || [])));
+            stubs.forEach((stub) => api[stub.name](...(stub.arguments || [])));
             setSetting(destination, {
                 stubs: [],
             });
@@ -1284,6 +1287,7 @@
                     userId,
                     data,
                     manifestVariables: variable.variableSet,
+                    destination,
                 });
             }
         }
@@ -1810,6 +1814,7 @@
                     userId,
                     data: { [key]: value },
                     manifestVariables: variable.variableSet,
+                    destination,
                 });
             }
         }
@@ -2015,81 +2020,224 @@
       }
     }
 
-    var api = new API();
+    var library = new API();
 
     (function () {
-      const handleStubs = (event) => {
+      const getTagDestination = (args) => {
+        if (args?.length < 4) {
+          return
+        }
+
+        return args[3].destination
+      };
+
+      const getInitUrl = (args) => {
+        if (args?.length < 1) {
+          return
+        }
+
+        return args[0].edgeURL
+      };
+
+      const addTagToDestination = (destination, tag) => {
+        if (!window.edgetag.destinations[destination]) {
+          window.edgetag.destinations[destination] = {};
+        }
+
+        if (!window.edgetag.destinations[destination].tags) {
+          window.edgetag.destinations[destination].tags = [];
+        }
+
+        window.edgetag.destinations[destination].tags.push({
+          name: 'tag',
+          arguments: tag,
+        });
+      };
+
+      const handleInit = (args) => {
+        if (!args?.length) {
+          console.error('EdgeTag SDK: Init event is missing arguments');
+          return
+        }
+
+        const destination = args[0]?.edgeURL;
+        if (!destination) {
+          console.error('EdgeTag SDK: edgeURL is required for initialization');
+          return
+        }
+
+        if (!window.edgetag.destinations?.[destination]?.initialized) {
+          window.edgetag.stubs.push(['init', ...args]);
+          return
+        }
+
+        const tags = [];
+
+        if (
+          window.edgetag.destinations['all'].tags &&
+          !window.edgetag.destinations['all'].resolvedInits.has(destination)
+        ) {
+          const destinationTags = window.edgetag.destinations['all'].tags.map(
+            (tag) => {
+              const newTag = structuredClone(tag);
+              newTag['arguments'][3] = {
+                ...newTag['arguments'][3],
+                destination,
+              };
+
+              return newTag
+            }
+          );
+          tags.push(...destinationTags);
+          window.edgetag.destinations['all'].resolvedInits.add(destination);
+        }
+
+        if (window.edgetag.destinations[destination].tags) {
+          tags.push(...window.edgetag.destinations[destination].tags);
+          window.edgetag.destinations[destination].tags = [];
+        }
+
+        if (tags.length) {
+          args[0]['afterManifestEvents'] = tags;
+        }
+
+        library.init(...args);
+      };
+
+      const handleTag = (args) => {
+        const destination = getTagDestination(args);
+
+        if (destination && !window.edgetag.destinations[destination]?.initialized) {
+          addTagToDestination(destination, args);
+          return
+        }
+
+        library.tag(...args);
+      };
+
+      const processStub = (name, args) => {
         try {
-          return library[event.name](...event.arguments)
+          if (name === 'init') {
+            handleInit(args);
+            return
+          }
+
+          if (name === 'tag') {
+            handleTag(args);
+            return
+          }
+
+          return library[name](...args)
         } catch (e) {
           console.error(e);
         }
       };
 
-      const library = api;
-      let stubs = [];
+      const handleEvent = (args) => {
+        const sliced = [].slice.call(args);
+        if (!Array.isArray(sliced) || !sliced.length) {
+          return
+        }
+
+        return processStub(sliced[0], sliced.slice(1))
+      };
+
+      let stubs = window.edgetag?.stubs;
+      if (!stubs) {
+        stubs = [];
+      }
+
       if (!window.edgetag?.live) {
-        stubs = window.edgetag?.stubs || [];
+        const destinations = window.edgetag?.destinations;
 
         // this needs to be regular function for arguments to work
         window.edgetag = function () {
-          const sliced = [].slice.call(arguments);
-          if (!Array.isArray(sliced)) {
-            return
-          }
-
-          try {
-            return library[sliced[0]](...sliced.slice(1))
-          } catch (e) {
-            console.error(e);
-          }
+          return handleEvent(arguments)
         };
 
         window.edgetag.live = true;
+        window.edgetag.destinations = destinations || {};
+      }
+
+      window.edgetag.stubs = [];
+
+      window.edgetag.handleStubs = () => {
+        if (!window.edgetag.stubs || !Array.isArray(window.edgetag.stubs)) {
+          console.error('EdgeTag SDK: Invalid stubs array');
+          return
+        }
+
+        stubs = window.edgetag.stubs;
+        window.edgetag.stubs = [];
+
+        stubs.forEach((stub) => {
+          handleEvent(stub);
+        });
+      };
+
+      if (!window.edgetag.destinations) {
+        window.edgetag.destinations = {};
       }
 
-      const beforeManifestEvents = [];
-      const afterManifestEvents = [];
-      const initCalls = [];
+      if (!stubs.length) {
+        return
+      }
+
+      const inits = [];
+      const tags = [];
 
-      stubs.forEach((arg) => {
-        const sliced = [].slice.call(arg);
+      stubs.forEach((stub) => {
+        const sliced = [].slice.call(stub);
         if (!Array.isArray(sliced)) {
           return
         }
 
-        if (sliced[0] === 'init') {
-          initCalls.push(sliced.slice(1));
+        const name = sliced[0];
+        const args = sliced.slice(1);
+
+        if (name === 'init') {
+          const destination = getInitUrl(args);
+          if (!window.edgetag.destinations[destination]) {
+            window.edgetag.destinations[destination] = {
+              tags: [],
+            };
+          }
+
+          inits.push(args);
           return
         }
 
-        if (sliced[0] === 'tag') {
-          afterManifestEvents.push({
-            name: sliced[0],
-            arguments: sliced.slice(1),
-          });
+        if (name === 'tag') {
+          tags.push(args);
           return
         }
 
-        beforeManifestEvents.push({
-          name: sliced[0],
-          arguments: sliced.slice(1),
-        });
+        processStub(name, args);
       });
 
-      if (initCalls?.length) {
-        initCalls[initCalls.length - 1][0]['afterManifestEvents'] =
-          afterManifestEvents;
+      tags.forEach((tag) => {
+        const destination = getTagDestination(tag);
+        if (destination) {
+          addTagToDestination(destination, tag);
+          return
+        }
 
-        initCalls.forEach((initCall) => {
-          handleStubs({
-            name: 'init',
-            arguments: initCall,
-          });
+        if (!window.edgetag.destinations['all']) {
+          window.edgetag.destinations['all'] = {
+            tags: [],
+            resolvedInits: new Set(),
+          };
+        }
+
+        window.edgetag.destinations['all'].tags.push({
+          name: 'tag',
+          arguments: tag,
         });
-      }
+      });
 
-      beforeManifestEvents.forEach(handleStubs);
+      inits.forEach((init) => {
+        window.edgetag.stubs.push(['init', ...init]);
+      });
     })();
 
 })();

package/package.json

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