@base44-preview/sdk 0.8.48-pr.280.7eec9ba → 0.8.48-pr.280.b5c6133

package/dist/client.js

@@ -230,7 +230,6 @@ export function createClient(config) {
             userAuthModule,
             enabled: (_f = analytics === null || analytics === void 0 ? void 0 : analytics.enabled) !== null && _f !== void 0 ? _f : true,
             getVisitorId: experiments.visitorId,
-            experimentsContext,
         }),
         actors: actorsModule.module,
         cleanup: () => {

package/dist/modules/analytics.d.ts

@@ -1,7 +1,6 @@
 import { AxiosInstance } from "axios";
-import { TrackEventParams, TrackEventData, AnalyticsModuleOptions, SessionContext } from "./analytics.types";
+import { TrackEventParams, AnalyticsModuleOptions } from "./analytics.types";
 import type { InternalAuthModule } from "./auth.types";
-import type { ExperimentsContext } from "./experiments-config.types.js";
 export declare const USER_HEARTBEAT_EVENT_NAME = "__user_heartbeat_event__";
 export declare const ANALYTICS_INITIALIZATION_EVENT_NAME = "__initialization_event__";
 export declare const ANALYTICS_SESSION_DURATION_EVENT_NAME = "__session_duration_event__";
@@ -14,21 +13,10 @@ export interface AnalyticsModuleArgs {
     userAuthModule: InternalAuthModule;
     enabled: boolean;
     getVisitorId?: () => string | undefined;
-    experimentsContext?: ExperimentsContext;
 }
 /** @internal */
-export declare function isAnalyticsEnabled(enabled: boolean, state?: {
-    requestsQueue: TrackEventData[];
-    isProcessing: boolean;
-    isHeartBeatProcessing: boolean;
-    wasInitializationTracked: boolean;
-    sessionContext: SessionContext | null;
-    sessionContextPromise: Promise<SessionContext> | null;
-    sessionStartTime: string | null;
-    fallbackSessionId: string | null;
-    config: Required<AnalyticsModuleOptions>;
-}): boolean;
-export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, userAuthModule, enabled, getVisitorId, experimentsContext, }: AnalyticsModuleArgs) => {
+export declare function isAnalyticsEnabled(enabled: boolean): boolean;
+export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, userAuthModule, enabled, getVisitorId, }: AnalyticsModuleArgs) => {
     track: (params: TrackEventParams) => void;
     cleanup: () => void;
 };
@@ -42,16 +30,6 @@ export declare const createAnalyticsModule: ({ axiosClient, serverUrl, appId, us
  *
  * @internal
  */
-export declare function resetAnalyticsSessionContext(axiosClient?: AxiosInstance): void;
+export declare function resetAnalyticsSessionContext(): void;
 export declare function getAnalyticsConfigFromUrlParams(): AnalyticsModuleOptions | undefined;
-export declare function getAnalyticsSessionId(state?: {
-    requestsQueue: TrackEventData[];
-    isProcessing: boolean;
-    isHeartBeatProcessing: boolean;
-    wasInitializationTracked: boolean;
-    sessionContext: SessionContext | null;
-    sessionContextPromise: Promise<SessionContext> | null;
-    sessionStartTime: string | null;
-    fallbackSessionId: string | null;
-    config: Required<AnalyticsModuleOptions>;
-}): string;
+export declare function getAnalyticsSessionId(): string;

package/dist/modules/analytics.js

@@ -18,41 +18,34 @@ const defaultConfiguration = {
 //// shared queue for analytics events     ////
 ///////////////////////////////////////////////
 const ANALYTICS_SHARED_STATE_NAME = "analytics";
-function createAnalyticsState() {
-    return {
-        requestsQueue: [],
-        isProcessing: false,
-        isHeartBeatProcessing: false,
-        wasInitializationTracked: false,
-        sessionContext: null,
-        sessionContextPromise: null,
-        sessionStartTime: null,
-        // Memoized session id for when `localStorage` can't persist one — see
-        // getAnalyticsSessionId.
-        fallbackSessionId: null,
-        config: {
-            ...defaultConfiguration,
-            ...getAnalyticsConfigFromUrlParams(),
-        },
-    };
-}
-const analyticsSharedState = getSharedInstance(ANALYTICS_SHARED_STATE_NAME, createAnalyticsState);
-const serverAnalyticsStates = new WeakMap();
+// shared state//
+const analyticsSharedState = getSharedInstance(ANALYTICS_SHARED_STATE_NAME, () => ({
+    requestsQueue: [],
+    isProcessing: false,
+    isHeartBeatProcessing: false,
+    wasInitializationTracked: false,
+    sessionContext: null,
+    sessionStartTime: null,
+    // Memoized session id for when `localStorage` can't persist one — see
+    // getAnalyticsSessionId.
+    fallbackSessionId: null,
+    config: {
+        ...defaultConfiguration,
+        ...getAnalyticsConfigFromUrlParams(),
+    },
+}));
 /** @internal */
-export function isAnalyticsEnabled(enabled, state = analyticsSharedState) {
-    return enabled && state.config.enabled && !isReactNative;
+export function isAnalyticsEnabled(enabled) {
+    return enabled && analyticsSharedState.config.enabled && !isReactNative;
 }
-export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthModule, enabled, getVisitorId, experimentsContext, }) => {
-    const state = typeof window === "undefined" ? createAnalyticsState() : analyticsSharedState;
-    if (typeof window === "undefined")
-        serverAnalyticsStates.set(axiosClient, state);
+export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthModule, enabled, getVisitorId, }) => {
     // prevent overflow of events //
-    const { maxQueueSize, throttleTime, batchSize } = state.config;
+    const { maxQueueSize, throttleTime, batchSize } = analyticsSharedState.config;
     // Disable analytics on React Native. It defines `window` but not `document`,
     // so the per-callsite `typeof window` guards below aren't enough to keep it
     // from touching `document` (e.g. `document.referrer` on init). Node/SSR is
     // still handled by those `window` guards, so this doesn't affect it.
-    if (!isAnalyticsEnabled(enabled, state)) {
+    if (!isAnalyticsEnabled(enabled)) {
         return {
             track: () => { },
             cleanup: () => { },
@@ -84,7 +77,7 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         var _a;
         if (eventsData.length === 0)
             return;
-        const sessionContext_ = await getSessionContext(userAuthModule, state);
+        const sessionContext_ = await getSessionContext(userAuthModule);
         const events = eventsData.map(transformEventDataToApiRequestData({ ...sessionContext_, session_id: (_a = getVisitorId === null || getVisitorId === void 0 ? void 0 : getVisitorId()) !== null && _a !== void 0 ? _a : sessionContext_.session_id }));
         try {
             if (!options.isBeacon || !beaconRequest(events)) {
@@ -99,25 +92,16 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         startAnalyticsProcessor(flush, {
             throttleTime,
             batchSize,
-        }, state);
+        });
     };
     const track = (params) => {
-        var _a;
-        if (state.requestsQueue.length >= maxQueueSize) {
+        if (analyticsSharedState.requestsQueue.length >= maxQueueSize) {
             return;
         }
         const intrinsicData = getEventIntrinsicData();
-        const preview = Object.fromEntries(Object.entries((_a = experimentsContext === null || experimentsContext === void 0 ? void 0 : experimentsContext.preview) !== null && _a !== void 0 ? _a : {}).filter(([, value]) => typeof value === "boolean"));
-        const properties = { ...params.properties };
-        delete properties.__b44_experiment_preview;
-        if (Object.keys(preview).length) {
-            // Capture now: a queued event must retain its occurrence-time preview.
-            properties.__b44_experiment_preview = JSON.stringify(preview);
-        }
-        state.requestsQueue.push({
+        analyticsSharedState.requestsQueue.push({
             ...params,
             ...intrinsicData,
-            properties: params.properties || Object.keys(properties).length ? properties : undefined,
         });
         startProcessing();
     };
@@ -125,16 +109,16 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         startAnalyticsProcessor(flush, {
             throttleTime,
             batchSize,
-        }, state);
-        clearHeartBeatProcessor = startHeartBeatProcessor(track, state);
-        setSessionDurationTimerStart(state);
+        });
+        clearHeartBeatProcessor = startHeartBeatProcessor(track);
+        setSessionDurationTimerStart();
     };
     const onDocHidden = () => {
-        stopAnalyticsProcessor(state);
+        stopAnalyticsProcessor();
         clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
-        trackSessionDurationEvent(track, state);
+        trackSessionDurationEvent(track);
         //  flush entire queue on visibility change and hope for the best //
-        const eventsData = state.requestsQueue.splice(0);
+        const eventsData = analyticsSharedState.requestsQueue.splice(0);
         flush(eventsData, { isBeacon: true });
     };
     const onVisibilityChange = () => {
@@ -148,7 +132,7 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         }
     };
     const cleanup = () => {
-        stopAnalyticsProcessor(state);
+        stopAnalyticsProcessor();
         clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
         if (typeof window !== "undefined") {
             window.removeEventListener("visibilitychange", onVisibilityChange);
@@ -157,9 +141,9 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
     // start the flusing process ///
     startProcessing();
     // start the heart beat processor //
-    clearHeartBeatProcessor = startHeartBeatProcessor(track, state);
+    clearHeartBeatProcessor = startHeartBeatProcessor(track);
     // track the referrer event //
-    trackInitializationEvent(track, state);
+    trackInitializationEvent(track);
     // start the visibility change listener //
     if (typeof window !== "undefined") {
         window.addEventListener("visibilitychange", onVisibilityChange);
@@ -169,50 +153,50 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         cleanup,
     };
 };
-function stopAnalyticsProcessor(state) {
-    state.isProcessing = false;
+function stopAnalyticsProcessor() {
+    analyticsSharedState.isProcessing = false;
 }
-async function startAnalyticsProcessor(handleTrack, options, state) {
-    if (state.isProcessing) {
+async function startAnalyticsProcessor(handleTrack, options) {
+    if (analyticsSharedState.isProcessing) {
         // only one instance of the analytics processor can be running at a time //
         return;
     }
-    state.isProcessing = true;
+    analyticsSharedState.isProcessing = true;
     const { throttleTime = 1000, batchSize = 30 } = options !== null && options !== void 0 ? options : {};
-    while (state.isProcessing &&
-        state.requestsQueue.length > 0) {
-        const requests = state.requestsQueue.splice(0, batchSize);
+    while (analyticsSharedState.isProcessing &&
+        analyticsSharedState.requestsQueue.length > 0) {
+        const requests = analyticsSharedState.requestsQueue.splice(0, batchSize);
         requests.length && (await handleTrack(requests));
         await new Promise((resolve) => setTimeout(resolve, throttleTime));
     }
-    state.isProcessing = false;
+    analyticsSharedState.isProcessing = false;
 }
-function startHeartBeatProcessor(track, state) {
+function startHeartBeatProcessor(track) {
     var _a;
     // Browser-only, like the other automatic events here (initialization, session
     // duration, visibility). Outside a browser this timer fired a `me()` every
     // interval for the lifetime of a long-lived server-side client, and kept the
     // Node event loop alive. Explicit `analytics.track()` calls still work.
     if (typeof window === "undefined" ||
-        state.isHeartBeatProcessing ||
-        ((_a = state.config.heartBeatInterval) !== null && _a !== void 0 ? _a : 0) < 10) {
+        analyticsSharedState.isHeartBeatProcessing ||
+        ((_a = analyticsSharedState.config.heartBeatInterval) !== null && _a !== void 0 ? _a : 0) < 10) {
         return () => { };
     }
-    state.isHeartBeatProcessing = true;
+    analyticsSharedState.isHeartBeatProcessing = true;
     const interval = setInterval(() => {
         track({ eventName: USER_HEARTBEAT_EVENT_NAME });
-    }, state.config.heartBeatInterval);
+    }, analyticsSharedState.config.heartBeatInterval);
     return () => {
         clearInterval(interval);
-        state.isHeartBeatProcessing = false;
+        analyticsSharedState.isHeartBeatProcessing = false;
     };
 }
-function trackInitializationEvent(track, state) {
+function trackInitializationEvent(track) {
     if (typeof window === "undefined" ||
-        state.wasInitializationTracked) {
+        analyticsSharedState.wasInitializationTracked) {
         return;
     }
-    state.wasInitializationTracked = true;
+    analyticsSharedState.wasInitializationTracked = true;
     track({
         eventName: ANALYTICS_INITIALIZATION_EVENT_NAME,
         properties: {
@@ -220,20 +204,20 @@ function trackInitializationEvent(track, state) {
         },
     });
 }
-function setSessionDurationTimerStart(state) {
+function setSessionDurationTimerStart() {
     if (typeof window === "undefined" ||
-        state.sessionStartTime !== null) {
+        analyticsSharedState.sessionStartTime !== null) {
         return;
     }
-    state.sessionStartTime = new Date().toISOString();
+    analyticsSharedState.sessionStartTime = new Date().toISOString();
 }
-function trackSessionDurationEvent(track, state) {
+function trackSessionDurationEvent(track) {
     if (typeof window === "undefined" ||
-        state.sessionStartTime === null)
+        analyticsSharedState.sessionStartTime === null)
         return;
     const sessionDuration = new Date().getTime() -
-        new Date(state.sessionStartTime).getTime();
-    state.sessionStartTime = null;
+        new Date(analyticsSharedState.sessionStartTime).getTime();
+    analyticsSharedState.sessionStartTime = null;
     track({
         eventName: ANALYTICS_SESSION_DURATION_EVENT_NAME,
         properties: { sessionDuration },
@@ -256,6 +240,7 @@ function transformEventDataToApiRequestData(sessionContext) {
         ...sessionContext,
     });
 }
+let sessionContextPromise = null;
 /**
  * Clears the memoized analytics session context.
  *
@@ -266,24 +251,22 @@ function transformEventDataToApiRequestData(sessionContext) {
  *
  * @internal
  */
-export function resetAnalyticsSessionContext(axiosClient) {
-    var _a;
-    const state = axiosClient ? (_a = serverAnalyticsStates.get(axiosClient)) !== null && _a !== void 0 ? _a : analyticsSharedState : analyticsSharedState;
-    state.sessionContext = null;
-    state.sessionContextPromise = null;
+export function resetAnalyticsSessionContext() {
+    analyticsSharedState.sessionContext = null;
+    sessionContextPromise = null;
 }
-async function getSessionContext(userAuthModule, state) {
-    if (!state.sessionContext) {
+async function getSessionContext(userAuthModule) {
+    if (!analyticsSharedState.sessionContext) {
         // With no token there is no identity to resolve: `me()` can only answer 401,
         // which the browser logs to the console before any handler here sees it. On
         // a public page that request is the sole reason an error appears, so skip
         // it. This is not memoized — a visitor who logs in later must still resolve.
         if (!userAuthModule.hasToken()) {
-            return { user_id: null, session_id: getAnalyticsSessionId(state) };
+            return { user_id: null, session_id: getAnalyticsSessionId() };
         }
-        if (!state.sessionContextPromise) {
-            const sessionId = getAnalyticsSessionId(state);
-            state.sessionContextPromise = userAuthModule
+        if (!sessionContextPromise) {
+            const sessionId = getAnalyticsSessionId();
+            sessionContextPromise = userAuthModule
                 .me()
                 .then((user) => ({
                 user_id: user.id,
@@ -294,7 +277,7 @@ async function getSessionContext(userAuthModule, state) {
                 session_id: sessionId,
             }));
         }
-        const pending = state.sessionContextPromise;
+        const pending = sessionContextPromise;
         const context = await pending;
         // Publish only if this lookup is still the current one. A reset that lands
         // while the request is in flight nulls `sessionContextPromise`, and an
@@ -302,12 +285,12 @@ async function getSessionContext(userAuthModule, state) {
         // for the rest of the session. The awaited value is still returned: these
         // events were queued before the identity changed, so that is who they
         // belong to.
-        if (state.sessionContextPromise === pending) {
-            state.sessionContext = context;
+        if (sessionContextPromise === pending) {
+            analyticsSharedState.sessionContext = context;
         }
         return context;
     }
-    return state.sessionContext;
+    return analyticsSharedState.sessionContext;
 }
 export function getAnalyticsConfigFromUrlParams() {
     // `window.location` is absent on React Native. This runs at module load (via
@@ -329,18 +312,19 @@ export function getAnalyticsConfigFromUrlParams() {
     // return the config object //
     return { enabled: analyticsEnable === "true" };
 }
-// Without persistent storage, keep the id stable within this analytics state.
-function getFallbackSessionId(state) {
+// When the id can't be persisted (React Native has no `localStorage`), keep
+// it stable for the process instead of minting a fresh one per call.
+function getFallbackSessionId() {
     var _a;
-    return ((_a = state.fallbackSessionId) !== null && _a !== void 0 ? _a : (state.fallbackSessionId = generateUuid()));
+    return ((_a = analyticsSharedState.fallbackSessionId) !== null && _a !== void 0 ? _a : (analyticsSharedState.fallbackSessionId = generateUuid()));
 }
-export function getAnalyticsSessionId(state = analyticsSharedState) {
+export function getAnalyticsSessionId() {
     var _a;
     const visitorId = (_a = getExperimentsRuntime()) === null || _a === void 0 ? void 0 : _a.visitorId;
     if (visitorId && visitorId !== "anon")
         return visitorId;
     if (typeof window === "undefined") {
-        return getFallbackSessionId(state);
+        return getFallbackSessionId();
     }
     try {
         const sessionId = localStorage.getItem(ANALYTICS_SESSION_ID_LOCAL_STORAGE_KEY);
@@ -352,6 +336,6 @@ export function getAnalyticsSessionId(state = analyticsSharedState) {
         return sessionId;
     }
     catch (_b) {
-        return getFallbackSessionId(state);
+        return getFallbackSessionId();
     }
 }

package/dist/modules/auth.js

@@ -177,7 +177,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
             // Drop identity resolved under the previous session: a `me()` already in
             // flight would otherwise resolve into callers that run after the logout.
             clearPendingMe();
-            resetAnalyticsSessionContext(axios);
+            resetAnalyticsSessionContext();
             hasAccessToken = false;
             notifyAuthState({ status: "anonymous" });
             // Only do the rest if in a browser environment
@@ -207,7 +207,7 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
             // Same reasoning as in `logout`: the identity changes here, so anything
             // resolved for the previous one must not be handed to later callers.
             clearPendingMe();
-            resetAnalyticsSessionContext(axios);
+            resetAnalyticsSessionContext();
             hasAccessToken = true;
             // handle token change for axios clients
             axios.defaults.headers.common["Authorization"] = `Bearer ${token}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.48-pr.280.7eec9ba",
+  "version": "0.8.48-pr.280.b5c6133",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",