@ninetailed/experience.js-utils 3.0.0-beta.32 → 3.0.0-beta.34

package/index.d.ts

@@ -1,2 +1,11 @@
-export { ExperienceMapper } from './lib';
-export { Experience, Experiment, Audience, Config, Variant } from './types';
+export { ExperienceMapper } from './lib/ExperienceMapper';
+export { Audience } from './types/Audience';
+export { Config } from './types/Config';
+export { Experience } from './types/Experience';
+export { Experiment } from './types/Experiment';
+export { Variant } from './types/Variant';
+export type { AudienceLike } from './types/Audience';
+export type { ConfigLike } from './types/Config';
+export type { ExperienceLike } from './types/Experience';
+export type { ExperimentLike } from './types/Experiment';
+export type { VariantLike } from './types/Variant';

package/index.js

@@ -26,10 +26,15 @@ const Config = z.object({
     }]
   }])
 });
+// export interface Config {
+//   distribution: number[];
+//   traffic: number;
+//   components: BaselineWithVariantRefs[];
+// }
 
 const Variant = z.object({
   id: z.string()
-}).passthrough();
+}).catchall(z.unknown());
 
 /**
  * Zod helper for parsing arrays and ignore items not specified in the schema
@@ -57,7 +62,7 @@ function isArray(item) {
   return Array.isArray(item);
 }
 
-const Experience = z.object({
+const ExperienceSchema = z.object({
   id: z.string(),
   /**
    * The name of the experience (Short Text)
@@ -66,7 +71,7 @@ const Experience = z.object({
   /**
    * The type if the experience (nt_experiment | nt_personalization)
    */
-  type: z.union([z.literal('nt_experiment'), z.literal('nt_personalization')]),
+  type: z.union([z.string().regex(/^nt_experiment$/g), z.string().regex(/^nt_personalization$/g)]),
   /**
    * The config of the experience (JSON)
    */
@@ -80,9 +85,51 @@ const Experience = z.object({
    */
   variants: zodArrayIgnoreUnknown(Variant).default([])
 });
+const parse$1 = input => {
+  const output = ExperienceSchema.parse(input);
+  return Object.assign(Object.assign({}, output), {
+    variants: input.variants
+  });
+};
+const safeParse$1 = input => {
+  const output = ExperienceSchema.safeParse(input);
+  if (!output.success) {
+    return output;
+  }
+  return Object.assign(Object.assign({}, output), {
+    data: Object.assign(Object.assign({}, output.data), {
+      variants: input.variants
+    })
+  });
+};
+const Experience = Object.assign(Object.assign({}, ExperienceSchema), {
+  parse: parse$1,
+  safeParse: safeParse$1
+});
 
-const Experiment = Experience.extend({
-  type: z.literal('nt_experiment')
+const ExperimentSchema = ExperienceSchema.extend({
+  type: z.string().regex(/^nt_experiment$/g)
+});
+const parse = input => {
+  const output = ExperimentSchema.parse(input);
+  return Object.assign(Object.assign({}, output), {
+    variants: input.variants
+  });
+};
+const safeParse = input => {
+  const output = ExperimentSchema.safeParse(input);
+  if (!output.success) {
+    return output;
+  }
+  return Object.assign(Object.assign({}, output), {
+    data: Object.assign(Object.assign({}, output.data), {
+      variants: input.variants
+    })
+  });
+};
+const Experiment = Object.assign(Object.assign({}, ExperimentSchema), {
+  parse,
+  safeParse
 });
 
 class ExperienceMapper {
@@ -102,33 +149,32 @@ class ExperienceMapper {
       config,
       variants
     } = parsedExperience.data;
+    const {
+      components,
+      traffic
+    } = config;
     return Object.assign(Object.assign({
       id,
-      type
+      type: type
     }, audience ? {
       audience
     } : {}), {
-      trafficAllocation: config.traffic,
+      trafficAllocation: traffic,
       distribution: config.distribution.map((percentage, index) => ({
         index,
         start: config.distribution.slice(0, index).reduce((a, b) => a + b, 0),
         end: config.distribution.slice(0, index + 1).reduce((a, b) => a + b, 0)
       })),
-      components: config.components.map(component => {
-        return {
-          baseline: component.baseline,
-          variants: component.variants.map(variant => {
-            if (variant.hidden) {
-              return variant;
-            }
-            const matchingVariant = variants.find(variantReference => variantReference.id === variant.id);
-            if (!matchingVariant) {
-              return null;
-            }
-            return matchingVariant;
-          }).filter(variant => variant !== null)
-        };
-      })
+      components: components.map(component => ({
+        baseline: component.baseline,
+        variants: component.variants.map(variantRef => {
+          if (variantRef.hidden) {
+            return variantRef;
+          }
+          const matchingVariant = variants.find(variant => variant.id === variantRef.id);
+          return matchingVariant !== null && matchingVariant !== void 0 ? matchingVariant : null;
+        }).filter(variant => variant !== null)
+      }))
     });
   }
   static isExperimentEntry(experiment) {

package/lib/ExperienceMapper.d.ts

@@ -1,12 +1,9 @@
-import { ExperienceConfiguration } from '@ninetailed/experience.js';
-import { z } from 'zod';
-import { Experience, Experiment } from '../types';
-declare type ExperienceEntry = z.input<typeof Experience>;
-declare type ExperimentEntry = z.input<typeof Experiment>;
+import { ExperienceConfiguration, Reference } from '@ninetailed/experience.js';
+import { Experience, ExperienceLike } from '../types/Experience';
+import { ExperimentLike } from '../types/Experiment';
 export declare class ExperienceMapper {
-    static isExperienceEntry(experience: ExperienceEntry): experience is Experience;
-    static mapExperience(experience: ExperienceEntry): ExperienceConfiguration;
-    static isExperimentEntry(experiment: ExperimentEntry): experiment is Experiment;
-    static mapExperiment(experiment: ExperimentEntry): ExperienceConfiguration;
+    static isExperienceEntry<Variant extends Reference>(experience: ExperienceLike<Variant>): experience is Experience<Variant>;
+    static mapExperience<Variant extends Reference>(experience: ExperienceLike<Variant>): ExperienceConfiguration<Variant>;
+    static isExperimentEntry<Variant extends Reference>(experiment: ExperimentLike<Variant>): experiment is ExperimentLike<Variant>;
+    static mapExperiment<Variant extends Reference>(experiment: ExperimentLike<Variant>): ExperienceConfiguration<Variant>;
 }
-export {};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ninetailed/experience.js-utils",
-  "version": "3.0.0-beta.32",
+  "version": "3.0.0-beta.34",
   "module": "./index.js",
   "main": "./index.js",
   "type": "module",
   "types": "./index.d.ts",
   "dependencies": {
-    "@ninetailed/experience.js": "3.0.0-beta.32",
-    "@ninetailed/experience.js-shared": "3.0.0-beta.32",
+    "@ninetailed/experience.js": "3.0.0-beta.34",
+    "@ninetailed/experience.js-shared": "3.0.0-beta.34",
     "zod": "3.20.2"
   },
   "peerDependencies": {}

package/types/Audience.d.ts

@@ -6,4 +6,5 @@ export declare const Audience: z.ZodObject<{
 }, {
     id: string;
 }>;
+export declare type AudienceLike = z.input<typeof Audience>;
 export declare type Audience = z.infer<typeof Audience>;

package/types/Config.d.ts

@@ -1,3 +1,4 @@
+import { Baseline, VariantRef } from '@ninetailed/experience.js';
 import { z } from 'zod';
 export declare const Config: z.ZodObject<{
     distribution: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
@@ -62,4 +63,9 @@ export declare const Config: z.ZodObject<{
         }[];
     }[] | undefined;
 }>;
+export declare type ConfigLike = z.input<typeof Config>;
 export declare type Config = z.infer<typeof Config>;
+export interface BaselineWithVariantRefs {
+    baseline: Baseline;
+    variants: VariantRef[];
+}