@ninetailed/experience.js 7.11.0 → 7.12.0-beta.0

package/src/lib/NinetailedCorePlugin/actions.d.ts

@@ -0,0 +1,59 @@
+import { HAS_SEEN_COMPONENT, HAS_SEEN_ELEMENT } from '@ninetailed/experience.js-plugin-analytics';
+import { PROFILE_CHANGE, Profile, SelectedVariantInfo, PROFILE_RESET, Change } from '@ninetailed/experience.js-shared';
+import { HAS_SEEN_STICKY_COMPONENT, PAGE_HIDDEN } from '../constants';
+type ReadyAction = {
+    type: 'ready';
+};
+type HasSeenElementAction = {
+    type: typeof HAS_SEEN_ELEMENT;
+    seenFor: number | undefined;
+    element: Element;
+};
+type PageHiddenAction = {
+    type: typeof PAGE_HIDDEN;
+};
+type ProfileChangeAction = {
+    type: typeof PROFILE_CHANGE;
+    profile: Profile;
+    experiences: SelectedVariantInfo[];
+    changes: Change[];
+    error: undefined | null;
+} | {
+    type: typeof PROFILE_CHANGE;
+    profile: Profile | null;
+    experiences: SelectedVariantInfo[];
+    changes: Change[];
+    error: Error;
+};
+type ProfileResetAction = {
+    type: typeof PROFILE_RESET;
+};
+type ProfileHasSeenStickyComponentAction = {
+    type: typeof HAS_SEEN_STICKY_COMPONENT;
+    componentId: string;
+    experienceId: string | undefined;
+    variantIndex: number | undefined;
+};
+type ProfileHasSeenComponentAction = {
+    type: typeof HAS_SEEN_COMPONENT;
+    variant: {
+        id: string;
+    };
+    audience: {
+        id: string;
+    };
+    isPersonalized: boolean;
+};
+export type DispatchAction = ReadyAction | ProfileChangeAction | ProfileResetAction | ProfileHasSeenStickyComponentAction | HasSeenElementAction | ProfileHasSeenComponentAction | PageHiddenAction;
+type RemoveTypeField<Type> = {
+    [Property in keyof Type as Exclude<Property, 'type'>]: Type[Property];
+};
+export type ExtractPayload<T extends {
+    type: string;
+}> = {
+    payload: RemoveTypeField<T>;
+};
+export type ActionPayloadMap = {
+    [A in DispatchAction as A['type']]: ExtractPayload<A>;
+};
+export {};

package/src/lib/NinetailedCorePlugin/constants.d.ts

@@ -3,6 +3,7 @@ export declare const ANONYMOUS_ID = "__nt_anonymous_id__";
 export declare const DEBUG_FLAG = "__nt_debug__";
 export declare const PROFILE_FALLBACK_CACHE = "__nt_profile__";
 export declare const EXPERIENCES_FALLBACK_CACHE = "__nt_experiences__";
+export declare const CHANGES_FALLBACK_CACHE = "__nt_changes__";
 export declare const PROFILE_CHANGE = "profile-change";
 export declare const PROFILE_RESET = "profile-reset";
 export declare const CONSENT = "__nt-consent__";

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

@@ -1,20 +1,25 @@
 import { ExperienceConfiguration, Profile, Reference } from '@ninetailed/experience.js-shared';
 import { NinetailedPlugin } from '@ninetailed/experience.js-plugin-analytics';
-import { ExperienceSelectionMiddleware, ExperienceSelectionMiddlewareArg } from '../types/interfaces/HasExperienceSelectionMiddleware';
-type MakeExperienceSelectMiddlewareArg<Baseline extends Reference, Variant extends Reference> = {
+import { ExperienceSelectionMiddleware } from '../types/interfaces/HasExperienceSelectionMiddleware';
+/**
+ * Args for creating an experience selection middleware
+ */
+type CreateExperienceSelectionMiddlewareArg<Baseline extends Reference, Variant extends Reference> = {
     plugins: NinetailedPlugin[];
     experiences: ExperienceConfiguration<Variant>[];
-    baseline: Reference;
+    baseline: Baseline;
     profile: Profile | null;
+};
+type MakeExperienceSelectMiddlewareArg<Baseline extends Reference, Variant extends Reference> = CreateExperienceSelectionMiddlewareArg<Baseline, Variant> & {
     onChange: (middleware: ExperienceSelectionMiddleware<Baseline, Variant>) => void;
 };
-export declare const makeExperienceSelectMiddleware: <TBaseline extends Reference, TVariant extends Reference>({ plugins, onChange, experiences, baseline, profile, }: MakeExperienceSelectMiddlewareArg<TBaseline, TVariant>) => {
+/**
+ * Result of creating an experience selection middleware
+ */
+interface ExperienceSelectMiddlewareResult<Baseline extends Reference, Variant extends Reference> {
     addListeners: () => void;
     removeListeners: () => void;
-    middleware: ({ experience, variant, variantIndex, }: ExperienceSelectionMiddlewareArg<TBaseline, TVariant>) => {
-        experience: ExperienceConfiguration<TVariant> | null;
-        variant: TBaseline | TVariant | import("@ninetailed/experience.js-shared").VariantRef;
-        variantIndex: number;
-    };
-};
+    middleware: ExperienceSelectionMiddleware<Baseline, Variant>;
+}
+export declare const makeExperienceSelectMiddleware: <Baseline extends Reference, Variant extends Reference>({ plugins, onChange, experiences, baseline, profile, }: MakeExperienceSelectMiddlewareArg<Baseline, Variant>) => ExperienceSelectMiddlewareResult<Baseline, Variant>;
 export {};

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

@@ -1,30 +1,44 @@
 import { DetachListeners } from 'analytics';
-import { Logger, PageviewProperties, Profile, Properties, Traits, SelectedVariantInfo, Reference, Event } from '@ninetailed/experience.js-shared';
+import { Logger, PageviewProperties, Profile, Properties, Traits, SelectedVariantInfo, Reference, Event, Change } from '@ninetailed/experience.js-shared';
 import { ElementSeenPayload, NinetailedPlugin, TrackComponentProperties } from '@ninetailed/experience.js-plugin-analytics';
 import { type Ninetailed } from '../Ninetailed';
 import { OnSelectVariant } from './OnSelectVariant';
 import { EventBuilder } from '../utils/EventBuilder';
-type Loading = {
+export type ProfileState = {
     status: 'loading';
     profile: null;
     experiences: null;
+    changes: null;
     error: null;
-};
-type Success = {
+    from: 'api' | 'hydrated';
+} | {
     status: 'success';
     profile: Profile;
     experiences: SelectedVariantInfo[];
+    changes: Change[];
     error: null;
+    from: 'api' | 'hydrated';
+} | {
+    status: 'error';
+    profile: Profile | null;
+    experiences: SelectedVariantInfo[] | null;
+    changes: Change[] | null;
+    error: Error;
+    from: 'api' | 'hydrated';
 };
-type Fail = {
+export type ChangesState = {
+    status: 'loading';
+    changes: null;
+    error: null;
+} | {
+    status: 'success';
+    changes: Change[];
+    error: null;
+} | {
     status: 'error';
-    profile: null;
-    experiences: null;
+    changes: null;
     error: Error;
 };
-export type ProfileState = {
-    from: 'api' | 'hydrated';
-} & (Loading | Success | Fail);
 export type OnIsInitializedCallback = () => void;
 export type OnIsInitialized = (cb: OnIsInitializedCallback) => void;
 export type EventFunctionOptions = {
@@ -36,7 +50,15 @@ export type EventFunctionOptions = {
 export type FlushResult = {
     success: boolean;
 };
+export type Result<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: Error;
+};
 export type OnProfileChangeCallback = (profile: ProfileState) => void;
+export type OnChangesChangeCallback = (changesState: ChangesState) => void;
 export type Page = (data?: Partial<PageviewProperties>, options?: EventFunctionOptions) => Promise<FlushResult>;
 export type Track = (event: string, properties?: Properties, options?: EventFunctionOptions) => Promise<FlushResult>;
 export type TrackHasSeenComponent = (properties: TrackComponentProperties) => Promise<void>;
@@ -46,6 +68,7 @@ export type Batch = (events: Event[]) => Promise<FlushResult>;
 export type Reset = () => void;
 export type Debug = (enable: boolean) => void;
 export type OnProfileChange = (cb: OnProfileChangeCallback) => DetachListeners;
+export type OnChangesChange = (cb: OnChangesChangeCallback) => DetachListeners;
 type ObserveElement = Ninetailed['observeElement'];
 type UnObserveElement = Ninetailed['unobserveElement'];
 export interface NinetailedInstance<TBaseline extends Reference = Reference, TVariant extends Reference = Reference> {
@@ -62,6 +85,7 @@ export interface NinetailedInstance<TBaseline extends Reference = Reference, TVa
     debug: Debug;
     profileState: ProfileState;
     onProfileChange: OnProfileChange;
+    onChangesChange: OnChangesChange;
     plugins: NinetailedPlugin[];
     logger: Logger;
     eventBuilder: EventBuilder;

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

@@ -1,8 +1,13 @@
 import { BuildPageEventArgs, BuildTrackEventArgs, IdentifyEventArgs, NinetailedRequestContext, Properties } from '@ninetailed/experience.js-shared';
+type PageData = Partial<Omit<BuildPageEventArgs, 'ctx' | 'properties'>>;
+type TrackData = Partial<Omit<BuildTrackEventArgs, 'ctx' | 'event' | 'properties'>>;
+type IdentifyData = Partial<Omit<IdentifyEventArgs, 'ctx' | 'userId' | 'traits'>>;
+type ComponentData = Partial<Omit<BuildPageEventArgs, 'ctx' | 'componentId' | 'experienceId' | 'variantIndex'>>;
 export declare class EventBuilder {
     private readonly buildRequestContext;
     constructor(buildRequestContext?: () => NinetailedRequestContext);
-    page(properties?: Properties, data?: Partial<Omit<BuildPageEventArgs, 'ctx' | 'properties'>>): {
+    private buildEventBase;
+    page(properties?: Properties, data?: PageData): {
         channel: import("@ninetailed/experience.js-shared").EventChanel;
         context: {
             app?: {
@@ -56,7 +61,7 @@ export declare class EventBuilder {
         name?: string | undefined;
         properties: import("@ninetailed/experience.js-shared").PageviewProperties;
     };
-    track(event: string, properties?: Properties, data?: Partial<Omit<BuildTrackEventArgs, 'ctx' | 'event' | 'properties'>>): {
+    track(event: string, properties?: Properties, data?: TrackData): {
         channel: import("@ninetailed/experience.js-shared").EventChanel;
         context: {
             app?: {
@@ -110,7 +115,7 @@ export declare class EventBuilder {
         event: string;
         properties: Properties;
     };
-    identify(userId: string, traits?: Properties, data?: Partial<Omit<IdentifyEventArgs, 'ctx' | 'userId' | 'traits'>>): {
+    identify(userId: string, traits?: Properties, data?: IdentifyData): {
         channel: import("@ninetailed/experience.js-shared").EventChanel;
         context: {
             app?: {
@@ -163,7 +168,7 @@ export declare class EventBuilder {
         userId?: string | undefined;
         traits: Properties;
     };
-    component(componentId: string, experienceId?: string, variantIndex?: number, data?: Partial<Omit<BuildPageEventArgs, 'ctx' | 'componentId' | 'experienceId' | 'variantIndex'>>): {
+    component(componentId: string, experienceId?: string, variantIndex?: number, data?: ComponentData): {
         channel: import("@ninetailed/experience.js-shared").EventChanel;
         context: {
             app?: {
@@ -219,3 +224,4 @@ export declare class EventBuilder {
         variantIndex?: number | undefined;
     };
 }
+export {};