@rebasepro/plugin-data-enhancement 0.0.1-canary.09e5ec5

package/dist/index.umd.js

@@ -0,0 +1,746 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("react-compiler-runtime"), require("react/jsx-runtime"), require("react"), require("@rebasepro/core"), require("@rebasepro/admin"), require("@rebasepro/common"), require("@rebasepro/utils"), require("@rebasepro/ui"), require("lucide-react")) : typeof define === "function" && define.amd ? define(["exports", "react-compiler-runtime", "react/jsx-runtime", "react", "@rebasepro/core", "@rebasepro/admin", "@rebasepro/common", "@rebasepro/utils", "@rebasepro/ui", "lucide-react"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.Rebase = {}, global.reactCompilerRuntime, global.jsxRuntime, global.React, global.core, global.admin, global.common, global.utils, global.ui, global.lucideReact));
+})(this, (function(exports2, reactCompilerRuntime, jsxRuntime, React, core, admin, common, utils, ui, lucideReact) {
+  "use strict";
+  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 (common.isPropertyBuilder(property)) return {};
+      const fullKey = path ? `${path}.${key}` : key;
+      const valueInPath = utils.getValueInPath(values, fullKey);
+      return getSimplifiedProperty(property, fullKey, valueInPath);
+    }).reduce((a, b) => ({
+      ...a,
+      ...b
+    }), {});
+  }
+  function getSimpleProperty(property) {
+    const fieldId = admin.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 (common.isPropertyBuilder(property)) return {};
+    if (property.type === "array") {
+      if (property.of && !Array.isArray(property.of) && !common.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) => {
+          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.disabled || property.readOnly)
+        };
+        return {
+          [path]: mapParentProperty,
+          ...mapProperties
+        };
+      }
+    } else {
+      const fieldId = admin.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 React.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] = React.useState(false);
+    const [suggestions, setSuggestions] = React.useState({});
+    const [loadingSuggestions, setLoadingSuggestions] = React.useState([]);
+    const enhancingInProgress = React.useRef(false);
+    const authController = core.useAuthController();
+    const snackbarController = core.useSnackbarController();
+    const properties = React.useMemo(() => getSimplifiedProperties(collection.properties, formContext?.values ?? {}), [formContext?.values]);
+    const valuesRef = React.useRef(formContext?.values ?? {});
+    React.useEffect(() => {
+      if (!enhancingInProgress.current) valuesRef.current = formContext?.values ?? {};
+    }, [formContext?.values]);
+    const allowReferenceDataSelection = false;
+    const updateConfig = React.useCallback(async () => {
+      if (!getConfigForPath) return;
+      const config = getConfigForPath({
+        path,
+        collection
+      });
+      if (config) {
+        setEnabled(true);
+      }
+    }, [collection, getConfigForPath, path]);
+    React.useEffect(() => {
+      if (!getConfigForPath) {
+        setEnabled(true);
+      } else {
+        updateConfig();
+      }
+    }, [getConfigForPath, updateConfig]);
+    const urlController = admin.useUrlController();
+    const clearSuggestion = React.useCallback((propertyKey) => {
+      setSuggestions((prev) => {
+        const {
+          [propertyKey]: _,
+          ...rest
+        } = prev;
+        return rest;
+      });
+    }, []);
+    const appendValueDelta = React.useCallback((propertyKey_0, delta) => {
+      const property = getPropertyFromKey(properties, propertyKey_0);
+      if (delta === null || property?.disabled) {
+        return;
+      }
+      const value = utils.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 = React.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 = utils.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 = utils.getValueInPath(formContext?.values, key);
+          const suggestion_0 = updatedValues[key];
+          return {
+            ...acc,
+            [key]: getAppendableSuggestion(suggestion_0, value_1) ?? suggestion_0
+          };
+        }, {})
+      }));
+    }, [properties, formContext]);
+    const displayNeededSubscriptionSnackbar = React.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 = React.useCallback(() => {
+      setSuggestions({});
+    }, []);
+    const enhance = React.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 = React.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 = React.useMemo(() => ({
+      enabled,
+      suggestions,
+      clearSuggestion,
+      enhance,
+      allowReferenceDataSelection,
+      clearAllSuggestions,
+      getSamplePrompts,
+      loadingSuggestions,
+      editorAIController
+    }), [enabled, suggestions, clearSuggestion, enhance, allowReferenceDataSelection, clearAllSuggestions, getSamplePrompts, loadingSuggestions, editorAIController]);
+    return /* @__PURE__ */ jsxRuntime.jsx(DataEnhancementControllerContext.Provider, { value: dataEnhancementController, children });
+  }
+  function FormEnhanceAction({
+    entityId,
+    path,
+    status,
+    collection,
+    formContext,
+    openEntityMode
+  }) {
+    const largeLayout = core.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 = React.useRef(false);
+    const updateSuggestedPrompts = React.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]);
+    React.useDeferredValue(formContext?.values);
+    React.useEffect(() => {
+      if (!samplePrompts) {
+        setSamplePrompts(getRecentPromptsFromStorage(storageKey));
+        updateSuggestedPrompts().then();
+      }
+    }, [samplePrompts, storageKey, updateSuggestedPrompts, instructions, status]);
+    React.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__ */ jsxRuntime.jsxs(ui.Menu, { align: "end", sideOffset: 8, className: "max-w-[100vw]", trigger: /* @__PURE__ */ jsxRuntime.jsxs(ui.Button, { variant: "filled", color: "neutral", fullWidth: largeLayout && openEntityMode === "full_screen", size: "small", disabled: loading, children: [
+      !loading && /* @__PURE__ */ jsxRuntime.jsx(core.AIIcon, { size: "small" }),
+      loading && /* @__PURE__ */ jsxRuntime.jsx(ui.CircularProgress, { size: "small" }),
+      "Autofill"
+    ] }), children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ui.MenuItem, { className: "py-4", onClick: () => {
+        enhance();
+      }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(core.AIIcon, { size: "small" }),
+        "Autofill based on the current content"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Separator, { orientation: "horizontal", className: "mt-2" }),
+      samplePrompts?.map((samplePrompt, index) => {
+        return /* @__PURE__ */ jsxRuntime.jsxs(ui.MenuItem, { onClick: () => {
+          setInstructions(samplePrompt.prompt);
+          enhance(samplePrompt.prompt);
+        }, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "pl-9 grow text-text-secondary dark:text-text-secondary-dark", children: samplePrompt.prompt }),
+          samplePrompt.type === "recent" && /* @__PURE__ */ jsxRuntime.jsx(ui.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__ */ jsxRuntime.jsx(lucideReact.XIcon, { size: ui.iconSize.smallest }) })
+        ] }, index + "_" + samplePrompt.prompt);
+      }),
+      /* @__PURE__ */ jsxRuntime.jsx(ui.Separator, { orientation: "horizontal" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: ui.cls("my-2 w-[500px] max-w-full flex items-start text-surface-700 dark:text-surface-200"), children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ui.TextareaAutosize, { className: ui.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", ui.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__ */ jsxRuntime.jsx(ui.IconButton, { size: "small", onClick: () => {
+          setInstructions("");
+        }, color: !instructions ? "primary" : void 0, disabled: loading || !instructions, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.XIcon, { size: ui.iconSize.small }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(ui.IconButton, { onClick: () => enhance(instructions), size: "small", color: !instructions ? "primary" : void 0, disabled: loading || !instructions, children: [
+          loading && /* @__PURE__ */ jsxRuntime.jsx(ui.CircularProgress, { size: "smallest" }),
+          !loading && /* @__PURE__ */ jsxRuntime.jsx(lucideReact.SendIcon, { color: "primary" })
+        ] })
+      ] })
+    ] });
+  }
+  function getPromptsForExistingEntities(properties) {
+    const multilineProperties = Object.values(properties).filter((p) => {
+      if (common.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}::${common.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 $ = reactCompilerRuntime.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;
+  }
+  exports2.useDataEnhancementPlugin = useDataEnhancementPlugin;
+  exports2.useEditorAIController = useEditorAIController;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+}));
+//# sourceMappingURL=index.umd.js.map