@jitsu/js 1.1.0-canary.344.20230430234929 → 1.1.0-canary.391.20230523080206

package/src/destination-plugins/index.ts

@@ -0,0 +1,34 @@
+import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
+import { tagPlugin } from "./tag";
+import { logrocketPlugin } from "./logrocket";
+import { gtmPlugin } from "./gtm";
+
+export type InternalPlugin<T> = {
+  id: string;
+  handle(config: T, 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 applyFilters(event: AnalyticsClientEvent, creds: CommonDestinationCredentials): boolean {
+  const { hosts = "*", events = "*" } = creds;
+  const eventsArray = events.split("\n");
+  return (
+    !!hosts.split("\n").find(hostFilter => satisfyFilter(hostFilter, event.context?.host)) &&
+    (!!eventsArray.find(eventFilter => satisfyFilter(eventFilter, event.type)) ||
+      !!eventsArray.find(eventFilter => satisfyFilter(eventFilter, event.event)))
+  );
+}
+
+export const internalDestinationPlugins: Record<string, InternalPlugin<any>> = {
+  [tagPlugin.id]: tagPlugin,
+  [gtmPlugin.id]: gtmPlugin,
+  [logrocketPlugin.id]: logrocketPlugin,
+};

package/src/destination-plugins/logrocket.ts

@@ -0,0 +1,83 @@
+import { loadScript } from "../script-loader";
+import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
+import { applyFilters, CommonDestinationCredentials, InternalPlugin } from "./index";
+
+export type LogRocketDestinationCredentials = {
+  appId: string;
+} & CommonDestinationCredentials;
+
+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(`https://cdn.lr-ingest.io/LogRocket.min.js`, { 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.ts → destination-plugins/tag.ts}

@@ -1,33 +1,12 @@
 import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
-import { isInBrowser, randomId } from "./analytics-plugin";
-
-export type InternalPlugin<T> = {
-  id: string;
-  handle(config: T, payload: AnalyticsClientEvent): Promise<void>;
-};
-
-export type CommonDestinationCredentials = {
-  hosts?: string[];
-  events?: string[];
-};
+import { applyFilters, CommonDestinationCredentials, InternalPlugin } from "./index";
+import { isInBrowser, randomId } from "../analytics-plugin";
 
 export type TagDestinationCredentials = {
   code: string;
 } & CommonDestinationCredentials;
 
-function satisfyFilter(filter: string, subject: string | undefined): boolean {
-  return filter === "*" || filter.toLowerCase().trim() === (subject || "").trim().toLowerCase();
-}
-
-function applyFilters(event: AnalyticsClientEvent, creds: CommonDestinationCredentials): boolean {
-  const { hosts = ["*"], events = ["*"] } = creds;
-  return (
-    !!hosts.find(hostFilter => satisfyFilter(hostFilter, event.context?.host)) &&
-    !!events.find(eventFilter => satisfyFilter(eventFilter, event.type))
-  );
-}
-
-const tagPlugin: InternalPlugin<TagDestinationCredentials> = {
+export const tagPlugin: InternalPlugin<TagDestinationCredentials> = {
   id: "tag",
   async handle(config, payload: AnalyticsClientEvent) {
     if (!applyFilters(payload, config)) {
@@ -97,7 +76,3 @@ function execJs(code: string, event: any) {
 function replaceMacro(code, event) {
   return code.replace(/{{\s*event\s*}}/g, JSON.stringify(event));
 }
-
-export const internalDestinationPlugins: Record<string, InternalPlugin<any>> = {
-  [tagPlugin.id]: tagPlugin,
-};

package/src/index.ts

@@ -1,8 +1,7 @@
 import Analytics from "analytics";
 import { AnalyticsInterface, JitsuOptions, RuntimeFacade } from "./jitsu";
 import jitsuAnalyticsPlugin, { emptyRuntime, isInBrowser, windowRuntime } from "./analytics-plugin";
-import { delayMethodExec } from "./method-queue";
-import e from "express";
+import { Callback, DispatchedEvent, ID, JSONObject, Options } from "@jitsu/protocols/analytics";
 
 export default function parse(input) {
   let value = input;
@@ -29,6 +28,7 @@ export const emptyAnalytics = {
   page: () => Promise.resolve(),
   user: () => ({}),
   identify: () => Promise.resolve({}),
+  group: () => Promise.resolve({}),
   reset: () => Promise.resolve({}),
 };
 
@@ -54,7 +54,17 @@ function createUnderlyingAnalyticsInstance(
       return originalPage(...args);
     }
   };
-  return analytics as AnalyticsInterface;
+  return {
+    ...analytics,
+    group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback): Promise<DispatchedEvent> {
+      for (const plugin of Object.values(analytics.plugins)) {
+        if (plugin["group"]) {
+          plugin["group"](groupId, traits, options, callback);
+        }
+      }
+      return Promise.resolve({});
+    },
+  } as AnalyticsInterface;
 }
 
 export function jitsuAnalytics(opts: JitsuOptions): AnalyticsInterface {

package/dist/destination-plugins.d.ts

@@ -1,13 +0,0 @@
-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>>;