@ninetailed/experience.js 7.5.0-beta.9 → 7.6.0-beta.1

package/index.cjs

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var experience_jsShared = require('@ninetailed/experience.js-shared');
 var Analytics = require('analytics');
+var uuid = require('uuid');
 var zod = require('zod');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -15,6 +16,7 @@ const HAS_SEEN_ELEMENT = 'has_seen_element';
 const COMPONENT = 'component';
 const COMPONENT_START = 'componentStart';
 const PAGE_HIDDEN = 'page_hidden';
+const HAS_SEEN_STICKY_COMPONENT = 'sticky_component_view';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -272,6 +274,20 @@ const ninetailedCorePlugin = ({
         ctx
       }));
     }),
+    [HAS_SEEN_STICKY_COMPONENT]: ({
+      payload
+    }) => __awaiter(void 0, void 0, void 0, function* () {
+      experience_jsShared.logger.info('Sending Sticky Components event.');
+      const ctx = buildContext();
+      return enqueueEvent(experience_jsShared.buildComponentViewEvent({
+        messageId: payload.meta.rid,
+        timestamp: payload.meta.ts,
+        componentId: payload.componentId,
+        experienceId: payload.experienceId,
+        variantIndex: payload.variantIndex,
+        ctx
+      }));
+    }),
     setItemStart: ({
       abort,
       payload
@@ -368,6 +384,189 @@ const isInterestedInHiddenPage = arg => {
   return typeof arg === 'object' && arg !== null && PAGE_HIDDEN in arg && typeof arg[PAGE_HIDDEN] === 'function';
 };
 
+const decodeExperienceVariantsMap = encodedExperienceVariantsMap => {
+  return encodedExperienceVariantsMap.split(',').map(experienceIdWithVariant => {
+    const [experienceId, _variantIndex] = experienceIdWithVariant.split('=');
+    const variantIndex = parseInt(_variantIndex);
+    if (!experienceId || !variantIndex) {
+      return null;
+    }
+    return {
+      experienceId,
+      variantIndex
+    };
+  }).filter(x => !!x).reduce((acc, curr) => Object.assign(Object.assign({}, acc), {
+    [curr.experienceId]: curr.variantIndex
+  }), {});
+};
+
+class OnChangeEmitter {
+  constructor() {
+    this.onChangeListeners = [];
+  }
+  addListener(listener) {
+    this.onChangeListeners.push(listener);
+    return () => {
+      this.removeOnChangeListener(listener);
+    };
+  }
+  invokeListeners() {
+    this.onChangeListeners.forEach(listener => listener());
+  }
+  removeOnChangeListener(listener) {
+    this.onChangeListeners = this.onChangeListeners.filter(l => l !== listener);
+  }
+}
+
+const hasOnChangeEmitter = arg => {
+  return typeof arg === 'object' && arg !== null && 'onChangeEmitter' in arg && typeof arg.onChangeEmitter === 'object' && arg.onChangeEmitter !== null && arg.onChangeEmitter.constructor === OnChangeEmitter;
+};
+
+const selectPluginsHavingOnChangeEmitter = plugins => {
+  const filteredPlugins = [];
+  for (const plugin of plugins) {
+    if (hasOnChangeEmitter(plugin)) {
+      filteredPlugins.push(plugin);
+    }
+  }
+  return filteredPlugins;
+};
+
+const hasExperienceSelectionMiddleware = arg => {
+  return typeof arg === 'object' && arg !== null && 'getExperienceSelectionMiddleware' in arg && typeof arg.getExperienceSelectionMiddleware === 'function';
+};
+
+const selectPluginsHavingExperienceSelectionMiddleware = plugins => {
+  const filteredPlugins = [];
+  for (const plugin of plugins) {
+    if (hasExperienceSelectionMiddleware(plugin)) {
+      filteredPlugins.push(plugin);
+    }
+  }
+  return filteredPlugins;
+};
+
+const createPassThroughMiddleware = () => {
+  return ({
+    experience,
+    variant,
+    variantIndex
+  }) => {
+    return {
+      experience,
+      variant,
+      variantIndex
+    };
+  };
+};
+const makeExperienceSelectMiddleware = ({
+  plugins,
+  onChange,
+  experiences,
+  baseline,
+  profile
+}) => {
+  let removeChangeListeners = [];
+  const pluginsHavingChangeEmitters = selectPluginsHavingOnChangeEmitter(plugins);
+  const prepareMiddleware = () => {
+    if (profile === null) {
+      return createPassThroughMiddleware();
+    }
+    const pluginsWithMiddleware = selectPluginsHavingExperienceSelectionMiddleware(plugins);
+    const middlewareFunctions = pluginsWithMiddleware.map(plugin => plugin.getExperienceSelectionMiddleware({
+      experiences,
+      baseline
+    }));
+    return experience_jsShared.pipe(...middlewareFunctions);
+  };
+  const middleware = prepareMiddleware();
+  const addListeners = () => {
+    removeChangeListeners = pluginsHavingChangeEmitters.map(plugin => {
+      const listener = () => {
+        onChange(middleware);
+      };
+      return plugin.onChangeEmitter.addListener(listener);
+    });
+  };
+  const removeListeners = () => {
+    removeChangeListeners.forEach(listener => listener());
+  };
+  return {
+    addListeners,
+    removeListeners,
+    middleware
+  };
+};
+
+class EventBuilder {
+  constructor(buildRequestContext) {
+    this.buildRequestContext = buildRequestContext || buildClientNinetailedRequestContext;
+  }
+  page(properties, data) {
+    return experience_jsShared.buildPageEvent(Object.assign(Object.assign({
+      messageId: (data === null || data === void 0 ? void 0 : data.messageId) || uuid.v4()
+    }, data), {
+      timestamp: Date.now(),
+      properties: properties || {},
+      ctx: this.buildRequestContext()
+    }));
+  }
+  track(event, properties, data) {
+    return experience_jsShared.buildTrackEvent(Object.assign(Object.assign({
+      messageId: (data === null || data === void 0 ? void 0 : data.messageId) || uuid.v4(),
+      timestamp: Date.now()
+    }, data), {
+      event,
+      properties: properties || {},
+      ctx: this.buildRequestContext()
+    }));
+  }
+  identify(userId, traits, data) {
+    return experience_jsShared.buildIdentifyEvent(Object.assign(Object.assign({
+      messageId: (data === null || data === void 0 ? void 0 : data.messageId) || uuid.v4(),
+      timestamp: Date.now()
+    }, data), {
+      traits: traits || {},
+      userId: userId || '',
+      ctx: this.buildRequestContext()
+    }));
+  }
+  component(componentId, experienceId, variantIndex, data) {
+    return experience_jsShared.buildComponentViewEvent(Object.assign(Object.assign({
+      messageId: (data === null || data === void 0 ? void 0 : data.messageId) || uuid.v4(),
+      timestamp: Date.now()
+    }, data), {
+      componentId,
+      experienceId: experienceId || '',
+      variantIndex: variantIndex || 0,
+      ctx: this.buildRequestContext()
+    }));
+  }
+}
+
+const buildOverrideMiddleware = experienceSelectionMiddleware => _a => {
+  var {
+      experience: originalExperience,
+      variant: originalVariant,
+      variantIndex: originalVariantIndex
+    } = _a,
+    other = __rest(_a, ["experience", "variant", "variantIndex"]);
+  const {
+    experience,
+    variant,
+    variantIndex
+  } = experienceSelectionMiddleware({
+    experience: originalExperience,
+    variant: originalVariant,
+    variantIndex: originalVariantIndex
+  });
+  return Object.assign(Object.assign({}, other), {
+    audience: (experience === null || experience === void 0 ? void 0 : experience.audience) ? experience.audience : null,
+    experience,
+    variant,
+    variantIndex
+  });
+};
 class Ninetailed {
   constructor(ninetailedApiClientInstanceOrOptions, {
     plugins,
@@ -379,7 +578,8 @@ class Ninetailed {
     buildClientContext,
     onInitProfileId,
     componentViewTrackingThreshold = 2000,
-    storageImpl
+    storageImpl,
+    useClientSideEvaluation = false
   } = {}) {
     this.isInitialized = false;
     this.page = (data, options) => __awaiter(this, void 0, void 0, function* () {
@@ -416,6 +616,78 @@ class Ninetailed {
         throw error;
       }
     });
+    this.identify = (uid, traits, options) => __awaiter(this, void 0, void 0, function* () {
+      try {
+        const result = experience_jsShared.Traits.default({}).safeParse(traits);
+        if (!result.success) {
+          throw new Error(`[Validation Error] "identify" was called with invalid params. Traits are no valid json: ${result.error.format()}`);
+        }
+        yield this.waitUntilInitialized();
+        yield this.instance.identify(uid && uid.toString() !== '' ? uid.toString() : EMPTY_MERGE_ID, result.data, this.buildOptions(options));
+        return this.ninetailedCorePlugin.flush();
+      } catch (error) {
+        experience_jsShared.logger.error(error);
+        if (error instanceof RangeError) {
+          throw new Error(`[Validation Error] "identify" was called with invalid params. Could not validate due to "RangeError: Maximum call stack size exceeded". This can be caused by passing a cyclic data structure as a parameter. Refrain from passing a cyclic data structure or sanitize it beforehand.`);
+        }
+        throw error;
+      }
+    });
+    this.batch = events => __awaiter(this, void 0, void 0, function* () {
+      try {
+        yield this.waitUntilInitialized();
+        const promises = events.map(event => {
+          if (experience_jsShared.isPageViewEvent(event)) {
+            return this.instance.page(event.properties);
+          }
+          if (experience_jsShared.isTrackEvent(event)) {
+            return this.instance.track(event.event, event.properties);
+          }
+          if (experience_jsShared.isIdentifyEvent(event)) {
+            return this.instance.identify(event.userId || EMPTY_MERGE_ID, event.traits);
+          }
+          if (experience_jsShared.isComponentViewEvent(event)) {
+            return this.instance.dispatch({
+              experienceId: event.experienceId,
+              componentId: event.componentId,
+              variantIndex: event.variantIndex,
+              type: HAS_SEEN_STICKY_COMPONENT
+            });
+          }
+          return Promise.resolve();
+        });
+        yield Promise.all(promises);
+        return this.ninetailedCorePlugin.flush();
+      } catch (error) {
+        experience_jsShared.logger.error(error);
+        if (error instanceof RangeError) {
+          throw new Error(`[Validation Error] "batch" was called with invalid params. Could not validate due to "RangeError: Maximum call stack size exceeded". This can be caused by passing a cyclic data structure as a parameter. Refrain from passing a cyclic data structure or sanitize it beforehand.`);
+        }
+        throw error;
+      }
+    });
+    this.trackStickyComponentView = ({
+      experienceId,
+      componentId,
+      variantIndex
+    }) => __awaiter(this, void 0, void 0, function* () {
+      try {
+        yield this.waitUntilInitialized();
+        yield this.instance.dispatch({
+          experienceId,
+          componentId,
+          variantIndex,
+          type: HAS_SEEN_STICKY_COMPONENT
+        });
+        return this.ninetailedCorePlugin.flush();
+      } catch (error) {
+        experience_jsShared.logger.error(error);
+        if (error instanceof RangeError) {
+          throw new Error(`[Validation Error] "trackStickyComponentView" was called with invalid params. Could not validate due to "RangeError: Maximum call stack size exceeded". This can be caused by passing a cyclic data structure as a parameter. Refrain from passing a cyclic data structure or sanitize it beforehand.`);
+        }
+        throw error;
+      }
+    });
     /**
      * @deprecated The legacy datamodel is not recommended anymore
      * Will be removed in the next version of the SDK
@@ -459,23 +731,6 @@ class Ninetailed {
         }, payload));
       }
     };
-    this.identify = (uid, traits, options) => __awaiter(this, void 0, void 0, function* () {
-      try {
-        const result = experience_jsShared.Traits.default({}).safeParse(traits);
-        if (!result.success) {
-          throw new Error(`[Validation Error] "identify" was called with invalid params. Traits are no valid json: ${result.error.format()}`);
-        }
-        yield this.waitUntilInitialized();
-        yield this.instance.identify(uid && uid.toString() !== '' ? uid.toString() : EMPTY_MERGE_ID, result.data, this.buildOptions(options));
-        return this.ninetailedCorePlugin.flush();
-      } catch (error) {
-        experience_jsShared.logger.error(error);
-        if (error instanceof RangeError) {
-          throw new Error(`[Validation Error] "identify" was called with invalid params. Could not validate due to "RangeError: Maximum call stack size exceeded". This can be caused by passing a cyclic data structure as a parameter. Refrain from passing a cyclic data structure or sanitize it beforehand.`);
-        }
-        throw error;
-      }
-    });
     this.reset = () => __awaiter(this, void 0, void 0, function* () {
       yield this.waitUntilInitialized();
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -510,6 +765,165 @@ class Ninetailed {
         }
       });
     };
+    this.onSelectVariant = ({
+      baseline,
+      experiences
+    }, cb) => {
+      let middlewareChangeListeners = [];
+      let state = null;
+      const removeMiddlewareChangeListeners = () => {
+        middlewareChangeListeners.forEach(removeListener => removeListener());
+        middlewareChangeListeners = [];
+      };
+      const setSelectedVariant = newState => {
+        state = newState;
+        cb(state);
+      };
+      const removeProfileChangeListener = this.onProfileChange(profileState => {
+        const {
+          addListeners,
+          removeListeners,
+          middleware: experienceSelectionMiddleware
+        } = makeExperienceSelectMiddleware({
+          plugins: this.plugins,
+          experiences,
+          baseline,
+          profile: profileState.profile,
+          onChange: middleware => {
+            const overrideResult = buildOverrideMiddleware(middleware);
+            if (state !== null) {
+              setSelectedVariant(overrideResult(state));
+            }
+          }
+        });
+        addListeners();
+        middlewareChangeListeners.push(removeListeners);
+        const overrideResult = buildOverrideMiddleware(experienceSelectionMiddleware);
+        const hasVariants = experiences.map(experience => experience_jsShared.selectHasVariants(experience, baseline)).reduce((acc, curr) => acc || curr, false);
+        const baseReturn = Object.assign(Object.assign({}, profileState), {
+          hasVariants,
+          baseline
+        });
+        const emptyReturn = Object.assign(Object.assign({}, baseReturn), {
+          experience: null,
+          variant: baseline,
+          variantIndex: 0,
+          audience: null,
+          isPersonalized: false,
+          profile: null,
+          error: null
+        });
+        if (profileState.status === 'loading') {
+          setSelectedVariant(overrideResult(Object.assign(Object.assign({}, emptyReturn), {
+            loading: true,
+            status: 'loading'
+          })));
+          return;
+        }
+        if (profileState.status === 'error') {
+          setSelectedVariant(overrideResult(Object.assign(Object.assign({}, emptyReturn), {
+            loading: false,
+            status: 'error',
+            error: profileState.error
+          })));
+          return;
+        }
+        const {
+          profile,
+          experiences: selectedExperiences
+        } = profileState;
+        if (!profile || !selectedExperiences) {
+          setSelectedVariant(overrideResult(Object.assign(Object.assign({}, emptyReturn), {
+            loading: false,
+            status: 'error',
+            error: new Error('No Profile or Selected Experiences were returned by the API')
+          })));
+          return;
+        }
+        if (this.useClientSideEvaluation) {
+          const _experience = experience_jsShared.selectExperience({
+            experiences,
+            profile
+          });
+          if (!_experience) {
+            setSelectedVariant(overrideResult(Object.assign(Object.assign({}, emptyReturn), {
+              loading: false,
+              status: 'success',
+              profile
+            })));
+            return;
+          }
+          const {
+            variant: _variant,
+            index
+          } = experience_jsShared.selectVariant({
+            baseline,
+            experience: _experience,
+            profile
+          });
+          setSelectedVariant(overrideResult(Object.assign(Object.assign({}, baseReturn), {
+            status: 'success',
+            loading: false,
+            error: null,
+            experience: _experience,
+            variant: _variant,
+            variantIndex: index,
+            audience: _experience.audience ? _experience.audience : null,
+            profile,
+            isPersonalized: true
+          })));
+          return;
+        }
+        const experience = experiences.find(experience => selectedExperiences.some(selectedExperience => selectedExperience.experienceId === experience.id));
+        const selectedExperience = selectedExperiences.find(({
+          experienceId
+        }) => experienceId === (experience === null || experience === void 0 ? void 0 : experience.id));
+        if (!experience || !selectedExperience) {
+          setSelectedVariant(overrideResult(Object.assign(Object.assign({}, emptyReturn), {
+            loading: false,
+            status: 'success',
+            profile
+          })));
+          return;
+        }
+        const baselineVariants = experience_jsShared.selectBaselineWithVariants(experience, baseline);
+        if (!baselineVariants) {
+          setSelectedVariant(overrideResult(Object.assign(Object.assign({}, emptyReturn), {
+            loading: false,
+            status: 'success',
+            profile
+          })));
+          return;
+        }
+        const {
+          variants
+        } = baselineVariants;
+        const variant = variants[selectedExperience.variantIndex - 1];
+        if (!variant) {
+          setSelectedVariant(overrideResult(Object.assign(Object.assign({}, emptyReturn), {
+            loading: false,
+            status: 'success',
+            profile
+          })));
+          return;
+        }
+        setSelectedVariant(overrideResult(Object.assign(Object.assign({}, baseReturn), {
+          status: 'success',
+          loading: false,
+          error: null,
+          experience,
+          variant,
+          variantIndex: selectedExperience.variantIndex,
+          audience: experience.audience ? experience.audience : null,
+          profile,
+          isPersonalized: true
+        })));
+      });
+      return () => {
+        removeProfileChangeListener();
+        removeMiddlewareChangeListeners();
+      };
+    };
     this.onIsInitialized = onIsInitialized => {
       if (typeof onIsInitialized === 'function') {
         if (this.isInitialized) {
@@ -540,6 +954,7 @@ class Ninetailed {
         }
       });
     };
+    this.useClientSideEvaluation = useClientSideEvaluation;
     if (ninetailedApiClientInstanceOrOptions instanceof experience_jsShared.NinetailedApiClient) {
       this.apiClient = ninetailedApiClientInstanceOrOptions;
     } else {
@@ -579,6 +994,7 @@ class Ninetailed {
     if (typeof onError === 'function') {
       experience_jsShared.logger.addSink(new experience_jsShared.OnErrorLogSink(onError));
     }
+    this.eventBuilder = new EventBuilder(buildClientContext);
     this.logger = experience_jsShared.logger;
     this.ninetailedCorePlugin = ninetailedCorePlugin({
       apiClient: this.apiClient,
@@ -763,120 +1179,6 @@ const ElementSeenPayloadSchema = zod.z.object({
   variantIndex: zod.z.number()
 });
 
-const decodeExperienceVariantsMap = encodedExperienceVariantsMap => {
-  return encodedExperienceVariantsMap.split(',').map(experienceIdWithVariant => {
-    const [experienceId, _variantIndex] = experienceIdWithVariant.split('=');
-    const variantIndex = parseInt(_variantIndex);
-    if (!experienceId || !variantIndex) {
-      return null;
-    }
-    return {
-      experienceId,
-      variantIndex
-    };
-  }).filter(x => !!x).reduce((acc, curr) => Object.assign(Object.assign({}, acc), {
-    [curr.experienceId]: curr.variantIndex
-  }), {});
-};
-
-class OnChangeEmitter {
-  constructor() {
-    this.onChangeListeners = [];
-  }
-  addListener(listener) {
-    this.onChangeListeners.push(listener);
-    return () => {
-      this.removeOnChangeListener(listener);
-    };
-  }
-  invokeListeners() {
-    this.onChangeListeners.forEach(listener => listener());
-  }
-  removeOnChangeListener(listener) {
-    this.onChangeListeners = this.onChangeListeners.filter(l => l !== listener);
-  }
-}
-
-const hasOnChangeEmitter = arg => {
-  return typeof arg === 'object' && arg !== null && 'onChangeEmitter' in arg && typeof arg.onChangeEmitter === 'object' && arg.onChangeEmitter !== null && arg.onChangeEmitter.constructor === OnChangeEmitter;
-};
-
-const selectPluginsHavingOnChangeEmitter = plugins => {
-  const filteredPlugins = [];
-  for (const plugin of plugins) {
-    if (hasOnChangeEmitter(plugin)) {
-      filteredPlugins.push(plugin);
-    }
-  }
-  return filteredPlugins;
-};
-
-const hasExperienceSelectionMiddleware = arg => {
-  return typeof arg === 'object' && arg !== null && 'getExperienceSelectionMiddleware' in arg && typeof arg.getExperienceSelectionMiddleware === 'function';
-};
-
-const selectPluginsHavingExperienceSelectionMiddleware = plugins => {
-  const filteredPlugins = [];
-  for (const plugin of plugins) {
-    if (hasExperienceSelectionMiddleware(plugin)) {
-      filteredPlugins.push(plugin);
-    }
-  }
-  return filteredPlugins;
-};
-
-const createPassThroughMiddleware = () => {
-  return ({
-    experience,
-    variant,
-    variantIndex
-  }) => {
-    return {
-      experience,
-      variant,
-      variantIndex
-    };
-  };
-};
-const makeExperienceSelectMiddleware = ({
-  plugins,
-  onChange,
-  experiences,
-  baseline,
-  profile
-}) => {
-  let removeChangeListeners = [];
-  const pluginsHavingChangeEmitters = selectPluginsHavingOnChangeEmitter(plugins);
-  const prepareMiddleware = () => {
-    if (profile === null) {
-      return createPassThroughMiddleware();
-    }
-    const pluginsWithMiddleware = selectPluginsHavingExperienceSelectionMiddleware(plugins);
-    const middlewareFunctions = pluginsWithMiddleware.map(plugin => plugin.getExperienceSelectionMiddleware({
-      experiences,
-      baseline
-    }));
-    return experience_jsShared.pipe(...middlewareFunctions);
-  };
-  const addListeners = () => {
-    removeChangeListeners = pluginsHavingChangeEmitters.map(plugin => {
-      const listener = () => {
-        onChange();
-      };
-      return plugin.onChangeEmitter.addListener(listener);
-    });
-  };
-  const removeListeners = () => {
-    removeChangeListeners.forEach(listener => listener());
-  };
-  const middleware = prepareMiddleware();
-  return {
-    addListeners,
-    removeListeners,
-    middleware
-  };
-};
-
 Object.defineProperty(exports, 'EXPERIENCE_TRAIT_PREFIX', {
     enumerable: true,
     get: function () { return experience_jsShared.EXPERIENCE_TRAIT_PREFIX; }
@@ -923,6 +1225,7 @@ exports.EXPERIENCES_FALLBACK_CACHE = EXPERIENCES_FALLBACK_CACHE;
 exports.ElementSeenPayloadSchema = ElementSeenPayloadSchema;
 exports.HAS_SEEN_COMPONENT = HAS_SEEN_COMPONENT;
 exports.HAS_SEEN_ELEMENT = HAS_SEEN_ELEMENT;
+exports.HAS_SEEN_STICKY_COMPONENT = HAS_SEEN_STICKY_COMPONENT;
 exports.LEGACY_ANONYMOUS_ID = LEGACY_ANONYMOUS_ID;
 exports.Ninetailed = Ninetailed;
 exports.NinetailedPlugin = NinetailedPlugin;