@ninetailed/experience.js-utils 2.2.3 → 2.2.5

package/{src/index.d.ts → index.d.ts}

@@ -1,2 +1,2 @@
-export { ExperienceMapper } from './lib';
-export { Experience, Experiment, Audience, Config, Variant } from './types';
+export { ExperienceMapper } from './lib';
+export { Experience, Experiment, Audience, Config, Variant } from './types';

package/index.esm.js

@@ -0,0 +1,130 @@
+import { logger } from '@ninetailed/experience.js';
+import { z } from 'zod';
+
+const Audience = z.object({
+  id: z.string()
+});
+
+const Config = z.object({
+  distribution: z.array(z.number()).default([0.5, 0.5]),
+  traffic: z.number().default(0),
+  components: z.array(z.object({
+    baseline: z.object({
+      id: z.string().default('')
+    }),
+    variants: z.array(z.object({
+      id: z.string().default(''),
+      hidden: z.boolean().default(false)
+    }))
+  })).default([{
+    baseline: {
+      id: ''
+    },
+    variants: [{
+      id: '',
+      hidden: false
+    }]
+  }])
+});
+
+const Variant = z.object({
+  id: z.string()
+}).passthrough();
+
+const Experience = 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')]),
+
+  /**
+   * 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: z.array(Variant).default([])
+});
+
+const Experiment = Experience.extend({
+  type: z.literal('nt_experiment')
+});
+
+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,
+      audience,
+      config,
+      variants
+    } = parsedExperience.data;
+    return Object.assign(Object.assign({
+      id,
+      type
+    }, audience ? {
+      audience
+    } : {}), {
+      trafficAllocation: config.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)
+        };
+      })
+    });
+  }
+
+  static isExperimentEntry(experiment) {
+    return Experiment.safeParse(experiment).success;
+  }
+
+  static mapExperiment(experiment) {
+    return ExperienceMapper.mapExperience(experiment);
+  }
+
+}
+
+export { Audience, Config, Experience, ExperienceMapper, Experiment, Variant };

package/index.umd.js

@@ -0,0 +1,182 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@ninetailed/experience.js'), require('zod')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@ninetailed/experience.js', 'zod'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UtilsJavascript = {}, global.experience_js, global.zod));
+})(this, (function (exports, experience_js, zod) { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    var Audience = zod.z.object({
+      id: zod.z.string()
+    });
+
+    var 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
+        }]
+      }])
+    });
+
+    var Variant = zod.z.object({
+      id: zod.z.string()
+    }).passthrough();
+
+    var Experience = 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.literal('nt_experiment'), zod.z.literal('nt_personalization')]),
+
+      /**
+       * 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: zod.z.array(Variant).default([])
+    });
+
+    var Experiment = Experience.extend({
+      type: zod.z.literal('nt_experiment')
+    });
+
+    var ExperienceMapper =
+    /** @class */
+    function () {
+      function ExperienceMapper() {}
+
+      ExperienceMapper.isExperienceEntry = function (experience) {
+        return Experience.safeParse(experience).success;
+      };
+
+      ExperienceMapper.mapExperience = function (experience) {
+        var parsedExperience = Experience.safeParse(experience);
+
+        if (!parsedExperience.success) {
+          experience_js.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".concat(JSON.stringify(parsedExperience.error.format(), null, 2)));
+        }
+
+        var _a = parsedExperience.data,
+            id = _a.id,
+            type = _a.type,
+            audience = _a.audience,
+            config = _a.config,
+            variants = _a.variants;
+        return __assign(__assign({
+          id: id,
+          type: type
+        }, audience ? {
+          audience: audience
+        } : {}), {
+          trafficAllocation: config.traffic,
+          distribution: config.distribution.map(function (percentage, index) {
+            return {
+              index: index,
+              start: config.distribution.slice(0, index).reduce(function (a, b) {
+                return a + b;
+              }, 0),
+              end: config.distribution.slice(0, index + 1).reduce(function (a, b) {
+                return a + b;
+              }, 0)
+            };
+          }),
+          components: config.components.map(function (component) {
+            return {
+              baseline: component.baseline,
+              variants: component.variants.map(function (variant) {
+                if (variant.hidden) {
+                  return variant;
+                }
+
+                var matchingVariant = variants.find(function (variantReference) {
+                  return variantReference.id === variant.id;
+                });
+
+                if (!matchingVariant) {
+                  return null;
+                }
+
+                return matchingVariant;
+              }).filter(function (variant) {
+                return variant !== null;
+              })
+            };
+          })
+        });
+      };
+
+      ExperienceMapper.isExperimentEntry = function (experiment) {
+        return Experiment.safeParse(experiment).success;
+      };
+
+      ExperienceMapper.mapExperiment = function (experiment) {
+        return ExperienceMapper.mapExperience(experiment);
+      };
+
+      return ExperienceMapper;
+    }();
+
+    exports.Audience = Audience;
+    exports.Config = Config;
+    exports.Experience = Experience;
+    exports.ExperienceMapper = ExperienceMapper;
+    exports.Experiment = Experiment;
+    exports.Variant = Variant;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/{src/lib → lib}/ExperienceMapper.d.ts

@@ -1,12 +1,12 @@
-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>;
-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;
-}
-export {};
+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>;
+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;
+}
+export {};

package/{src/lib → lib}/index.d.ts

@@ -1 +1 @@
-export { ExperienceMapper } from './ExperienceMapper';
+export { ExperienceMapper } from './ExperienceMapper';

package/package.json

@@ -1,7 +1,22 @@
 {
   "name": "@ninetailed/experience.js-utils",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "type": "commonjs",
-  "main": "./src/index.js",
-  "typings": "./src/index.d.ts"
+  "main": "./index.umd.js",
+  "module": "./index.esm.js",
+  "typings": "./index.d.ts",
+  "dependencies": {
+    "@ninetailed/experience.js": "2.2.5",
+    "analytics": "^0.8.0",
+    "@ninetailed/experience.js-shared": "2.2.5",
+    "uuid": "^8.3.2",
+    "ts-toolbelt": "^9.6.0",
+    "locale-enum": "^1.1.1",
+    "i18n-iso-countries": "^7.3.0",
+    "lodash": "^4.17.21",
+    "murmurhash-js": "^1.0.0",
+    "diary": "^0.3.1",
+    "zod": "^3.18.0"
+  },
+  "peerDependencies": {}
 }

package/{src/types → types}/Audience.d.ts

@@ -1,9 +1,9 @@
-import { z } from 'zod';
-export declare const Audience: z.ZodObject<{
-    id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
-export declare type Audience = z.infer<typeof Audience>;
+import { z } from 'zod';
+export declare const Audience: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare type Audience = z.infer<typeof Audience>;

package/{src/types → types}/Config.d.ts

@@ -1,65 +1,65 @@
-import { z } from 'zod';
-export declare const Config: z.ZodObject<{
-    distribution: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
-    traffic: z.ZodDefault<z.ZodNumber>;
-    components: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        baseline: z.ZodObject<{
-            id: z.ZodDefault<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            id: string;
-        }, {
-            id?: string | undefined;
-        }>;
-        variants: z.ZodArray<z.ZodObject<{
-            id: z.ZodDefault<z.ZodString>;
-            hidden: z.ZodDefault<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            id: string;
-            hidden: boolean;
-        }, {
-            id?: string | undefined;
-            hidden?: boolean | undefined;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        baseline: {
-            id: string;
-        };
-        variants: {
-            id: string;
-            hidden: boolean;
-        }[];
-    }, {
-        baseline: {
-            id?: string | undefined;
-        };
-        variants: {
-            id?: string | undefined;
-            hidden?: boolean | undefined;
-        }[];
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    distribution: number[];
-    traffic: number;
-    components: {
-        baseline: {
-            id: string;
-        };
-        variants: {
-            id: string;
-            hidden: boolean;
-        }[];
-    }[];
-}, {
-    distribution?: number[] | undefined;
-    traffic?: number | undefined;
-    components?: {
-        baseline: {
-            id?: string | undefined;
-        };
-        variants: {
-            id?: string | undefined;
-            hidden?: boolean | undefined;
-        }[];
-    }[] | undefined;
-}>;
-export declare type Config = z.infer<typeof Config>;
+import { z } from 'zod';
+export declare const Config: z.ZodObject<{
+    distribution: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+    traffic: z.ZodDefault<z.ZodNumber>;
+    components: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        baseline: z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+        }, {
+            id?: string | undefined;
+        }>;
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodDefault<z.ZodString>;
+            hidden: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            hidden: boolean;
+        }, {
+            id?: string | undefined;
+            hidden?: boolean | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        baseline: {
+            id: string;
+        };
+        variants: {
+            id: string;
+            hidden: boolean;
+        }[];
+    }, {
+        baseline: {
+            id?: string | undefined;
+        };
+        variants: {
+            id?: string | undefined;
+            hidden?: boolean | undefined;
+        }[];
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    distribution: number[];
+    traffic: number;
+    components: {
+        baseline: {
+            id: string;
+        };
+        variants: {
+            id: string;
+            hidden: boolean;
+        }[];
+    }[];
+}, {
+    distribution?: number[] | undefined;
+    traffic?: number | undefined;
+    components?: {
+        baseline: {
+            id?: string | undefined;
+        };
+        variants: {
+            id?: string | undefined;
+            hidden?: boolean | undefined;
+        }[];
+    }[] | undefined;
+}>;
+export declare type Config = z.infer<typeof Config>;