@ninetailed/experience.js-utils 7.12.0 → 7.13.0-beta.0

package/index.cjs.js

@@ -11,24 +11,52 @@ const Audience = zod.z.object({
   description: zod.z.string().optional()
 });
 
+var ComponentTypeEnum;
+(function (ComponentTypeEnum) {
+  ComponentTypeEnum["EntryReplacement"] = "EntryReplacement";
+  ComponentTypeEnum["InlineVariable"] = "InlineVariable";
+})(ComponentTypeEnum || (ComponentTypeEnum = {}));
+var InlineVariableComponentValueTypeEnum;
+(function (InlineVariableComponentValueTypeEnum) {
+  InlineVariableComponentValueTypeEnum["String"] = "String";
+  InlineVariableComponentValueTypeEnum["Object"] = "Object";
+})(InlineVariableComponentValueTypeEnum || (InlineVariableComponentValueTypeEnum = {}));
+const entryReplacementVariantSchema = zod.z.object({
+  id: zod.z.string(),
+  hidden: zod.z.boolean().default(false)
+});
+const variableVariantSchema = zod.z.object({
+  value: zod.z.union([zod.z.string(), experience_jsShared.SerializableObject])
+});
+const EntryReplacementComponentSchema = zod.z.object({
+  type: zod.z.literal(ComponentTypeEnum.EntryReplacement).optional(),
+  baseline: entryReplacementVariantSchema,
+  variants: zod.z.array(entryReplacementVariantSchema)
+});
+function isEntryReplacementComponent(component) {
+  return component.type === ComponentTypeEnum.EntryReplacement || component.type === undefined;
+}
+const InlineVariableComponentSchema = zod.z.object({
+  type: zod.z.literal(ComponentTypeEnum.InlineVariable),
+  key: zod.z.string(),
+  valueType: zod.z.nativeEnum(InlineVariableComponentValueTypeEnum),
+  baseline: variableVariantSchema,
+  variants: zod.z.array(variableVariantSchema)
+});
+function isInlineVariableComponent(component) {
+  return component.type === ComponentTypeEnum.InlineVariable;
+}
+const ExperienceConfigComponentSchema = zod.z.discriminatedUnion('type', [EntryReplacementComponentSchema, InlineVariableComponentSchema]);
 const Config = zod.z.object({
   distribution: zod.z.array(zod.z.number()).optional().default([0.5, 0.5]),
   traffic: zod.z.number().optional().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)
-    }))
-  })).optional().default([{
+  components: zod.z.array(ExperienceConfigComponentSchema).optional().default([{
+    type: ComponentTypeEnum.EntryReplacement,
     baseline: {
       id: ''
     },
     variants: [{
-      id: '',
-      hidden: false
+      id: ''
     }]
   }]),
   sticky: zod.z.boolean().optional().default(false)
@@ -178,16 +206,27 @@ class ExperienceMapper {
         end: config.distribution.slice(0, index + 1).reduce((a, b) => a + b, 0)
       })),
       sticky,
-      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)
-      }))
+      components: components.map(component => {
+        if (isEntryReplacementComponent(component)) {
+          // Process EntryReplacement component
+          const processedVariants = 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);
+          return {
+            type: ComponentTypeEnum.EntryReplacement,
+            baseline: component.baseline,
+            variants: processedVariants
+          };
+        }
+        if (isInlineVariableComponent(component)) {
+          return component;
+        }
+        throw new Error(`Unsupported component type encountered`);
+      })
     });
   }
   static isExperimentEntry(experiment) {

package/index.esm.js

@@ -1,4 +1,4 @@
-import { logger } from '@ninetailed/experience.js-shared';
+import { SerializableObject, logger } from '@ninetailed/experience.js-shared';
 import { z } from 'zod';
 
 const Audience = z.object({
@@ -7,24 +7,53 @@ const Audience = z.object({
   description: z.string().optional()
 });
 
+let ComponentTypeEnum = /*#__PURE__*/function (ComponentTypeEnum) {
+  ComponentTypeEnum["EntryReplacement"] = "EntryReplacement";
+  ComponentTypeEnum["InlineVariable"] = "InlineVariable";
+  return ComponentTypeEnum;
+}({});
+let InlineVariableComponentValueTypeEnum = /*#__PURE__*/function (InlineVariableComponentValueTypeEnum) {
+  InlineVariableComponentValueTypeEnum["String"] = "String";
+  InlineVariableComponentValueTypeEnum["Object"] = "Object";
+  return InlineVariableComponentValueTypeEnum;
+}({});
+const entryReplacementVariantSchema = z.object({
+  id: z.string(),
+  hidden: z.boolean().default(false)
+});
+const variableVariantSchema = z.object({
+  value: z.union([z.string(), SerializableObject])
+});
+const EntryReplacementComponentSchema = z.object({
+  type: z.literal(ComponentTypeEnum.EntryReplacement).optional(),
+  // [components-migration] TODO: to become mandatory once migration is finalized
+  baseline: entryReplacementVariantSchema,
+  variants: z.array(entryReplacementVariantSchema)
+});
+function isEntryReplacementComponent(component) {
+  return component.type === ComponentTypeEnum.EntryReplacement || component.type === undefined;
+}
+const InlineVariableComponentSchema = z.object({
+  type: z.literal(ComponentTypeEnum.InlineVariable),
+  key: z.string(),
+  valueType: z.nativeEnum(InlineVariableComponentValueTypeEnum),
+  baseline: variableVariantSchema,
+  variants: z.array(variableVariantSchema)
+});
+function isInlineVariableComponent(component) {
+  return component.type === ComponentTypeEnum.InlineVariable;
+}
+const ExperienceConfigComponentSchema = z.discriminatedUnion('type', [EntryReplacementComponentSchema, InlineVariableComponentSchema]);
 const Config = z.object({
   distribution: z.array(z.number()).optional().default([0.5, 0.5]),
   traffic: z.number().optional().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)
-    }))
-  })).optional().default([{
+  components: z.array(ExperienceConfigComponentSchema).optional().default([{
+    type: ComponentTypeEnum.EntryReplacement,
     baseline: {
       id: ''
     },
     variants: [{
-      id: '',
-      hidden: false
+      id: ''
     }]
   }]),
   sticky: z.boolean().optional().default(false)
@@ -174,16 +203,27 @@ class ExperienceMapper {
         end: config.distribution.slice(0, index + 1).reduce((a, b) => a + b, 0)
       })),
       sticky,
-      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 : null;
-        }).filter(variant => variant !== null)
-      }))
+      components: components.map(component => {
+        if (isEntryReplacementComponent(component)) {
+          // Process EntryReplacement component
+          const processedVariants = component.variants.map(variantRef => {
+            if (variantRef.hidden) {
+              return variantRef;
+            }
+            const matchingVariant = variants.find(variant => variant.id === variantRef.id);
+            return matchingVariant != null ? matchingVariant : null;
+          }).filter(variant => variant !== null);
+          return {
+            type: ComponentTypeEnum.EntryReplacement,
+            baseline: component.baseline,
+            variants: processedVariants
+          };
+        }
+        if (isInlineVariableComponent(component)) {
+          return component;
+        }
+        throw new Error(`Unsupported component type encountered`);
+      })
     });
   }
   static isExperimentEntry(experiment) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ninetailed/experience.js-utils",
-  "version": "7.12.0",
+  "version": "7.13.0-beta.0",
   "description": "Ninetailed Experience.js Utils",
   "license": "MIT",
   "repository": {
@@ -9,8 +9,8 @@
     "directory": "packages/utils/javascript"
   },
   "dependencies": {
-    "@ninetailed/experience.js": "7.12.0",
-    "@ninetailed/experience.js-shared": "7.12.0",
+    "@ninetailed/experience.js": "7.13.0-beta.0",
+    "@ninetailed/experience.js-shared": "7.13.0-beta.0",
     "zod": "3.23.0"
   },
   "module": "./index.esm.js",

package/src/types/Config.d.ts

@@ -1,69 +1,333 @@
 import { Baseline, VariantRef } from '@ninetailed/experience.js';
+import { SerializableObject } from '@ninetailed/experience.js-shared';
 import { z } from 'zod';
+export declare enum ComponentTypeEnum {
+    EntryReplacement = "EntryReplacement",
+    InlineVariable = "InlineVariable"
+}
+export declare enum InlineVariableComponentValueTypeEnum {
+    String = "String",
+    Object = "Object"
+}
+export declare const entryReplacementVariantSchema: z.ZodObject<{
+    id: z.ZodString;
+    hidden: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    hidden: boolean;
+}, {
+    id: string;
+    hidden?: boolean | undefined;
+}>;
+export declare const variableVariantSchema: z.ZodObject<{
+    value: z.ZodUnion<[z.ZodString, z.ZodType<SerializableObject, z.ZodTypeDef, unknown>]>;
+}, "strip", z.ZodTypeAny, {
+    value: string | SerializableObject;
+}, {
+    value?: unknown;
+}>;
+export declare const EntryReplacementComponentSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<ComponentTypeEnum.EntryReplacement>>;
+    baseline: z.ZodObject<{
+        id: z.ZodString;
+        hidden: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        hidden: boolean;
+    }, {
+        id: string;
+        hidden?: boolean | undefined;
+    }>;
+    variants: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        hidden: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        hidden: boolean;
+    }, {
+        id: string;
+        hidden?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    baseline: {
+        id: string;
+        hidden: boolean;
+    };
+    variants: {
+        id: string;
+        hidden: boolean;
+    }[];
+    type?: ComponentTypeEnum.EntryReplacement | undefined;
+}, {
+    baseline: {
+        id: string;
+        hidden?: boolean | undefined;
+    };
+    variants: {
+        id: string;
+        hidden?: boolean | undefined;
+    }[];
+    type?: ComponentTypeEnum.EntryReplacement | undefined;
+}>;
+export type EntryReplacementComponent = z.infer<typeof EntryReplacementComponentSchema>;
+export type TExperienceConfigComponentSchema = z.infer<typeof ExperienceConfigComponentSchema>;
+export declare function isEntryReplacementComponent(component: TExperienceConfigComponentSchema): component is EntryReplacementComponent;
+export declare const InlineVariableComponentSchema: z.ZodObject<{
+    type: z.ZodLiteral<ComponentTypeEnum.InlineVariable>;
+    key: z.ZodString;
+    valueType: z.ZodNativeEnum<typeof InlineVariableComponentValueTypeEnum>;
+    baseline: z.ZodObject<{
+        value: z.ZodUnion<[z.ZodString, z.ZodType<SerializableObject, z.ZodTypeDef, unknown>]>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | SerializableObject;
+    }, {
+        value?: unknown;
+    }>;
+    variants: z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<[z.ZodString, z.ZodType<SerializableObject, z.ZodTypeDef, unknown>]>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | SerializableObject;
+    }, {
+        value?: unknown;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: ComponentTypeEnum.InlineVariable;
+    baseline: {
+        value: string | SerializableObject;
+    };
+    variants: {
+        value: string | SerializableObject;
+    }[];
+    key: string;
+    valueType: InlineVariableComponentValueTypeEnum;
+}, {
+    type: ComponentTypeEnum.InlineVariable;
+    baseline: {
+        value?: unknown;
+    };
+    variants: {
+        value?: unknown;
+    }[];
+    key: string;
+    valueType: InlineVariableComponentValueTypeEnum;
+}>;
+export type InlineVariableComponent = z.infer<typeof InlineVariableComponentSchema>;
+export declare function isInlineVariableComponent(component: TExperienceConfigComponentSchema): component is InlineVariableComponent;
+export declare const ExperienceConfigComponentSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<ComponentTypeEnum.EntryReplacement>>;
+    baseline: z.ZodObject<{
+        id: z.ZodString;
+        hidden: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        hidden: boolean;
+    }, {
+        id: string;
+        hidden?: boolean | undefined;
+    }>;
+    variants: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        hidden: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        hidden: boolean;
+    }, {
+        id: string;
+        hidden?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    baseline: {
+        id: string;
+        hidden: boolean;
+    };
+    variants: {
+        id: string;
+        hidden: boolean;
+    }[];
+    type?: ComponentTypeEnum.EntryReplacement | undefined;
+}, {
+    baseline: {
+        id: string;
+        hidden?: boolean | undefined;
+    };
+    variants: {
+        id: string;
+        hidden?: boolean | undefined;
+    }[];
+    type?: ComponentTypeEnum.EntryReplacement | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ComponentTypeEnum.InlineVariable>;
+    key: z.ZodString;
+    valueType: z.ZodNativeEnum<typeof InlineVariableComponentValueTypeEnum>;
+    baseline: z.ZodObject<{
+        value: z.ZodUnion<[z.ZodString, z.ZodType<SerializableObject, z.ZodTypeDef, unknown>]>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | SerializableObject;
+    }, {
+        value?: unknown;
+    }>;
+    variants: z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<[z.ZodString, z.ZodType<SerializableObject, z.ZodTypeDef, unknown>]>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | SerializableObject;
+    }, {
+        value?: unknown;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: ComponentTypeEnum.InlineVariable;
+    baseline: {
+        value: string | SerializableObject;
+    };
+    variants: {
+        value: string | SerializableObject;
+    }[];
+    key: string;
+    valueType: InlineVariableComponentValueTypeEnum;
+}, {
+    type: ComponentTypeEnum.InlineVariable;
+    baseline: {
+        value?: unknown;
+    };
+    variants: {
+        value?: unknown;
+    }[];
+    key: string;
+    valueType: InlineVariableComponentValueTypeEnum;
+}>]>;
 export declare const Config: z.ZodObject<{
     distribution: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
     traffic: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    components: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    components: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodOptional<z.ZodLiteral<ComponentTypeEnum.EntryReplacement>>;
         baseline: z.ZodObject<{
-            id: z.ZodDefault<z.ZodString>;
+            id: z.ZodString;
+            hidden: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             id: string;
+            hidden: boolean;
         }, {
-            id?: string | undefined;
+            id: string;
+            hidden?: boolean | undefined;
         }>;
         variants: z.ZodArray<z.ZodObject<{
-            id: z.ZodDefault<z.ZodString>;
+            id: z.ZodString;
             hidden: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             id: string;
             hidden: boolean;
         }, {
-            id?: string | undefined;
+            id: string;
             hidden?: boolean | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         baseline: {
             id: string;
+            hidden: boolean;
         };
         variants: {
             id: string;
             hidden: boolean;
         }[];
+        type?: ComponentTypeEnum.EntryReplacement | undefined;
     }, {
         baseline: {
-            id?: string | undefined;
+            id: string;
+            hidden?: boolean | undefined;
         };
         variants: {
-            id?: string | undefined;
+            id: string;
             hidden?: boolean | undefined;
         }[];
-    }>, "many">>>;
+        type?: ComponentTypeEnum.EntryReplacement | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<ComponentTypeEnum.InlineVariable>;
+        key: z.ZodString;
+        valueType: z.ZodNativeEnum<typeof InlineVariableComponentValueTypeEnum>;
+        baseline: z.ZodObject<{
+            value: z.ZodUnion<[z.ZodString, z.ZodType<SerializableObject, z.ZodTypeDef, unknown>]>;
+        }, "strip", z.ZodTypeAny, {
+            value: string | SerializableObject;
+        }, {
+            value?: unknown;
+        }>;
+        variants: z.ZodArray<z.ZodObject<{
+            value: z.ZodUnion<[z.ZodString, z.ZodType<SerializableObject, z.ZodTypeDef, unknown>]>;
+        }, "strip", z.ZodTypeAny, {
+            value: string | SerializableObject;
+        }, {
+            value?: unknown;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: ComponentTypeEnum.InlineVariable;
+        baseline: {
+            value: string | SerializableObject;
+        };
+        variants: {
+            value: string | SerializableObject;
+        }[];
+        key: string;
+        valueType: InlineVariableComponentValueTypeEnum;
+    }, {
+        type: ComponentTypeEnum.InlineVariable;
+        baseline: {
+            value?: unknown;
+        };
+        variants: {
+            value?: unknown;
+        }[];
+        key: string;
+        valueType: InlineVariableComponentValueTypeEnum;
+    }>]>, "many">>>;
     sticky: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     distribution: number[];
     traffic: number;
-    components: {
+    components: ({
         baseline: {
             id: string;
+            hidden: boolean;
         };
         variants: {
             id: string;
             hidden: boolean;
         }[];
-    }[];
+        type?: ComponentTypeEnum.EntryReplacement | undefined;
+    } | {
+        type: ComponentTypeEnum.InlineVariable;
+        baseline: {
+            value: string | SerializableObject;
+        };
+        variants: {
+            value: string | SerializableObject;
+        }[];
+        key: string;
+        valueType: InlineVariableComponentValueTypeEnum;
+    })[];
     sticky: boolean;
 }, {
     distribution?: number[] | undefined;
     traffic?: number | undefined;
-    components?: {
+    components?: ({
         baseline: {
-            id?: string | undefined;
+            id: string;
+            hidden?: boolean | undefined;
         };
         variants: {
-            id?: string | undefined;
+            id: string;
             hidden?: boolean | undefined;
         }[];
-    }[] | undefined;
+        type?: ComponentTypeEnum.EntryReplacement | undefined;
+    } | {
+        type: ComponentTypeEnum.InlineVariable;
+        baseline: {
+            value?: unknown;
+        };
+        variants: {
+            value?: unknown;
+        }[];
+        key: string;
+        valueType: InlineVariableComponentValueTypeEnum;
+    })[] | undefined;
     sticky?: boolean | undefined;
 }>;
 export type ConfigLike = z.input<typeof Config>;