@rebasepro/plugin-data-enhancement 0.0.1-canary.4d4fb3e

package/dist/index.es.js

@@ -0,0 +1,1222 @@
+import React, { useState, useRef, useMemo, useEffect, useCallback, useContext, useDeferredValue } from "react";
+import { useAuthController, useSnackbarController, useLargeLayout, AIIcon } from "@rebasepro/core";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { getFieldId, useUrlController, useClearRestoreValue, getIconForProperty, LabelWithIconAndTooltip, PropertyIdCopyTooltip, FieldHelperText, MarkdownEditorFieldBinding } from "@rebasepro/cms";
+import { isPropertyBuilder, stripCollectionPath } from "@rebasepro/common";
+import { getValueInPath } from "@rebasepro/utils";
+import { c } from "react-compiler-runtime";
+import { deepEqual } from "fast-equals";
+import { TextField, InputLabel, cls, TextareaAutosize, fieldBackgroundMixin, fieldBackgroundDisabledMixin, fieldBackgroundHoverMixin, Tooltip, Menu, MenuItem, AutoAwesomeIcon, Typography, IconButton, SendIcon, CircularProgress, Separator, CloseIcon, focusedDisabled, Button } from "@rebasepro/ui";
+function flatMapEntityValues(values, path = "") {
+  if (!values) return {};
+  return Object.entries(values).flatMap(([key, value]) => {
+    const currentPath = path ? `${path}.${key}` : key;
+    if (typeof value === "object") {
+      return flatMapEntityValues(value, currentPath);
+    } else {
+      return {
+        [currentPath]: value
+      };
+    }
+  }).reduce((acc, curr) => ({
+    ...acc,
+    ...curr
+  }), {});
+}
+const DEFAULT_SERVER = "https://api.rebase.pro";
+async function enhanceDataAPIStream(props) {
+  const flatValues = flatMapEntityValues(props.values);
+  const properties = props.properties;
+  const inputEntity = {
+    entityId: props.entityId,
+    values: flatValues
+  };
+  const request = {
+    inputEntity,
+    properties,
+    entityName: props.entityName,
+    entityDescription: props.entityDescription,
+    propertyKey: props.propertyKey,
+    propertyInstructions: props.propertyInstructions,
+    instructions: props.instructions
+  };
+  console.debug("enhanceDataAPIStream", request);
+  return fetch((props.host ?? DEFAULT_SERVER) + "/data/enhance_stream/", {
+    // mode: "no-cors",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Basic ${props.firebaseToken}`,
+      "x-de-api-key": `Basic ${props.apiKey}`
+      // "x-de-version": version
+    },
+    body: JSON.stringify(request)
+  }).then(async (res) => {
+    if (!res.ok) {
+      console.error("enhanceDataAPIStream error", res);
+      throw await res.json();
+    }
+    const reader = res.body?.getReader();
+    if (!reader) {
+      throw new Error("No reader");
+    }
+    for await (const chunk of readChunks(reader)) {
+      const str = new TextDecoder().decode(chunk);
+      try {
+        str.split("&$# ").forEach((s) => {
+          if (s && s.length > 0) {
+            const data = JSON.parse(s.trim());
+            if (data.type === "suggestion_delta") props.onUpdateDelta(data.data.propertyKey, data.data.partialValue);
+            else if (data.type === "suggestion") props.onUpdate(data.data);
+            else if (data.type === "result") props.onEnd(data.data);
+          }
+        });
+      } catch (e) {
+        console.error("str", str);
+        console.error("Error parsing stream", e);
+        props.onError(e);
+      }
+    }
+  });
+}
+function readChunks(reader) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      let readResult = await reader.read();
+      while (!readResult.done) {
+        yield readResult.value;
+        readResult = await reader.read();
+      }
+    }
+  };
+}
+async function fetchEntityPromptSuggestion(props) {
+  return fetch((props.host ?? DEFAULT_SERVER) + "/data/prompt_autocomplete/", {
+    // mode: "no-cors",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Basic ${props.firebaseToken}`,
+      "x-de-api-key": `Basic ${props.apiKey}`
+    },
+    body: JSON.stringify({
+      entityName: props.entityName,
+      input: props.input ?? null
+    })
+  }).then(async (res) => {
+    const data = await res.json();
+    if (!res.ok) {
+      console.error("fetchEntityPromptSuggestion", data);
+      throw Error(data.message);
+    }
+    return {
+      prompts: data.data.prompts.map((e) => ({
+        prompt: e,
+        type: "sample"
+      }))
+    };
+  });
+}
+async function autocompleteStream(props) {
+  let result = "";
+  return fetch((props.host ?? DEFAULT_SERVER) + "/data/autocomplete/", {
+    // mode: "no-cors",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Basic ${props.firebaseToken}`
+      // "x-de-version": version
+    },
+    body: JSON.stringify({
+      textBefore: props.textBefore,
+      textAfter: props.textAfter
+    })
+  }).then(async (res) => {
+    if (!res.ok) {
+      console.error("enhanceDataAPIStream error", res);
+      throw await res.json();
+    }
+    const reader = res.body?.getReader();
+    if (!reader) {
+      throw new Error("No reader");
+    }
+    for await (const chunk of readChunks(reader)) {
+      const str = new TextDecoder().decode(chunk);
+      result += str;
+      console.debug("Autocomplete update:", str);
+      props.onUpdate(str);
+    }
+  }).then(() => {
+    console.debug("Autocomplete result:", result);
+    return result;
+  });
+}
+function getAppendableSuggestion(suggestion, value) {
+  const suggestionIncludesValue = typeof suggestion === "string" && typeof value === "string" && suggestion.toLowerCase().trim().startsWith(value.toLowerCase().trim());
+  return typeof value === "string" && suggestionIncludesValue ? suggestion.substring(suggestion.toLowerCase().trim().indexOf(value.toLowerCase().trim()) + value.trim().length) : void 0;
+}
+function getSimplifiedProperties(properties, values, path = "") {
+  if (!properties) return {};
+  return Object.entries(properties).map(([key, property]) => {
+    if (isPropertyBuilder(property)) return {};
+    const fullKey = path ? `${path}.${key}` : key;
+    const valueInPath = getValueInPath(values, fullKey);
+    return getSimplifiedProperty(property, fullKey, valueInPath);
+  }).reduce((a, b) => ({
+    ...a,
+    ...b
+  }), {});
+}
+function getSimpleProperty(property) {
+  const fieldId = getFieldId(property);
+  if (!fieldId) {
+    console.error("No fieldId found for property", property);
+    throw new Error("Field id not found");
+  }
+  return {
+    name: property.name,
+    description: property.description,
+    type: property.type,
+    fieldConfigId: fieldId,
+    enum: "enum" in property && property.enum ? getSimpleEnumValues(property.enum) : void 0,
+    disabled: Boolean(property.disabled || property.readOnly)
+  };
+}
+function getSimplifiedProperty(property, path, value) {
+  if (isPropertyBuilder(property)) return {};
+  if (property.type === "array") {
+    if (property.of && !Array.isArray(property.of) && !isPropertyBuilder(property.of)) {
+      const arrayParentProperty = {
+        name: property.name,
+        description: property.description,
+        type: property.type,
+        fieldConfigId: "repeat",
+        disabled: Boolean(property.disabled || property.readOnly),
+        of: getSimpleProperty(property.of)
+      };
+      const result = {
+        [path]: arrayParentProperty
+      };
+      return result;
+    } else if (property.oneOf) {
+      const arrayParentProperty = {
+        name: property.name,
+        description: property.description,
+        type: property.type,
+        fieldConfigId: "block",
+        disabled: Boolean(property.disabled || property.readOnly),
+        oneOf: {
+          typeField: property.oneOf.typeField,
+          valueField: property.oneOf.valueField,
+          properties: Object.entries(property.oneOf.properties).map(([key, prop]) => ({
+            [key]: getSimpleProperty(prop)
+          })).reduce((a, b) => ({
+            ...a,
+            ...b
+          }), {})
+        }
+      };
+      if (!Array.isArray(value)) {
+        return {
+          [path]: arrayParentProperty
+        };
+      }
+      return value.map((v, i) => {
+        const typeKey = property.oneOf.typeField ?? "type";
+        const oneOfType = v[typeKey];
+        const valueKey = property.oneOf.valueField ?? "value";
+        const oneOfValue = v[valueKey];
+        const childProperty = property.oneOf.properties[oneOfType];
+        if (childProperty === void 0) {
+          console.error(`No property found for type ${oneOfType}`, property.oneOf.properties);
+          return {};
+        }
+        const simplifiedProperty = getSimplifiedProperty(childProperty, `${path}.${i}.${valueKey}`, oneOfValue);
+        return {
+          [`${path}.${i}.${typeKey}`]: oneOfType,
+          ...simplifiedProperty
+        };
+      }).reduce((a, b) => ({
+        ...a,
+        ...b
+      }), {
+        [path]: arrayParentProperty
+      });
+    }
+  } else if (property.type === "map") {
+    if (property.properties) {
+      const mapProperties = Object.entries(property.properties).map(([key, childProperty]) => {
+        const childValue = value?.[key];
+        return getSimplifiedProperty(childProperty, key, childValue);
+      }).map((o) => attachPathToKeys(o, path)).reduce((a, b) => ({
+        ...a,
+        ...b
+      }), {});
+      if (Object.keys(mapProperties).length === 0) return {};
+      const mapParentProperty = {
+        name: property.name,
+        description: property.description,
+        type: property.type,
+        fieldConfigId: "group",
+        disabled: Boolean(property.disabled || property.readOnly)
+      };
+      return {
+        [path]: mapParentProperty,
+        ...mapProperties
+      };
+    }
+  } else {
+    const fieldId = getFieldId(property);
+    if (!fieldId) {
+      console.warn(`No fieldId found for property ${path} with type ${property.type}`);
+      return {};
+    }
+    return {
+      [path]: getSimpleProperty(property)
+    };
+  }
+  return {};
+}
+function attachPathToKeys(obj, path = "") {
+  return Object.entries(obj).map(([key, value]) => {
+    const fullKey = path ? `${path}.${key}` : key;
+    return {
+      [fullKey]: value
+    };
+  }).reduce((a, b) => ({
+    ...a,
+    ...b
+  }), {});
+}
+function getSimpleEnumValues(enumValues) {
+  if (Array.isArray(enumValues)) return enumValues.map((v) => String(v.id));
+  if (typeof enumValues === "object") return Object.keys(enumValues);
+  throw Error("getSimpleEnumValues: Invalid enumValues");
+}
+function useEditorAIController({
+  getAuthToken
+}) {
+  const autocomplete = async (textBefore, textAfter, onUpdate) => {
+    if (!getAuthToken) {
+      throw new Error("Firebase token is required");
+    }
+    const firebaseToken = await getAuthToken();
+    return autocompleteStream({
+      firebaseToken,
+      textBefore,
+      textAfter,
+      onUpdate
+    });
+  };
+  return {
+    autocomplete
+  };
+}
+const DataEnhancementControllerContext = React.createContext(null);
+const useDataEnhancementController = () => {
+  return useContext(DataEnhancementControllerContext);
+};
+function getPropertyFromKey(properties, propertyKey) {
+  if (propertyKey in properties) {
+    return properties[propertyKey];
+  } else {
+    const split = propertyKey.split(".");
+    if (split.length === 1) {
+      return void 0;
+    }
+    const parentKey = split.slice(0, split.length - 1).join(".");
+    return getPropertyFromKey(properties, parentKey);
+  }
+}
+function DataEnhancementControllerProvider({
+  apiKey,
+  getConfigForPath,
+  children,
+  host,
+  path,
+  collection,
+  formContext
+}) {
+  const [enabled, setEnabled] = useState(false);
+  const [suggestions, setSuggestions] = useState({});
+  const [loadingSuggestions, setLoadingSuggestions] = useState([]);
+  const enhancingInProgress = useRef(false);
+  const authController = useAuthController();
+  const snackbarController = useSnackbarController();
+  const properties = useMemo(() => getSimplifiedProperties(collection.properties, formContext?.values), [formContext?.values]);
+  const valuesRef = React.useRef(formContext?.values ?? {});
+  useEffect(() => {
+    if (!enhancingInProgress.current) valuesRef.current = formContext?.values ?? {};
+  }, [formContext?.values]);
+  const allowReferenceDataSelection = false;
+  const updateConfig = useCallback(async () => {
+    if (!getConfigForPath) return;
+    const config = getConfigForPath({
+      path,
+      collection
+    });
+    if (config) {
+      setEnabled(true);
+    }
+  }, [collection, getConfigForPath, path]);
+  useEffect(() => {
+    if (!getConfigForPath) {
+      setEnabled(true);
+    } else {
+      updateConfig();
+    }
+  }, [getConfigForPath, updateConfig]);
+  const urlController = useUrlController();
+  const clearSuggestion = useCallback((propertyKey) => {
+    setSuggestions((prev) => {
+      const {
+        [propertyKey]: _,
+        ...rest
+      } = prev;
+      return rest;
+    });
+  }, []);
+  const appendValueDelta = (propertyKey_0, delta) => {
+    const property = getPropertyFromKey(properties, propertyKey_0);
+    if (delta === null || property?.disabled) {
+      return;
+    }
+    const value = getValueInPath(valuesRef.current, propertyKey_0);
+    const currentValue = value ? value + "" : "";
+    const updatedValue = currentValue + delta;
+    valuesRef.current = {
+      ...valuesRef.current,
+      [propertyKey_0]: updatedValue
+    };
+    formContext?.setFieldValue(propertyKey_0, updatedValue, false);
+    setSuggestions((prev_0) => ({
+      ...prev_0,
+      [propertyKey_0]: (prev_0[propertyKey_0] ?? "") + delta
+    }));
+  };
+  const updateSuggestedValues = (currentValues, updatedValues, replaceValues) => {
+    setLoadingSuggestions((prev_1) => {
+      return prev_1.filter((p) => !Object.keys(updatedValues).includes(p));
+    });
+    Object.entries(updatedValues).forEach(([propertyKey_1, suggestion]) => {
+      const value_0 = getValueInPath(currentValues, propertyKey_1);
+      const property_0 = getPropertyFromKey(properties, propertyKey_1);
+      if (!property_0 || suggestion === null || property_0.disabled) {
+        return;
+      }
+      if (typeof suggestion === "number") {
+        formContext?.setFieldValue(propertyKey_1, suggestion);
+        return;
+      }
+      if (replaceValues) {
+        formContext?.setFieldValue(propertyKey_1, suggestion);
+        return;
+      }
+      const appendableValue = getAppendableSuggestion(suggestion, value_0);
+      const currentValue_0 = value_0 ? value_0 + "" : "";
+      if (appendableValue) {
+        formContext?.setFieldValue(propertyKey_1, suggestion);
+      } else {
+        const multiline = property_0?.fieldConfigId === "multiline" || property_0?.fieldConfigId === "markdown";
+        const trimmedValue = currentValue_0.trimEnd();
+        if (multiline && (trimmedValue.endsWith(".") || trimmedValue.endsWith("?") || trimmedValue.endsWith("!") || trimmedValue.endsWith(":"))) {
+          formContext?.setFieldValue(propertyKey_1, trimmedValue + "\n\n" + suggestion.trimStart());
+        } else {
+          formContext?.setFieldValue(propertyKey_1, trimmedValue + (trimmedValue.length > 0 ? " " : "") + suggestion);
+        }
+      }
+    });
+    setSuggestions((prev_2) => ({
+      ...prev_2,
+      ...Object.keys(updatedValues).reduce((acc, key) => {
+        const value_1 = getValueInPath(formContext?.values, key);
+        const suggestion_0 = updatedValues[key];
+        return {
+          ...acc,
+          [key]: getAppendableSuggestion(suggestion_0, value_1) ?? suggestion_0
+        };
+      }, {})
+    }));
+  };
+  function displayNeededSubscriptionSnackbar(projectId) {
+    snackbarController.open({
+      type: "warning",
+      message: "A valid subscription is needed in order to use this function.",
+      autoHideDuration: 4e3
+    });
+  }
+  const editorAIController = useEditorAIController({
+    getAuthToken: authController.getAuthToken
+  });
+  const enhance = async (props) => {
+    if (!authController.user) {
+      snackbarController.open({
+        type: "warning",
+        message: "You need to be logged in to enhance data"
+      });
+      return Promise.reject(new Error("Not logged in"));
+    }
+    const resolvedPath = urlController.resolveDatabasePathsFrom(path);
+    const firebaseToken = await authController.getAuthToken();
+    if (props.propertyKey) {
+      clearSuggestion(props.propertyKey);
+    } else {
+      clearAllSuggestions();
+    }
+    setLoadingSuggestions((prev_3) => [...prev_3, ...props.propertyKey ? [props.propertyKey] : Object.keys(properties)]);
+    enhancingInProgress.current = true;
+    const currentValues_0 = valuesRef.current ?? {};
+    return new Promise((resolve, reject) => {
+      function onError(e) {
+        setLoadingSuggestions([]);
+        if (e.code === "payment-required") {
+          e.data.projectId;
+          displayNeededSubscriptionSnackbar();
+        } else {
+          console.error("Enhance error", e);
+        }
+        reject(e);
+        enhancingInProgress.current = false;
+      }
+      try {
+        enhanceDataAPIStream({
+          ...props,
+          host,
+          apiKey,
+          properties,
+          path: resolvedPath,
+          entityName: collection.singularName ?? collection.name,
+          entityDescription: collection.description,
+          firebaseToken,
+          onUpdate: (suggestions_0) => {
+            console.debug("de onUpdate", suggestions_0);
+            updateSuggestedValues(currentValues_0, suggestions_0, props.replaceValues ?? false);
+          },
+          onUpdateDelta: (propertyKey_2, partialValue) => {
+            appendValueDelta(propertyKey_2, partialValue);
+          },
+          onError,
+          onEnd: (result) => {
+            console.debug("de onEnd", result);
+            if (result.errors) {
+              result.errors.forEach((error) => {
+                snackbarController.open({
+                  type: "warning",
+                  message: error
+                });
+              });
+            }
+            if (Object.keys(result.suggestions).length === 0) {
+              snackbarController.open({
+                type: "info",
+                autoHideDuration: 1800,
+                message: "No fields were updated"
+              });
+            }
+            setLoadingSuggestions([]);
+            resolve(result);
+            enhancingInProgress.current = false;
+          }
+        }).catch(onError);
+      } catch (e_0) {
+        onError(e_0);
+      }
+    });
+  };
+  const clearAllSuggestions = useCallback(() => {
+    setSuggestions({});
+  }, []);
+  const getSamplePrompts = useCallback(async (entityName, input) => {
+    const firebaseToken_0 = await authController.getAuthToken();
+    return fetchEntityPromptSuggestion({
+      host,
+      entityName,
+      firebaseToken: firebaseToken_0,
+      apiKey,
+      input
+    });
+  }, [apiKey, authController.getAuthToken]);
+  const dataEnhancementController = {
+    enabled,
+    suggestions,
+    clearSuggestion,
+    enhance,
+    allowReferenceDataSelection,
+    clearAllSuggestions,
+    getSamplePrompts,
+    loadingSuggestions,
+    editorAIController
+  };
+  return /* @__PURE__ */ jsx(DataEnhancementControllerContext.Provider, { value: dataEnhancementController, children });
+}
+const SUPPORTED_FIELDS_ENHANCEMENT = ["text_field", "number_input", "multiline", "markdown", "email", "select", "multi_select"];
+function AdvancedTextField({
+  value,
+  setValue,
+  label,
+  inputType,
+  multiline = false,
+  highlight,
+  disabled,
+  error,
+  size = "large",
+  className
+}) {
+  const inputRef = useRef(null);
+  const ref = useRef(null);
+  const [internalValue, setInternalValue] = React.useState(value ? value.toString() : "");
+  useEffect(() => {
+    setInternalValue(value ? value.toString() : "");
+  }, [value]);
+  const onScroll = useCallback((e) => {
+    if (!ref.current) return;
+    ref.current.scrollTop = e.target.scrollTop;
+    ref.current.scrollLeft = e.target.scrollLeft;
+  }, []);
+  const [focused, setFocused] = React.useState(document.activeElement === inputRef.current);
+  const hasValue = internalValue !== void 0 && internalValue !== null && internalValue !== "";
+  const endsWithHighlight = !!highlight && (value === highlight || String(value).endsWith(highlight));
+  const originalValue = endsWithHighlight ? String(value).substring(0, String(value).length - highlight.length) : internalValue;
+  const onChange = useCallback((event) => {
+    const stringValue = event.target.value;
+    if (inputType === "number") {
+      if (stringValue === "-" || stringValue.startsWith(".") || stringValue.endsWith(".")) {
+        setInternalValue(stringValue);
+      } else {
+        const numberValue = stringValue ? parseFloat(stringValue) : void 0;
+        if (numberValue && isNaN(numberValue)) {
+          setValue(null);
+          setInternalValue("");
+        } else if (numberValue !== void 0 && numberValue !== null) {
+          setValue(numberValue);
+          setInternalValue(numberValue.toString());
+        } else {
+          setValue(null);
+          setInternalValue("");
+        }
+      }
+    } else {
+      setValue(stringValue);
+      setInternalValue(stringValue);
+    }
+  }, [inputType, setValue]);
+  useCallback((e_0) => {
+    e_0.target.blur();
+    e_0.stopPropagation();
+    setTimeout(() => {
+      e_0.target.focus();
+    }, 0);
+  }, []);
+  if (disabled) {
+    return /* @__PURE__ */ jsx(TextField, { label, disabled: true, value: internalValue });
+  }
+  const additional = {
+    onKeyPress: (e_1) => {
+      if (!multiline && e_1.key === "Enter") {
+        e_1.preventDefault();
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: cls("rounded-md relative max-w-full", fieldBackgroundMixin, disabled ? fieldBackgroundDisabledMixin : fieldBackgroundHoverMixin, error ? "border border-red-500 dark:border-red-600" : "", {
+    "min-h-[28px]": size === "smallest",
+    "min-h-[32px]": size === "small",
+    "min-h-[44px]": size === "medium",
+    "min-h-[64px]": size === "large"
+  }, className), children: [
+    label && /* @__PURE__ */ jsx(InputLabel, { className: cls("absolute pointer-events-none", !error ? focused ? "text-primary" : "text-text-secondary dark:text-text-secondary-dark" : "text-red-500 dark:text-red-600", disabled ? "opacity-50" : "", size === "large" ? "top-1" : "-top-px"), shrink: hasValue || focused, children: label }),
+    /* @__PURE__ */ jsxs("div", { ref, className: cls("inset-0 whitespace-pre-wrap overflow-x-auto select-none pb-2 px-3", {
+      "pt-8": size === "large",
+      "pt-4": size === "medium" || size === "small"
+    }), children: [
+      addLineBreaks(originalValue, !endsWithHighlight && multiline),
+      endsWithHighlight && /* @__PURE__ */ jsx("span", { className: "dark:bg-surface-700 bg-surface-300 p-px -m-px rounded-xs", children: addLineBreaks(highlight, multiline) })
+    ] }),
+    /* @__PURE__ */ jsx(TextareaAutosize, { className: cls({
+      "min-h-[28px]": size === "smallest",
+      "min-h-[32px]": size === "small",
+      "min-h-[44px]": size === "medium",
+      "min-h-[64px]": size === "large"
+    }, "rounded-md resize-none w-full outline-hidden text-base bg-transparent ", disabled && "border border-transparent outline-hidden opacity-50 text-surface-600 dark:text-surface-500", "absolute top-0 right-0 left-0 max-w-full bg-transparent text-transparent caret-text-primary dark:caret-text-primary-dark", "pt-8 pb-2 px-3", label ? size === "large" ? "pt-8 pb-2" : "pt-4 pb-2" : "py-2"), ignoreBoxSizing: true, ref: inputRef, onFocus: () => setFocused(true), onBlur: () => setFocused(false), value: internalValue, sizeRef: ref, onChange, onScroll, ...additional })
+  ] });
+}
+function addLineBreaks(value, addLastBreak = false) {
+  if (typeof value === "number" || value === void 0) return value;
+  if (typeof value !== "string") {
+    console.error("addLineBreaks: value is not a string", value);
+    return "";
+  }
+  const lines = value.split("\n");
+  if (lines.length === 1) return /* @__PURE__ */ jsx("span", { className: "break-words", children: value ?? " " });
+  return lines.map((p, i) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+    /* @__PURE__ */ jsx("span", { className: "break-words", children: p ?? " " }),
+    (lines.length - 1 !== i || addLastBreak) && /* @__PURE__ */ jsx("br", {})
+  ] }, i));
+}
+const EnhanceTextFieldBinding = React.memo(function EnhanceTextFieldBinding2(t0) {
+  const $ = c(32);
+  const {
+    propertyKey,
+    value,
+    setValue,
+    error,
+    showError,
+    disabled,
+    property,
+    includeDescription,
+    highlight,
+    size
+  } = t0;
+  let multiline = false;
+  if (property.type === "string") {
+    multiline = (property.multiline || property.markdown) ?? false;
+  }
+  let t1;
+  if ($[0] !== property || $[1] !== setValue || $[2] !== value) {
+    t1 = {
+      property,
+      value,
+      setValue
+    };
+    $[0] = property;
+    $[1] = setValue;
+    $[2] = value;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  useClearRestoreValue(t1);
+  const internalValue = value ?? (property.type === "string" ? "" : value === 0 ? 0 : "");
+  const t2 = property.type === "number" ? "number" : "text";
+  let t3;
+  if ($[4] !== property) {
+    t3 = getIconForProperty(property);
+    $[4] = property;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const t4 = (property.name ?? "") + (property.validation?.required ? " *" : "");
+  let t5;
+  if ($[6] !== propertyKey || $[7] !== t3 || $[8] !== t4) {
+    t5 = /* @__PURE__ */ jsx(LabelWithIconAndTooltip, { propertyKey, icon: t3, title: t4 });
+    $[6] = propertyKey;
+    $[7] = t3;
+    $[8] = t4;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  let t6;
+  if ($[10] !== disabled || $[11] !== highlight || $[12] !== internalValue || $[13] !== multiline || $[14] !== setValue || $[15] !== showError || $[16] !== size || $[17] !== t2 || $[18] !== t5) {
+    t6 = /* @__PURE__ */ jsx(AdvancedTextField, { inputType: t2, label: t5, value: internalValue, multiline, highlight, setValue, disabled, error: showError, size });
+    $[10] = disabled;
+    $[11] = highlight;
+    $[12] = internalValue;
+    $[13] = multiline;
+    $[14] = setValue;
+    $[15] = showError;
+    $[16] = size;
+    $[17] = t2;
+    $[18] = t5;
+    $[19] = t6;
+  } else {
+    t6 = $[19];
+  }
+  let t7;
+  if ($[20] !== propertyKey || $[21] !== t6) {
+    t7 = /* @__PURE__ */ jsx(PropertyIdCopyTooltip, { propertyKey, children: t6 });
+    $[20] = propertyKey;
+    $[21] = t6;
+    $[22] = t7;
+  } else {
+    t7 = $[22];
+  }
+  let t8;
+  if ($[23] !== disabled || $[24] !== error || $[25] !== includeDescription || $[26] !== property || $[27] !== showError) {
+    t8 = /* @__PURE__ */ jsx(FieldHelperText, { includeDescription, showError, error, disabled, property });
+    $[23] = disabled;
+    $[24] = error;
+    $[25] = includeDescription;
+    $[26] = property;
+    $[27] = showError;
+    $[28] = t8;
+  } else {
+    t8 = $[28];
+  }
+  let t9;
+  if ($[29] !== t7 || $[30] !== t8) {
+    t9 = /* @__PURE__ */ jsxs(Fragment, { children: [
+      t7,
+      t8
+    ] });
+    $[29] = t7;
+    $[30] = t8;
+    $[31] = t9;
+  } else {
+    t9 = $[31];
+  }
+  return t9;
+}, (prevProps, nextProps) => {
+  return prevProps.value === nextProps.value && prevProps.error === nextProps.error && prevProps.showError === nextProps.showError && prevProps.disabled === nextProps.disabled && deepEqual(prevProps.property, nextProps.property) && prevProps.highlight === nextProps.highlight;
+});
+function countStringCharacters(values, properties) {
+  let count = 0;
+  for (const key in values) {
+    const value = values[key];
+    const property = properties[key];
+    if (property && !property.disabled) {
+      if (property.type === "string" || property.type === "number") {
+        count += String(value).length;
+      } else if (property.type === "array" && Array.isArray(value) && property.of && !Array.isArray(property.of) && property.of.type === "string") {
+        count += value.reduce((acc, curr) => acc + (curr?.length ?? 0), 0);
+      } else if (property.type === "map" && property.properties && typeof value === "object") {
+        count += countStringCharacters(value, property.properties);
+      }
+    }
+  }
+  return count;
+}
+function fieldBuilder(params) {
+  const {
+    fieldConfigId,
+    property
+  } = params;
+  const wrappedComponent = React.useMemo(() => function FieldWrapper(props) {
+    const {
+      enabled,
+      suggestions,
+      enhance,
+      loadingSuggestions,
+      editorAIController
+    } = useDataEnhancementController();
+    const loading = loadingSuggestions?.includes(props.propertyKey);
+    const suggestedValue = suggestions?.[props.propertyKey];
+    const filledCharacters = countStringCharacters(props.context.values, props.context.collection?.properties ?? {});
+    const enoughData = filledCharacters > 5;
+    return /* @__PURE__ */ jsx(FieldInner, { loading, props, suggestedValue, enabled, enoughData, Field: params.Field, enhance, editorAIController });
+  }, []);
+  if (property.disabled || property.readOnly || property.Field) {
+    return null;
+  }
+  if (SUPPORTED_FIELDS_ENHANCEMENT.includes(fieldConfigId)) {
+    return wrappedComponent;
+  }
+  return null;
+}
+const FieldInner = React.memo(function FieldInner2(t0) {
+  const $ = c(46);
+  const {
+    loading,
+    props,
+    suggestedValue,
+    enabled,
+    enoughData,
+    Field,
+    enhance,
+    editorAIController
+  } = t0;
+  const [dataLoading, setDataLoading] = useState(false);
+  const [tooltipOpen, setTooltipOpen] = React.useState(false);
+  const [menuOpen, setMenuOpen] = React.useState(false);
+  const [propertyInstructions, setPropertyInstructions] = useState();
+  const property = props.property;
+  let t1;
+  bb0: {
+    if (props.partOfBlock) {
+      t1 = "-top-4";
+      break bb0;
+    }
+    if (property.widthPercentage !== void 0) {
+      t1 = "top-4";
+    } else {
+      if (property.type === "array" && property.of?.type === "string") {
+        t1 = "top-4";
+        break bb0;
+      }
+      t1 = property.type === "string" && property.markdown ? "top-3" : "-top-4";
+    }
+  }
+  const topClass = t1;
+  const rightClass = props.partOfBlock ? "right-8" : props.partOfArray ? "right-12" : "right-2";
+  if (!enabled) {
+    let t22;
+    if ($[0] !== Field || $[1] !== props) {
+      t22 = /* @__PURE__ */ jsx(Field, { ...props });
+      $[0] = Field;
+      $[1] = props;
+      $[2] = t22;
+    } else {
+      t22 = $[2];
+    }
+    return t22;
+  }
+  const showEnhanceIcon = !props.disabled && (!props.value || property.type === "string" && (property.multiline || property.markdown) || property.type === "array" && property.of?.type === "string");
+  const indexOfSuggestion = props.value && typeof props.value === "string" && typeof suggestedValue === "string" && props.value.endsWith(suggestedValue) ? props.value.indexOf(suggestedValue) + 1 : void 0;
+  let t2;
+  if ($[3] !== indexOfSuggestion || $[4] !== suggestedValue) {
+    t2 = indexOfSuggestion && typeof suggestedValue === "string" ? {
+      from: indexOfSuggestion,
+      to: suggestedValue.length + indexOfSuggestion
+    } : void 0;
+    $[3] = indexOfSuggestion;
+    $[4] = suggestedValue;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const highlightRange = t2;
+  let fieldBinding;
+  if (property.type === "string" && property.markdown) {
+    const t32 = props;
+    let t42;
+    if ($[6] !== editorAIController) {
+      t42 = {
+        aiController: editorAIController
+      };
+      $[6] = editorAIController;
+      $[7] = t42;
+    } else {
+      t42 = $[7];
+    }
+    let t52;
+    if ($[8] !== highlightRange || $[9] !== t42) {
+      t52 = {
+        highlight: highlightRange,
+        editorProps: t42
+      };
+      $[8] = highlightRange;
+      $[9] = t42;
+      $[10] = t52;
+    } else {
+      t52 = $[10];
+    }
+    let t6;
+    if ($[11] !== t32 || $[12] !== t52) {
+      t6 = /* @__PURE__ */ jsx(MarkdownEditorFieldBinding, { ...t32, customProps: t52 });
+      $[11] = t32;
+      $[12] = t52;
+      $[13] = t6;
+    } else {
+      t6 = $[13];
+    }
+    fieldBinding = t6;
+  } else {
+    if (property.type === "string" && !property.enum) {
+      const t32 = props;
+      const t42 = suggestedValue;
+      let t52;
+      if ($[14] !== t32 || $[15] !== t42) {
+        t52 = /* @__PURE__ */ jsx(EnhanceTextFieldBinding, { ...t32, highlight: t42 });
+        $[14] = t32;
+        $[15] = t42;
+        $[16] = t52;
+      } else {
+        t52 = $[16];
+      }
+      fieldBinding = t52;
+    } else {
+      let t32;
+      if ($[17] !== Field || $[18] !== props) {
+        t32 = /* @__PURE__ */ jsx(Field, { ...props });
+        $[17] = Field;
+        $[18] = props;
+        $[19] = t32;
+      } else {
+        t32 = $[19];
+      }
+      fieldBinding = t32;
+    }
+  }
+  let t3;
+  if ($[20] !== enhance || $[21] !== enoughData || $[22] !== props.context.entityId || $[23] !== props.context.values || $[24] !== props.propertyKey) {
+    t3 = (instructions) => {
+      if (!props.context.entityId) {
+        return;
+      }
+      if (!enoughData) {
+        return;
+      }
+      setMenuOpen(false);
+      setDataLoading(true);
+      return enhance({
+        entityId: props.context.entityId,
+        propertyKey: props.propertyKey,
+        propertyInstructions: instructions,
+        values: props.context.values,
+        replaceValues: false
+      }).finally(() => setDataLoading(false));
+    };
+    $[20] = enhance;
+    $[21] = enoughData;
+    $[22] = props.context.entityId;
+    $[23] = props.context.values;
+    $[24] = props.propertyKey;
+    $[25] = t3;
+  } else {
+    t3 = $[25];
+  }
+  const enhanceData = t3;
+  const allowInstructions = property.type === "string" && !property.enum;
+  let t4;
+  if ($[26] !== allowInstructions || $[27] !== dataLoading || $[28] !== enhance || $[29] !== enhanceData || $[30] !== enoughData || $[31] !== loading || $[32] !== menuOpen || $[33] !== property.name || $[34] !== propertyInstructions || $[35] !== props.context.entityId || $[36] !== props.context.values || $[37] !== props.propertyKey || $[38] !== rightClass || $[39] !== showEnhanceIcon || $[40] !== tooltipOpen || $[41] !== topClass) {
+    t4 = showEnhanceIcon && /* @__PURE__ */ jsx("div", { className: cls("dark:bg-surface-700 bg-surface-100 rounded-full absolute", rightClass, topClass), children: /* @__PURE__ */ jsx(Tooltip, { open: tooltipOpen, onOpenChange: setTooltipOpen, side: "left", asChild: false, title: enoughData ? `Autofill ${property.name ?? "this field"}` : `You need to input some data in the form before enhancing ${property.name ?? "this field"}`, children: /* @__PURE__ */ jsxs(Menu, { open: menuOpen, onOpenChange: setMenuOpen, trigger: /* @__PURE__ */ jsx(IconButton, { size: "smallest", "aria-label": "Enhance field", disabled: dataLoading || loading, className: enoughData ? "text-surface-900 dark:text-white" : "text-surface-400 dark:text-surface-600", onClick: () => {
+      if (!props.context.entityId) {
+        return;
+      }
+      if (!enoughData) {
+        return;
+      }
+      setTooltipOpen(false);
+      setDataLoading(true);
+      return enhance({
+        entityId: props.context.entityId,
+        propertyKey: props.propertyKey,
+        values: props.context.values,
+        replaceValues: false
+      }).finally(() => setDataLoading(false));
+    }, children: dataLoading || loading ? /* @__PURE__ */ jsx(CircularProgress, { size: "smallest" }) : /* @__PURE__ */ jsx(AutoAwesomeIcon, { size: "smallest" }) }), children: [
+      /* @__PURE__ */ jsxs(MenuItem, { onClick: () => enhanceData(), children: [
+        /* @__PURE__ */ jsx(AutoAwesomeIcon, { size: "small" }),
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col", children: [
+          /* @__PURE__ */ jsxs(Typography, { variant: "body2", children: [
+            " ",
+            `Autofill ${property.name ?? "this field"}`
+          ] }),
+          /* @__PURE__ */ jsx(Typography, { variant: "caption", children: "based on the rest of the entity" })
+        ] })
+      ] }),
+      allowInstructions && /* @__PURE__ */ jsx("div", { className: "p-4", children: /* @__PURE__ */ jsx(TextField, { label: "Ask AI to write", size: "small", className: "w-[400px] max-w-full text-text-primary dark:text-text-primary-dark", value: propertyInstructions ?? "", onKeyDown: (e) => {
+        if (e.key === "Enter") {
+          enhanceData(propertyInstructions);
+        }
+      }, placeholder: "Instructions", onChange: (e_0) => setPropertyInstructions(e_0.target.value), endAdornment: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: () => enhanceData(propertyInstructions), disabled: !propertyInstructions, children: /* @__PURE__ */ jsx(SendIcon, { size: "small" }) }) }) })
+    ] }) }) });
+    $[26] = allowInstructions;
+    $[27] = dataLoading;
+    $[28] = enhance;
+    $[29] = enhanceData;
+    $[30] = enoughData;
+    $[31] = loading;
+    $[32] = menuOpen;
+    $[33] = property.name;
+    $[34] = propertyInstructions;
+    $[35] = props.context.entityId;
+    $[36] = props.context.values;
+    $[37] = props.propertyKey;
+    $[38] = rightClass;
+    $[39] = showEnhanceIcon;
+    $[40] = tooltipOpen;
+    $[41] = topClass;
+    $[42] = t4;
+  } else {
+    t4 = $[42];
+  }
+  let t5;
+  if ($[43] !== fieldBinding || $[44] !== t4) {
+    t5 = /* @__PURE__ */ jsxs(Fragment, { children: [
+      fieldBinding,
+      t4
+    ] });
+    $[43] = fieldBinding;
+    $[44] = t4;
+    $[45] = t5;
+  } else {
+    t5 = $[45];
+  }
+  return t5;
+}, (prevProps, nextProps) => {
+  return prevProps.loading === nextProps.loading && prevProps.suggestedValue === nextProps.suggestedValue && prevProps.enabled === nextProps.enabled && prevProps.props.value === nextProps.props.value && prevProps.props.error === nextProps.props.error && prevProps.props.showError === nextProps.props.showError && prevProps.props.disabled === nextProps.props.disabled && deepEqual(prevProps.props.property, nextProps.props.property) && prevProps.Field === nextProps.Field && prevProps.enoughData === nextProps.enoughData;
+});
+function FormEnhanceAction({
+  entityId,
+  path,
+  status,
+  collection,
+  disabled,
+  formContext,
+  openEntityMode
+}) {
+  const largeLayout = useLargeLayout();
+  const storageKey = createLocalStorageKey(path, status);
+  const [loading, setLoading] = React.useState(false);
+  const dataEnhancementController = useDataEnhancementController();
+  const [samplePrompts, setSamplePrompts] = React.useState(void 0);
+  const [instructions, setInstructions] = React.useState("");
+  const {
+    suggestions,
+    getSamplePrompts
+  } = dataEnhancementController;
+  const loadingPrompts = useRef(false);
+  const updateSuggestedPrompts = useCallback(async function updateSuggestedPrompts2(instructions_0) {
+    if (loadingPrompts.current) return;
+    loadingPrompts.current = true;
+    const prompts = status === "new" ? (await getSamplePrompts(collection.singularName ?? collection.name, instructions_0)).prompts : getPromptsForExistingEntities(collection.properties);
+    const recentPromptsFromStorage = getRecentPromptsFromStorage(storageKey);
+    const recentPrompts = recentPromptsFromStorage.map((prompt) => prompt.prompt);
+    setSamplePrompts([...recentPromptsFromStorage, ...prompts.filter((p) => !recentPrompts.includes(p.prompt))].slice(0, 5));
+    loadingPrompts.current = false;
+  }, [collection.name, collection.singularName, getSamplePrompts, status]);
+  useDeferredValue(formContext?.values);
+  useEffect(() => {
+    if (!samplePrompts) {
+      setSamplePrompts(getRecentPromptsFromStorage(storageKey));
+      updateSuggestedPrompts().then();
+    }
+  }, [samplePrompts, storageKey, updateSuggestedPrompts, instructions, status]);
+  useEffect(() => {
+    updateSuggestedPrompts().then();
+  }, [status]);
+  const enhance = (prompt_0) => {
+    if (!formContext?.values) return;
+    setLoading(true);
+    if (prompt_0) {
+      addRecentPrompt(storageKey, prompt_0);
+      setSamplePrompts([{
+        prompt: prompt_0,
+        type: "recent"
+      }, ...(samplePrompts ?? []).slice(0, 5)]);
+    }
+    return dataEnhancementController.enhance({
+      entityId,
+      values: formContext.values,
+      instructions: prompt_0,
+      replaceValues: true
+    }).finally(() => {
+      setLoading(false);
+    });
+  };
+  if (!dataEnhancementController?.enabled) return null;
+  Object.values(suggestions).filter(Boolean).length > 0;
+  (samplePrompts ?? []).length > 0 && instructions.length === 0;
+  function submit() {
+    enhance(instructions);
+  }
+  return /* @__PURE__ */ jsxs(Menu, { align: "end", sideOffset: 8, className: "max-w-[100vw]", trigger: /* @__PURE__ */ jsxs(Button, { variant: "filled", color: "neutral", fullWidth: largeLayout && openEntityMode === "full_screen", size: "small", disabled: loading || disabled, children: [
+    !loading && /* @__PURE__ */ jsx(AIIcon, { size: "small" }),
+    loading && /* @__PURE__ */ jsx(CircularProgress, { size: "small" }),
+    "Autofill"
+  ] }), children: [
+    /* @__PURE__ */ jsxs(MenuItem, { className: "py-4", onClick: () => {
+      enhance();
+    }, children: [
+      /* @__PURE__ */ jsx(AIIcon, { size: "small" }),
+      "Autofill based on the current content"
+    ] }),
+    /* @__PURE__ */ jsx(Separator, { orientation: "horizontal", className: "mt-2" }),
+    samplePrompts?.map((samplePrompt, index) => {
+      return /* @__PURE__ */ jsxs(MenuItem, { onClick: () => {
+        setInstructions(samplePrompt.prompt);
+        enhance(samplePrompt.prompt);
+      }, children: [
+        /* @__PURE__ */ jsx("div", { className: "pl-9 grow text-text-secondary dark:text-text-secondary-dark", children: samplePrompt.prompt }),
+        samplePrompt.type === "recent" && /* @__PURE__ */ jsx(IconButton, { onClick: (e) => {
+          e.preventDefault();
+          e.stopPropagation();
+          removeRecentPrompt(storageKey, samplePrompt.prompt);
+          setSamplePrompts((samplePrompts ?? []).filter((p_0) => p_0.prompt !== samplePrompt.prompt));
+        }, size: "smallest", children: /* @__PURE__ */ jsx(CloseIcon, { size: "smallest" }) })
+      ] }, index + "_" + samplePrompt.prompt);
+    }),
+    /* @__PURE__ */ jsx(Separator, { orientation: "horizontal" }),
+    /* @__PURE__ */ jsxs("div", { className: cls("my-2 w-[500px] max-w-full flex items-start text-surface-700 dark:text-surface-200"), children: [
+      /* @__PURE__ */ jsx(TextareaAutosize, { className: cls("p-4 rounded-lg resize-none bg-surface-100 dark:bg-surface-800 mx-2 w-full grow outline-hidden max-h-[300px] overflow-auto", focusedDisabled), value: instructions, autoFocus: status === "new", disabled: loading, onFocus: (event) => {
+        event.stopPropagation();
+      }, placeholder: "...or provide instructions", onKeyDown: (e_0) => {
+        e_0.stopPropagation();
+        if (e_0.key === "Enter" && !e_0.shiftKey) {
+          e_0.preventDefault();
+          submit();
+        }
+      }, onChange: (e_1) => {
+        setInstructions(e_1.target.value);
+      } }),
+      /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: () => {
+        setInstructions("");
+      }, color: !instructions ? "primary" : void 0, disabled: loading || !instructions, children: /* @__PURE__ */ jsx(CloseIcon, { size: "small" }) }),
+      /* @__PURE__ */ jsxs(IconButton, { onClick: () => enhance(instructions), size: "small", color: !instructions ? "primary" : void 0, disabled: loading || !instructions, children: [
+        loading && /* @__PURE__ */ jsx(CircularProgress, { size: "smallest" }),
+        !loading && /* @__PURE__ */ jsx(SendIcon, { color: "primary" })
+      ] })
+    ] })
+  ] });
+}
+function getPromptsForExistingEntities(properties) {
+  const multilineProperties = Object.values(properties).filter((p) => {
+    if (isPropertyBuilder(p)) {
+      return false;
+    }
+    return p.type === "string" && (p.markdown || p.multiline);
+  });
+  const multilinePrompt = multilineProperties.length > 0 ? multilineProperties[Math.floor(Math.random() * multilineProperties.length)] : void 0;
+  const prompts = ["Fill the missing fields", "Translate the missing content"];
+  if (multilinePrompt) {
+    prompts.push(`Add 2 paragraphs to '${multilinePrompt.name}'`);
+  }
+  return prompts.map((p) => ({
+    prompt: p,
+    type: "sample"
+  }));
+}
+const createLocalStorageKey = (path, status) => {
+  const statusString = status === "new" ? "new" : "existing";
+  return `data_enhancement::${statusString}::${stripCollectionPath(path)}`;
+};
+const getRecentPromptsFromStorage = (storageKey) => {
+  const item = localStorage.getItem(storageKey);
+  return item ? JSON.parse(item).map((e) => ({
+    prompt: e,
+    type: "recent"
+  })) : [];
+};
+const addRecentPrompt = (storageKey, prompt) => {
+  if (!prompt || prompt.trim().length === 0) {
+    return;
+  }
+  const recentPrompts = getRecentPromptsFromStorage(storageKey);
+  localStorage.setItem(storageKey, JSON.stringify([prompt, ...recentPrompts.map((e) => e.prompt).filter((e) => e !== prompt).slice(0, 5)]));
+};
+const removeRecentPrompt = (storageKey, prompt) => {
+  localStorage.setItem(storageKey, JSON.stringify(getRecentPromptsFromStorage(storageKey).map((e) => e.prompt).filter((e) => e !== prompt)));
+};
+const DEFAULT_API_KEY = "fcms-U9jdDii0xXWSDC34asfrf54lbkFJBfKfRWcEDEwdc4V5wDWEDF";
+function useDataEnhancementPlugin(props) {
+  const apiKey = props?.apiKey ?? DEFAULT_API_KEY;
+  const getConfigForPath = props?.getConfigForPath;
+  const authController = useAuthController();
+  const fieldBuilderEnabled = useCallback((params) => {
+    if (!getConfigForPath) return true;
+    if (!params.path || !params.collection) return false;
+    return getConfigForPath({
+      path: params.path,
+      collection: params.collection,
+      user: authController.user
+    });
+  }, [getConfigForPath, authController.user?.uid]);
+  return {
+    key: "data_enhancement",
+    slots: [{
+      slot: "form.actions",
+      Component: FormEnhanceAction,
+      order: 40
+    }],
+    providers: [{
+      scope: "form",
+      Component: DataEnhancementControllerProvider,
+      props: {
+        apiKey,
+        getConfigForPath,
+        host: props?.host
+      }
+    }],
+    fieldBuilder: {
+      wrap: fieldBuilder,
+      enabled: fieldBuilderEnabled
+    }
+    // loading: configController.loading,
+  };
+}
+export {
+  useDataEnhancementPlugin,
+  useEditorAIController
+};
+//# sourceMappingURL=index.es.js.map