@sanity/personalization-plugin 2.5.0-field-level-personalization.1 → 2.5.0

package/dist/index.mjs

@@ -1,82 +1,105 @@
-import { clearChildrenGroups, CloseIcon, flattenSchemaType, ArrayItem } from "./_chunks-es/fieldExperiments.mjs";
-import { fieldLevelExperiments } from "./_chunks-es/fieldExperiments.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { useClient, useWorkspace, defineDocumentFieldAction, set, unset, useFormValue, isReference, isImage, definePlugin, isObjectInputProps, defineType, defineField } from "sanity";
-import { Stack, Inline, Button } from "@sanity/ui";
+import { useClient, useWorkspace, useFormValue, defineDocumentFieldAction, set, unset, useDocumentOperation, getPublishedId, isReference, isImage, isDocumentSchemaType, definePlugin, isObjectInputProps, defineType, defineField } from "sanity";
+import { Stack, Inline, Button, Select as Select$1, Card, Text } from "@sanity/ui";
 import { uuid } from "@sanity/uuid";
-import { createContext, useMemo, useContext, useCallback, useState, useEffect } from "react";
+import { createContext, useMemo, useContext, useCallback, forwardRef, useState, useEffect } from "react";
 import equal from "fast-deep-equal";
 import { suspend } from "suspend-react";
-import { IoMdPeople } from "react-icons/io";
+import { GiSoapExperiment } from "react-icons/gi";
 const CONFIG_DEFAULT = {
   fields: [],
   apiVersion: "2024-11-07",
-  personalizationNameOverride: "personalization",
-  segmentNameOverride: "segment",
-  segmentId: "segmentId",
-  segmentArrayName: "segments"
-}, PersonalizationContext = createContext({
+  experimentNameOverride: "experiment",
+  variantNameOverride: "variant",
+  variantId: "variantId",
+  variantArrayName: "variants",
+  experimentId: "experimentId"
+}, ExperimentContext = createContext({
   ...CONFIG_DEFAULT,
-  segments: []
+  experiments: []
 });
-function usePersonalizationContext() {
-  return useContext(PersonalizationContext);
+function useExperimentContext() {
+  return useContext(ExperimentContext);
 }
-function PersonalizationProvider(props) {
-  const { personalizationFieldPluginConfig } = props, client = useClient({ apiVersion: personalizationFieldPluginConfig.apiVersion }), workspace = useWorkspace(), segments = Array.isArray(personalizationFieldPluginConfig.segments) ? personalizationFieldPluginConfig.segments : suspend(
+function ExperimentProvider(props) {
+  const { experimentFieldPluginConfig } = props, client = useClient({ apiVersion: experimentFieldPluginConfig.apiVersion }), workspace = useWorkspace(), experiments = Array.isArray(experimentFieldPluginConfig.experiments) ? experimentFieldPluginConfig.experiments : suspend(
     // eslint-disable-next-line require-await
-    async () => typeof personalizationFieldPluginConfig.segments == "function" ? personalizationFieldPluginConfig.segments(client) : personalizationFieldPluginConfig.segments,
+    async () => typeof experimentFieldPluginConfig.experiments == "function" ? experimentFieldPluginConfig.experiments(client) : experimentFieldPluginConfig.experiments,
     [workspace],
     { equal }
   ), context = useMemo(
-    () => ({ ...personalizationFieldPluginConfig, segments }),
-    [personalizationFieldPluginConfig, segments]
+    () => ({ ...experimentFieldPluginConfig, experiments }),
+    [experimentFieldPluginConfig, experiments]
   );
-  return /* @__PURE__ */ jsx(PersonalizationContext.Provider, { value: context, children: props.renderDefault(props) });
+  return /* @__PURE__ */ jsx(ExperimentContext.Provider, { value: context, children: props.renderDefault(props) });
 }
 const ArrayInput = (props) => {
-  const { onItemAppend, segmentName, segmentId } = props, { segments } = usePersonalizationContext(), handleClick = useCallback(
-    async (segment) => {
+  const fieldPath = props.path.slice(0, -1), { onItemAppend, variantName, variantId, experimentId } = props, experimentValue = useFormValue([...fieldPath, experimentId]), { experiments } = useExperimentContext(), handleClick = useCallback(
+    async (variant) => {
       const item = {
         _key: uuid(),
-        [segmentId]: segment.id,
-        _type: segmentName
+        [variantId]: variant.id,
+        [experimentId]: experimentValue,
+        _type: variantName
       };
       onItemAppend(item);
     },
-    [segmentId, segmentName, onItemAppend]
-  ), usedSegments = (props.value || [])?.map((segment) => segment[segmentId]);
+    [variantId, experimentId, experimentValue, variantName, onItemAppend]
+  ), filteredVariants = experiments.find((option) => option.id === experimentValue)?.variants || [], usedVariants = (props.value || [])?.map((variant) => variant[variantId]);
   return /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
     props.renderDefault({ ...props, arrayFunctions: () => null }),
-    /* @__PURE__ */ jsx(Inline, { space: 1, children: segments.map((segment) => /* @__PURE__ */ jsx(
+    /* @__PURE__ */ jsx(Inline, { space: 1, children: filteredVariants.map((variant) => /* @__PURE__ */ jsx(
       Button,
       {
-        text: `Add ${segment.label}`,
+        text: `Add ${variant.label}`,
         mode: "ghost",
-        disabled: usedSegments?.includes(segment.id),
-        onClick: () => handleClick(segment)
+        disabled: usedVariants?.includes(variant.id),
+        onClick: () => handleClick(variant)
       },
-      `${segment.id}`
+      `${experimentValue}-${variant.id}`
     )) })
   ] });
-}, useAddExperimentAction = (props) => {
-  const { onChange, active, personalizationNameOverride } = props, handleAddAction = useCallback(() => {
+}, CloseIcon = /* @__PURE__ */ forwardRef(function(props, ref) {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      "data-sanity-icon": "close",
+      width: "1em",
+      height: "1em",
+      viewBox: "0 0 25 25",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      ref,
+      children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M18 7L7 18M7 7L18 18",
+          stroke: "currentColor",
+          strokeWidth: 1.2,
+          strokeLinejoin: "round"
+        }
+      )
+    }
+  );
+}), useAddExperimentAction = (props) => {
+  const { onChange, active, experimentNameOverride } = props, handleAddAction = useCallback(() => {
     onChange([set(!active, ["active"])]);
   }, [onChange, active]);
   return {
-    title: `Add ${personalizationNameOverride}`,
+    title: `Add ${experimentNameOverride}`,
     type: "action",
-    icon: IoMdPeople,
+    icon: GiSoapExperiment,
     onAction: handleAddAction,
     renderAsButton: !0
   };
 }, useRemoveExperimentAction = (props) => {
-  const { onChange, active, personalizationNameOverride, segmentNameOverride } = props, handleClearAction = useCallback(() => {
-    const activeId = ["active"], segments = [`${segmentNameOverride}s`];
-    onChange([set(!active, activeId), unset(segments)]);
-  }, [onChange, active, segmentNameOverride]);
+  const { onChange, active, experimentId, experimentNameOverride, variantNameOverride } = props, handleClearAction = useCallback(() => {
+    const activeId = ["active"], experiment = [experimentId], variants = [`${variantNameOverride}s`];
+    onChange([set(!active, activeId), unset(experiment), unset(variants)]);
+  }, [onChange, active, experimentId, variantNameOverride]);
   return {
-    title: `Remove ${personalizationNameOverride}`,
+    title: `Remove ${experimentNameOverride}`,
     type: "action",
     icon: CloseIcon,
     onAction: handleClearAction,
@@ -86,57 +109,115 @@ const ArrayInput = (props) => {
   onChange,
   inputId,
   active,
-  personalizationNameOverride,
-  segmentNameOverride
+  experimentNameOverride,
+  experimentId,
+  variantNameOverride
 }) => {
   const removeAction = defineDocumentFieldAction({
-    name: `Remove ${personalizationNameOverride}`,
+    name: `Remove ${experimentNameOverride}`,
     useAction: (props) => useRemoveExperimentAction({
       active: !0,
       onChange,
-      personalizationNameOverride,
-      segmentNameOverride
+      experimentNameOverride,
+      experimentId,
+      variantNameOverride
     })
   }), addAction = defineDocumentFieldAction({
-    name: `Add ${personalizationNameOverride}`,
+    name: `Add ${experimentNameOverride}`,
     useAction: (props) => useAddExperimentAction({
       active: !1,
       onChange,
-      personalizationNameOverride
+      experimentNameOverride
     })
   });
   return active ? removeAction : addAction;
-}, Field = (props) => {
-  const { onChange } = props.inputProps, { inputId, personalizationNameOverride, segmentNameOverride } = props, active = props.value?.active, actionProps = useMemo(
+}, ExperimentField = (props) => {
+  const { onChange } = props.inputProps, { inputId, experimentNameOverride, experimentId, variantNameOverride } = props, active = props.value?.active, actionProps = useMemo(
     () => ({
       onChange,
       inputId,
       active,
-      personalizationNameOverride,
-      segmentNameOverride
+      experimentNameOverride,
+      experimentId,
+      variantNameOverride
     }),
-    [onChange, inputId, active, personalizationNameOverride, segmentNameOverride]
+    [onChange, inputId, active, experimentNameOverride, experimentId, variantNameOverride]
   ), memoizedActions = useMemo(() => {
     const oldActions = props.actions || [];
     return [createActions(actionProps), ...oldActions];
-  }, [actionProps, props.actions]), enhancedProps = useMemo(() => ({
-    ...clearChildrenGroups(props),
-    actions: memoizedActions
-  }), [props, memoizedActions]);
-  return props.renderDefault(enhancedProps);
-}, SegmentInput = (props) => {
-  const personalizationPath = props.path.slice(0, -2), defaultValue = useFormValue([...personalizationPath, "default"]), handleClick = () => {
+  }, [actionProps, props.actions]), withActionProps = useMemo(
+    () => ({
+      ...props,
+      actions: memoizedActions
+    }),
+    [props, memoizedActions]
+  );
+  return props.renderDefault(withActionProps);
+}, Select = (props) => {
+  const {
+    value,
+    // Current field value
+    onChange,
+    // Method to handle patch events,
+    elementProps,
+    listOptions,
+    handleChange
+  } = props;
+  return /* @__PURE__ */ jsxs(
+    Select$1,
+    {
+      ...elementProps,
+      fontSize: 2,
+      padding: 3,
+      space: [3, 3, 4],
+      value: value || "",
+      onChange: (event) => handleChange(event, onChange),
+      children: [
+        /* @__PURE__ */ jsx("option", { value: "", children: "Select an option..." }),
+        listOptions.map(({ value: optionValue, title }) => /* @__PURE__ */ jsx("option", { value: optionValue, children: title }, optionValue))
+      ]
+    }
+  );
+}, formatlistOptions = (experiments) => experiments.map((experiment) => ({
+  title: experiment.label,
+  value: experiment.id
+})), ExperimentInput = (props) => {
+  const { experiments } = useExperimentContext(), id = useFormValue(["_id"]), additionalChangePath = useMemo(
+    () => [...props.path.slice(0, -1), `${props.variantNameOverride}s`],
+    [props.variantNameOverride, props.path]
+  ), subValues = useFormValue(additionalChangePath), { patch } = useDocumentOperation(getPublishedId(id), props.schemaType.name), handleChange = useCallback(
+    (event, onChange) => {
+      const inputValue = event.currentTarget.value;
+      if (onChange(inputValue ? set(inputValue) : unset()), subValues) {
+        const patchEvent = {
+          unset: [additionalChangePath.join(".")]
+        };
+        patch.execute([patchEvent]);
+      }
+    },
+    [patch, subValues, additionalChangePath]
+  );
+  return experiments.length ? /* @__PURE__ */ jsx(Select, { ...props, listOptions: formatlistOptions(experiments), handleChange }) : /* @__PURE__ */ jsx(Card, { padding: [3, 3, 4], radius: 2, shadow: 1, tone: "caution", children: /* @__PURE__ */ jsxs(Text, { align: "center", size: [2, 2, 3], children: [
+    "There are no defined ",
+    props.experimentNameOverride,
+    "s"
+  ] }) });
+}, ExperimentItem = (props) => {
+  const { active } = props.value;
+  return active || props.inputProps.onChange(set(!0, ["active"])), props.renderDefault(props);
+}, VariantInput = (props) => {
+  const experimentPath = props.path.slice(0, -2), defaultValue = useFormValue([...experimentPath, "default"]), handleClick = () => {
     props.onChange(set(defaultValue, ["value"]));
   };
   return /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
     props.renderDefault(props),
     /* @__PURE__ */ jsx(Inline, { space: 1, children: /* @__PURE__ */ jsx(Button, { text: "Copy default", mode: "ghost", onClick: () => handleClick() }) })
   ] });
-}, SegmentPreview = (props) => {
-  const [subtitle, setSubtitle] = useState(void 0), [title, setTitle] = useState(void 0), [media, setMedia] = useState(void 0), client = useClient({ apiVersion: "2025-01-01" }), { segments } = usePersonalizationContext(), { segment, value } = props, selectedSegment = segments.find((segmentItem) => segmentItem.id === segment);
+}, VariantPreview = (props) => {
+  const [subtitle, setSubtitle] = useState(void 0), [title, setTitle] = useState(void 0), [media, setMedia] = useState(void 0), client = useClient({ apiVersion: "2025-01-01" }), { experiments } = useExperimentContext(), { experiment, variant, value } = props, selectedExperiment = experiments.find((experimentItem) => experimentItem.id === experiment), selectedVariant = selectedExperiment?.variants.find((variantItem) => variantItem.id === variant);
   useEffect(() => {
     (async () => {
-      if (setTitle(`${selectedSegment?.label}`), typeof value == "string")
+      if (setTitle(`${selectedExperiment?.label} - ${selectedVariant?.label}`), typeof value == "string")
         return setSubtitle(value);
       if (isReference(value)) {
         const doc = await client.getDocument(value._ref), referenceType = (props.schemaType.fields.find((field) => field.name === "value")?.type).to.find((field) => field.type?.name === doc?._type), selectFields = {}, previewFields = referenceType?.preview?.select || {};
@@ -149,7 +230,7 @@ const ArrayInput = (props) => {
       }
       return isImage(value) && setMedia(value), "";
     })();
-  }, [value, client, selectedSegment?.label, props.schemaType]);
+  }, [value, client, selectedExperiment?.label, selectedVariant?.label, props.schemaType]);
   const previewProps = {
     ...props,
     title,
@@ -157,59 +238,65 @@ const ArrayInput = (props) => {
     media
   };
   return props.renderDefault(previewProps);
-}, createPersonalizationType = ({
+};
+function flattenSchemaType(schemaType) {
+  return isDocumentSchemaType(schemaType) ? extractInnerFields(schemaType.fields, [], 5) : (console.error("Schema type is not a document"), []);
+}
+function extractInnerFields(fields, path, maxDepth) {
+  return path.length >= maxDepth ? [] : fields.reduce((acc, field) => {
+    const thisFieldWithPath = { path: [...path, field.name], ...field };
+    if (field.type.jsonType === "object") {
+      const innerFields = extractInnerFields(field.type.fields, [...path, field.name], maxDepth);
+      return [...acc, thisFieldWithPath, ...innerFields];
+    } else if (field.type.jsonType === "array") {
+      const innerFields = (field.type.of || []).reduce((arrayAcc, arrayType) => {
+        if ("fields" in arrayType) {
+          const typeFields = extractInnerFields(arrayType.fields, [...path, field.name], maxDepth);
+          return [...arrayAcc, ...typeFields];
+        }
+        return arrayAcc;
+      }, []);
+      return [...acc, thisFieldWithPath, ...innerFields];
+    }
+    return [...acc, thisFieldWithPath];
+  }, []);
+}
+const createExperimentType = ({
   field,
-  personalizationNameOverride,
-  segmentNameOverride,
-  segmentId,
-  segmentArrayName
+  experimentNameOverride,
+  variantNameOverride,
+  variantId,
+  variantArrayName,
+  experimentId
 }) => {
-  const typeName = typeof field == "string" ? field : field.name, usedName = String(typeName[0]).toUpperCase() + String(typeName).slice(1), segmentName = `${segmentNameOverride}${usedName}`;
+  const typeName = typeof field == "string" ? field : field.name, usedName = String(typeName[0]).toUpperCase() + String(typeName).slice(1), variantName = `${variantNameOverride}${usedName}`;
   return defineType({
-    name: `${personalizationNameOverride}${usedName}`,
+    name: `${experimentNameOverride}${usedName}`,
     type: "object",
-    groups: [
-      {
-        name: "default",
-        title: "Default",
-        hidden: ({ parent }) => !Array.isArray(parent)
-      },
-      {
-        name: "personalization",
-        title: "Personalization options",
-        hidden: ({ parent }) => !Array.isArray(parent)
-      },
-      {
-        name: "all-fields",
-        title: "All fields",
-        hidden: ({ parent }) => Array.isArray(parent)
-      }
-    ],
     components: {
       field: (props) => /* @__PURE__ */ jsx(
-        Field,
+        ExperimentField,
         {
           ...props,
-          personalizationNameOverride,
-          segmentNameOverride
+          experimentId,
+          experimentNameOverride,
+          variantNameOverride
         }
       ),
-      item: ArrayItem
+      item: ExperimentItem
     },
     fields: [
       typeof field == "string" ? (
         // Define a simple field if all we have is the name as a string
         defineField({
           name: "default",
-          type: field,
-          group: "default"
+          type: field
         })
       ) : (
         // Pass in the configured options, but overwrite the name
         {
           ...field,
-          name: "default",
-          group: "default"
+          name: "default"
         }
       ),
       defineField({
@@ -219,54 +306,84 @@ const ArrayInput = (props) => {
         initialValue: !1
       }),
       defineField({
-        name: segmentArrayName,
+        name: experimentId,
+        type: "string",
+        components: {
+          input: (props) => /* @__PURE__ */ jsx(
+            ExperimentInput,
+            {
+              ...props,
+              experimentNameOverride,
+              variantNameOverride
+            }
+          )
+        },
+        hidden: ({ parent }) => !parent?.active
+      }),
+      defineField({
+        name: variantArrayName,
         type: "array",
-        hidden: ({ parent }) => !parent?.active,
-        group: "personalization",
+        hidden: ({ parent }) => !parent?.[experimentId],
         components: {
-          input: (props) => /* @__PURE__ */ jsx(ArrayInput, { ...props, segmentName, segmentId })
+          input: (props) => /* @__PURE__ */ jsx(
+            ArrayInput,
+            {
+              ...props,
+              variantName,
+              variantId,
+              experimentId
+            }
+          )
         },
         of: [
           defineField({
-            name: segmentName,
-            type: segmentName
+            name: variantName,
+            type: variantName
           })
         ]
       })
     ],
     preview: {
       select: {
-        base: "default"
+        base: "default",
+        experiment: experimentId
       },
-      prepare: ({ base }) => {
-        const title = base?.title || base?.name || typeof base == "string" ? base : "", media = base?.image || base?.photo || base?.media || "";
+      prepare: ({ base, experiment }) => {
+        const title = base?.title || base?.name || typeof base == "string" ? base : "", experimentTitle = experiment ? `Experiment: ${experiment}` : "", media = base?.image || base?.photo || base?.media || "";
         return {
-          title,
+          title: title || experimentTitle,
+          subtitle: title ? experimentTitle : "",
           media
         };
       }
     }
   });
-}, createSegmentType = ({
+}, createVariantType = ({
   field,
-  segmentNameOverride,
-  segmentId
+  variantNameOverride,
+  variantId,
+  experimentId
 }) => {
   const typeName = typeof field == "string" ? field : field.name, usedName = String(typeName[0]).toUpperCase() + String(typeName).slice(1);
   return defineType({
-    name: `${segmentNameOverride}${usedName}`,
-    title: `${segmentNameOverride} array ${usedName}`,
+    name: `${variantNameOverride}${usedName}`,
+    title: `${variantNameOverride} array ${usedName}`,
     type: "object",
     components: {
-      preview: SegmentPreview,
-      input: SegmentInput
+      preview: VariantPreview,
+      input: VariantInput
     },
     fields: [
       {
         type: "string",
-        name: segmentId,
+        name: variantId,
         readOnly: !0
       },
+      {
+        type: "string",
+        name: experimentId,
+        hidden: !0
+      },
       typeof field == "string" ? (
         // Define a simple field if all we have is the name as a string
         defineField({
@@ -285,67 +402,71 @@ const ArrayInput = (props) => {
     ],
     preview: {
       select: {
-        segment: segmentId,
+        variant: variantId,
+        experiment: experimentId,
         value: "value"
       }
     }
   });
 }, fieldSchema = ({
   fields,
-  personalizationNameOverride,
-  segmentNameOverride,
-  segmentId,
-  segmentArrayName
+  experimentNameOverride,
+  variantNameOverride,
+  variantId,
+  variantArrayName,
+  experimentId
 }) => [
-  ...fields.map((field) => createSegmentType({ field, segmentNameOverride, segmentId })),
   ...fields.map(
-    (field) => createPersonalizationType({
+    (field) => createVariantType({ field, variantNameOverride, variantId, experimentId })
+  ),
+  ...fields.map(
+    (field) => createExperimentType({
       field,
-      personalizationNameOverride,
-      segmentNameOverride,
-      segmentId,
-      segmentArrayName
+      experimentNameOverride,
+      variantNameOverride,
+      variantId,
+      variantArrayName,
+      experimentId
     })
   )
-], fieldLevelPersonalization = definePlugin(
-  (config) => {
-    const pluginConfig = { ...CONFIG_DEFAULT, ...config }, { fields, personalizationNameOverride, segmentNameOverride } = pluginConfig, segmentArrayName = `${segmentNameOverride}s`, segmentId = `${segmentNameOverride}Id`;
-    return {
-      name: "sanity-personalistaion-plugin-field-level-personalization",
-      schema: {
-        types: fieldSchema({
-          fields,
-          personalizationNameOverride,
-          segmentNameOverride,
-          segmentId,
-          segmentArrayName
-        })
-      },
-      form: {
-        components: {
-          input: (props) => {
-            if (!(props.id === "root" && isObjectInputProps(props)) || !flattenSchemaType(props.schemaType).some(
-              (field) => field.type.name.startsWith(personalizationNameOverride) || field.name.startsWith(personalizationNameOverride)
-            ))
-              return props.renderDefault(props);
-            const providerProps = {
-              ...props,
-              personalizationFieldPluginConfig: {
-                ...pluginConfig,
-                segmentId,
-                segmentArrayName
-              }
-            };
-            return PersonalizationProvider(providerProps);
-          }
+], fieldLevelExperiments = definePlugin((config) => {
+  const pluginConfig = { ...CONFIG_DEFAULT, ...config }, { fields, experimentNameOverride, variantNameOverride } = pluginConfig, experimentId = `${experimentNameOverride}Id`, variantArrayName = `${variantNameOverride}s`, variantId = `${variantNameOverride}Id`;
+  return {
+    name: "sanity-personalistaion-plugin-field-level-experiments",
+    schema: {
+      types: fieldSchema({
+        fields,
+        experimentNameOverride,
+        variantNameOverride,
+        variantId,
+        variantArrayName,
+        experimentId
+      })
+    },
+    form: {
+      components: {
+        input: (props) => {
+          if (!(props.id === "root" && isObjectInputProps(props)) || !flattenSchemaType(props.schemaType).some(
+            (field) => field.type.name.startsWith(experimentNameOverride) || field.name.startsWith(experimentNameOverride)
+          ))
+            return props.renderDefault(props);
+          const providerProps = {
+            ...props,
+            experimentFieldPluginConfig: {
+              ...pluginConfig,
+              variantId,
+              variantArrayName,
+              experimentId
+            }
+          };
+          return ExperimentProvider(providerProps);
         }
       }
-    };
-  }
-);
+    }
+  };
+});
 export {
   fieldLevelExperiments,
-  fieldLevelPersonalization,
   flattenSchemaType
 };
 //# sourceMappingURL=index.mjs.map