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

package/.turbo/turbo-build.log

@@ -1,33 +1,65 @@
-@jitsu/js:build: cache hit, replaying output b530f4244fe3e541
-@jitsu/js:build: 
-@jitsu/js:build: > @jitsu/js@0.0.0 build /Users/vklmn/dev2/onetag/libs/jitsu-js
-@jitsu/js:build: > tsc -p . && rollup -c && cp compiled/src/*.d.ts dist
-@jitsu/js:build: 
-@jitsu/js:build: 
-@jitsu/js:build: ./compiled/src/browser.js → dist/web/p.js.txt...
-@jitsu/js:build: (!) Circular dependency
-@jitsu/js:build: compiled/src/index.js -> compiled/src/analytics-plugin.js -> compiled/src/index.js
-@jitsu/js:build: (!) Use of eval is strongly discouraged
-@jitsu/js:build: https://rollupjs.org/guide/en/#avoiding-eval
-@jitsu/js:build: compiled/src/analytics-plugin.js
-@jitsu/js:build: 258:   })()`;
-@jitsu/js:build: 259:     try {
-@jitsu/js:build: 260:         eval(iif);
-@jitsu/js:build:              ^
-@jitsu/js:build: 261:     }
-@jitsu/js:build: 262:     catch (e) {
-@jitsu/js:build: created dist/web/p.js.txt in 226ms
-@jitsu/js:build: 
-@jitsu/js:build: ./compiled/src/index.js, ./compiled/src/jitsu.js, ./compiled/src/analytics-plugin.js → dist/jitsu.es.js, dist/jitsu.cjs.js...
-@jitsu/js:build: (!) Circular dependency
-@jitsu/js:build: compiled/src/index.js -> compiled/src/analytics-plugin.js -> compiled/src/index.js
-@jitsu/js:build: (!) Use of eval is strongly discouraged
-@jitsu/js:build: https://rollupjs.org/guide/en/#avoiding-eval
-@jitsu/js:build: compiled/src/analytics-plugin.js
-@jitsu/js:build: 258:   })()`;
-@jitsu/js:build: 259:     try {
-@jitsu/js:build: 260:         eval(iif);
-@jitsu/js:build:              ^
-@jitsu/js:build: 261:     }
-@jitsu/js:build: 262:     catch (e) {
-@jitsu/js:build: created dist/jitsu.es.js, dist/jitsu.cjs.js in 121ms
+@jitsu/js:build: cache hit, replaying output c41fba61aef5e756
+@jitsu/js:build: 
+@jitsu/js:build: > @jitsu/js@0.0.0 build /Users/vklmn/dev2/onetag/libs/jitsu-js
+@jitsu/js:build: > tsc -p . && rollup -c && cp compiled/src/*.d.ts dist
+@jitsu/js:build: 
+@jitsu/js:build: 
+@jitsu/js:build: ./compiled/src/browser.js → dist/web/p.js.txt...
+@jitsu/js:build: (!) "this" has been rewritten to "undefined"
+@jitsu/js:build: https://rollupjs.org/guide/en/#error-this-is-undefined
+@jitsu/js:build: compiled/src/analytics-plugin.js
+@jitsu/js:build: 1: /* global analytics */
+@jitsu/js:build: 2: var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+@jitsu/js:build:                     ^
+@jitsu/js:build: 3:     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+@jitsu/js:build: 4:     return new (P || (P = Promise))(function (resolve, reject) {
+@jitsu/js:build: ...and 1 other occurrence
+@jitsu/js:build: compiled/src/destination-plugins.js
+@jitsu/js:build: 1: var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+@jitsu/js:build:                     ^
+@jitsu/js:build: 2:     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+@jitsu/js:build: 3:     return new (P || (P = Promise))(function (resolve, reject) {
+@jitsu/js:build: ...and 1 other occurrence
+@jitsu/js:build: (!) Circular dependencies
+@jitsu/js:build: compiled/src/index.js -> compiled/src/analytics-plugin.js -> compiled/src/index.js
+@jitsu/js:build: compiled/src/analytics-plugin.js -> compiled/src/destination-plugins.js -> compiled/src/analytics-plugin.js
+@jitsu/js:build: (!) Use of eval is strongly discouraged
+@jitsu/js:build: https://rollupjs.org/guide/en/#avoiding-eval
+@jitsu/js:build: compiled/src/destination-plugins.js
+@jitsu/js:build: 75:   })()`;
+@jitsu/js:build: 76:     try {
+@jitsu/js:build: 77:         eval(iif);
+@jitsu/js:build:             ^
+@jitsu/js:build: 78:     }
+@jitsu/js:build: 79:     catch (e) {
+@jitsu/js:build: created dist/web/p.js.txt in 252ms
+@jitsu/js:build: 
+@jitsu/js:build: ./compiled/src/index.js, ./compiled/src/jitsu.js, ./compiled/src/analytics-plugin.js → dist/jitsu.es.js, dist/jitsu.cjs.js...
+@jitsu/js:build: (!) "this" has been rewritten to "undefined"
+@jitsu/js:build: https://rollupjs.org/guide/en/#error-this-is-undefined
+@jitsu/js:build: compiled/src/analytics-plugin.js
+@jitsu/js:build: 1: /* global analytics */
+@jitsu/js:build: 2: var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+@jitsu/js:build:                     ^
+@jitsu/js:build: 3:     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+@jitsu/js:build: 4:     return new (P || (P = Promise))(function (resolve, reject) {
+@jitsu/js:build: ...and 1 other occurrence
+@jitsu/js:build: compiled/src/destination-plugins.js
+@jitsu/js:build: 1: var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+@jitsu/js:build:                     ^
+@jitsu/js:build: 2:     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+@jitsu/js:build: 3:     return new (P || (P = Promise))(function (resolve, reject) {
+@jitsu/js:build: ...and 1 other occurrence
+@jitsu/js:build: (!) Circular dependencies
+@jitsu/js:build: compiled/src/index.js -> compiled/src/analytics-plugin.js -> compiled/src/index.js
+@jitsu/js:build: compiled/src/analytics-plugin.js -> compiled/src/destination-plugins.js -> compiled/src/analytics-plugin.js
+@jitsu/js:build: (!) Use of eval is strongly discouraged
+@jitsu/js:build: https://rollupjs.org/guide/en/#avoiding-eval
+@jitsu/js:build: compiled/src/destination-plugins.js
+@jitsu/js:build: 75:   })()`;
+@jitsu/js:build: 76:     try {
+@jitsu/js:build: 77:         eval(iif);
+@jitsu/js:build:             ^
+@jitsu/js:build: 78:     }
+@jitsu/js:build: 79:     catch (e) {
+@jitsu/js:build: created dist/jitsu.es.js, dist/jitsu.cjs.js in 151ms

package/.turbo/turbo-clean.log

@@ -1,5 +1,5 @@
-@jitsu/js:clean: cache hit, replaying output 928bbc238fc9b4c5
-@jitsu/js:clean: 
-@jitsu/js:clean: > @jitsu/js@0.0.0 clean /Users/vklmn/dev2/onetag/libs/jitsu-js
-@jitsu/js:clean: > rm -rf ./dist
-@jitsu/js:clean: 
+@jitsu/js:clean: cache hit, replaying output c648dd4be85c0190
+@jitsu/js:clean: 
+@jitsu/js:clean: > @jitsu/js@0.0.0 clean /Users/vklmn/dev2/onetag/libs/jitsu-js
+@jitsu/js:clean: > rm -rf ./dist
+@jitsu/js:clean: 

package/__tests__/node/method-queue.test.ts

@@ -0,0 +1,66 @@
+import { delayMethodExec } from "../../src/method-queue";
+import { expect } from "@playwright/test";
+
+interface ITest {
+  method(str: string, num: number): string;
+
+  _internalMethod(str: string, num: number): string;
+}
+
+interface AsyncInterface {
+  method(str: string, num: number): Promise<string>;
+
+  _internalMethod(str: string, num: number);
+}
+
+test("method-queue", async () => {
+  const testResult: string[] = [];
+  const wrap = delayMethodExec<ITest>({
+    method: true,
+    _internalMethod: false,
+  });
+  const instance = wrap.get();
+  const wrapPromise = instance.method("a", 1).then(res => testResult.push(res));
+
+  expect(testResult).toEqual([]);
+  expect(() => instance._internalMethod("a", 1)).toThrowError();
+
+  wrap.loaded({
+    _internalMethod(str, num) {
+      return `${str}${num}`;
+    },
+    method(str, num) {
+      const result = this._internalMethod(str, num);
+      testResult.push(result);
+      return `result:${result}`;
+    },
+  });
+  await wrapPromise;
+
+  expect(testResult).toEqual(["a1", "result:a1"]);
+
+  instance.method("b", 2);
+  expect(testResult).toEqual(["a1", "result:a1", "b2"]);
+});
+
+test("test-async", async () => {
+  const testResult: string[] = [];
+  const wrap = delayMethodExec<AsyncInterface>({
+    method: true,
+    _internalMethod: false,
+  });
+  const instance = wrap.get();
+  const wrapPromise = instance.method("a", 1).then(res => testResult.push(res));
+
+  wrap.loaded({
+    _internalMethod(str, num) {
+      return `${str}${num}`;
+    },
+    async method(str, num) {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      return `result:${this._internalMethod(str, num)}`;
+    },
+  });
+  await wrapPromise;
+  expect(testResult).toEqual(["result:a1"]);
+});

package/__tests__/playwright/integration.test.ts

@@ -3,7 +3,7 @@ import { createServer, SimpleSyrup } from "../simple-syrup";
 import * as fs from "fs";
 import * as path from "path";
 import ejs from "ejs";
-import chalk from "chalk";
+// import chalk from "chalk";
 import * as process from "process";
 import * as console from "console";
 import { AnalyticsClientEvent, AnalyticsInterface } from "@jitsu/protocols/analytics.d";
@@ -14,6 +14,11 @@ test.use({
   ignoreHTTPSErrors: true,
 });
 
+const chalk = {
+  cyan: (str: string) => str,
+  bold: (str: string) => str,
+};
+
 const express = require("express");
 const cookieParser = require("cookie-parser");
 const app = express();
@@ -79,17 +84,6 @@ function sortKeysRecursively(obj: any): any {
   return obj;
 }
 
-function logColor(type: string) {
-  return (
-    {
-      error: chalk.bgRed,
-      warn: chalk.bgYellow,
-      info: chalk.bgBlack,
-      log: chalk.bgGray,
-    }[type] || (x => x)
-  );
-}
-
 function shouldKeepBrowserOpen() {
   return process.env.KEEP_BROWSER_OPEN === "true" || process.env.KEEP_BROWSER_OPEN === "1";
 }

package/dist/analytics-plugin.d.ts

@@ -5,6 +5,23 @@ export type StorageFactory = (cookieDomain: string, cookie2key: Record<string, s
 export declare function getTopLevelDomain(opts?: JitsuOptions): string;
 export declare function windowRuntime(opts: JitsuOptions): RuntimeFacade;
 export declare const emptyRuntime: (config: JitsuOptions) => RuntimeFacade;
+export declare function isInBrowser(): boolean;
+export type DestinationDescriptor = {
+    id: string;
+    destinationType: string;
+    credentials: any;
+    deviceOptions: DeviceOptions;
+};
+export type AnalyticsPluginDescriptor = {
+    type: "analytics-plugin";
+    packageCdn: string;
+    moduleVarName: string;
+};
+export type InternalPluginDescriptor = {
+    type: "internal-plugin";
+    name: string;
+};
+export type DeviceOptions = AnalyticsPluginDescriptor | InternalPluginDescriptor;
 declare const jitsuAnalyticsPlugin: (pluginConfig?: JitsuOptions) => AnalyticsPlugin;
 export declare function randomId(hashString?: string | undefined): string;
 export default jitsuAnalyticsPlugin;

package/dist/destination-plugins.d.ts

@@ -0,0 +1,13 @@
+import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
+export type InternalPlugin<T> = {
+    id: string;
+    handle(config: T, payload: AnalyticsClientEvent): Promise<void>;
+};
+export type CommonDestinationCredentials = {
+    hosts?: string[];
+    events?: string[];
+};
+export type TagDestinationCredentials = {
+    code: string;
+} & CommonDestinationCredentials;
+export declare const internalDestinationPlugins: Record<string, InternalPlugin<any>>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { JitsuOptions, AnalyticsInterface } from "./jitsu";
+import { AnalyticsInterface, JitsuOptions } from "./jitsu";
 export default function parse(input: any): any;
 export declare function jitsuAnalytics(opts: JitsuOptions): AnalyticsInterface;
 export * from "./jitsu";

package/dist/jitsu.cjs.js

@@ -67,7 +67,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,
@@ -279,7 +423,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;
@@ -317,62 +461,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;
@@ -405,18 +549,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) {
@@ -446,9 +591,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");
@@ -456,17 +601,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
@@ -519,13 +664,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) => {
@@ -538,9 +682,37 @@ 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));
+    // }
+}
 
 exports.emptyRuntime = emptyRuntime;
 exports.getTopLevelDomain = getTopLevelDomain;
+exports.isInBrowser = isInBrowser;
 exports.jitsuAnalytics = jitsuAnalytics;
 exports.parseQuery = parseQuery;
 exports.randomId = randomId;