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

package/index.cjs

@@ -0,0 +1,197 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var experience_jsShared = require('@ninetailed/experience.js-shared');
+var zod = require('zod');
+
+const Audience = zod.z.object({
+  id: zod.z.string()
+});
+
+const Config = zod.z.object({
+  distribution: zod.z.array(zod.z.number()).default([0.5, 0.5]),
+  traffic: zod.z.number().default(0),
+  components: zod.z.array(zod.z.object({
+    baseline: zod.z.object({
+      id: zod.z.string().default('')
+    }),
+    variants: zod.z.array(zod.z.object({
+      id: zod.z.string().default(''),
+      hidden: zod.z.boolean().default(false)
+    }))
+  })).default([{
+    baseline: {
+      id: ''
+    },
+    variants: [{
+      id: '',
+      hidden: false
+    }]
+  }])
+});
+// export interface Config {
+//   distribution: number[];
+//   traffic: number;
+//   components: BaselineWithVariantRefs[];
+// }
+
+const Variant = zod.z.object({
+  id: zod.z.string()
+}).catchall(zod.z.unknown());
+
+/**
+ * Zod helper for parsing arrays and ignore items not specified in the schema
+ *
+ * @param zodUnion - union of known types
+ *
+ * @example
+ * const binaryArraySchema = arrayIgnoreUnknown(z.union([z.literal('0'), z.literal('1')]))
+ * type BinaryArray = z.TypeOf<typeof binaryArraySchema>
+ *
+ * const binaryArray: BinaryArray = binaryArraySchema.parse(['0', '1', '2', '0'])
+ * console.log(binaryArray) // ['0', '1', '0']
+ */
+function zodArrayIgnoreUnknown(zodType) {
+  const isKnownItem = item => zodType.safeParse(item).success;
+  return zod.z.preprocess(val => toSafeArray(val).filter(isKnownItem), zod.z.array(zodType));
+}
+function toSafeArray(item) {
+  if (isArray(item)) {
+    return item;
+  }
+  return [item];
+}
+function isArray(item) {
+  return Array.isArray(item);
+}
+
+const ExperienceSchema = zod.z.object({
+  id: zod.z.string(),
+  /**
+   * The name of the experience (Short Text)
+   */
+  name: zod.z.string(),
+  /**
+   * The type if the experience (nt_experiment | nt_personalization)
+   */
+  type: zod.z.union([zod.z.string().regex(/^nt_experiment$/g), zod.z.string().regex(/^nt_personalization$/g)]),
+  /**
+   * The config of the experience (JSON)
+   */
+  config: Config.default({}),
+  /**
+   * The audience of the experience (Audience)
+   */
+  audience: Audience.optional().nullable(),
+  /**
+   * All used variants of the experience (References to other Content Types)
+   */
+  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 ExperimentSchema = ExperienceSchema.extend({
+  type: zod.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 {
+  static isExperienceEntry(experience) {
+    return Experience.safeParse(experience).success;
+  }
+  static mapExperience(experience) {
+    const parsedExperience = Experience.safeParse(experience);
+    if (!parsedExperience.success) {
+      experience_jsShared.logger.warn('[Ninetailed ExperienceMapper]', 'Error parsing experience', parsedExperience.error.format());
+      throw new Error(`[Ninetailed ExperienceMapper] The Experience Input is not valid. Please filter data first with "ExperienceMapper.isExperienceEntry".\n${JSON.stringify(parsedExperience.error.format(), null, 2)}`);
+    }
+    const {
+      id,
+      type,
+      audience,
+      config,
+      variants
+    } = parsedExperience.data;
+    const {
+      components,
+      traffic
+    } = config;
+    return Object.assign(Object.assign({
+      id,
+      type: type
+    }, audience ? {
+      audience
+    } : {}), {
+      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: 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) {
+    return Experiment.safeParse(experiment).success;
+  }
+  static mapExperiment(experiment) {
+    return ExperienceMapper.mapExperience(experiment);
+  }
+}
+
+exports.Audience = Audience;
+exports.Config = Config;
+exports.Experience = Experience;
+exports.ExperienceMapper = ExperienceMapper;
+exports.Experiment = Experiment;
+exports.Variant = Variant;

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.esm.js → 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
@@ -43,71 +48,100 @@ const Variant = z.object({
  * const binaryArray: BinaryArray = binaryArraySchema.parse(['0', '1', '2', '0'])
  * console.log(binaryArray) // ['0', '1', '0']
  */
-
 function zodArrayIgnoreUnknown(zodType) {
   const isKnownItem = item => zodType.safeParse(item).success;
-
   return z.preprocess(val => toSafeArray(val).filter(isKnownItem), z.array(zodType));
 }
-
 function toSafeArray(item) {
   if (isArray(item)) {
     return item;
   }
-
   return [item];
 }
-
 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)
    */
   name: z.string(),
-
   /**
    * 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)
    */
   config: Config.default({}),
-
   /**
    * The audience of the experience (Audience)
    */
   audience: Audience.optional().nullable(),
-
   /**
    * All used variants of the experience (References to other Content Types)
    */
   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 {
   static isExperienceEntry(experience) {
     return Experience.safeParse(experience).success;
   }
-
   static mapExperience(experience) {
     const parsedExperience = Experience.safeParse(experience);
-
     if (!parsedExperience.success) {
       logger.warn('[Ninetailed ExperienceMapper]', 'Error parsing experience', parsedExperience.error.format());
       throw new Error(`[Ninetailed ExperienceMapper] The Experience Input is not valid. Please filter data first with "ExperienceMapper.isExperienceEntry".\n${JSON.stringify(parsedExperience.error.format(), null, 2)}`);
     }
-
     const {
       id,
       type,
@@ -115,47 +149,40 @@ 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) {
     return Experiment.safeParse(experiment).success;
   }
-
   static mapExperiment(experiment) {
     return ExperienceMapper.mapExperience(experiment);
   }
-
 }
 
 export { Audience, Config, Experience, ExperienceMapper, Experiment, Variant };

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,20 +1,14 @@
 {
   "name": "@ninetailed/experience.js-utils",
-  "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": "3.0.1-beta.4",
-    "@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": "3.0.2-beta.1",
+    "@ninetailed/experience.js-shared": "3.0.2-beta.1",
+    "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[];
+}