@ninetailed/experience.js-utils 2.2.8 → 3.0.1-beta.3

package/index.esm.js

@@ -1,4 +1,4 @@
-import { logger } from '@ninetailed/experience.js';
+import { logger } from '@ninetailed/experience.js-shared';
 import { z } from 'zod';
 
 const Audience = z.object({
@@ -31,6 +31,37 @@ const Variant = z.object({
   id: z.string()
 }).passthrough();
 
+/**
+ * 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 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({
   id: z.string(),
 
@@ -57,7 +88,7 @@ const Experience = z.object({
   /**
    * All used variants of the experience (References to other Content Types)
    */
-  variants: z.array(Variant).default([])
+  variants: zodArrayIgnoreUnknown(Variant).default([])
 });
 
 const Experiment = Experience.extend({

package/index.umd.js

@@ -1,8 +1,8 @@
 (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';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@ninetailed/experience.js-shared'), require('zod')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@ninetailed/experience.js-shared', 'zod'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UtilsJavascript = {}, global.experience_jsShared, global.zod));
+})(this, (function (exports, experience_jsShared, zod) { 'use strict';
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -60,6 +60,41 @@
       id: zod.z.string()
     }).passthrough();
 
+    /**
+     * 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) {
+      var isKnownItem = function (item) {
+        return zodType.safeParse(item).success;
+      };
+
+      return zod.z.preprocess(function (val) {
+        return 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);
+    }
+
     var Experience = zod.z.object({
       id: zod.z.string(),
 
@@ -86,7 +121,7 @@
       /**
        * All used variants of the experience (References to other Content Types)
        */
-      variants: zod.z.array(Variant).default([])
+      variants: zodArrayIgnoreUnknown(Variant).default([])
     });
 
     var Experiment = Experience.extend({
@@ -106,7 +141,7 @@
         var parsedExperience = Experience.safeParse(experience);
 
         if (!parsedExperience.success) {
-          experience_js.logger.warn('[Ninetailed ExperienceMapper]', 'Error parsing experience', parsedExperience.error.format());
+          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".concat(JSON.stringify(parsedExperience.error.format(), null, 2)));
         }
 

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@ninetailed/experience.js-utils",
-  "version": "2.2.8",
+  "version": "3.0.1-beta.3",
   "main": "./index.umd.js",
   "module": "./index.esm.js",
   "typings": "./index.d.ts",
   "dependencies": {
-    "@ninetailed/experience.js": "2.2.8",
-    "analytics": "^0.8.0",
-    "@ninetailed/experience.js-shared": "2.2.8",
-    "uuid": "^8.3.2",
+    "@ninetailed/experience.js": "3.0.1-beta.3",
+    "@ninetailed/experience.js-shared": "3.0.1-beta.3",
     "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",
-    "diary": "^0.3.1",
-    "zod": "^3.18.0"
+    "murmurhash-js": "^1.0.0"
   },
   "peerDependencies": {}
 }

package/types/Experience.d.ts

@@ -22,9 +22,7 @@ export declare const Experience: z.ZodObject<{
                 id: string;
             }, {
                 id?: string | undefined;
-            }>; /**
-             * The type if the experience (nt_experiment | nt_personalization)
-             */
+            }>;
             variants: z.ZodArray<z.ZodObject<{
                 id: z.ZodDefault<z.ZodString>;
                 hidden: z.ZodDefault<z.ZodBoolean>;
@@ -34,9 +32,7 @@ export declare const Experience: z.ZodObject<{
             }, {
                 id?: string | undefined;
                 hidden?: boolean | undefined;
-            }>, "many">; /**
-             * The config of the experience (JSON)
-             */
+            }>, "many">;
         }, "strip", z.ZodTypeAny, {
             baseline: {
                 id: string;
@@ -92,13 +88,17 @@ export declare const Experience: z.ZodObject<{
     /**
      * All used variants of the experience (References to other Content Types)
      */
-    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    variants: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
     }, "passthrough", z.ZodTypeAny, {
         id: string;
     }, {
         id: string;
-    }>, "many">>;
+    }>, "many">, {
+        id: string;
+    }[], {
+        id: string;
+    }[]>>;
 }, "strip", z.ZodTypeAny, {
     audience?: {
         id: string;

package/types/Experiment.d.ts

@@ -73,13 +73,17 @@ export declare const Experiment: z.ZodObject<z.extendShape<{
     }, {
         id: string;
     }>>>;
-    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    variants: z.ZodDefault<z.ZodEffects<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
     }, "passthrough", z.ZodTypeAny, {
         id: string;
     }, {
         id: string;
-    }>, "many">>;
+    }>, "many">, {
+        id: string;
+    }[], {
+        id: string;
+    }[]>>;
 }, {
     type: z.ZodLiteral<"nt_experiment">;
 }>, "strip", z.ZodTypeAny, {

package/types/zodArrayIgnoreUnknown.d.ts

@@ -0,0 +1,14 @@
+import { z, ZodTypeAny } from 'zod';
+/**
+ * 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']
+ */
+export declare function zodArrayIgnoreUnknown<T extends ZodTypeAny>(zodType: T): z.ZodEffects<z.ZodArray<T, "many">, T["_output"][], T["_input"][]>;