@jitsu/js 1.0.0-canary-20230211030946 → 1.0.0-canary-20230219230011

package/dist/jitsu.es.js

@@ -65,7 +65,151 @@ function analyticsLib() {
   return ke(_objectSpread2(_objectSpread2({}, defaultSettings), opts));
 }
 
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (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());
+    });
+};
+function satisfyFilter(filter, subject) {
+    return filter === "*" || filter.toLowerCase().trim() === (subject || "").trim().toLowerCase();
+}
+function applyFilters(event, creds) {
+    const { hosts = ["*"], events = ["*"] } = creds;
+    return (!!hosts.find(hostFilter => { var _a; return satisfyFilter(hostFilter, (_a = event.context) === null || _a === void 0 ? void 0 : _a.host); }) &&
+        !!events.find(eventFilter => satisfyFilter(eventFilter, event.type)));
+}
+const tagPlugin = {
+    id: "tag",
+    handle(config, payload) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            if (!applyFilters(payload, config)) {
+                return;
+            }
+            insertTags(config.code, payload);
+        });
+    },
+};
+function insertTags(code, event, opts = {}) {
+    let tag;
+    try {
+        tag = JSON.parse(code);
+    }
+    catch (e) {
+        tag = { code, lang: "javascript" };
+    }
+    const debug = opts.debug || false;
+    if (isInBrowser()) {
+        if (tag.lang === "javascript") {
+            execJs(tag.code, event);
+        }
+        else {
+            const codeHolder = document.createElement("span");
+            codeHolder.innerHTML = replaceMacro(tag.code, event);
+            document.body.insertAdjacentElement("beforeend", codeHolder);
+            const scripts = codeHolder.querySelectorAll("script");
+            scripts.forEach(script => {
+                const scriptClone = document.createElement("script");
+                scriptClone.type = scriptClone.type || "text/javascript";
+                if (script.hasAttribute("src")) {
+                    scriptClone.src = script.src;
+                }
+                scriptClone.text = script.text;
+                if (debug) {
+                    console.log(`[JITSU] Executing script${script.hasAttribute("src") ? ` ${script.src}` : ""}`, scriptClone.text);
+                }
+                document.head.appendChild(scriptClone);
+                document.head.removeChild(scriptClone);
+            });
+        }
+    }
+    else {
+        if (debug) {
+            console.log(`[JITSU] insertTags(): cannot insert tags in non-browser environment`);
+        }
+    }
+}
+function execJs(code, event) {
+    const varName = `jitsu_event_${randomId()}`;
+    window[varName] = event;
+    const iif = `(function(){
+      const event = ${varName};
+      ${code}
+  })()`;
+    try {
+        eval(iif);
+    }
+    catch (e) {
+        console.error(`[JITSU] Error executing JS code: ${e.message}. Code: `, iif);
+    }
+    finally {
+        delete window[varName];
+    }
+    return iif;
+}
+function replaceMacro(code, event) {
+    return code.replace(/{{\s*event\s*}}/g, JSON.stringify(event));
+}
+const internalDestinationPlugins = {
+    [tagPlugin.id]: tagPlugin,
+};
+
+function findScript(src) {
+    const scripts = Array.prototype.slice.call(window.document.querySelectorAll("script"));
+    return scripts.find(s => s.src === src);
+}
+function loadScript(src, attributes) {
+    const found = findScript(src);
+    if (found !== undefined) {
+        const status = found === null || found === void 0 ? void 0 : found.getAttribute("status");
+        if (status === "loaded") {
+            return Promise.resolve(found);
+        }
+        if (status === "loading") {
+            return new Promise((resolve, reject) => {
+                found.addEventListener("load", () => resolve(found));
+                found.addEventListener("error", err => reject(err));
+            });
+        }
+    }
+    return new Promise((resolve, reject) => {
+        var _a;
+        const script = window.document.createElement("script");
+        script.type = "text/javascript";
+        script.src = src;
+        script.async = true;
+        script.setAttribute("status", "loading");
+        for (const [k, v] of Object.entries(attributes !== null && attributes !== void 0 ? attributes : {})) {
+            script.setAttribute(k, v);
+        }
+        script.onload = () => {
+            script.onerror = script.onload = null;
+            script.setAttribute("status", "loaded");
+            resolve(script);
+        };
+        script.onerror = () => {
+            script.onerror = script.onload = null;
+            script.setAttribute("status", "error");
+            reject(new Error(`Failed to load ${src}`));
+        };
+        const tag = window.document.getElementsByTagName("script")[0];
+        (_a = tag.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(script, tag);
+    });
+}
+
 /* global analytics */
+var __awaiter = (undefined && undefined.__awaiter) || function (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 config = {
     /* Your segment writeKey */
     writeKey: null,
@@ -277,7 +421,7 @@ function deepMerge(target, source) {
     }, target);
 }
 function isInBrowser() {
-    return typeof document !== "undefined";
+    return typeof document !== "undefined" && typeof window !== "undefined";
 }
 function adjustPayload(payload, config, storage) {
     var _a, _b;
@@ -315,62 +459,62 @@ function adjustPayload(payload, config, storage) {
     delete withContext.options;
     return withContext;
 }
-function execJs(code, event) {
-    const varName = `jitsu_event_${randomId()}`;
-    window[varName] = event;
-    const iif = `(function(){
-      ${code}
-      onEvent(${varName});
-  })()`;
-    try {
-        eval(iif);
-    }
-    catch (e) {
-        console.error(`[JITSU] Error executing JS code: ${e.message}`);
-    }
-    finally {
-        delete window[varName];
-    }
-    return iif;
-}
-function replaceMacro(code, event) {
-    return code.replace(/{{\s*event\s*}}/g, JSON.stringify(event));
-}
-function insertTags(tags, event, opts = {}) {
-    const debug = opts.debug || false;
-    if (isInBrowser()) {
-        Object.values(tags).forEach(tag => {
-            if (tag.mode === "javascript") {
-                execJs(tag.code, event);
+function processDestinations(destinations, method, event, debug, analyticsInstance) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const promises = [];
+        for (const destination of destinations) {
+            if (destination.deviceOptions.type === "internal-plugin") {
+                const plugin = internalDestinationPlugins[destination.deviceOptions.name];
+                if (plugin) {
+                    try {
+                        promises.push(plugin.handle(destination.credentials, event));
+                    }
+                    catch (e) {
+                        console.warn(`[JITSU] Error processing event with internal plugin '${destination.deviceOptions.name}': ${e === null || e === void 0 ? void 0 : e.message}`, e);
+                    }
+                }
+                else {
+                    console.warn(`[JITSU] Unknown internal plugin '${destination.deviceOptions.name}' for destination '${destination.id}'`);
+                }
             }
-            else {
-                const codeHolder = document.createElement("span");
-                codeHolder.innerHTML = replaceMacro(tag.code, event);
-                document.body.insertAdjacentElement("beforeend", codeHolder);
-                const scripts = codeHolder.querySelectorAll("script");
-                scripts.forEach(script => {
-                    const scriptClone = document.createElement("script");
-                    scriptClone.type = scriptClone.type || "text/javascript";
-                    if (script.hasAttribute("src")) {
-                        scriptClone.src = script.src;
+            else if (destination.deviceOptions.type === "analytics-plugin") {
+                yield loadScript(destination.deviceOptions.packageCdn);
+                const plugin = window[destination.deviceOptions.moduleVarName];
+                if (!plugin) {
+                    console.warn(`[JITSU] Broken plugin '${destination.deviceOptions.packageCdn}' for destination '${destination.id}' - it doesn't export '${destination.deviceOptions.moduleVarName}' variable`);
+                }
+                else {
+                    let pluginInstance;
+                    try {
+                        pluginInstance = (typeof plugin === "function" ? plugin : plugin.init)(destination.credentials);
+                    }
+                    catch (e) {
+                        console.warn(`[JITSU] Error creating plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e === null || e === void 0 ? void 0 : e.message}`, e);
+                    }
+                    try {
+                        if (debug) {
+                            console.log(`[JITSU] Plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}' initialized with config:`, pluginInstance.config);
+                        }
+                        pluginInstance.initialize({ config: pluginInstance.config, instance: analyticsInstance });
                     }
-                    scriptClone.text = script.text;
-                    if (debug) {
-                        console.log(`Executing script${script.hasAttribute("src") ? ` ${script.src}` : ""}`, scriptClone.text);
+                    catch (e) {
+                        console.warn(`[JITSU] Error initializing plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e === null || e === void 0 ? void 0 : e.message}. Config: ${JSON.stringify(pluginInstance.config)}`, e);
+                        continue;
                     }
-                    document.head.appendChild(scriptClone);
-                    document.head.removeChild(scriptClone);
-                });
+                    if (pluginInstance[method]) {
+                        try {
+                            pluginInstance[method]({ payload: event, config: pluginInstance.config, instance: analyticsInstance });
+                        }
+                        catch (e) {
+                            console.warn(`[JITSU] Error processing ${method}() with plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e === null || e === void 0 ? void 0 : e.message}`, e);
+                        }
+                    }
+                }
             }
-        });
-    }
-    else {
-        if (debug) {
-            console.log(`insertTags: cannot insert tags in non-browser environment`);
         }
-    }
+    });
 }
-function send(method, payload, jitsuConfig, store) {
+function send(method, payload, jitsuConfig, instance, store) {
     if (jitsuConfig.echoEvents) {
         console.log(`[JITSU] sending '${method}' event:`, payload);
         return;
@@ -403,18 +547,19 @@ function send(method, payload, jitsuConfig, store) {
         }
     })
         .then(responseText => {
+        let response;
         try {
-            const response = JSON.parse(responseText);
-            if (response.tags) {
-                if (jitsuConfig.debug) {
-                    console.log(`[JITSU] Response Tags: `, JSON.stringify(response.tags, null, 2));
-                }
-                insertTags(response.tags, payload, { debug: jitsuConfig.debug });
-            }
+            response = JSON.parse(responseText);
         }
         catch (e) {
             return Promise.reject(`Can't parse JSON: ${responseText}: ${e === null || e === void 0 ? void 0 : e.message}`);
         }
+        if (response.destinations) {
+            if (jitsuConfig.debug) {
+                console.log(`[JITSU] Processing device destianations: `, JSON.stringify(response.destinations, null, 2));
+            }
+            return processDestinations(response.destinations, method, adjustedPayload, !!jitsuConfig.debug, instance);
+        }
     })
         .catch(err => {
         if (jitsuConfig.debug) {
@@ -444,9 +589,9 @@ const jitsuAnalyticsPlugin = (pluginConfig = {}) => {
         name: "jitsu",
         config: Object.assign(Object.assign({}, config), pluginConfig),
         initialize: args => {
-            const { config, instance } = args;
+            const { config } = args;
             if (config.debug) {
-                console.debug("Initializing Jitsu plugin with config: ", JSON.stringify(config));
+                console.debug("[JITSU] Initializing Jitsu plugin with config: ", JSON.stringify(config));
             }
             if (!config.host && !config.echoEvents) {
                 throw new Error("Please specify host variable in jitsu plugin initialization, or set echoEvents to true");
@@ -454,17 +599,17 @@ const jitsuAnalyticsPlugin = (pluginConfig = {}) => {
         },
         page: args => {
             const { payload, config, instance } = args;
-            return send("page", payload, config, cachingStorageWrapper(instance.storage));
+            return send("page", payload, config, instance, cachingStorageWrapper(instance.storage));
         },
         track: args => {
             const { payload, config, instance } = args;
-            return send("track", payload, config, cachingStorageWrapper(instance.storage));
+            return send("track", payload, config, instance, cachingStorageWrapper(instance.storage));
         },
         identify: args => {
             const { payload, config, instance } = args;
             // Store traits in cache to be able to use them in page and track events that run asynchronously with current identify.
             storageCache["__user_traits"] = payload.traits;
-            return send("identify", payload, config, cachingStorageWrapper(instance.storage));
+            return send("identify", payload, config, instance, cachingStorageWrapper(instance.storage));
         },
         reset: args => {
             //clear storage cache
@@ -517,13 +662,12 @@ function parse(input) {
     }
     return value;
 }
-function jitsuAnalytics(opts) {
-    const rt = opts.runtime || (typeof window === "undefined" ? emptyRuntime(opts) : windowRuntime(opts));
+function createUnderlyingAnalyticsInstance(opts, rt, plugins = []) {
     const analytics = analyticsLib({
         app: "test",
         debug: !!opts.debug,
         storage: rt.store(),
-        plugins: [jitsuAnalyticsPlugin(opts)],
+        plugins: [jitsuAnalyticsPlugin(opts), ...plugins],
     });
     const originalPage = analytics.page;
     analytics.page = (...args) => {
@@ -536,5 +680,32 @@ function jitsuAnalytics(opts) {
     };
     return analytics;
 }
+function jitsuAnalytics(opts) {
+    const inBrowser = isInBrowser();
+    const rt = opts.runtime || (inBrowser ? windowRuntime(opts) : emptyRuntime(opts));
+    return createUnderlyingAnalyticsInstance(opts, rt);
+    // if (inBrowser) {
+    //   const fetch = opts.fetch || globalThis.fetch;
+    //   if (!fetch) {
+    //     throw new Error(
+    //       "Please specify fetch function in jitsu plugin initialization, fetch isn't available in global scope"
+    //     );
+    //   }
+    //   const url = `${opts.host}/api/s/cfg`;
+    //   const authHeader = {};
+    //   const debugHeader = opts.debug ? { "X-Enable-Debug": "true" } : {};
+    //   fetch(url)
+    //     .then(res => res.json())
+    //     .then(res => {
+    //       result.loaded(createUnderlyingAnalyticsInstance(opts, rt, []));
+    //     })
+    //     .catch(e => {
+    //       console.warn(`[JITSU] error getting device-destinations from ${url}`, e);
+    //       result.loaded(createUnderlyingAnalyticsInstance(opts, rt));
+    //     });
+    // } else {
+    //   result.loaded(createUnderlyingAnalyticsInstance(opts, rt));
+    // }
+}
 
-export { emptyRuntime, getTopLevelDomain, jitsuAnalytics, parseQuery, randomId, windowRuntime };
+export { emptyRuntime, getTopLevelDomain, isInBrowser, jitsuAnalytics, parseQuery, randomId, windowRuntime };

package/dist/method-queue.d.ts

@@ -0,0 +1,17 @@
+export type InterfaceWrapper<T> = {
+    get(): WithAsyncMethods<T>;
+    loaded(instance: T): any;
+};
+type WithAsyncMethods<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => R extends Promise<any> ? R : Promise<R> : T[K];
+};
+/**
+ * This function creates a wrapper around an interface that allows to call methods on it, but all methods will go to queue. Once actual instance
+ * implementation becomes available, all queued methods will be called on it.
+ *
+ *
+ * @param methods of methods that should be wrapped. Per each method of you should specify if it should be wrapped. You'll need to mark all
+ * methods for type safety. If method is not wrapped, it will throw an error when called.
+ */
+export declare function delayMethodExec<T>(methods: Record<keyof T, boolean>): InterfaceWrapper<T>;
+export {};

package/dist/script-loader.d.ts

@@ -0,0 +1 @@
+export declare function loadScript(src: string, attributes?: Record<string, string>): Promise<HTMLScriptElement>;