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

package/dist/index.mjs

@@ -1,105 +1,82 @@
+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, 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 { useClient, useWorkspace, defineDocumentFieldAction, set, unset, useFormValue, isReference, isImage, definePlugin, isObjectInputProps, defineType, defineField } from "sanity";
+import { Stack, Inline, Button } from "@sanity/ui";
 import { uuid } from "@sanity/uuid";
-import { createContext, useMemo, useContext, useCallback, forwardRef, useState, useEffect } from "react";
+import { createContext, useMemo, useContext, useCallback, useState, useEffect } from "react";
 import equal from "fast-deep-equal";
 import { suspend } from "suspend-react";
-import { GiSoapExperiment } from "react-icons/gi";
+import { IoMdPeople } from "react-icons/io";
 const CONFIG_DEFAULT = {
   fields: [],
   apiVersion: "2024-11-07",
-  experimentNameOverride: "experiment",
-  variantNameOverride: "variant",
-  variantId: "variantId",
-  variantArrayName: "variants",
-  experimentId: "experimentId"
-}, ExperimentContext = createContext({
+  personalizationNameOverride: "personalization",
+  segmentNameOverride: "segment",
+  segmentId: "segmentId",
+  segmentArrayName: "segments"
+}, PersonalizationContext = createContext({
   ...CONFIG_DEFAULT,
-  experiments: []
+  segments: []
 });
-function useExperimentContext() {
-  return useContext(ExperimentContext);
+function usePersonalizationContext() {
+  return useContext(PersonalizationContext);
 }
-function ExperimentProvider(props) {
-  const { experimentFieldPluginConfig } = props, client = useClient({ apiVersion: experimentFieldPluginConfig.apiVersion }), workspace = useWorkspace(), experiments = Array.isArray(experimentFieldPluginConfig.experiments) ? experimentFieldPluginConfig.experiments : suspend(
+function PersonalizationProvider(props) {
+  const { personalizationFieldPluginConfig } = props, client = useClient({ apiVersion: personalizationFieldPluginConfig.apiVersion }), workspace = useWorkspace(), segments = Array.isArray(personalizationFieldPluginConfig.segments) ? personalizationFieldPluginConfig.segments : suspend(
     // eslint-disable-next-line require-await
-    async () => typeof experimentFieldPluginConfig.experiments == "function" ? experimentFieldPluginConfig.experiments(client) : experimentFieldPluginConfig.experiments,
+    async () => typeof personalizationFieldPluginConfig.segments == "function" ? personalizationFieldPluginConfig.segments(client) : personalizationFieldPluginConfig.segments,
     [workspace],
     { equal }
   ), context = useMemo(
-    () => ({ ...experimentFieldPluginConfig, experiments }),
-    [experimentFieldPluginConfig, experiments]
+    () => ({ ...personalizationFieldPluginConfig, segments }),
+    [personalizationFieldPluginConfig, segments]
   );
-  return /* @__PURE__ */ jsx(ExperimentContext.Provider, { value: context, children: props.renderDefault(props) });
+  return /* @__PURE__ */ jsx(PersonalizationContext.Provider, { value: context, children: props.renderDefault(props) });
 }
 const ArrayInput = (props) => {
-  const fieldPath = props.path.slice(0, -1), { onItemAppend, variantName, variantId, experimentId } = props, experimentValue = useFormValue([...fieldPath, experimentId]), { experiments } = useExperimentContext(), handleClick = useCallback(
-    async (variant) => {
+  const { onItemAppend, segmentName, segmentId } = props, { segments } = usePersonalizationContext(), handleClick = useCallback(
+    async (segment) => {
       const item = {
         _key: uuid(),
-        [variantId]: variant.id,
-        [experimentId]: experimentValue,
-        _type: variantName
+        [segmentId]: segment.id,
+        _type: segmentName
       };
       onItemAppend(item);
     },
-    [variantId, experimentId, experimentValue, variantName, onItemAppend]
-  ), filteredVariants = experiments.find((option) => option.id === experimentValue)?.variants || [], usedVariants = (props.value || [])?.map((variant) => variant[variantId]);
+    [segmentId, segmentName, onItemAppend]
+  ), usedSegments = (props.value || [])?.map((segment) => segment[segmentId]);
   return /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
     props.renderDefault({ ...props, arrayFunctions: () => null }),
-    /* @__PURE__ */ jsx(Inline, { space: 1, children: filteredVariants.map((variant) => /* @__PURE__ */ jsx(
+    /* @__PURE__ */ jsx(Inline, { space: 1, children: segments.map((segment) => /* @__PURE__ */ jsx(
       Button,
       {
-        text: `Add ${variant.label}`,
+        text: `Add ${segment.label}`,
         mode: "ghost",
-        disabled: usedVariants?.includes(variant.id),
-        onClick: () => handleClick(variant)
+        disabled: usedSegments?.includes(segment.id),
+        onClick: () => handleClick(segment)
       },
-      `${experimentValue}-${variant.id}`
+      `${segment.id}`
     )) })
   ] });
-}, 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(() => {
+}, useAddExperimentAction = (props) => {
+  const { onChange, active, personalizationNameOverride } = props, handleAddAction = useCallback(() => {
     onChange([set(!active, ["active"])]);
   }, [onChange, active]);
   return {
-    title: `Add ${experimentNameOverride}`,
+    title: `Add ${personalizationNameOverride}`,
     type: "action",
-    icon: GiSoapExperiment,
+    icon: IoMdPeople,
     onAction: handleAddAction,
     renderAsButton: !0
   };
 }, useRemoveExperimentAction = (props) => {
-  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]);
+  const { onChange, active, personalizationNameOverride, segmentNameOverride } = props, handleClearAction = useCallback(() => {
+    const activeId = ["active"], segments = [`${segmentNameOverride}s`];
+    onChange([set(!active, activeId), unset(segments)]);
+  }, [onChange, active, segmentNameOverride]);
   return {
-    title: `Remove ${experimentNameOverride}`,
+    title: `Remove ${personalizationNameOverride}`,
     type: "action",
     icon: CloseIcon,
     onAction: handleClearAction,
@@ -109,112 +86,57 @@ const ArrayInput = (props) => {
   onChange,
   inputId,
   active,
-  experimentNameOverride,
-  experimentId,
-  variantNameOverride
+  personalizationNameOverride,
+  segmentNameOverride
 }) => {
   const removeAction = defineDocumentFieldAction({
-    name: `Remove ${experimentNameOverride}`,
+    name: `Remove ${personalizationNameOverride}`,
     useAction: (props) => useRemoveExperimentAction({
       active: !0,
       onChange,
-      experimentNameOverride,
-      experimentId,
-      variantNameOverride
+      personalizationNameOverride,
+      segmentNameOverride
     })
   }), addAction = defineDocumentFieldAction({
-    name: `Add ${experimentNameOverride}`,
+    name: `Add ${personalizationNameOverride}`,
     useAction: (props) => useAddExperimentAction({
       active: !1,
       onChange,
-      experimentNameOverride
+      personalizationNameOverride
     })
   });
   return active ? removeAction : addAction;
-}, ExperimentField = (props) => {
-  const { onChange } = props.inputProps, { inputId, experimentNameOverride, experimentId, variantNameOverride } = props, active = props.value?.active, actionProps = useMemo(
+}, Field = (props) => {
+  const { onChange } = props.inputProps, { inputId, personalizationNameOverride, segmentNameOverride } = props, active = props.value?.active, actionProps = useMemo(
     () => ({
       onChange,
       inputId,
       active,
-      experimentNameOverride,
-      experimentId,
-      variantNameOverride
+      personalizationNameOverride,
+      segmentNameOverride
     }),
-    [onChange, inputId, active, experimentNameOverride, experimentId, variantNameOverride]
+    [onChange, inputId, active, personalizationNameOverride, segmentNameOverride]
   ), memoizedActions = useMemo(() => {
     const oldActions = props.actions || [];
     return [createActions(actionProps), ...oldActions];
-  }, [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"
-  ] }) });
-}, VariantInput = (props) => {
-  const defaultValue = useFormValue([props.path[0], "default"]), handleClick = () => {
+  }, [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 = () => {
     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() }) })
   ] });
-}, 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);
+}, 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);
   useEffect(() => {
     (async () => {
-      if (setTitle(`${selectedExperiment?.label} - ${selectedVariant?.label}`), typeof value == "string")
+      if (setTitle(`${selectedSegment?.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 || {};
@@ -227,7 +149,7 @@ const ArrayInput = (props) => {
       }
       return isImage(value) && setMedia(value), "";
     })();
-  }, [value, client, selectedExperiment?.label, selectedVariant?.label, props.schemaType]);
+  }, [value, client, selectedSegment?.label, props.schemaType]);
   const previewProps = {
     ...props,
     title,
@@ -235,64 +157,59 @@ const ArrayInput = (props) => {
     media
   };
   return props.renderDefault(previewProps);
-};
-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 = ({
+}, createPersonalizationType = ({
   field,
-  experimentNameOverride,
-  variantNameOverride,
-  variantId,
-  variantArrayName,
-  experimentId
+  personalizationNameOverride,
+  segmentNameOverride,
+  segmentId,
+  segmentArrayName
 }) => {
-  const typeName = typeof field == "string" ? field : field.name, usedName = String(typeName[0]).toUpperCase() + String(typeName).slice(1), variantName = `${variantNameOverride}${usedName}`;
+  const typeName = typeof field == "string" ? field : field.name, usedName = String(typeName[0]).toUpperCase() + String(typeName).slice(1), segmentName = `${segmentNameOverride}${usedName}`;
   return defineType({
-    name: `${experimentNameOverride}${usedName}`,
+    name: `${personalizationNameOverride}${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(
-        ExperimentField,
+        Field,
         {
           ...props,
-          experimentId,
-          experimentNameOverride,
-          variantNameOverride
+          personalizationNameOverride,
+          segmentNameOverride
         }
-      )
+      ),
+      item: ArrayItem
     },
     fields: [
       typeof field == "string" ? (
         // Define a simple field if all we have is the name as a string
         defineField({
           name: "default",
-          type: field
+          type: field,
+          group: "default"
         })
       ) : (
         // Pass in the configured options, but overwrite the name
         {
           ...field,
-          name: "default"
+          name: "default",
+          group: "default"
         }
       ),
       defineField({
@@ -302,84 +219,54 @@ const createExperimentType = ({
         initialValue: !1
       }),
       defineField({
-        name: experimentId,
-        type: "string",
-        components: {
-          input: (props) => /* @__PURE__ */ jsx(
-            ExperimentInput,
-            {
-              ...props,
-              experimentNameOverride,
-              variantNameOverride
-            }
-          )
-        },
-        hidden: ({ parent }) => !parent?.active
-      }),
-      defineField({
-        name: variantArrayName,
+        name: segmentArrayName,
         type: "array",
-        hidden: ({ parent }) => !parent?.[experimentId],
+        hidden: ({ parent }) => !parent?.active,
+        group: "personalization",
         components: {
-          input: (props) => /* @__PURE__ */ jsx(
-            ArrayInput,
-            {
-              ...props,
-              variantName,
-              variantId,
-              experimentId
-            }
-          )
+          input: (props) => /* @__PURE__ */ jsx(ArrayInput, { ...props, segmentName, segmentId })
         },
         of: [
           defineField({
-            name: variantName,
-            type: variantName
+            name: segmentName,
+            type: segmentName
           })
         ]
       })
     ],
     preview: {
       select: {
-        base: "default",
-        experiment: experimentId
+        base: "default"
       },
-      prepare: ({ base, experiment }) => {
-        const title = base?.title || base?.name || "", experimentTitle = experiment ? `Experiment: ${experiment}` : "", media = base?.image || base?.photo || base?.media || "";
+      prepare: ({ base }) => {
+        const title = base?.title || base?.name || typeof base == "string" ? base : "", media = base?.image || base?.photo || base?.media || "";
         return {
-          title: title || experimentTitle,
-          subtitle: title ? experimentTitle : "",
+          title,
           media
         };
       }
     }
   });
-}, createVariantType = ({
+}, createSegmentType = ({
   field,
-  variantNameOverride,
-  variantId,
-  experimentId
+  segmentNameOverride,
+  segmentId
 }) => {
   const typeName = typeof field == "string" ? field : field.name, usedName = String(typeName[0]).toUpperCase() + String(typeName).slice(1);
   return defineType({
-    name: `${variantNameOverride}${usedName}`,
-    title: `${variantNameOverride} array ${usedName}`,
+    name: `${segmentNameOverride}${usedName}`,
+    title: `${segmentNameOverride} array ${usedName}`,
     type: "object",
     components: {
-      preview: VariantPreview,
-      input: VariantInput
+      preview: SegmentPreview,
+      input: SegmentInput
     },
     fields: [
       {
         type: "string",
-        name: variantId,
+        name: segmentId,
         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({
@@ -398,71 +285,67 @@ const createExperimentType = ({
     ],
     preview: {
       select: {
-        variant: variantId,
-        experiment: experimentId,
+        segment: segmentId,
         value: "value"
       }
     }
   });
 }, fieldSchema = ({
   fields,
-  experimentNameOverride,
-  variantNameOverride,
-  variantId,
-  variantArrayName,
-  experimentId
+  personalizationNameOverride,
+  segmentNameOverride,
+  segmentId,
+  segmentArrayName
 }) => [
+  ...fields.map((field) => createSegmentType({ field, segmentNameOverride, segmentId })),
   ...fields.map(
-    (field) => createVariantType({ field, variantNameOverride, variantId, experimentId })
-  ),
-  ...fields.map(
-    (field) => createExperimentType({
+    (field) => createPersonalizationType({
       field,
-      experimentNameOverride,
-      variantNameOverride,
-      variantId,
-      variantArrayName,
-      experimentId
+      personalizationNameOverride,
+      segmentNameOverride,
+      segmentId,
+      segmentArrayName
     })
   )
-], 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);
+], 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);
+          }
         }
       }
-    }
-  };
-});
+    };
+  }
+);
 export {
   fieldLevelExperiments,
+  fieldLevelPersonalization,
   flattenSchemaType
 };
 //# sourceMappingURL=index.mjs.map