Skip to content

LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows

4.0 KB
Raw Blame
import debounce from "lodash/debounce";
import PropTypes from "prop-types";
import { useCallback, useEffect, useRef, useState } from "react";
import { Input } from "@/components/ui/shims/antd-inputs";
import { Typography } from "@/components/ui/shims/antd-typography";

import "./EditableText.css";
import { useCustomToolStore } from "../../../store/custom-tool-store";

function EditableText({
  isEditing,
  setIsEditing,
  text,
  setText,
  promptId,
  defaultText,
  handleChange,
  isTextarea,
  placeHolder,
  isCoverageLoading,
  error,
}) {
  const name = isTextarea ? "prompt" : "prompt_key";
  const [triggerHandleChange, setTriggerHandleChange] = useState(false);
  const [isHovered, setIsHovered] = useState(false);
  const divRef = useRef(null);
  const { isSinglePassExtractLoading, isPublicSource } = useCustomToolStore();

  useEffect(() => {
    // A rejected edit rolls the stored value back; keep the typed text on
    // screen so the user can correct it in place.
    if (error) {
      return;
    }
    setText(defaultText);
  }, [defaultText]);

  useEffect(() => {
    // Attach the event listener when the component mounts
    document.addEventListener("click", handleClickOutside);

    // Clean up the event listener when the component unmounts
    return () => {
      document.removeEventListener("click", handleClickOutside);
    };
  }, []);

  const handleBlur = () => {
    setIsEditing(false);
  };

  const handleTextChange = (event) => {
    const value = event.target.value;
    setText(value);
    onSearchDebounce(event);
  };

  const onSearchDebounce = useCallback(
    debounce((event) => {
      setTriggerHandleChange(true);
    }, 1000),
    [],
  );

  useEffect(() => {
    if (!triggerHandleChange) {
      return;
    }
    handleChange(text, promptId, name, true, false).catch(() => {});
    setTriggerHandleChange(false);
  }, [triggerHandleChange]);

  const handleClickOutside = (event) => {
    if (divRef.current && !divRef.current.contains(event.target)) {
      // Clicked outside the div
      setIsEditing(false);
    }
  };

  if (isTextarea) {
    return (
      <Input.TextArea
        className="font-size-12 width-100"
        value={text}
        onChange={handleTextChange}
        placeholder={placeHolder}
        name={name}
        size="small"
        style={{ backgroundColor: "transparent" }}
        variant={`${!isEditing && !isHovered ? "borderless" : "outlined"}`}
        autoSize={true}
        onMouseOver={() => setIsHovered(true)}
        onMouseOut={() => setIsHovered(false)}
        onBlur={handleBlur}
        onClick={() => setIsEditing(true)}
        disabled={
          isCoverageLoading || isSinglePassExtractLoading || isPublicSource
        }
      />
    );
  }

  return (
    <>
      <Input
        className="width-100 input-header-text"
        value={text}
        onChange={handleTextChange}
        placeholder="Enter Key"
        name={name}
        size="small"
        style={{ backgroundColor: "transparent" }}
        variant={`${!isEditing && !isHovered ? "borderless" : "outlined"}`}
        autoSize={true}
        onMouseOver={() => setIsHovered(true)}
        onMouseOut={() => setIsHovered(false)}
        onBlur={handleBlur}
        onClick={() => setIsEditing(true)}
        disabled={
          isCoverageLoading || isSinglePassExtractLoading || isPublicSource
        }
        status={error ? "error" : undefined}
      />
      {error && (
        <Typography.Text type="danger" className="editable-text-error-message">
          {error}
        </Typography.Text>
      )}
    </>
  );
}

EditableText.propTypes = {
  isEditing: PropTypes.bool.isRequired,
  setIsEditing: PropTypes.func.isRequired,
  text: PropTypes.string,
  setText: PropTypes.func.isRequired,
  promptId: PropTypes.string,
  defaultText: PropTypes.string,
  handleChange: PropTypes.func.isRequired,
  isTextarea: PropTypes.bool,
  placeHolder: PropTypes.string,
  isCoverageLoading: PropTypes.bool.isRequired,
  error: PropTypes.string,
};

export { EditableText };