@ninetailed/experience.js-utils 3.0.0 → 3.0.1-beta.0

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/package.json

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