@rebasepro/plugin-ai 0.0.1-canary.4829d6e

package/dist/index.es.js

@@ -0,0 +1,741 @@
+import React, { useCallback, useContext, useDeferredValue, useEffect, useMemo, useRef, useState } from "react";
+import { AIIcon, useAuthController, useLargeLayout, useSnackbarController } from "@rebasepro/app";
+import { getFieldId, useUrlController } from "@rebasepro/admin";
+import { isPropertyBuilder, stripCollectionPath } from "@rebasepro/common";
+import { getValueInPath } from "@rebasepro/utils";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, CircularProgress, IconButton, Menu, MenuItem, SendIcon, Separator, TextareaAutosize, XIcon, cls, focusedDisabled, iconSize } from "@rebasepro/ui";
+//#region src/utils/values.ts
+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
+	}), {});
+}
+//#endregion
+//#region src/api.ts
+var DEFAULT_SERVER = "https://api.rebase.pro";
+async function enhanceDataAPIStream(props) {
+	const flatValues = flatMapEntityValues(props.values);
+	const properties = props.properties;
+	const request = {
+		inputEntity: {
+			entityId: props.entityId,
+			values: flatValues
+		},
+		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/", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Basic ${props.firebaseToken}`,
+			"x-de-api-key": `Basic ${props.apiKey}`
+		},
+		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 instanceof Error ? e : new Error(String(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/", {
+		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/", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Basic ${props.firebaseToken}`
+		},
+		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;
+	});
+}
+//#endregion
+//#region src/utils/suggestions.ts
+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;
+}
+//#endregion
+//#region src/utils/properties.ts
+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;
+		return getSimplifiedProperty(property, fullKey, getValueInPath(values, fullKey));
+	}).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)
+			};
+			return { [path]: arrayParentProperty };
+		} 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]) => {
+				return getSimplifiedProperty(childProperty, key, value && typeof value === "object" ? value[key] : void 0);
+			}).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 {
+		if (!getFieldId(property)) {
+			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]) => {
+		return { [path ? `${path}.${key}` : key]: 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");
+}
+//#endregion
+//#region src/editor/useEditorAIController.tsx
+function useEditorAIController({ getAuthToken }) {
+	const autocomplete = async (textBefore, textAfter, onUpdate) => {
+		if (!getAuthToken) throw new Error("Firebase token is required");
+		return autocompleteStream({
+			firebaseToken: await getAuthToken(),
+			textBefore,
+			textAfter,
+			onUpdate
+		});
+	};
+	return { autocomplete };
+}
+//#endregion
+//#region src/components/DataEnhancementControllerProvider.tsx
+var DataEnhancementControllerContext = React.createContext(null);
+var useDataEnhancementController = () => useContext(DataEnhancementControllerContext);
+function getPropertyFromKey(properties, propertyKey) {
+	if (propertyKey in properties) return properties[propertyKey];
+	else {
+		const split = propertyKey.split(".");
+		if (split.length === 1) return;
+		return getPropertyFromKey(properties, split.slice(0, split.length - 1).join("."));
+	}
+}
+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;
+		if (getConfigForPath({
+			path,
+			collection
+		})) 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, delta) => {
+		const property = getPropertyFromKey(properties, propertyKey);
+		if (delta === null || property?.disabled) return;
+		const value = getValueInPath(valuesRef.current, propertyKey);
+		const updatedValue = (value ? value + "" : "") + delta;
+		valuesRef.current = {
+			...valuesRef.current,
+			[propertyKey]: updatedValue
+		};
+		formContext?.setFieldValue(propertyKey, updatedValue, false);
+		setSuggestions((prev) => ({
+			...prev,
+			[propertyKey]: (prev[propertyKey] ?? "") + delta
+		}));
+	}, [properties, formContext]);
+	const updateSuggestedValues = useCallback((currentValues, updatedValues, replaceValues) => {
+		setLoadingSuggestions((prev) => {
+			return prev.filter((p) => !Object.keys(updatedValues).includes(p));
+		});
+		Object.entries(updatedValues).forEach(([propertyKey, suggestion]) => {
+			const value = getValueInPath(currentValues, propertyKey);
+			const property = getPropertyFromKey(properties, propertyKey);
+			if (!property || suggestion === null || property?.disabled) return;
+			if (typeof suggestion === "number") {
+				formContext?.setFieldValue(propertyKey, suggestion);
+				return;
+			}
+			if (replaceValues) {
+				formContext?.setFieldValue(propertyKey, suggestion);
+				return;
+			}
+			const appendableValue = getAppendableSuggestion(suggestion, value);
+			const currentValue = value ? value + "" : "";
+			if (appendableValue) formContext?.setFieldValue(propertyKey, suggestion);
+			else {
+				const multiline = property?.fieldConfigId === "multiline" || property?.fieldConfigId === "markdown";
+				const trimmedValue = currentValue.trimEnd();
+				if (multiline && (trimmedValue.endsWith(".") || trimmedValue.endsWith("?") || trimmedValue.endsWith("!") || trimmedValue.endsWith(":"))) formContext?.setFieldValue(propertyKey, trimmedValue + "\n\n" + suggestion.trimStart());
+				else formContext?.setFieldValue(propertyKey, trimmedValue + (trimmedValue.length > 0 ? " " : "") + suggestion);
+			}
+		});
+		setSuggestions((prev) => ({
+			...prev,
+			...Object.keys(updatedValues).reduce((acc, key) => {
+				const value = getValueInPath(formContext?.values, key);
+				const suggestion = updatedValues[key];
+				return {
+					...acc,
+					[key]: getAppendableSuggestion(suggestion, value) ?? suggestion
+				};
+			}, {})
+		}));
+	}, [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(/* @__PURE__ */ 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) => [...prev, ...props.propertyKey ? [props.propertyKey] : Object.keys(properties)]);
+		enhancingInProgress.current = true;
+		const currentValues = valuesRef.current ?? {};
+		return new Promise((resolve, reject) => {
+			function onError(e) {
+				setLoadingSuggestions([]);
+				const errorObj = e instanceof Error ? e : typeof e === "object" && e !== null ? e : new Error(String(e));
+				if (errorObj.code === "payment-required") {
+					const projectId = errorObj.data?.projectId;
+					displayNeededSubscriptionSnackbar(projectId);
+				} 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) => {
+						console.debug("de onUpdate", suggestions);
+						updateSuggestedValues(currentValues, suggestions, props.replaceValues ?? false);
+					},
+					onUpdateDelta: (propertyKey, partialValue) => {
+						appendValueDelta(propertyKey, 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) {
+				onError(e);
+			}
+		});
+	}, [
+		authController,
+		urlController,
+		path,
+		clearSuggestion,
+		clearAllSuggestions,
+		properties,
+		host,
+		apiKey,
+		collection,
+		updateSuggestedValues,
+		appendValueDelta,
+		displayNeededSubscriptionSnackbar,
+		snackbarController
+	]);
+	const getSamplePrompts = useCallback(async (entityName, input) => {
+		return fetchEntityPromptSuggestion({
+			host,
+			entityName,
+			firebaseToken: await authController.getAuthToken(),
+			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
+	});
+}
+//#endregion
+//#region src/components/FormEnhanceAction.tsx
+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 getSamplePrompts = dataEnhancementController?.getSamplePrompts;
+	const loadingPrompts = useRef(false);
+	const updateSuggestedPrompts = useCallback(async function updateSuggestedPrompts(instructions) {
+		if (!getSamplePrompts) return;
+		if (loadingPrompts.current) return;
+		loadingPrompts.current = true;
+		const prompts = status === "new" ? (await getSamplePrompts(collection.singularName ?? collection.name, instructions)).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 (!dataEnhancementController) return;
+		if (!samplePrompts) {
+			setSamplePrompts(getRecentPromptsFromStorage(storageKey));
+			updateSuggestedPrompts().then();
+		}
+	}, [
+		dataEnhancementController,
+		samplePrompts,
+		storageKey,
+		updateSuggestedPrompts,
+		instructions,
+		status
+	]);
+	useEffect(() => {
+		if (!dataEnhancementController) return;
+		updateSuggestedPrompts().then();
+	}, [dataEnhancementController, status]);
+	const enhance = (prompt) => {
+		if (!dataEnhancementController || !formContext?.values) return;
+		setLoading(true);
+		if (prompt) {
+			addRecentPrompt(storageKey, prompt);
+			setSamplePrompts([{
+				prompt,
+				type: "recent"
+			}, ...(samplePrompts ?? []).slice(0, 5)]);
+		}
+		return dataEnhancementController.enhance({
+			entityId,
+			values: formContext.values,
+			instructions: prompt,
+			replaceValues: true
+		}).finally(() => {
+			setLoading(false);
+		});
+	};
+	if (!dataEnhancementController?.enabled) return null;
+	const suggestions = dataEnhancementController.suggestions;
+	Object.values(suggestions).filter(Boolean).length;
+	(samplePrompts ?? []).length > 0 && instructions.length;
+	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) => p.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) => {
+							e.stopPropagation();
+							if (e.key === "Enter" && !e.shiftKey) {
+								e.preventDefault();
+								submit();
+							}
+						},
+						onChange: (e) => {
+							setInstructions(e.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"
+	}));
+}
+var createLocalStorageKey = (path, status) => {
+	return `data_enhancement::${status === "new" ? "new" : "existing"}::${stripCollectionPath(path)}`;
+};
+var getRecentPromptsFromStorage = (storageKey) => {
+	const item = localStorage.getItem(storageKey);
+	return item ? JSON.parse(item).map((e) => ({
+		prompt: e,
+		type: "recent"
+	})) : [];
+};
+var 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)]));
+};
+var removeRecentPrompt = (storageKey, prompt) => {
+	localStorage.setItem(storageKey, JSON.stringify(getRecentPromptsFromStorage(storageKey).map((e) => e.prompt).filter((e) => e !== prompt)));
+};
+//#endregion
+//#region src/useDataEnhancementPlugin.tsx
+var DEFAULT_API_KEY = "fcms-U9jdDii0xXWSDC34asfrf54lbkFJBfKfRWcEDEwdc4V5wDWEDF";
+/**
+* Use this hook to initialise the data enhancement plugin.
+* This is likely the only hook you will need to use.
+* @param props
+*/
+function useDataEnhancementPlugin(props) {
+	const apiKey = props?.apiKey ?? DEFAULT_API_KEY;
+	const getConfigForPath = props?.getConfigForPath;
+	return React.useMemo(() => ({
+		key: "data_enhancement",
+		slots: [{
+			slot: "form.actions",
+			Component: FormEnhanceAction,
+			order: 40
+		}],
+		providers: [{
+			scope: "form",
+			Component: DataEnhancementControllerProvider,
+			props: {
+				apiKey,
+				getConfigForPath,
+				host: props?.host
+			}
+		}]
+	}), [
+		apiKey,
+		getConfigForPath,
+		props?.host
+	]);
+}
+//#endregion
+export { useDataEnhancementPlugin, useEditorAIController };
+
+//# sourceMappingURL=index.es.js.map