@ninetailed/experience.js 3.0.1-beta.4 → 3.0.2-beta.1

package/lib/Ninetailed.d.ts

@@ -1,7 +1,6 @@
-import { PageData, AnalyticsPlugin, DetachListeners } from 'analytics';
-import { Locale, Traits, Profile, Variant, OnLogHandler, OnErrorHandler, Logger } from '@ninetailed/experience.js-shared';
-import { ProfileState } from './types';
-import { ExperienceConfiguration } from './experience';
+import { AnalyticsPlugin } from 'analytics';
+import { Locale, Traits, Profile, OnLogHandler, OnErrorHandler, Logger, PageviewProperties, Properties, NinetailedApiClient, NinetailedApiClientOptions } from '@ninetailed/experience.js-shared';
+import { EventFunctionOptions, NinetailedInstance, OnIsInitializedCallback, OnProfileChangeCallback, ProfileState, TrackHasSeenComponent, TrackHasSeenExperience } from './types';
 declare global {
     interface Window {
         ninetailed?: {
@@ -11,8 +10,6 @@ declare global {
         } & unknown;
     }
 }
-declare type OnIsInitializedCallback = () => void;
-export declare type OnIsInitialized = (cb: OnIsInitializedCallback) => void;
 declare type Options = {
     url?: string;
     locale?: Locale;
@@ -22,67 +19,24 @@ declare type Options = {
     onLog?: OnLogHandler;
     onError?: OnErrorHandler;
 };
-declare type EventFunctionOptions = {
-    plugins?: {
-        all: boolean;
-        [key: string]: boolean;
-    };
-};
-declare type OnProfileChangeCallback = (profile: ProfileState) => void;
-export declare type Page = (data?: PageData, options?: EventFunctionOptions) => Promise<void>;
-export declare type Track = (event: string, payload?: unknown, options?: EventFunctionOptions) => Promise<void>;
-export declare type TrackHasSeenComponent = (payload: {
-    variant: Variant<unknown>;
-    audience: {
-        id: string;
-    };
-    isPersonalized: boolean;
-}) => Promise<void>;
-export declare type TrackExperiencePayload = {
-    experience: ExperienceConfiguration;
-    variant: number;
-    component: {
-        id: string;
-    };
-};
-export declare type TrackExperience = (payload: TrackExperiencePayload) => Promise<void>;
-export declare type Identify = (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<void>;
-export declare type Reset = () => void;
-export declare type Debug = (enable: boolean) => void;
-export declare type OnProfileChange = (cb: OnProfileChangeCallback) => DetachListeners;
-export interface NinetailedInstance {
-    page: Page;
-    track: Track;
-    trackHasSeenComponent: TrackHasSeenComponent;
-    trackExperience: TrackExperience;
-    identify: Identify;
-    reset: Reset;
-    debug: Debug;
-    profileState: ProfileState;
-    onProfileChange: OnProfileChange;
-    plugins: AnalyticsPlugin[];
-    logger: Logger;
-    onIsInitialized: OnIsInitialized;
-}
+declare type NinetailedApiClientInstanceOrOptions = NinetailedApiClient | NinetailedApiClientOptions;
 export declare class Ninetailed implements NinetailedInstance {
     private readonly instance;
     private _profileState;
     private isInitialized;
+    private readonly apiClient;
+    private readonly eventQueue;
     readonly plugins: AnalyticsPlugin[];
     readonly logger: Logger;
-    constructor({ clientId, environment, preview, }: {
-        clientId: string;
-        environment?: string;
-        preview?: boolean;
-    }, { plugins, url, profile, locale, requestTimeout, onLog, onError, }?: Options);
-    page: (data?: PageData<string> | undefined, options?: EventFunctionOptions | undefined) => Promise<any>;
-    track: (event: string, payload?: unknown, options?: EventFunctionOptions | undefined) => Promise<any>;
+    constructor(ninetailedApiClientInstanceOrOptions: NinetailedApiClientInstanceOrOptions, { plugins, url, profile, locale, requestTimeout, onLog, onError, }?: Options);
+    page: (data?: Partial<PageviewProperties>, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
+    track: (event: string, properties?: Properties, options?: EventFunctionOptions) => Promise<import("./types").FlushResult>;
     trackHasSeenComponent: TrackHasSeenComponent;
-    trackExperience: TrackExperience;
-    identify: (uid: string, traits?: Traits | undefined, options?: EventFunctionOptions | undefined) => Promise<any>;
-    reset: () => void;
-    debug: (enabled: boolean) => void;
-    onProfileChange: (cb: OnProfileChangeCallback) => DetachListeners;
+    trackHasSeenExperience: TrackHasSeenExperience;
+    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;
     onIsInitialized: (onIsInitialized: OnIsInitializedCallback) => void;
     private waitUntilInitialized;
     get profileState(): ProfileState;

package/lib/analytics/constants.d.ts

@@ -2,3 +2,5 @@ export declare const LEGACY_ANONYMOUS_ID = "__anon_id";
 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 PROFILE_CHANGE = "profile-change";
+export declare const PROFILE_RESET = "profile-reset";

package/lib/analytics/get-analytics-plugin.d.ts

@@ -1,20 +1,16 @@
 import { AnalyticsPlugin } from 'analytics';
-import { Profile, Locale } from '@ninetailed/experience.js-shared';
+import { Profile, Locale, NinetailedApiClient } from '@ninetailed/experience.js-shared';
+import { NinetailedInstance, FlushResult } from '../types';
 declare type AnalyticsPluginNinetailedConfig = {
-    clientId: string;
-    environment?: string;
-    preview?: boolean;
-    url?: string;
+    apiClient: NinetailedApiClient;
     profile?: Profile;
     locale?: Locale;
     requestTimeout?: number;
-};
-export declare const NINETAILED_TRACKER_EVENTS: {
-    /**
-     * `profile` - Fires when the profile is returned by the cdp API.
-     */
-    profile: string;
+    ninetailed: NinetailedInstance;
 };
 export declare const PLUGIN_NAME = "ninetailed";
-export declare const ninetailedPlugin: ({ clientId, environment, preview, url, profile, locale, }: AnalyticsPluginNinetailedConfig) => AnalyticsPlugin;
+export interface NinetailedEventQueue extends AnalyticsPlugin {
+    flush: () => Promise<FlushResult>;
+}
+export declare const ninetailedPlugin: ({ apiClient, profile, locale, ninetailed, }: AnalyticsPluginNinetailedConfig) => NinetailedEventQueue;
 export {};

package/lib/analytics/index.d.ts

@@ -1 +1,2 @@
 export * from './get-analytics-plugin';
+export * from './constants';

package/lib/experience/isExperienceMatch.d.ts

@@ -1,9 +1,9 @@
 import { Profile } from '@ninetailed/experience.js-shared';
 import { ExperienceConfiguration } from './types';
 declare type IsExperienceMatchArgs = {
-    experience: ExperienceConfiguration;
-    activeExperiments: ExperienceConfiguration[];
+    experience: ExperienceConfiguration<any>;
+    activeExperiments: ExperienceConfiguration<any>[];
     profile: Profile;
 };
-export declare const isExperienceMatch: ({ experience, activeExperiments, profile }: IsExperienceMatchArgs) => boolean;
+export declare const isExperienceMatch: ({ experience, activeExperiments, profile, }: IsExperienceMatchArgs) => boolean;
 export {};

package/lib/experience/selectActiveExperiments.d.ts

@@ -1,3 +1,3 @@
 import { Profile } from '@ninetailed/experience.js-shared';
-import { ExperienceConfiguration } from './types';
-export declare const selectActiveExperiments: (experiments: ExperienceConfiguration[], profile: Profile) => ExperienceConfiguration[];
+import { ExperienceConfiguration, Reference } from './types';
+export declare const selectActiveExperiments: <Variant extends Reference>(experiments: ExperienceConfiguration<Variant>[], profile: Profile) => ExperienceConfiguration<Variant>[];

package/lib/experience/selectBaselineWithVariants.d.ts

@@ -1,2 +1,2 @@
-import { Baseline, BaselineWithVariants, ExperienceConfiguration } from './types';
-export declare const selectBaselineWithVariants: (experience: ExperienceConfiguration, baseline: Baseline) => BaselineWithVariants | null;
+import { Baseline, BaselineWithVariants, ExperienceConfiguration, Reference } from './types';
+export declare const selectBaselineWithVariants: <Variant extends Reference>(experience: ExperienceConfiguration<Variant>, baseline: Baseline) => BaselineWithVariants<Variant> | null;

package/lib/experience/selectDistribution.d.ts

@@ -1,8 +1,8 @@
 import { Profile } from '@ninetailed/experience.js-shared';
-import { Distribution, ExperienceConfiguration } from './types';
-declare type SelectDistributionArgs = {
-    experience: ExperienceConfiguration;
+import { Distribution, ExperienceConfiguration, Reference } from './types';
+declare type SelectDistributionArgs<Variant extends Reference> = {
+    experience: ExperienceConfiguration<Variant>;
     profile: Profile;
 };
-export declare const selectDistribution: ({ experience, profile, }: SelectDistributionArgs) => Distribution;
+export declare const selectDistribution: <Variant extends Reference>({ experience, profile, }: SelectDistributionArgs<Variant>) => Distribution;
 export {};

package/lib/experience/selectEligibleExperiences.d.ts

@@ -1,12 +1,12 @@
-import { ExperienceConfiguration } from './types';
-declare type SelectEligibleExperiencesArgs = {
-    experiences: ExperienceConfiguration[];
-    activeExperiments: ExperienceConfiguration[];
+import { ExperienceConfiguration, Reference } from './types';
+declare type SelectEligibleExperiencesArgs<Variant extends Reference> = {
+    experiences: ExperienceConfiguration<Variant>[];
+    activeExperiments: ExperienceConfiguration<Variant>[];
 };
 /**
  * We can use any personalization as eligible experience
  * When going for an experiment we can only select a active experiment when 1 or more experiments are active
  * If the profile is not in any active experiments, we can select any expermiment
  */
-export declare const selectEligibleExperiences: ({ experiences, activeExperiments, }: SelectEligibleExperiencesArgs) => ExperienceConfiguration[];
+export declare const selectEligibleExperiences: <Variant extends Reference>({ experiences, activeExperiments, }: SelectEligibleExperiencesArgs<Variant>) => ExperienceConfiguration<Variant>[];
 export {};

package/lib/experience/selectExperience.d.ts

@@ -1,9 +1,9 @@
 import { Profile } from '@ninetailed/experience.js-shared';
-import { ExperienceConfiguration } from './types';
-declare type SelectExprienceArgs = {
-    experiences: ExperienceConfiguration[];
-    activeExperiments: ExperienceConfiguration[];
+import { ExperienceConfiguration, Reference } from './types';
+declare type SelectExprienceArgs<Variant extends Reference> = {
+    experiences: ExperienceConfiguration<Variant>[];
+    activeExperiments: ExperienceConfiguration<Variant>[];
     profile: Profile;
 };
-export declare const selectExperience: ({ experiences, activeExperiments, profile, }: SelectExprienceArgs) => ExperienceConfiguration | null;
+export declare const selectExperience: <Variant extends Reference>({ experiences, activeExperiments, profile, }: SelectExprienceArgs<Variant>) => ExperienceConfiguration<Variant> | null;
 export {};

package/lib/experience/selectHasVariants.d.ts

@@ -1,2 +1,2 @@
-import { Baseline, ExperienceConfiguration } from "./types";
-export declare const selectHasVariants: (experience: ExperienceConfiguration, baseline: Baseline) => boolean;
+import { Baseline, ExperienceConfiguration, Reference } from './types';
+export declare const selectHasVariants: <Variant extends Reference>(experience: ExperienceConfiguration<Variant>, baseline: Baseline) => boolean;

package/lib/experience/selectVariant.d.ts

@@ -1,9 +1,9 @@
 import { Profile } from '@ninetailed/experience.js-shared';
-import { Baseline, ExperienceConfiguration, Variant } from './types';
-declare type SelectVariantArgs = {
+import { Baseline, ExperienceConfiguration, Reference, VariantRef } from './types';
+declare type SelectVariantArgs<Variant extends Reference> = {
     baseline: Baseline;
-    experience: ExperienceConfiguration;
+    experience: ExperienceConfiguration<Variant>;
     profile: Profile;
 };
-export declare const selectVariant: ({ baseline, experience, profile, }: SelectVariantArgs) => Variant | null;
+export declare const selectVariant: <Variant extends Reference>({ baseline, experience, profile, }: SelectVariantArgs<Variant>) => Variant | VariantRef | null;
 export {};

package/lib/experience/selectVariants.d.ts

@@ -1,2 +1,2 @@
-import { Baseline, Variant, ExperienceConfiguration } from './types';
-export declare const selectVariants: (experience: ExperienceConfiguration, baseline: Baseline) => Variant[];
+import { Baseline, ExperienceConfiguration, Reference, VariantRef } from './types';
+export declare const selectVariants: <Variant extends Reference>(experience: ExperienceConfiguration<Variant>, baseline: Baseline) => (Variant | VariantRef)[];

package/lib/experience/types/Baseline.d.ts

@@ -1,3 +1,2 @@
-export declare type Baseline<P = {}> = P & {
-    id: string;
-};
+import { Reference } from './Reference';
+export declare type Baseline<P = unknown> = P & Reference;

package/lib/experience/types/BaselineWithVariants.d.ts

@@ -1,6 +1,7 @@
 import { Baseline } from './Baseline';
-import { Variant } from './Variant';
-export declare type BaselineWithVariants = {
-    baseline: Baseline<{}>;
-    variants: Variant<{}>[];
+import { Reference } from './Reference';
+import { VariantRef } from './VariantRef';
+export declare type BaselineWithVariants<Variant extends Reference> = {
+    baseline: Baseline;
+    variants: (Variant | VariantRef)[];
 };

package/lib/experience/types/ExperienceConfiguration.d.ts

@@ -1,7 +1,8 @@
 import { BaselineWithVariants } from './BaselineWithVariants';
 import { Distribution } from './Distribution';
+import { Reference } from './Reference';
 export declare type ExperienceType = 'nt_personalization' | 'nt_experiment';
-export declare type ExperienceConfiguration = {
+export declare type ExperienceConfiguration<Variant extends Reference = Reference> = {
     id: string;
     type: ExperienceType;
     audience?: {
@@ -9,5 +10,5 @@ export declare type ExperienceConfiguration = {
     };
     trafficAllocation: number;
     distribution: Distribution[];
-    components: BaselineWithVariants[];
+    components: BaselineWithVariants<Variant>[];
 };

package/lib/experience/types/Reference.d.ts

@@ -0,0 +1,3 @@
+export declare type Reference = {
+    id: string;
+};

package/lib/experience/types/VariantRef.d.ts

@@ -0,0 +1,4 @@
+export declare type VariantRef = {
+    id: string;
+    hidden: boolean;
+};

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

@@ -1,5 +1,6 @@
+export type { Reference } from './Reference';
 export type { Baseline } from './Baseline';
-export type { Variant } from './Variant';
+export type { VariantRef } from './VariantRef';
 export type { BaselineWithVariants } from './BaselineWithVariants';
 export type { Distribution } from './Distribution';
 export type { ExperienceConfiguration, ExperienceType, } from './ExperienceConfiguration';

package/lib/experience/utils.d.ts

@@ -1,4 +1,4 @@
 import { Profile } from '@ninetailed/experience.js-shared';
 import { ExperienceConfiguration } from './types';
-export declare const getTrafficRandom: (profile: Profile, experience: ExperienceConfiguration) => number;
-export declare const getDistributionRandom: (profile: Profile, experience: ExperienceConfiguration) => number;
+export declare const getTrafficRandom: (profile: Profile, experience: ExperienceConfiguration<any>) => number;
+export declare const getDistributionRandom: (profile: Profile, experience: ExperienceConfiguration<any>) => number;

package/lib/types.d.ts

@@ -1,4 +1,6 @@
-import { Profile } from '@ninetailed/experience.js-shared';
+import { TrackComponentProperties, TrackExperienceProperties } from '@ninetailed/experience.js-plugin-analytics';
+import { Logger, PageviewProperties, Profile, Properties, Traits } from '@ninetailed/experience.js-shared';
+import { AnalyticsPlugin, DetachListeners } from 'analytics';
 declare type Loading = {
     status: 'loading';
     profile: null;
@@ -17,4 +19,38 @@ declare type Fail = {
 export declare type ProfileState = {
     from: 'api' | 'hydrated';
 } & (Loading | Success | Fail);
+export declare type OnIsInitializedCallback = () => void;
+export declare type OnIsInitialized = (cb: OnIsInitializedCallback) => void;
+export declare type EventFunctionOptions = {
+    plugins?: {
+        all: boolean;
+        [key: string]: boolean;
+    };
+};
+export declare type FlushResult = {
+    success: boolean;
+};
+export declare type OnProfileChangeCallback = (profile: ProfileState) => void;
+export declare type Page = (data?: Partial<PageviewProperties>, options?: EventFunctionOptions) => Promise<FlushResult>;
+export declare type Track = (event: string, properties?: Properties, options?: EventFunctionOptions) => Promise<FlushResult>;
+export declare type TrackHasSeenComponent = (properties: TrackComponentProperties) => Promise<void>;
+export declare type TrackHasSeenExperience = (properties: TrackExperienceProperties) => Promise<void>;
+export declare type Identify = (uid: string, traits?: Traits, options?: EventFunctionOptions) => Promise<FlushResult>;
+export declare type Reset = () => void;
+export declare type Debug = (enable: boolean) => void;
+export declare type OnProfileChange = (cb: OnProfileChangeCallback) => DetachListeners;
+export interface NinetailedInstance {
+    page: Page;
+    track: Track;
+    trackHasSeenComponent: TrackHasSeenComponent;
+    trackHasSeenExperience: TrackHasSeenExperience;
+    identify: Identify;
+    reset: Reset;
+    debug: Debug;
+    profileState: ProfileState;
+    onProfileChange: OnProfileChange;
+    plugins: AnalyticsPlugin[];
+    logger: Logger;
+    onIsInitialized: OnIsInitialized;
+}
 export {};

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@ninetailed/experience.js",
-  "version": "3.0.1-beta.4",
-  "main": "./index.umd.js",
-  "module": "./index.esm.js",
-  "typings": "./index.d.ts",
+  "version": "3.0.2-beta.1",
+  "module": "./index.js",
+  "main": "./index.cjs",
+  "type": "module",
+  "types": "./index.d.ts",
   "dependencies": {
-    "@ninetailed/experience.js-shared": "3.0.1-beta.4",
-    "ts-toolbelt": "^9.6.0",
-    "diary": "^0.3.1",
-    "zod": "^3.18.0",
-    "locale-enum": "^1.1.1",
-    "i18n-iso-countries": "^7.3.0",
-    "analytics": "^0.8.0",
-    "lodash": "^4.17.21",
-    "murmurhash-js": "^1.0.0"
+    "@ninetailed/experience.js-shared": "3.0.2-beta.1",
+    "analytics": "0.8.1",
+    "lodash": "4.17.21",
+    "murmurhash-js": "1.0.0",
+    "@ninetailed/experience.js-plugin-analytics": "3.0.2-beta.1"
   },
   "peerDependencies": {}
 }