@jitsu/js 1.9.15 → 1.9.18-canary.1269.20250403142744

package/src/browser.ts

@@ -1,163 +0,0 @@
-import type { AnalyticsInterface, JitsuOptions } from "@jitsu/protocols/analytics";
-import { jitsuAnalytics } from "./index";
-
-export type JitsuBrowserOptions = {
-  namespace?: string;
-  onload?: string;
-  initOnly?: boolean;
-} & JitsuOptions;
-
-function snakeToCamel(s: string) {
-  return s.replace(/([-_][a-z])/gi, $1 => {
-    return $1.toUpperCase().replace("-", "").replace("_", "");
-  });
-}
-
-export type Parser = {
-  path?: (name: string) => string[];
-  parse: (arg: string) => any;
-};
-const trimPrefix = (s: string, prefix: string) => s.replace(new RegExp(`^${prefix}`), "");
-
-const defaultParser = (nestedPath: string[] = []) => ({
-  path: (name: string) => [
-    ...nestedPath,
-    snakeToCamel(nestedPath.length > 0 ? trimPrefix(name, nestedPath.join("-") + "-") : name),
-  ],
-  parse: (arg: string) => arg,
-});
-
-const booleanParser = (nestedPath: string[] = []) => ({
-  ...defaultParser(nestedPath),
-  parse: (arg: string) => arg === "true" || arg === "1" || arg === "yes",
-});
-
-const jsonParser = (nestedPath: string[] = []) => ({
-  ...defaultParser(nestedPath),
-  parse: (arg: string) => {
-    try {
-      return JSON.parse(arg);
-    } catch (e) {
-      console.error(`Can't parse Jitsu Option as JSON: ${arg}`);
-      return {};
-    }
-  },
-});
-
-const parsers: Partial<Record<string, Parser>> = {
-  debug: booleanParser(),
-  "privacy-disable-user-ids": booleanParser(["privacy"]),
-  "privacy-dont-send": booleanParser(["privacy"]),
-  "privacy-ip-policy": defaultParser(["privacy"]),
-  "echo-events": booleanParser(),
-  "init-only": booleanParser(),
-  "cookie-names": jsonParser(),
-  "cookie-capture": jsonParser(),
-  "default-payload-context": jsonParser(),
-};
-
-function getParser(name: string): Parser {
-  return parsers[name] || defaultParser();
-}
-
-function setPath(obj: any, path: string[], value: any) {
-  let current = obj;
-  let i = 0;
-  for (; i < path.length - 1; i++) {
-    const key = path[i];
-    current[key] = current[key] || {};
-    current = current[key];
-  }
-  current[path[i]] = value;
-}
-
-function getScriptAttributes(scriptElement: HTMLScriptElement) {
-  return scriptElement
-    .getAttributeNames()
-    .filter(name => name.indexOf("data-") === 0)
-    .map(name => name.substring("data-".length))
-    .reduce((res, name) => {
-      const parser = getParser(name);
-      const path = parser.path(name);
-      setPath(res, path, parser.parse(scriptElement.getAttribute(`data-${name}`)));
-      return res;
-    }, {});
-}
-
-function runCallback(callback: any, jitsu: AnalyticsInterface) {
-  if (typeof callback === "function") {
-    callback(jitsu);
-  } else if (Array.isArray(callback) && typeof callback[0] === "string") {
-    const [method, ...args] = callback;
-    if (typeof jitsu[method] === "function") {
-      jitsu[method](...args);
-    } else {
-      console.warn(`Method ${method} is not supported, ignoring callback`);
-    }
-  } else {
-    console.warn(`Invalid jitsu queue callback`, callback);
-  }
-}
-
-(function () {
-  function readJitsuOptions(): JitsuBrowserOptions {
-    const scriptElement = window.document.currentScript as HTMLScriptElement;
-    if (!scriptElement) {
-      throw new Error(`Can't find script element`);
-    }
-    const host = new URL(scriptElement.src).origin;
-
-    return { ...((window as any)?.jitsuConfig || {}), ...getScriptAttributes(scriptElement), host };
-  }
-
-  const options = readJitsuOptions();
-  const JITSU_V2_ID: string = options.namespace || "jitsu";
-  if (options.debug) {
-    console.log(`Jitsu options: `, JSON.stringify(options));
-  }
-  const jitsu = jitsuAnalytics(options);
-
-  if (options.onload) {
-    const onloadFunction = window[options.onload] as any;
-    if (!onloadFunction) {
-      console.warn(`onload function ${options.onload} is not found in window`);
-    }
-    if (typeof onloadFunction === "function") {
-      onloadFunction(jitsu);
-    } else {
-      console.warn(`onload function ${options.onload} is not callable: ${typeof onloadFunction}`);
-    }
-  }
-  window[JITSU_V2_ID] = jitsu;
-
-  /**
-   * New callback based queue, see below
-   */
-  //make a copy of the queue
-  const callbackQueue =
-    window[JITSU_V2_ID + "Q"] && window[JITSU_V2_ID + "Q"].length ? [...window[JITSU_V2_ID + "Q"]] : [];
-  //replace push with a function that calls callback immediately
-  window[JITSU_V2_ID + "Q"] = {
-    push: (callback: any) => {
-      if (typeof callback === "function") {
-        callback(jitsu);
-      } else {
-        console.warn(`${JITSU_V2_ID}Q.push() accepts only function, ${typeof callback} given`);
-      }
-    },
-  };
-
-  if (options.debug) {
-    console.log(`[JITSU DEBUG] Jitsu callback queue size: ${callbackQueue.length}`, callbackQueue);
-  }
-  callbackQueue.forEach((callback: any) => {
-    try {
-      runCallback(callback, jitsu);
-    } catch (e: any) {
-      console.warn(`Error processing callback from Jitsu queue`, e);
-    }
-  });
-  if (!options.initOnly) {
-    jitsu.page();
-  }
-})();

package/src/destination-plugins/ga4.ts

@@ -1,138 +0,0 @@
-import { loadScript } from "../script-loader";
-import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
-import { applyFilters, CommonDestinationCredentials, InternalPlugin } from "./index";
-
-const urlData = [
-  new Uint8Array([109, 111, 99, 46, 114, 101, 103, 97, 110, 97, 109, 103, 97, 116, 101, 108, 103, 111, 111, 103]),
-  new Uint8Array([103, 97, 116, 103]),
-  new Uint8Array([115, 106]),
-];
-
-function byteArrayToString(byteArray: Uint8Array): string {
-  const decoder = new TextDecoder();
-  return decoder.decode(byteArray);
-}
-
-function buildTagUrl() {
-  return urlData
-    .map(d => d.reverse())
-    .map(byteArrayToString)
-    .join("/");
-}
-
-export type Ga4DestinationCredentials = {
-  debug?: boolean;
-  measurementIds?: string;
-  autoPageView?: boolean;
-  dataLayerName?: string;
-} & CommonDestinationCredentials;
-
-export const ga4Plugin: InternalPlugin<Ga4DestinationCredentials> = {
-  id: "ga4-tag",
-  async handle(config, payload: AnalyticsClientEvent) {
-    if (!applyFilters(payload, config)) {
-      return;
-    }
-    await initGa4IfNeeded(config, payload);
-
-    const dataLayer = window[config.dataLayerName || "dataLayer"];
-    const gtag = function () {
-      dataLayer.push(arguments);
-    };
-    const ids = {
-      ...(payload.userId ? { user_id: payload.userId, userId: payload.userId } : {}),
-      ...(payload.anonymousId ? { anonymousId: payload.anonymousId } : {}),
-    };
-    if (payload.userId) {
-      // @ts-ignore
-      gtag("set", { user_id: payload.userId });
-    }
-
-    switch (payload.type) {
-      case "page":
-        if (config.autoPageView) {
-          console.log("autoPageView");
-          break;
-        }
-        const { properties: pageProperties, context } = payload;
-        const pageEvent = {
-          page_location: pageProperties.url,
-          page_title: pageProperties.title,
-          page_path: pageProperties.path,
-          page_hash: pageProperties.hash,
-          page_search: pageProperties.search,
-          page_referrer: context?.page?.referrer ?? "",
-          ...ids,
-        };
-        // @ts-ignore
-        gtag("event", "page_view", pageEvent);
-        break;
-      case "track":
-        const { properties: trackProperties } = payload;
-        const trackEvent: any = {
-          ...trackProperties,
-          ...ids,
-        };
-        // @ts-ignore
-        gtag("event", payload.event, trackEvent);
-        break;
-      case "identify":
-        const { traits } = payload;
-        const identifyEvent: any = {
-          ...traits,
-          ...ids,
-        };
-        // @ts-ignore
-        gtag("event", "identify", identifyEvent);
-        break;
-    }
-  },
-};
-
-type GtmState = "fresh" | "loading" | "loaded" | "failed";
-
-function getGa4State(): GtmState {
-  return window["__jitsuGa4State"] || "fresh";
-}
-
-function setGa4State(s: GtmState) {
-  window["__jitsuGa4State"] = s;
-}
-
-async function initGa4IfNeeded(config: Ga4DestinationCredentials, payload: AnalyticsClientEvent) {
-  if (getGa4State() !== "fresh") {
-    return;
-  }
-  setGa4State("loading");
-
-  const dlName = config.dataLayerName || "dataLayer";
-  const dlParam = dlName !== "dataLayer" ? "&l=" + dlName : "";
-
-  // to work with both GA4 and GTM
-  const tagId = config.measurementIds;
-
-  window[dlName] = window[dlName] || [];
-  const gtag = function () {
-    window[dlName].push(arguments);
-  };
-  // @ts-ignore
-  gtag("js", new Date());
-  gtag(
-    // @ts-ignore
-    "config",
-    tagId,
-    {
-      ...(payload.userId ? { user_id: payload.userId } : {}),
-      ...(!config.autoPageView ? { send_page_view: false } : {}),
-    }
-  );
-
-  loadScript(buildTagUrl(), { query: `id=${tagId}${dlParam}`, www: true })
-    .then(() => {
-      setGa4State("loaded");
-    })
-    .catch(e => {
-      console.warn(`GA4 (containerId=${config.measurementIds}) init failed: ${e.message}`, e);
-      setGa4State("failed");
-    });
-}

package/src/destination-plugins/gtm.ts

@@ -1,142 +0,0 @@
-import { loadScript } from "../script-loader";
-import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
-import { applyFilters, CommonDestinationCredentials, InternalPlugin } from "./index";
-
-export type GtmDestinationCredentials = {
-  containerId?: string;
-  dataLayerName?: string;
-} & CommonDestinationCredentials;
-
-function omit(obj: any, ...keys: string[]) {
-  return Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));
-}
-
-export const gtmPlugin: InternalPlugin<GtmDestinationCredentials> = {
-  id: "gtm",
-  async handle(config, payload: AnalyticsClientEvent) {
-    const debug = !!config.debug;
-    if (!applyFilters(payload, config)) {
-      return;
-    }
-    await initGtmIfNeeded(config, payload);
-
-    const dataLayer = window[config.dataLayerName || "dataLayer"];
-    //traits could be in both nodes, context.traits takes precedence
-    const traits = {
-      ...(payload?.traits || {}),
-      ...(payload?.context?.traits || {}),
-    };
-    //remove properties that defined separately
-    const idsFromTraits = omit(traits, "id", "userId", "user_id", "anonymousId", "userId");
-    if (debug) {
-      console.debug("GTM plugin will be applied to following payload", payload);
-    }
-
-    // See  https://developers.google.com/tag-platform/tag-manager/server-side/common-event-data
-    const userData = {
-      email_address: traits.email,
-    };
-    const ids = {
-      ...(payload.userId ? { user_id: payload.userId, userId: payload.userId } : {}),
-      ...(payload.anonymousId ? { anonymousId: payload.anonymousId } : {}),
-      ...idsFromTraits,
-      user_data: Object.keys(userData).length > 0 ? userData : undefined,
-    };
-    if (debug) {
-      console.debug("GTM plugin will set following user-related data layer vars", ids);
-    }
-    const pageProperties = payload.properties || {};
-    const pageVariables = {
-      page_location: pageProperties.url || payload.context?.page?.url,
-      page_title: pageProperties.title || payload.context?.page?.title,
-      page_path: pageProperties.path || payload.context?.page?.path,
-      page_hash: pageProperties.hash || payload.context?.page?.hash,
-      page_search: pageProperties.search || payload.context?.page?.search,
-      page_referrer: payload?.context?.page?.referrer ?? "",
-    };
-    if (debug) {
-      console.debug("GTM plugin will set following context (page) related data layer vars", ids);
-    }
-    const pushToDataLayer = (data: any) => {
-      dataLayer.push(data);
-      if (debug) {
-        console.debug("GTM plugin will push following data to dataLayer", data);
-      }
-    };
-    switch (payload.type) {
-      case "page":
-        const { properties: pageProperties, context } = payload;
-        const pageEvent = {
-          event: "page_view",
-          ...pageVariables,
-          ...ids,
-        };
-        pushToDataLayer(pageEvent);
-        break;
-      case "track":
-        const { properties: trackProperties } = payload;
-        const trackEvent: any = {
-          event: payload.event,
-          ...pageVariables,
-          ...trackProperties,
-          ...ids,
-        };
-        pushToDataLayer(trackEvent);
-        break;
-      case "identify":
-        const { traits } = payload;
-        const identifyEvent: any = {
-          event: "identify",
-          ...pageVariables,
-          ...traits,
-          ...ids,
-        };
-        pushToDataLayer(identifyEvent);
-        break;
-    }
-    dataLayer.push(function () {
-      this.reset();
-    });
-  },
-};
-
-type GtmState = "fresh" | "loading" | "loaded" | "failed";
-
-function getGtmState(): GtmState {
-  return window["__jitsuGtmState"] || "fresh";
-}
-
-function setGtmState(s: GtmState) {
-  window["__jitsuGtmState"] = s;
-}
-
-async function initGtmIfNeeded(config: GtmDestinationCredentials, payload: AnalyticsClientEvent) {
-  if (getGtmState() !== "fresh") {
-    return;
-  }
-  setGtmState("loading");
-
-  const dlName = config.dataLayerName || "dataLayer";
-  const tagId = config.containerId;
-
-  (function (w, l, i) {
-    w[l] = w[l] || [];
-    w[l].push({
-      user_id: payload.userId,
-    });
-    w[l].push({
-      "gtm.start": new Date().getTime(),
-      event: "gtm.js",
-    });
-    const dl = l != "dataLayer" ? "&l=" + l : "";
-    const scriptSrc = "googletagmanager.com/gtm";
-    loadScript(scriptSrc, { www: true, js: true, query: "id=" + i + dl })
-      .then(() => {
-        setGtmState("loaded");
-      })
-      .catch(e => {
-        console.warn(`GTM (containerId=${tagId}) init failed: ${e.message}`, e);
-        setGtmState("failed");
-      });
-  })(window, dlName, tagId);
-}

package/src/destination-plugins/index.ts

@@ -1,61 +0,0 @@
-import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
-import { tagPlugin } from "./tag";
-import { logrocketPlugin } from "./logrocket";
-import { gtmPlugin } from "./gtm";
-import { ga4Plugin } from "./ga4";
-
-export type InternalPlugin<T> = {
-  id: string;
-  handle(config: T & { debug?: boolean }, payload: AnalyticsClientEvent): Promise<void>;
-};
-
-export type CommonDestinationCredentials = {
-  hosts?: string;
-  events?: string;
-};
-
-export function satisfyFilter(filter: string, subject: string | undefined): boolean {
-  return filter === "*" || filter.toLowerCase().trim() === (subject || "").trim().toLowerCase();
-}
-
-export function satisfyDomainFilter(filter: string, subject: string | undefined): boolean {
-  if (filter === "*") {
-    return true;
-  }
-  subject = subject || "";
-
-  if (filter.startsWith("*.")) {
-    return subject.endsWith(filter.substring(1));
-  } else {
-    return filter === subject;
-  }
-}
-
-export function applyFilters(event: AnalyticsClientEvent, creds: CommonDestinationCredentials): boolean {
-  const { hosts = "*", events = "*" } = creds;
-  try {
-    const eventsArray = Array.isArray(events) ? events : events.split("\n");
-    const hostsArray = Array.isArray(hosts) ? hosts : hosts.split("\n");
-    return (
-      !!hostsArray.find(hostFilter => satisfyDomainFilter(hostFilter, event.context?.page?.host)) &&
-      (!!eventsArray.find(eventFilter => satisfyFilter(eventFilter, event.type)) ||
-        !!eventsArray.find(eventFilter => satisfyFilter(eventFilter, event.event)))
-    );
-  } catch (e) {
-    console.warn(
-      `Failed to apply filters: ${e.message}. Typeof events: ${typeof events}, typeof hosts: ${typeof hosts}. Values`,
-      events,
-      hosts
-    );
-    throw new Error(
-      `Failed to apply filters: ${e.message}. Typeof events: ${typeof events}, typeof hosts: ${typeof hosts}`
-    );
-  }
-}
-
-export const internalDestinationPlugins: Record<string, InternalPlugin<any>> = {
-  [tagPlugin.id]: tagPlugin,
-  [gtmPlugin.id]: gtmPlugin,
-  [ga4Plugin.id]: ga4Plugin,
-  [logrocketPlugin.id]: logrocketPlugin,
-};

package/src/destination-plugins/logrocket.ts

@@ -1,85 +0,0 @@
-import { loadScript } from "../script-loader";
-import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
-import { applyFilters, CommonDestinationCredentials, InternalPlugin } from "./index";
-
-export type LogRocketDestinationCredentials = {
-  appId: string;
-} & CommonDestinationCredentials;
-
-const cdn = "cdn.lr-ingest.io/";
-
-export const logrocketPlugin: InternalPlugin<LogRocketDestinationCredentials> = {
-  id: "logrocket",
-  async handle(config, payload: AnalyticsClientEvent) {
-    if (!applyFilters(payload, config)) {
-      return;
-    }
-    initLogrocketIfNeeded(config.appId);
-
-    const action = logRocket => {
-      if (payload.type === "identify" && payload.userId) {
-        logRocket.identify(payload.userId, payload.traits || {});
-      }
-    };
-    getLogRocketQueue().push(action);
-    if (getLogRocketState() === "loaded") {
-      flushLogRocketQueue(window["LogRocket"]);
-    }
-  },
-};
-
-type LogRocketState = "fresh" | "loading" | "loaded" | "failed";
-
-function getLogRocketState(): LogRocketState {
-  return window["__jitsuLrState"] || "fresh";
-}
-
-function setLogRocketState(s: LogRocketState) {
-  window["__jitsuLrState"] = s;
-}
-
-function getLogRocketQueue(): ((lr: LogRocket) => void | Promise<void>)[] {
-  return window["__jitsuLrQueue"] || (window["__jitsuLrQueue"] = []);
-}
-
-export type LogRocket = any;
-
-function flushLogRocketQueue(lr: LogRocket) {
-  const queue = getLogRocketQueue();
-
-  while (queue.length > 0) {
-    const method = queue.shift();
-    try {
-      const res = method(lr);
-      if (res) {
-        res.catch(e => console.warn(`Async LogRocket method failed: ${e.message}`, e));
-      }
-    } catch (e) {
-      console.warn(`LogRocket method failed: ${e.message}`, e);
-    }
-  }
-}
-
-async function initLogrocketIfNeeded(appId: string) {
-  if (getLogRocketState() !== "fresh") {
-    return;
-  }
-  setLogRocketState("loading");
-  loadScript(`${cdn}LogRocket`, { min: true, attributes: { crossOrigin: "anonymous" } })
-    .then(() => {
-      if (window["LogRocket"]) {
-        try {
-          window["LogRocket"].init(appId);
-        } catch (e) {
-          console.warn(`LogRocket (id=${appId}) init failed: ${e.message}`, e);
-          setLogRocketState("failed");
-        }
-        setLogRocketState("loaded");
-        flushLogRocketQueue(window["LogRocket"]);
-      }
-    })
-    .catch(e => {
-      console.warn(`LogRocket (id=${appId}) init failed: ${e.message}`, e);
-      setLogRocketState("failed");
-    });
-}

package/src/destination-plugins/tag.ts

@@ -1,85 +0,0 @@
-import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
-import { applyFilters, CommonDestinationCredentials, InternalPlugin } from "./index";
-import { isInBrowser, randomId } from "../analytics-plugin";
-
-export type TagDestinationCredentials = {
-  code: string;
-} & CommonDestinationCredentials;
-
-export const tagPlugin: InternalPlugin<TagDestinationCredentials> = {
-  id: "tag",
-  async handle(config, payload: AnalyticsClientEvent) {
-    if (!applyFilters(payload, config)) {
-      return;
-    }
-    insertTags(config.code, payload);
-  },
-};
-
-function insertTags(code, event: AnalyticsClientEvent, opts: { debug?: boolean } = {}) {
-  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`);
-    }
-  }
-}
-
-//This weird code is used to mask eval() usage.
-//Although the code can be executed in the browser, some server side bundlers (like Vercel) fails
-//the build if a direct reference to eval() is found.
-let al = "al";
-let ev = "ve".split("").reverse().join("");
-const execF = globalThis[ev + al];
-
-function execJs(code: string, event: any) {
-  const varName = `jitsu_event_${randomId()}`;
-  window[varName] = event;
-  const iif = `(function(){
-      const event = ${varName};
-      ${code}
-  })()`;
-  try {
-    execF(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));
-}