@rebasepro/plugin-data-enhancement 0.0.1-canary.000dc36

package/dist/index.es.js

@@ -0,0 +1,751 @@
+import { c } from "react-compiler-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { useState, useRef, useMemo, useEffect, useCallback, useContext, useDeferredValue } from "react";
+import { useAuthController, useSnackbarController, useLargeLayout, AIIcon } from "@rebasepro/core";
+import { getFieldId, useUrlController } from "@rebasepro/admin";
+import { isPropertyBuilder, stripCollectionPath } from "@rebasepro/common";
+import { getValueInPath } from "@rebasepro/utils";
+import { Menu, MenuItem, Separator, IconButton, iconSize, TextareaAutosize, cls, focusedDisabled, CircularProgress, Button } from "@rebasepro/ui";
+import { XIcon, SendIcon } from "lucide-react";
+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.ui?.disabled || property.ui?.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.ui?.disabled || property.ui?.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.ui?.disabled || property.ui?.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) => {
+        if (v == null) return {};
+        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.ui?.disabled || property.ui?.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 = useCallback((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
+    }));
+  }, [properties, formContext]);
+  const updateSuggestedValues = useCallback((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
+        };
+      }, {})
+    }));
+  }, [properties, formContext]);
+  const displayNeededSubscriptionSnackbar = useCallback((projectId) => {
+    snackbarController.open({
+      type: "warning",
+      message: "A valid subscription is needed in order to use this function.",
+      autoHideDuration: 4e3
+    });
+  }, [snackbarController]);
+  const editorAIController = useEditorAIController({
+    getAuthToken: authController.getAuthToken
+  });
+  const clearAllSuggestions = useCallback(() => {
+    setSuggestions({});
+  }, []);
+  const enhance = useCallback(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") {
+          const projectId_0 = e.data.projectId;
+          displayNeededSubscriptionSnackbar(projectId_0);
+        } 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);
+      }
+    });
+  }, [authController, urlController, path, clearSuggestion, clearAllSuggestions, properties, host, apiKey, collection, updateSuggestedValues, appendValueDelta, displayNeededSubscriptionSnackbar, snackbarController]);
+  const getSamplePrompts = useCallback(async (entityName, input) => {
+    const firebaseToken_0 = await authController.getAuthToken();
+    return fetchEntityPromptSuggestion({
+      host,
+      entityName,
+      firebaseToken: firebaseToken_0,
+      apiKey,
+      input
+    });
+  }, [apiKey, authController.getAuthToken, host]);
+  const dataEnhancementController = useMemo(() => ({
+    enabled,
+    suggestions,
+    clearSuggestion,
+    enhance,
+    allowReferenceDataSelection,
+    clearAllSuggestions,
+    getSamplePrompts,
+    loadingSuggestions,
+    editorAIController
+  }), [enabled, suggestions, clearSuggestion, enhance, allowReferenceDataSelection, clearAllSuggestions, getSamplePrompts, loadingSuggestions, editorAIController]);
+  return /* @__PURE__ */ jsx(DataEnhancementControllerContext.Provider, { value: dataEnhancementController, children });
+}
+function FormEnhanceAction({
+  entityId,
+  path,
+  status,
+  collection,
+  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, 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(XIcon, { size: iconSize.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-950 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(XIcon, { size: iconSize.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.ui?.markdown || p.ui?.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 $ = c(5);
+  const apiKey = props?.apiKey ?? DEFAULT_API_KEY;
+  const getConfigForPath = props?.getConfigForPath;
+  props?.host;
+  let t0;
+  let t1;
+  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t1 = [{
+      slot: "form.actions",
+      Component: FormEnhanceAction,
+      order: 40
+    }];
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const t2 = props?.host;
+  let t3;
+  if ($[1] !== apiKey || $[2] !== getConfigForPath || $[3] !== t2) {
+    t3 = {
+      key: "data_enhancement",
+      slots: t1,
+      providers: [{
+        scope: "form",
+        Component: DataEnhancementControllerProvider,
+        props: {
+          apiKey,
+          getConfigForPath,
+          host: t2
+        }
+      }]
+    };
+    $[1] = apiKey;
+    $[2] = getConfigForPath;
+    $[3] = t2;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  t0 = t3;
+  return t0;
+}
+export {
+  useDataEnhancementPlugin,
+  useEditorAIController
+};
+//# sourceMappingURL=index.es.js.map