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

package/src/lib/Ninetailed.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="analytics" />
-import { Locale, Traits, OnLogHandler, OnErrorHandler, Logger, PageviewProperties, Properties, NinetailedApiClient, NinetailedApiClientOptions, NinetailedRequestContext } from '@ninetailed/experience.js-shared';
+import { Locale, Traits, OnLogHandler, OnErrorHandler, Logger, PageviewProperties, Properties, NinetailedApiClient, NinetailedApiClientOptions, NinetailedRequestContext, Reference, Event } from '@ninetailed/experience.js-shared';
 import { OnInitProfileId } from './ninetailedCorePlugin';
 import { EventFunctionOptions, NinetailedInstance, NinetailedPlugin, OnIsInitializedCallback, OnProfileChangeCallback, ProfileState, TrackHasSeenComponent, ElementSeenPayload, TrackComponentView } from './types';
 import { ObserveOptions } from './ElementSeenObserver';
+import { OnSelectVariantArgs, OnSelectVariantCallback } from './types/OnSelectVariant';
+import { EventBuilder } from './utils/EventBuilder';
 declare global {
     interface Window {
         ninetailed?: {
@@ -32,6 +34,7 @@ type Options = {
     onInitProfileId?: OnInitProfileId;
     buildClientContext?: () => NinetailedRequestContext;
     storageImpl?: Storage;
+    useClientSideEvaluation?: boolean;
 };
 type NinetailedApiClientInstanceOrOptions = NinetailedApiClient | NinetailedApiClientOptions;
 export declare class Ninetailed implements NinetailedInstance {
@@ -47,9 +50,18 @@ export declare class Ninetailed implements NinetailedInstance {
     readonly plugins: NinetailedPlugin[];
     readonly logger: Logger;
     private readonly componentViewTrackingThreshold;
-    constructor(ninetailedApiClientInstanceOrOptions: NinetailedApiClientInstanceOrOptions, { plugins, url, locale, requestTimeout, onLog, onError, buildClientContext, onInitProfileId, componentViewTrackingThreshold, storageImpl, }?: Options);
+    private readonly useClientSideEvaluation;
+    readonly eventBuilder: EventBuilder;
+    constructor(ninetailedApiClientInstanceOrOptions: NinetailedApiClientInstanceOrOptions, { plugins, url, locale, requestTimeout, onLog, onError, buildClientContext, onInitProfileId, componentViewTrackingThreshold, storageImpl, useClientSideEvaluation, }?: Options);
     page: (data?: Partial<PageviewProperties>, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
     track: (event: string, properties?: Properties, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
+    identify: (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
+    batch: (events: Event[]) => Promise<import("./types").FlushResult>;
+    trackStickyComponentView: ({ experienceId, componentId, variantIndex, }: {
+        experienceId: string;
+        componentId: string;
+        variantIndex: number;
+    }) => Promise<import("./types").FlushResult>;
     /**
      * @deprecated The legacy datamodel is not recommended anymore
      * Will be removed in the next version of the SDK
@@ -59,10 +71,10 @@ export declare class Ninetailed implements NinetailedInstance {
     observeElement: (payload: ElementSeenPayload, options?: ObserveOptions) => void;
     unobserveElement: (element: Element) => void;
     private onElementSeen;
-    identify: (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
     reset: () => Promise<void>;
     debug: (enabled: boolean) => Promise<void>;
     onProfileChange: (cb: OnProfileChangeCallback) => import("analytics").DetachListeners;
+    onSelectVariant: <Baseline extends Reference, Variant extends Reference>({ baseline, experiences }: OnSelectVariantArgs<Baseline, Variant>, cb: OnSelectVariantCallback<Baseline, Variant>) => () => void;
     onIsInitialized: (onIsInitialized: OnIsInitializedCallback) => void;
     private waitUntilInitialized;
     get profileState(): ProfileState;

package/src/lib/constants.d.ts

@@ -3,3 +3,4 @@ export declare const HAS_SEEN_ELEMENT = "has_seen_element";
 export declare const COMPONENT = "component";
 export declare const COMPONENT_START = "componentStart";
 export declare const PAGE_HIDDEN = "page_hidden";
+export declare const HAS_SEEN_STICKY_COMPONENT = "sticky_component_view";

package/src/lib/experience/makeExperienceSelectMiddleware.d.ts

@@ -1,19 +1,19 @@
-import { ExperienceConfiguration, Profile, Reference, VariantRef } from '@ninetailed/experience.js-shared';
+import { ExperienceConfiguration, Profile, Reference } from '@ninetailed/experience.js-shared';
 import { NinetailedPlugin } from '../types/NinetailedPlugin';
-import { ExperienceSelectionMiddlewareReturnArg } from '../types/interfaces/HasExperienceSelectionMiddleware';
-type MakeExperienceSelectMiddlewareArg<Variant extends Reference> = {
+import { ExperienceSelectionMiddleware, ExperienceSelectionMiddlewareArg } from '../types/interfaces/HasExperienceSelectionMiddleware';
+type MakeExperienceSelectMiddlewareArg<Baseline extends Reference, Variant extends Reference> = {
     plugins: NinetailedPlugin[];
     experiences: ExperienceConfiguration<Variant>[];
     baseline: Reference;
     profile: Profile | null;
-    onChange: () => void;
+    onChange: (middleware: ExperienceSelectionMiddleware<Baseline, Variant>) => void;
 };
-export declare const makeExperienceSelectMiddleware: <Variant extends Reference>({ plugins, onChange, experiences, baseline, profile, }: MakeExperienceSelectMiddlewareArg<Variant>) => {
+export declare const makeExperienceSelectMiddleware: <TBaseline extends Reference, TVariant extends Reference>({ plugins, onChange, experiences, baseline, profile, }: MakeExperienceSelectMiddlewareArg<TBaseline, TVariant>) => {
     addListeners: () => void;
     removeListeners: () => void;
-    middleware: ({ experience, variant, variantIndex, }: ExperienceSelectionMiddlewareReturnArg<Variant | VariantRef>) => {
-        experience: ExperienceConfiguration<Variant | VariantRef> | null;
-        variant: Variant | VariantRef;
+    middleware: ({ experience, variant, variantIndex, }: ExperienceSelectionMiddlewareArg<TBaseline, TVariant>) => {
+        experience: ExperienceConfiguration<TVariant> | null;
+        variant: TBaseline | TVariant | import("@ninetailed/experience.js-shared").VariantRef;
         variantIndex: number;
     };
 };

package/src/lib/guards/hasExperienceSelectionMiddleware.d.ts

@@ -1,3 +1,3 @@
 import { Reference } from '@ninetailed/experience.js-shared';
 import { HasExperienceSelectionMiddleware } from '../types/interfaces/HasExperienceSelectionMiddleware';
-export declare const hasExperienceSelectionMiddleware: <Variant extends Reference>(arg: unknown) => arg is HasExperienceSelectionMiddleware<Variant>;
+export declare const hasExperienceSelectionMiddleware: <TBaseline extends Reference, TVariant extends Reference>(arg: unknown) => arg is HasExperienceSelectionMiddleware<TBaseline, TVariant>;

package/src/lib/plugins/selectPluginsHavingExperienceSelectionMiddleware.d.ts

@@ -1,4 +1,4 @@
 import { Reference } from '@ninetailed/experience.js-shared';
 import { HasExperienceSelectionMiddleware } from '../types/interfaces/HasExperienceSelectionMiddleware';
 import { NinetailedPlugin } from '../types/NinetailedPlugin';
-export declare const selectPluginsHavingExperienceSelectionMiddleware: <Variant extends Reference>(plugins: NinetailedPlugin[]) => HasExperienceSelectionMiddleware<Variant>[];
+export declare const selectPluginsHavingExperienceSelectionMiddleware: <Baseline extends Reference, Variant extends Reference>(plugins: NinetailedPlugin[]) => HasExperienceSelectionMiddleware<Baseline, Variant>[];

package/src/lib/types/OnSelectVariant.d.ts

@@ -0,0 +1,51 @@
+import { Profile, ExperienceConfiguration, Reference, VariantRef } from '@ninetailed/experience.js-shared';
+import type { DetachListeners } from 'analytics';
+type Loading<TBaseline extends Reference> = {
+    status: 'loading';
+    loading: boolean;
+    hasVariants: boolean;
+    baseline: TBaseline;
+    experience: null;
+    variant: TBaseline;
+    variantIndex: number;
+    audience: null;
+    isPersonalized: boolean;
+    profile: null;
+    error: null;
+};
+type Success<TBaseline extends Reference, TVariant extends Reference> = {
+    status: 'success';
+    loading: boolean;
+    hasVariants: boolean;
+    baseline: TBaseline;
+    experience: ExperienceConfiguration<TVariant> | null;
+    variant: TBaseline | TVariant | VariantRef;
+    variantIndex: number;
+    audience: {
+        id: string;
+    } | null;
+    isPersonalized: boolean;
+    profile: Profile;
+    error: null;
+};
+type Fail<TBaseline extends Reference> = {
+    status: 'error';
+    loading: boolean;
+    hasVariants: boolean;
+    baseline: TBaseline;
+    experience: null;
+    variant: TBaseline;
+    variantIndex: number;
+    audience: null;
+    isPersonalized: boolean;
+    profile: null;
+    error: Error;
+};
+export type OnSelectVariantArgs<TBaseline extends Reference, TVariant extends Reference> = {
+    baseline: TBaseline;
+    experiences: ExperienceConfiguration<TVariant>[];
+};
+export type OnSelectVariantCallbackArgs<TBaseline extends Reference, TVariant extends Reference> = Loading<TBaseline> | Success<TBaseline, TVariant> | Fail<TBaseline>;
+export type OnSelectVariantCallback<TBaseline extends Reference, TVariant extends Reference> = (state: OnSelectVariantCallbackArgs<TBaseline, TVariant>) => void;
+export type OnSelectVariant<TBaseline extends Reference = Reference, TVariant extends Reference = Reference> = (args: OnSelectVariantArgs<TBaseline, TVariant>, cb: OnSelectVariantCallback<TBaseline, TVariant>) => DetachListeners;
+export {};

package/src/lib/types/index.d.ts

@@ -1,9 +1,11 @@
-import { Logger, PageviewProperties, Profile, Properties, Traits, SelectedVariantInfo } from '@ninetailed/experience.js-shared';
+import { Logger, PageviewProperties, Profile, Properties, Traits, SelectedVariantInfo, Reference, Event } from '@ninetailed/experience.js-shared';
 import { DetachListeners } from 'analytics';
 import { TrackComponentProperties } from './TrackingProperties';
 import { NinetailedPlugin } from './NinetailedPlugin';
 import { type Ninetailed } from '../Ninetailed';
 import { ElementSeenPayload } from './ElementSeenPayload';
+import { OnSelectVariant } from './OnSelectVariant';
+import { EventBuilder } from '../utils/EventBuilder';
 type Loading = {
     status: 'loading';
     profile: null;
@@ -42,12 +44,13 @@ export type Track = (event: string, properties?: Properties, options?: EventFunc
 export type TrackHasSeenComponent = (properties: TrackComponentProperties) => Promise<void>;
 export type TrackComponentView = (properties: ElementSeenPayload) => Promise<void>;
 export type Identify = (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<FlushResult>;
+export type Batch = (events: Event[]) => Promise<FlushResult>;
 export type Reset = () => void;
 export type Debug = (enable: boolean) => void;
 export type OnProfileChange = (cb: OnProfileChangeCallback) => DetachListeners;
 type ObserveElement = Ninetailed['observeElement'];
 type UnObserveElement = Ninetailed['unobserveElement'];
-export interface NinetailedInstance {
+export interface NinetailedInstance<TBaseline extends Reference = Reference, TVariant extends Reference = Reference> {
     page: Page;
     track: Track;
     /**
@@ -56,15 +59,18 @@ export interface NinetailedInstance {
     trackHasSeenComponent: TrackHasSeenComponent;
     trackComponentView: TrackComponentView;
     identify: Identify;
+    batch: Batch;
     reset: Reset;
     debug: Debug;
     profileState: ProfileState;
     onProfileChange: OnProfileChange;
     plugins: NinetailedPlugin[];
     logger: Logger;
+    eventBuilder: EventBuilder;
     onIsInitialized: OnIsInitialized;
     observeElement: ObserveElement;
     unobserveElement: UnObserveElement;
+    onSelectVariant: OnSelectVariant<TBaseline, TVariant>;
 }
 export { NinetailedPlugin, TrackComponentProperties };
 export type { EventHandler } from './EventHandler';

package/src/lib/types/interfaces/HasExperienceSelectionMiddleware.d.ts

@@ -1,16 +1,16 @@
-import { ExperienceConfiguration, Reference } from '@ninetailed/experience.js-shared';
-export type ExperienceSelectionMiddlewareReturnArg<Variant extends Reference> = {
-    experience: ExperienceConfiguration<Variant> | null;
-    variant: Variant;
+import { ExperienceConfiguration, Reference, VariantRef } from '@ninetailed/experience.js-shared';
+export type ExperienceSelectionMiddlewareArg<TBaseline extends Reference, TVariant extends Reference> = {
+    experience: ExperienceConfiguration<TVariant> | null;
+    variant: TBaseline | TVariant | VariantRef;
     variantIndex: number;
 };
-type ExperienceSelectionMiddlewareReturn<Variant extends Reference> = (arg: ExperienceSelectionMiddlewareReturnArg<Variant>) => ExperienceSelectionMiddlewareReturnArg<Variant>;
-type ExperienceSelectionMiddlewareArg<Variant extends Reference> = {
-    experiences: ExperienceConfiguration<Variant>[];
+export type ExperienceSelectionMiddleware<TBaseline extends Reference, TVariant extends Reference> = (arg: ExperienceSelectionMiddlewareArg<TBaseline, TVariant>) => ExperienceSelectionMiddlewareArg<TBaseline, TVariant>;
+type BuildExperienceSelectionMiddlewareArg<TVariant extends Reference> = {
+    experiences: ExperienceConfiguration<TVariant>[];
     baseline: Reference;
 };
-export type ExperienceSelectionMiddleware<Variant extends Reference> = (arg: ExperienceSelectionMiddlewareArg<Variant>) => ExperienceSelectionMiddlewareReturn<Variant>;
-export interface HasExperienceSelectionMiddleware<Variant extends Reference> {
-    getExperienceSelectionMiddleware: ExperienceSelectionMiddleware<Variant>;
+export type BuildExperienceSelectionMiddleware<TBaseline extends Reference, TVariant extends Reference> = (arg: BuildExperienceSelectionMiddlewareArg<TVariant>) => ExperienceSelectionMiddleware<TBaseline, TVariant>;
+export interface HasExperienceSelectionMiddleware<TBaseline extends Reference, TVariant extends Reference> {
+    getExperienceSelectionMiddleware: BuildExperienceSelectionMiddleware<TBaseline, TVariant>;
 }
 export {};

package/src/lib/utils/EventBuilder.d.ts

@@ -0,0 +1,221 @@
+import { BuildPageEventArgs, BuildTrackEventArgs, IdentifyEventArgs, NinetailedRequestContext, Properties } from '@ninetailed/experience.js-shared';
+export declare class EventBuilder {
+    private readonly buildRequestContext;
+    constructor(buildRequestContext?: () => NinetailedRequestContext);
+    page(properties?: Properties, data?: Partial<Omit<BuildPageEventArgs, 'ctx' | 'properties'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        name?: string | undefined;
+        properties: import("@ninetailed/experience.js-shared").PageviewProperties;
+    };
+    track(event: string, properties?: Properties, data?: Partial<Omit<BuildTrackEventArgs, 'ctx' | 'event' | 'properties'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        event: string;
+        properties: Properties;
+    };
+    identify(userId: string, traits?: Properties, data?: Partial<Omit<IdentifyEventArgs, 'ctx' | 'userId' | 'traits'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        traits: Properties;
+    };
+    component(componentId: string, experienceId?: string, variantIndex?: number, data?: Partial<Omit<BuildPageEventArgs, 'ctx' | 'componentId' | 'experienceId' | 'variantIndex'>>): {
+        channel: import("@ninetailed/experience.js-shared").EventChanel;
+        context: {
+            app?: {
+                name: string;
+                version: string;
+            } | undefined;
+            campaign: {
+                name?: string | undefined;
+                source?: string | undefined;
+                medium?: string | undefined;
+                term?: string | undefined;
+                content?: string | undefined;
+            };
+            library: {
+                name: string;
+                version: string;
+            };
+            locale: string;
+            page: {
+                path: string;
+                url: string;
+                query: Record<string, string>;
+                referrer: string;
+                search: string;
+            };
+            userAgent?: string | undefined;
+            gdpr: {
+                isConsentGiven: boolean;
+            };
+            location?: {
+                coordinates?: {
+                    latitude: number;
+                    longitude: number;
+                } | undefined;
+                city?: string | undefined;
+                postalCode?: string | undefined;
+                region?: string | undefined;
+                regionCode?: string | undefined;
+                country?: string | undefined;
+                countryCode?: string | undefined;
+                continent?: string | undefined;
+                timezone?: string | undefined;
+            } | undefined;
+        };
+        messageId: string;
+        originalTimestamp: string;
+        timestamp: string;
+        sentAt: string;
+        type: import("@ninetailed/experience.js-shared").EventType;
+        userId?: string | undefined;
+        componentId: string;
+        experienceId?: string | undefined;
+        variantIndex?: number | undefined;
+    };
+}

package/src/lib/utils/noop.d.ts

@@ -0,0 +1 @@
+export declare const noop: () => void;