@jitsu/js 1.7.1 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jitsu/js",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "",
   "author": "Jitsu Dev Team <dev@jitsu.com>",
   "main": "dist/jitsu.cjs.js",
@@ -33,11 +33,11 @@
     "raw-loader": "^4.0.2",
     "rollup": "^3.2.5",
     "ts-jest": "29.0.5",
-    "typescript": "^4.9.5",
-    "@jitsu/protocols": "1.7.1"
+    "typescript": "^5.3.3",
+    "@jitsu/protocols": "1.8.0"
   },
   "dependencies": {
-    "analytics": "^0.8.1"
+    "analytics": "0.8.9"
   },
   "scripts": {
     "clean": "rm -rf ./dist",

package/rollup.config.js

@@ -4,9 +4,16 @@ const commonjs = require("@rollup/plugin-commonjs");
 const rollupJson = require("@rollup/plugin-json");
 const terser = require("@rollup/plugin-terser");
 
+
 module.exports = [
   {
-    plugins: [multi(), resolve({ preferBuiltins: false }), commonjs(), rollupJson(), terser()],
+    plugins: [
+      multi(),
+      resolve({ preferBuiltins: false }),
+      commonjs(),
+      rollupJson(),
+      (process.JITSU_JS_DEBUG_BUILD = "1" ? undefined : terser()),
+    ],
     input: "./compiled/src/browser.js",
     output: {
       file: `dist/web/p.js.txt`,

package/src/analytics-plugin.ts

@@ -20,6 +20,7 @@ const defaultConfig: Required<JitsuOptions> = {
   echoEvents: false,
   cookieDomain: undefined,
   runtime: undefined,
+  s2s: undefined,
 };
 
 export const parseQuery = (qs?: string): Record<string, string> => {
@@ -62,11 +63,24 @@ function safeCall<T>(f: () => T, defaultVal?: T): T | undefined {
 }
 
 function restoreTraits(storage: PersistentStorage) {
-  const val = storage.getItem("__user_traits");
+  let val = storage.getItem("__user_traits");
   if (typeof val === "string") {
-    return safeCall(() => JSON.parse(val), {});
+    val = safeCall(() => JSON.parse(val), {});
   }
-  return val;
+  if (typeof val !== "object" || val === null) {
+    val = {};
+  }
+  let groupVal = storage.getItem("__group_traits");
+  if (typeof groupVal === "string") {
+    groupVal = safeCall(() => JSON.parse(groupVal), {});
+  }
+  if (typeof groupVal !== "object" || groupVal === null) {
+    groupVal = {};
+  }
+  return {
+    ...(groupVal || {}),
+    ...(val || {}), //user traits override group traits
+  };
 }
 
 export type StorageFactory = (cookieDomain: string, cookie2key: Record<string, string>) => PersistentStorage;
@@ -77,25 +91,32 @@ function getCookie(name: string) {
   return parts.length === 2 ? parts.pop().split(";").shift() : undefined;
 }
 
-function getGa4Sessions(allCookies: Record<string, string>): Record<string, string> | undefined {
-  const gaCookies = Object.entries(allCookies).filter(([key]) => key.startsWith("_ga_"));
-  if (gaCookies.length === 0) {
+function getGa4Ids(runtime: RuntimeFacade) {
+  const allCookies = runtime.getCookies();
+  const clientId = allCookies["_ga"]?.split(".").slice(-2).join(".");
+  const gaSessionCookies = Object.entries(allCookies).filter(([key]) => key.startsWith("_ga_"));
+  const sessionIds =
+    gaSessionCookies.length > 0
+      ? Object.fromEntries(
+          gaSessionCookies
+            .map(([key, value]) => {
+              if (typeof value !== "string") {
+                return null;
+              }
+              const parts = value.split(".");
+              if (parts.length < 3) {
+                return null;
+              }
+              return [key.substring("_ga_".length), parts[2]];
+            })
+            .filter(v => v !== null)
+        )
+      : undefined;
+  if (clientId || sessionIds) {
+    return { ga4: { clientId, sessionIds } };
+  } else {
     return undefined;
   }
-  return Object.fromEntries(
-    gaCookies
-      .map(([key, value]) => {
-        if (typeof value !== "string") {
-          return null;
-        }
-        const parts = value.split(".");
-        if (parts.length < 3) {
-          return null;
-        }
-        return [key.substring("_ga_".length), parts[2]];
-      })
-      .filter(v => v !== null)
-  );
 }
 
 function removeCookie(name: string) {
@@ -277,12 +298,33 @@ export function isInBrowser() {
   return typeof document !== "undefined" && typeof window !== "undefined";
 }
 
-function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentStorage): AnalyticsClientEvent {
+/**
+ * Fixes a weird bug in analytics URL where path
+ * of https://test.com becomes //test.com
+ */
+function fixPath(path: string): string {
+  if (path.indexOf("//") === 0 && path.lastIndexOf("/") === 1) {
+    return "/";
+  }
+  return path;
+}
+
+function adjustPayload(
+  payload: any,
+  config: JitsuOptions,
+  storage: PersistentStorage,
+  s2s: boolean
+): AnalyticsClientEvent {
   const runtime: RuntimeFacade = config.runtime || (isInBrowser() ? windowRuntime(config) : emptyRuntime(config));
   const url = runtime.pageUrl();
   const parsedUrl = safeCall(() => new URL(url), undefined);
   const query = parsedUrl ? parseQuery(parsedUrl.search) : {};
   const properties = payload.properties || {};
+
+  if (properties.path) {
+    properties.path = fixPath(properties.path);
+  }
+
   const customContext = payload.properties?.context || {};
   delete payload.properties?.context;
   const referrer = runtime.referrer();
@@ -290,6 +332,7 @@ function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentSt
     library: {
       name: jitsuLibraryName,
       version: jitsuVersion,
+      env: s2s ? "node" : "browser",
     },
     userAgent: runtime.userAgent(),
     locale: runtime.language(),
@@ -308,10 +351,7 @@ function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentSt
     clientIds: {
       fbc: runtime.getCookie("_fbc"),
       fbp: runtime.getCookie("_fbp"),
-      ga4: {
-        clientId: runtime.getCookie("_ga")?.split(".").slice(-2).join("."), //last 2 parts of GA cookie
-        sessions: getGa4Sessions(runtime.getCookies()),
-      },
+      ...getGa4Ids(runtime),
     },
     campaign: parseUtms(query),
   };
@@ -321,6 +361,7 @@ function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentSt
     sentAt: new Date().toISOString(),
     messageId: randomId(properties.path || (parsedUrl && parsedUrl.pathname)),
     writeKey: maskWriteKey(config.writeKey),
+    groupId: storage.getItem("__group_id"),
     context: deepMerge(context, customContext),
   };
   delete withContext.meta;
@@ -467,19 +508,19 @@ function maskWriteKey(writeKey?: string): string | undefined {
   return writeKey;
 }
 
-function send(
+async function send(
   method,
   payload,
   jitsuConfig: Required<JitsuOptions>,
   instance: AnalyticsInstance,
   store: PersistentStorage
-): Promise<void> {
+): Promise<any> {
   if (jitsuConfig.echoEvents) {
-    console.log(`[JITSU] sending '${method}' event:`, payload);
+    console.log(`[JITSU DEBUG] sending '${method}' event:`, payload);
     return;
   }
-
-  const url = `${jitsuConfig.host}/api/s/${method}`;
+  const s2s = jitsuConfig.s2s === undefined ? !isInBrowser() : jitsuConfig.s2s;
+  const url = s2s ? `${jitsuConfig.host}/api/s/s2s/${method}` : `${jitsuConfig.host}/api/s/${method}`;
   const fetch = jitsuConfig.fetch || globalThis.fetch;
   if (!fetch) {
     throw new Error(
@@ -491,72 +532,72 @@ function send(
   // if (jitsuConfig.debug) {
   //   console.log(`[JITSU] Sending event to ${url}: `, JSON.stringify(payload, null, 2));
   // }
-  const adjustedPayload = adjustPayload(payload, jitsuConfig, store);
+  const adjustedPayload = adjustPayload(payload, jitsuConfig, store, s2s);
 
   const authHeader = jitsuConfig.writeKey ? { "X-Write-Key": jitsuConfig.writeKey } : {};
+  let fetchResult;
+  try {
+    fetchResult = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
 
-  return fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
+        ...authHeader,
+        ...debugHeader,
+      },
+      body: JSON.stringify(adjustedPayload),
+    });
+  } catch (e: any) {
+    throw new Error(`Calling ${url} failed: ${e.message}`);
+  }
+  let responseText;
+  try {
+    responseText = await fetchResult.text();
+  } catch (e) {
+    console.warn(
+      `Can't read response text from ${url} (status - ${fetchResult.status}  ${fetchResult.statusText}): ${e?.message}`
+    );
+  }
+  if (jitsuConfig.debug) {
+    console.log(
+      `[JITSU DEBUG] ${url} replied ${fetchResult.status}: ${responseText}. Original payload:\n${JSON.stringify(
+        adjustedPayload,
+        null,
+        2
+      )}`
+    );
+  }
+  if (!fetchResult.ok) {
+    throw new Error(`Jitsu ${url} replied ${fetchResult.status} - ${fetchResult.statusText}: ${responseText}`);
+  }
 
-      ...authHeader,
-      ...debugHeader,
-    },
-    body: JSON.stringify(adjustedPayload),
-  })
-    .then(res => {
-      if (jitsuConfig.debug) {
-        console.log(
-          `[JITSU] ${url} replied ${res.status}. Original payload: `,
-          JSON.stringify(adjustedPayload, null, 2)
-        );
-      }
-      if (res.ok) {
-        return res.text();
-      } else {
-        return Promise.reject(res.text());
-      }
-    })
-    .then(responseText => {
-      let response: any;
-      try {
-        response = JSON.parse(responseText);
-      } catch (e) {
-        return Promise.reject(`Can't parse JSON: ${responseText}: ${e?.message}`);
-      }
-      if (response.destinations) {
-        if (jitsuConfig.debug) {
-          console.log(`[JITSU] Processing device destinations: `, JSON.stringify(response.destinations, null, 2));
-        }
-        return processDestinations(response.destinations, method, adjustedPayload, !!jitsuConfig.debug, instance);
-      }
-    })
-    .catch(err => {
+  let responseJson: any;
+  try {
+    responseJson = JSON.parse(responseText);
+  } catch (e) {
+    return Promise.reject(`Can't parse JSON: ${responseText}: ${e?.message}`);
+  }
+
+  if (responseJson.destinations && responseJson.destinations.length > 0) {
+    if (jitsuConfig.s2s) {
+      console.warn(
+        `[JITSU] ${payload.type} responded with list of ${responseJson.destinations.length} destinations. However, this code is running in server-to-server mode, so destinations will be ignored`,
+        jitsuConfig.debug ? JSON.stringify(responseJson.destinations, null, 2) : undefined
+      );
+    } else {
       if (jitsuConfig.debug) {
-        console.error(`Jitsu ${url} failed: `, err);
+        console.log(`[JITSU] Processing device destinations: `, JSON.stringify(responseJson.destinations, null, 2));
       }
-    });
+      return processDestinations(responseJson.destinations, method, adjustedPayload, !!jitsuConfig.debug, instance);
+    }
+  }
+  return adjustedPayload;
 }
 
-const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin => {
-  const storageCache: any = {};
-  // AnalyticsInstance's storage is async somewhere inside. So if we make 'page' call right after 'identify' call
-  // 'page' call will load traits from storage before 'identify' call had a change to save them.
-  // to avoid that we use in-memory cache for storage
-  const cachingStorageWrapper = (persistentStorage: PersistentStorage): PersistentStorage => ({
-    setItem(key: string, val: any) {
-      storageCache[key] = val;
-      persistentStorage.setItem(key, val);
-    },
-    getItem(key: string) {
-      return storageCache[key] || persistentStorage.getItem(key);
-    },
-    removeItem(key: string) {
-      delete storageCache[key];
-      persistentStorage.removeItem(key);
-    },
-  });
+export type JitsuPluginConfig = JitsuOptions & {
+  storageWrapper?: (persistentStorage: PersistentStorage) => PersistentStorage & { reset: () => void };
+};
+const jitsuAnalyticsPlugin = (pluginConfig: JitsuPluginConfig = {}): AnalyticsPlugin => {
   const instanceConfig = {
     ...defaultConfig,
     ...pluginConfig,
@@ -564,10 +605,11 @@ const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin
   return {
     name: "jitsu",
     config: instanceConfig,
+
     initialize: args => {
       const { config } = args;
       if (config.debug) {
-        console.debug("[JITSU] Initializing Jitsu plugin with config: ", JSON.stringify(config));
+        console.debug("[JITSU DEBUG] Initializing Jitsu plugin with config: ", JSON.stringify(config, null, 2));
       }
       if (!config.host && !config.echoEvents) {
         throw new Error("Please specify host variable in jitsu plugin initialization, or set echoEvents to true");
@@ -576,35 +618,65 @@ const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin
     },
     page: args => {
       const { payload, config, instance } = args;
-      return send("page", payload, config, instance, cachingStorageWrapper(instance.storage));
+      return send(
+        "page",
+        payload,
+        config,
+        instance,
+        pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage
+      );
     },
     track: args => {
       const { payload, config, instance } = args;
-      return send("track", payload, config, instance, cachingStorageWrapper(instance.storage));
+      return send(
+        "track",
+        payload,
+        config,
+        instance,
+        pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : 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, instance, cachingStorageWrapper(instance.storage));
+      const storage = pluginConfig.storageWrapper ? pluginConfig.storageWrapper(instance.storage) : instance.storage;
+      storage.setItem("__user_id", payload.userId);
+      if (payload.traits && typeof payload.traits === "object") {
+        storage.setItem("__user_traits", payload.traits);
+      }
+      return send("identify", payload, config, instance, storage);
     },
     reset: args => {
       //clear storage cache
-      Object.keys(storageCache).forEach(key => delete storageCache[key]);
+      if (pluginConfig.storageWrapper) {
+        pluginConfig.storageWrapper(args.instance.storage).reset();
+      }
     },
     methods: {
       //analytics doesn't support group as a base method, so we need to add it manually
       group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback) {
+        if (typeof groupId === "number") {
+          //fix potential issues with group id being used incorrectly
+          groupId = groupId + "";
+        }
+
         const analyticsInstance = this.instance;
+        const cacheWrap = pluginConfig.storageWrapper
+          ? pluginConfig.storageWrapper(analyticsInstance.storage)
+          : analyticsInstance.storage;
         const user = analyticsInstance.user();
         const userId = options?.userId || user?.userId;
-        const anonymousId = options?.anonymousId || user?.anonymousId;
+        const anonymousId = options?.anonymousId || user?.anonymousId || cacheWrap.getItem("__anon_id");
+        cacheWrap.setItem("__group_id", groupId);
+        if (traits && typeof traits === "object") {
+          cacheWrap.setItem("__group_traits", traits);
+        }
         return send(
           "group",
           { type: "group", groupId, traits, ...(anonymousId ? { anonymousId } : {}), ...(userId ? { userId } : {}) },
           instanceConfig,
           analyticsInstance,
-          cachingStorageWrapper(analyticsInstance.storage)
+          cacheWrap
         );
       },
     },

package/src/browser.ts

@@ -53,35 +53,10 @@ function getScriptAttributes(scriptElement: HTMLScriptElement) {
 
   const options = readJitsuOptions();
   const JITSU_V2_ID: string = options.namespace || "jitsu";
-  const queue = [];
-  if (window[JITSU_V2_ID]) {
-    if (Array.isArray(window[JITSU_V2_ID])) {
-      //processing queue of events
-      if (options.debug) {
-        console.log(
-          `Initializing Jitsu with prior events queue size of ${window[JITSU_V2_ID].length}`,
-          window[JITSU_V2_ID]
-        );
-      }
-      queue.push(...window[JITSU_V2_ID]);
-    } else {
-      console.warn("Attempted to initialize Jitsu twice. Returning the existing instance");
-    }
-  }
   if (options.debug) {
     console.log(`Jitsu options: `, JSON.stringify(options));
   }
   const jitsu = jitsuAnalytics(options);
-  for (const [method, args] of queue) {
-    if (options.debug) {
-      console.log(`Processing event ${method} from Jitsu queue on`, args);
-    }
-    try {
-      jitsu[method](...args);
-    } catch (e: any) {
-      console.warn(`Error processing event ${method} from Jitsu queue on`, args, e);
-    }
-  }
 
   if (options.onload) {
     const onloadFunction = window[options.onload] as any;
@@ -96,10 +71,25 @@ function getScriptAttributes(scriptElement: HTMLScriptElement) {
   }
   window[JITSU_V2_ID] = jitsu;
 
-  //new callback based queue
-  const callbackQueue = window[JITSU_V2_ID + "Q"] || [];
+  /**
+   * 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 callback queue size: ${callbackQueue.length}`, callbackQueue);
+    console.log(`[JITSU DEBUG] Jitsu callback queue size: ${callbackQueue.length}`, callbackQueue);
   }
   callbackQueue.forEach((callback: any) => {
     try {

package/src/index.ts

@@ -1,5 +1,5 @@
 import Analytics from "analytics";
-import { AnalyticsInterface, JitsuOptions, RuntimeFacade } from "./jitsu";
+import { AnalyticsInterface, JitsuOptions, PersistentStorage, RuntimeFacade } from "./jitsu";
 import jitsuAnalyticsPlugin, { emptyRuntime, isInBrowser, windowRuntime } from "./analytics-plugin";
 import { Callback, DispatchedEvent, ID, JSONObject, Options } from "@jitsu/protocols/analytics";
 
@@ -23,7 +23,8 @@ export default function parse(input) {
   return value;
 }
 
-export const emptyAnalytics = {
+export const emptyAnalytics: AnalyticsInterface = {
+  setAnonymousId: () => {},
   track: () => Promise.resolve(),
   page: () => Promise.resolve(),
   user: () => ({}),
@@ -37,32 +38,116 @@ function createUnderlyingAnalyticsInstance(
   rt: RuntimeFacade,
   plugins: any[] = []
 ): AnalyticsInterface {
+  const storage = rt.store();
+
+  const storageCache: any = {};
+
+  // AnalyticsInstance's storage is async somewhere inside. So if we make 'page' call right after 'identify' call
+  // 'page' call will load traits from storage before 'identify' call had a change to save them.
+  // to avoid that we use in-memory cache for storage
+  const cachingStorageWrapper = (persistentStorage: PersistentStorage) => ({
+    setItem(key: string, val: any) {
+      if (opts.debug) {
+        console.log(`[JITSU DEBUG] Caching storage setItem: ${key}=${val}`);
+      }
+      storageCache[key] = val;
+      persistentStorage.setItem(key, val);
+    },
+    getItem(key: string) {
+      const value = storageCache[key] || persistentStorage.getItem(key);
+      if (opts.debug) {
+        console.log(
+          `[JITSU DEBUG] Caching storage getItem: ${key}=${value}. Evicted from cache: ${!storageCache[key]}`
+        );
+      }
+      return value;
+    },
+    reset() {
+      for (const key of [...Object.keys(storageCache)]) {
+        storage.removeItem(key);
+        delete storageCache[key];
+      }
+    },
+    removeItem(key: string) {
+      if (opts.debug) {
+        console.log(`[JITSU DEBUG] Caching storage removeItem: ${key}`);
+      }
+      delete storageCache[key];
+      persistentStorage.removeItem(key);
+    },
+  });
+
   const analytics = Analytics({
-    app: "test",
     debug: !!opts.debug,
-    storage: rt.store(),
-    plugins: [jitsuAnalyticsPlugin(opts), ...plugins],
+    storage,
+    plugins: [jitsuAnalyticsPlugin({ ...opts, storageWrapper: cachingStorageWrapper }), ...plugins],
   } as any);
-  const originalPage = analytics.page;
-  analytics.page = (...args) => {
-    if (args.length === 2 && typeof args[0] === "string" && typeof args[1] === "object") {
-      return originalPage({
-        name: args[0],
-        ...args[1],
-      });
-    } else {
-      return originalPage(...args);
-    }
-  };
+
   return {
     ...analytics,
-    group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback): Promise<DispatchedEvent> {
+    page: (...args) => {
+      if (args.length === 2 && typeof args[0] === "string" && typeof args[1] === "object") {
+        return analytics.page({
+          name: args[0],
+          ...args[1],
+        });
+      } else {
+        return (analytics.page as any)(...args);
+      }
+    },
+    identify: (...args) => {
+      if (args[0] && typeof args[0] !== "object" && typeof args[0] !== "string") {
+        //fix the quirk of analytics.js: if you pass number as first argument, it will be converted to string
+        args[0] = args[0] + "";
+      }
+
+      //analytics.js sets userId and traits asynchronously, so if
+      //we want them to be available immediately after identify call in subsequent page() calls,
+      //we need to put them into storage manually
+      const storage = (analytics as any).storage;
+      const storageWrapper = cachingStorageWrapper(storage);
+      if (typeof args[0] === "string") {
+        //first argument is user id
+        storageWrapper.setItem("__user_id", args[0]);
+      } else if (typeof args[0] === "object") {
+        //first argument is traits
+        storageWrapper.setItem("__user_traits", args[0]);
+      }
+
+      if (args.length === 2 && typeof args[1] === "object") {
+        //first argument is user id, second is traits
+        storageWrapper.setItem("__user_traits", args[1]);
+      }
+      return (analytics.identify as any)(...args);
+    },
+    setAnonymousId: (id: string) => {
+      if (opts.debug) {
+        console.log("[JITSU DEBUG] Setting anonymous id to " + id);
+        //Workaround for analytics.js bug. Underlying setAnonymousId doesn't work set the id immediately,
+        //so we got to it manually here. See https://github.com/jitsucom/jitsu/issues/1060
+        storage.setItem("__anon_id", id);
+        const userState = analytics.user();
+        if (userState) {
+          userState.anonymousId = id;
+        }
+        (analytics as any).setAnonymousId(id);
+      }
+    },
+    async group(
+      groupId?: ID,
+      traits?: JSONObject | null,
+      options?: Options,
+      callback?: Callback
+    ): Promise<DispatchedEvent> {
+      const results: any[] = [];
       for (const plugin of Object.values(analytics.plugins)) {
         if (plugin["group"]) {
-          plugin["group"](groupId, traits, options, callback);
+          results.push(await plugin["group"](groupId, traits, options, callback));
         }
       }
-      return Promise.resolve({});
+      //It's incorrect at many levels. First, it's not a dispatched event. Second, we take a first result
+      //However, since returned values are used for debugging purposes only, it's ok
+      return results[0];
     },
   } as AnalyticsInterface;
 }

package/src/jitsu.ts

@@ -38,6 +38,13 @@ type JitsuOptions = {
    * writeKey / host. It's useful for debugging development environment
    */
   echoEvents?: boolean;
+
+  /**
+   * If true, events will go to s2s endpoints like ${host}/api/s/s2s/{type}. Otherwise they'll go to ${host}/api/s/{type}.
+   *
+   * If not set at all, it will be detected automatically by presence of `window` object
+   */
+  s2s?: boolean;
 };
 
 type PersistentStorage = {

package/src/version.ts

@@ -1,3 +1,6 @@
-import { name as jitsuLibraryName, version as jitsuVersion } from "../package.json";
+//import pkg from "../package.json";
+
+const jitsuVersion = "0.0.0";
+const jitsuLibraryName = "@jitsu/js";
 
 export { jitsuVersion, jitsuLibraryName };