Skip to content

Free, simple, and intuitive online database diagram editor and SQL generator.

84.2 KB
Raw Blame
import { useContext, useEffect, useMemo, useState } from "react";
import { v4 as uuidv4 } from "uuid";
import { Slot, useExtensions } from "../../context/ExtensionsContext";
import { createPortal } from "react-dom";
import {
  IconCaretdown,
  IconChevronRight,
  IconChevronLeft,
  IconSaveStroked,
  IconUndo,
  IconRedo,
  IconEdit,
  IconShareStroked,
} from "@douyinfe/semi-icons";
import { Link, useMatch, useParams } from "react-router-dom";
import icon from "../../assets/icon_dark_64.png";
import {
  Button,
  Divider,
  Dropdown,
  InputNumber,
  Tooltip,
  Spin,
  Tag,
  Badge,
  Toast,
  Popconfirm,
  Typography,
  Modal as SemiModal,
} from "@douyinfe/semi-ui";
import { toPng, toJpeg, toSvg } from "html-to-image";
import {
  jsonToMySQL,
  jsonToPostgreSQL,
  jsonToSQLite,
  jsonToMariaDB,
  jsonToSQLServer,
  jsonToOracleSQL,
} from "../../utils/exportSQL/generic";
import {
  ObjectType,
  Action,
  Tab,
  State,
  MODAL,
  SIDESHEET,
  DB,
  IMPORT_FROM,
  noteWidth,
  pngExportPixelRatio,
  keyboardPanStep,
} from "../../data/constants";
import jsPDF from "jspdf";
import { useHotkeys } from "react-hotkeys-hook";
import { Validator } from "jsonschema";
import {
  areaSchema,
  noteSchema,
  tableSchema,
  viewSchema,
} from "../../data/schemas";
import { db } from "../../data/db";
import {
  useLayout,
  useSettings,
  useTransform,
  useDiagram,
  useUndoRedo,
  useSelect,
  useSaveState,
  useTypes,
  useNotes,
  useAreas,
  useEnums,
  useViews,
  useFullscreen,
  useNavigateWithParams,
} from "../../hooks";
import { enterFullscreen, exitFullscreen } from "../../utils/fullscreen";
import { dataURItoBlob } from "../../utils/utils";
import {
  IconAddArea,
  IconAddNote,
  IconAddTable,
  IconAddView,
} from "../../icons";
import LayoutDropdown from "./LayoutDropdown";
import Sidesheet from "./SideSheet/Sidesheet";
import Modal from "./Modal/Modal";
import { useTranslation } from "react-i18next";
import { exportSQL } from "../../utils/exportSQL";
import { databases } from "../../data/databases";
import { jsonToMermaid } from "../../utils/exportAs/mermaid";
import { isRtl } from "../../i18n/utils/rtl";
import { jsonToDocumentation } from "../../utils/exportAs/documentation";
import { IdContext } from "../Workspace";
import { socials } from "../../data/socials";
import { toDBML } from "../../utils/exportAs/dbml";
import { applyDiagramPlan } from "../../utils/dbml/applyPlan";
import { diffDiagram } from "../../utils/dbml/diff";
import { exportSavedData } from "../../utils/exportSavedData";
import { nanoid } from "nanoid";
import {
  getRelatedFieldKeysByTable,
  getTableHeight,
  getTableWidth,
} from "../../utils/utils";
import {
  getViewHeight,
  getViewWidth,
  resolveViewColumns,
} from "../../utils/views";
import { autoArrange } from "../../utils/autoArrange";
import { schemaQueries } from "../../utils/importFrom/schemaQuery";
import { findAutoFKRelationships } from "../../utils/autoRelationships";
import { deleteFromCache, STORAGE_KEY } from "../../utils/cache";
import { DateTime } from "luxon";
import ConfigureCustomTypes from "./ConfigureCustomTypes";
import { useDiagramList } from "./Modal/Open/hooks/useDiagramList";
import { mergeDiagrams, sortDiagrams } from "./Modal/Open/diagram";

const EDITOR_HOTKEY = {
  preventDefault: true,
  ignoreEventWhen: (e) => Boolean(e.target?.closest?.(".monaco-editor")),
};

export default function ControlPanel({
  title,
  setTitle,
  lastSaved,
  setLastSaved,
  toolbarContainer,
  startWith,
  setStartWith,
  onBackToStart,
}) {
  const { id: diagramId } = useParams();

  const [modal, setModal] = useState(MODAL.NONE);
  const [sidesheet, setSidesheet] = useState(SIDESHEET.NONE);
  const [showEditName, setShowEditName] = useState(false);
  const [showAutoConnectModal, setShowAutoConnectModal] = useState(false);
  const [importDb, setImportDb] = useState("");
  const [exportData, setExportData] = useState({
    data: null,
    filename: `${title}_${new Date().toISOString()}`,
    extension: "",
  });

  const openExportModal = (modalType) => {
    setExportData((prev) => ({
      ...prev,
      filename: `${title}_${new Date().toISOString()}`,
    }));
    setModal(modalType);
  };
  const [importFrom, setImportFrom] = useState(IMPORT_FROM.JSON);

  const [openedFromStart, setOpenedFromStart] = useState(false);
  const [seenMenuTags, setSeenMenuTags] = useState(() => {
    try {
      return new Set(
        JSON.parse(localStorage.getItem("drawdb:seenMenuTags") || "[]"),
      );
    } catch {
      return new Set();
    }
  });

  useEffect(() => {
    if (!startWith) return;
    if (startWith.importFrom) setImportFrom(startWith.importFrom);
    setModal(startWith.modal);
    setOpenedFromStart(true);
    setStartWith(null);
  }, [startWith, setStartWith]);

  useEffect(() => {
    if (modal === MODAL.NONE) setOpenedFromStart(false);
  }, [modal]);
  const { saveState, setSaveState } = useSaveState();
  const { layout, setLayout } = useLayout();
  const { settings, setSettings } = useSettings();
  const {
    relationships,
    tables,
    setTables,
    addTable,
    updateTable,
    deleteField,
    deleteTable,
    updateField,
    setRelationships,
    addRelationship,
    deleteRelationship,
    updateRelationship,
    database,
    sqlHeader,
  } = useDiagram();
  const { enums, setEnums, deleteEnum, addEnum, updateEnum } = useEnums();
  const { types, addType, deleteType, updateType, setTypes } = useTypes();
  const { views, setViews, addView, updateView, deleteView } = useViews();
  const { notes, setNotes, updateNote, addNote, deleteNote } = useNotes();
  const { areas, setAreas, updateArea, addArea, deleteArea } = useAreas();
  const { undoStack, redoStack, setUndoStack, setRedoStack } = useUndoRedo();
  const { selectedElement, setSelectedElement } = useSelect();
  const { transform, setTransform } = useTransform();
  const { t, i18n } = useTranslation();
  const { version, gistId, setGistId } = useContext(IdContext);
  const isTemplate = useMatch("/editor/templates/:id");
  const navigate = useNavigateWithParams();
  const extensions = useExtensions();

  const swapDbmlSnapshot = (entry) => {
    const current = { tables, relationships, enums };
    applyDiagramPlan(diffDiagram(current, entry.data.snapshot), {
      addTable,
      updateTable,
      updateField,
      deleteTable,
      addRelationship,
      updateRelationship,
      deleteRelationship,
      setEnums,
    });
    return { ...entry, data: { snapshot: current } };
  };

  const undo = () => {
    if (undoStack.length === 0) return;
    const a = undoStack[undoStack.length - 1];
    setUndoStack((prev) => prev.filter((_, i) => i !== prev.length - 1));

    if (a.bulk) {
      if (a.element === ObjectType.RELATIONSHIP && a.action === Action.ADD) {
        const idsToDelete = new Set((a.relationships || []).map((r) => r.id));
        setRelationships((prev) => prev.filter((r) => !idsToDelete.has(r.id)));
        setRedoStack((prev) => [...prev, a]);
        return;
      }
      for (const element of a.elements) {
        if (element.type === ObjectType.TABLE) {
          updateTable(element.id, element.undo);
        } else if (element.type === ObjectType.AREA) {
          updateArea(element.id, element.undo);
        } else if (element.type === ObjectType.NOTE) {
          updateNote(element.id, element.undo);
        } else if (element.type === ObjectType.VIEW) {
          updateView(element.id, element.undo);
        }
      }
      setRedoStack((prev) => [...prev, a]);
      return;
    }

    if (a.element === ObjectType.DBML) {
      setRedoStack((prev) => [...prev, swapDbmlSnapshot(a)]);
      return;
    }

    if (a.action === Action.ADD) {
      if (a.element === ObjectType.TABLE) {
        deleteTable(a.data.table.id, false);
      } else if (a.element === ObjectType.AREA) {
        deleteArea(a.data.id, false);
      } else if (a.element === ObjectType.NOTE) {
        deleteNote(notes[notes.length - 1].id, false);
      } else if (a.element === ObjectType.RELATIONSHIP) {
        deleteRelationship(a.data.relationship.id, false);
      } else if (a.element === ObjectType.TYPE) {
        deleteType(a.data.type.id, false);
      } else if (a.element === ObjectType.ENUM) {
        deleteEnum(a.data.enum.id, false);
      } else if (a.element === ObjectType.VIEW) {
        deleteView(a.data.view.id, false);
      }
      setRedoStack((prev) => [...prev, a]);
    } else if (a.action === Action.MOVE) {
      if (a.element === ObjectType.TABLE) {
        const { x, y } = tables.find((t) => t.id === a.id);
        setRedoStack((prev) => [...prev, { ...a, x, y }]);
        updateTable(a.id, { x: a.x, y: a.y });
      } else if (a.element === ObjectType.AREA) {
        const { x, y } = areas.find((area) => area.id === a.id);
        setRedoStack((prev) => [...prev, { ...a, x, y }]);
        updateArea(a.id, { x: a.x, y: a.y });
      } else if (a.element === ObjectType.NOTE) {
        setRedoStack((prev) => [
          ...prev,
          { ...a, x: notes[a.id].x, y: notes[a.id].y },
        ]);
        updateNote(a.id, { x: a.x, y: a.y });
      }
    } else if (a.action === Action.DELETE) {
      if (a.element === ObjectType.TABLE) {
        a.data.relationship.forEach((x) => addRelationship(x, false));
        addTable(a.data, false);
      } else if (a.element === ObjectType.RELATIONSHIP) {
        addRelationship(a.data, false);
      } else if (a.element === ObjectType.NOTE) {
        addNote(a.data, false);
      } else if (a.element === ObjectType.AREA) {
        addArea(a.data, false, a.index);
      } else if (a.element === ObjectType.TYPE) {
        addType(a.data, false);
      } else if (a.element === ObjectType.ENUM) {
        addEnum(a.data, false);
      } else if (a.element === ObjectType.VIEW) {
        addView(a.data, false);
      }
      setRedoStack((prev) => [...prev, a]);
    } else if (a.action === Action.EDIT) {
      if (a.element === ObjectType.AREA) {
        updateArea(a.aid, a.undo);
      } else if (a.element === ObjectType.NOTE) {
        updateNote(a.nid, a.undo);
      } else if (a.element === ObjectType.TABLE) {
        const table = tables.find((t) => t.id === a.tid);
        if (a.component === "field") {
          updateField(a.tid, a.fid, a.undo);
        } else if (a.component === "field_delete") {
          setRelationships((prev) => {
            let temp = [...prev];
            a.data.relationship.forEach((r) => {
              temp.splice(r.id, 0, r);
            });
            return temp;
          });
          const updatedFields = table.fields.slice();
          updatedFields.splice(a.data.index, 0, a.data.field);
          updateTable(a.tid, { fields: updatedFields });
        } else if (a.component === "field_add") {
          updateTable(a.tid, {
            fields: table.fields.filter((e) => e.id !== a.fid),
          });
        } else if (a.component === "index_add") {
          updateTable(a.tid, {
            indices: table.indices
              .filter((e) => e.id !== table.indices.length - 1)
              .map((t, i) => ({ ...t, id: i })),
          });
        } else if (a.component === "index") {
          updateTable(a.tid, {
            indices: table.indices.map((index) =>
              index.id === a.iid
                ? {
                    ...index,
                    ...a.undo,
                  }
                : index,
            ),
          });
        } else if (a.component === "index_delete") {
          const updatedIndices = table.indices.slice();
          updatedIndices.splice(a.data.id, 0, a.data);
          updateTable(a.tid, {
            indices: updatedIndices.map((t, i) => ({ ...t, id: i })),
          });
        } else if (a.component === "unique_constraint_add") {
          const constraints = table.uniqueConstraints || [];
          updateTable(a.tid, {
            uniqueConstraints: constraints
              .filter((e) => e.id !== constraints.length - 1)
              .map((t, i) => ({ ...t, id: i })),
          });
        } else if (a.component === "unique_constraint") {
          updateTable(a.tid, {
            uniqueConstraints: (table.uniqueConstraints || []).map(
              (constraint) =>
                constraint.id === a.cid
                  ? {
                      ...constraint,
                      ...a.undo,
                    }
                  : constraint,
            ),
          });
        } else if (a.component === "unique_constraint_delete") {
          const updatedConstraints = (table.uniqueConstraints || []).slice();
          updatedConstraints.splice(a.data.id, 0, a.data);
          updateTable(a.tid, {
            uniqueConstraints: updatedConstraints.map((t, i) => ({
              ...t,
              id: i,
            })),
          });
        } else if (a.component === "self") {
          updateTable(a.tid, a.undo);
        }
      } else if (a.element === ObjectType.RELATIONSHIP) {
        updateRelationship(a.rid, a.undo);
      } else if (a.element === ObjectType.TYPE) {
        if (a.component === "field_add") {
          const type = types.find((t, i) =>
            typeof a.tid === "number" ? i === a.tid : t.id === a.tid,
          );
          updateType(a.tid, {
            fields: type.fields.filter((f, i) =>
              f.id ? f.id !== a.data.field.id : i !== type.fields.length - 1,
            ),
          });
        }
        if (a.component === "field") {
          updateType(a.tid, {
            fields: types[a.tid].fields.map((e, i) =>
              i === a.fid ? { ...e, ...a.undo } : e,
            ),
          });
        } else if (a.component === "field_delete") {
          setTypes((prev) =>
            prev.map((t, i) => {
              if (i === a.tid) {
                const temp = t.fields.slice();
                temp.splice(a.fid, 0, a.data);
                return { ...t, fields: temp };
              }
              return t;
            }),
          );
        } else if (a.component === "self") {
          updateType(a.tid, a.undo);
          if (a.updatedFields) {
            if (a.undo.name) {
              a.updatedFields.forEach((x) =>
                updateField(x.tid, x.fid, { type: a.undo.name.toUpperCase() }),
              );
            }
          }
        }
      } else if (a.element === ObjectType.VIEW) {
        updateView(a.vid, a.undo);
      } else if (a.element === ObjectType.ENUM) {
        updateEnum(a.id, a.undo);
        if (a.updatedFields) {
          if (a.undo.name) {
            a.updatedFields.forEach((x) =>
              updateField(x.tid, x.fid, { type: a.undo.name.toUpperCase() }),
            );
          }
        }
      }
      setRedoStack((prev) => [...prev, a]);
    }
  };

  const redo = () => {
    if (redoStack.length === 0) return;
    const a = redoStack[redoStack.length - 1];
    setRedoStack((prev) => prev.filter((e, i) => i !== prev.length - 1));

    if (a.bulk) {
      if (a.element === ObjectType.RELATIONSHIP && a.action === Action.ADD) {
        setRelationships((prev) => [...prev, ...(a.relationships || [])]);
        setUndoStack((prev) => [...prev, a]);
        return;
      }
      for (const element of a.elements) {
        if (element.type === ObjectType.TABLE) {
          updateTable(element.id, element.redo);
        } else if (element.type === ObjectType.AREA) {
          updateArea(element.id, element.redo);
        } else if (element.type === ObjectType.NOTE) {
          updateNote(element.id, element.redo);
        } else if (element.type === ObjectType.VIEW) {
          updateView(element.id, element.redo);
        }
      }
      setUndoStack((prev) => [...prev, a]);
      return;
    }

    if (a.element === ObjectType.DBML) {
      setUndoStack((prev) => [...prev, swapDbmlSnapshot(a)]);
      return;
    }

    if (a.action === Action.ADD) {
      if (a.element === ObjectType.TABLE) {
        addTable(a.data, false);
      } else if (a.element === ObjectType.AREA) {
        addArea(a.data, false);
      } else if (a.element === ObjectType.NOTE) {
        addNote(null, false);
      } else if (a.element === ObjectType.RELATIONSHIP) {
        addRelationship(a.data, false);
      } else if (a.element === ObjectType.TYPE) {
        addType(a.data, false);
      } else if (a.element === ObjectType.ENUM) {
        addEnum(a.data, false);
      } else if (a.element === ObjectType.VIEW) {
        addView(a.data, false);
      }
      setUndoStack((prev) => [...prev, a]);
    } else if (a.action === Action.MOVE) {
      if (a.element === ObjectType.TABLE) {
        const { x, y } = tables.find((t) => t.id == a.id);
        setUndoStack((prev) => [...prev, { ...a, x, y }]);
        updateTable(a.id, { x: a.x, y: a.y });
      } else if (a.element === ObjectType.AREA) {
        const { x, y } = areas.find((area) => area.id === a.id);
        setUndoStack((prev) => [...prev, { ...a, x, y }]);
        updateArea(a.id, { x: a.x, y: a.y });
      } else if (a.element === ObjectType.NOTE) {
        setUndoStack((prev) => [
          ...prev,
          { ...a, x: notes[a.id].x, y: notes[a.id].y },
        ]);
        updateNote(a.id, { x: a.x, y: a.y });
      }
    } else if (a.action === Action.DELETE) {
      if (a.element === ObjectType.TABLE) {
        deleteTable(a.data.table.id, false);
      } else if (a.element === ObjectType.RELATIONSHIP) {
        deleteRelationship(a.data.relationship.id, false);
      } else if (a.element === ObjectType.NOTE) {
        deleteNote(a.data.id, false);
      } else if (a.element === ObjectType.AREA) {
        deleteArea(a.data.id, false);
      } else if (a.element === ObjectType.TYPE) {
        deleteType(a.data.type.id, false);
      } else if (a.element === ObjectType.ENUM) {
        deleteEnum(a.data.enum.id, false);
      } else if (a.element === ObjectType.VIEW) {
        deleteView(a.data.view.id, false);
      }
      setUndoStack((prev) => [...prev, a]);
    } else if (a.action === Action.EDIT) {
      if (a.element === ObjectType.AREA) {
        updateArea(a.aid, a.redo);
      } else if (a.element === ObjectType.NOTE) {
        updateNote(a.nid, a.redo);
      } else if (a.element === ObjectType.TABLE) {
        const table = tables.find((t) => t.id === a.tid);
        if (a.component === "field") {
          updateField(a.tid, a.fid, a.redo);
        } else if (a.component === "field_delete") {
          deleteField(a.data.field, a.tid, false);
        } else if (a.component === "field_add") {
          updateTable(a.tid, {
            fields: [
              ...table.fields,
              {
                name: "",
                type: "",
                default: "",
                check: "",
                primary: false,
                unique: false,
                notNull: false,
                increment: false,
                comment: "",
                id: nanoid(),
              },
            ],
          });
        } else if (a.component === "index_add") {
          updateTable(a.tid, {
            indices: [
              ...table.indices,
              {
                id: table.indices.length,
                name: `index_${table.indices.length}`,
                fields: [],
              },
            ],
          });
        } else if (a.component === "index") {
          updateTable(a.tid, {
            indices: table.indices.map((index) =>
              index.id === a.iid
                ? {
                    ...index,
                    ...a.redo,
                  }
                : index,
            ),
          });
        } else if (a.component === "index_delete") {
          updateTable(a.tid, {
            indices: table.indices
              .filter((e) => e.id !== a.data.id)
              .map((t, i) => ({ ...t, id: i })),
          });
        } else if (a.component === "unique_constraint_add") {
          const constraints = table.uniqueConstraints || [];
          updateTable(a.tid, {
            uniqueConstraints: [
              ...constraints,
              {
                id: constraints.length,
                name: `${table.name}_unique_${constraints.length}`,
                fields: [],
              },
            ],
          });
        } else if (a.component === "unique_constraint") {
          updateTable(a.tid, {
            uniqueConstraints: (table.uniqueConstraints || []).map(
              (constraint) =>
                constraint.id === a.cid
                  ? {
                      ...constraint,
                      ...a.redo,
                    }
                  : constraint,
            ),
          });
        } else if (a.component === "unique_constraint_delete") {
          updateTable(a.tid, {
            uniqueConstraints: (table.uniqueConstraints || [])
              .filter((e) => e.id !== a.data.id)
              .map((t, i) => ({ ...t, id: i })),
          });
        } else if (a.component === "self") {
          updateTable(a.tid, a.redo, false);
        }
      } else if (a.element === ObjectType.RELATIONSHIP) {
        updateRelationship(a.rid, a.redo);
      } else if (a.element === ObjectType.TYPE) {
        if (a.component === "field_add") {
          const type = types.find((t, i) =>
            typeof a.tid === "number" ? i === a.tid : t.id === a.tid,
          );
          updateType(a.tid, {
            fields: [...type.fields, a.data.field],
          });
        } else if (a.component === "field") {
          updateType(a.tid, {
            fields: types[a.tid].fields.map((e, i) =>
              i === a.fid ? { ...e, ...a.redo } : e,
            ),
          });
        } else if (a.component === "field_delete") {
          updateType(a.tid, {
            fields: types[a.tid].fields.filter((field, i) => i !== a.fid),
          });
        } else if (a.component === "self") {
          updateType(a.tid, a.redo);
          if (a.updatedFields) {
            if (a.redo.name) {
              a.updatedFields.forEach((x) =>
                updateField(x.tid, x.fid, { type: a.redo.name.toUpperCase() }),
              );
            }
          }
        }
      } else if (a.element === ObjectType.VIEW) {
        updateView(a.vid, a.redo);
      } else if (a.element === ObjectType.ENUM) {
        updateEnum(a.id, a.redo);
        if (a.updatedFields) {
          if (a.redo.name) {
            a.updatedFields.forEach((x) =>
              updateField(x.tid, x.fid, { type: a.redo.name.toUpperCase() }),
            );
          }
        }
      }
      setUndoStack((prev) => [...prev, a]);
    }
  };

  const fileImport = () => setModal(MODAL.IMPORT);
  const viewGrid = () =>
    setSettings((prev) => ({ ...prev, showGrid: !prev.showGrid }));
  const snapToGrid = () =>
    setSettings((prev) => ({ ...prev, snapToGrid: !prev.snapToGrid }));
  const zoomIn = () =>
    setTransform((prev) => ({ ...prev, zoom: prev.zoom * 1.2 }));
  const zoomOut = () =>
    setTransform((prev) => ({ ...prev, zoom: prev.zoom / 1.2 }));
  const panBy = (dx, dy) =>
    setTransform((prev) => ({
      ...prev,
      pan: {
        x: prev.pan.x + dx / prev.zoom,
        y: prev.pan.y + dy / prev.zoom,
      },
    }));
  const panLeft = () => panBy(-keyboardPanStep, 0);
  const panRight = () => panBy(keyboardPanStep, 0);
  const panUp = () => panBy(0, -keyboardPanStep);
  const panDown = () => panBy(0, keyboardPanStep);
  const viewStrictMode = () => {
    setSettings((prev) => ({ ...prev, strictMode: !prev.strictMode }));
  };
  const viewFieldSummary = () => {
    setSettings((prev) => ({
      ...prev,
      showFieldSummary: !prev.showFieldSummary,
    }));
  };
  const copyAsImage = () => {
    toPng(document.getElementById("canvas"), {
      pixelRatio: pngExportPixelRatio,
    }).then(function (dataUrl) {
      const blob = dataURItoBlob(dataUrl);
      navigator.clipboard
        .write([new ClipboardItem({ "image/png": blob })])
        .then(() => {
          Toast.success(t("copied_to_clipboard"));
        })
        .catch(() => {
          Toast.error(t("oops_smth_went_wrong"));
        });
    });
  };
  const resetView = () =>
    setTransform((prev) => ({ ...prev, zoom: 1, pan: { x: 0, y: 0 } }));
  const fitWindow = () => fitToView(tables);
  const fitToView = (tablesToFit) => {
    const canvas = document.getElementById("canvas").getBoundingClientRect();

    const minMaxXY = {
      minX: Infinity,
      minY: Infinity,
      maxX: -Infinity,
      maxY: -Infinity,
    };

    const relatedFieldKeysByTable = getRelatedFieldKeysByTable(relationships);
    tablesToFit.forEach((table) => {
      minMaxXY.minX = Math.min(minMaxXY.minX, table.x);
      minMaxXY.minY = Math.min(minMaxXY.minY, table.y);
      minMaxXY.maxX = Math.max(minMaxXY.maxX, table.x + getTableWidth(table));
      minMaxXY.maxY = Math.max(
        minMaxXY.maxY,
        table.y +
          getTableHeight(
            table,
            settings.showComments,
            relatedFieldKeysByTable.get(table.id),
          ),
      );
    });

    views.forEach((view) => {
      minMaxXY.minX = Math.min(minMaxXY.minX, view.x);
      minMaxXY.minY = Math.min(minMaxXY.minY, view.y);
      minMaxXY.maxX = Math.max(minMaxXY.maxX, view.x + getViewWidth(view));
      minMaxXY.maxY = Math.max(
        minMaxXY.maxY,
        view.y +
          getViewHeight(
            view,
            resolveViewColumns(view, tables),
            settings.showComments,
          ),
      );
    });

    areas.forEach((area) => {
      minMaxXY.minX = Math.min(minMaxXY.minX, area.x);
      minMaxXY.minY = Math.min(minMaxXY.minY, area.y);
      minMaxXY.maxX = Math.max(minMaxXY.maxX, area.x + area.width);
      minMaxXY.maxY = Math.max(minMaxXY.maxY, area.y + area.height);
    });

    notes.forEach((note) => {
      minMaxXY.minX = Math.min(minMaxXY.minX, note.x);
      minMaxXY.minY = Math.min(minMaxXY.minY, note.y);
      minMaxXY.maxX = Math.max(
        minMaxXY.maxX,
        note.x + (note.width ?? noteWidth),
      );
      minMaxXY.maxY = Math.max(minMaxXY.maxY, note.y + note.height);
    });

    const padding = 10;
    const width = minMaxXY.maxX - minMaxXY.minX + padding;
    const height = minMaxXY.maxY - minMaxXY.minY + padding;

    const scaleX = canvas.width / width;
    const scaleY = canvas.height / height;
    // Making sure the scale is a multiple of 0.05
    const scale = Math.floor(Math.min(scaleX, scaleY) * 20) / 20;

    const centerX = (minMaxXY.minX + minMaxXY.maxX) / 2;
    const centerY = (minMaxXY.minY + minMaxXY.maxY) / 2;

    setTransform((prev) => ({
      ...prev,
      zoom: scale,
      pan: { x: centerX, y: centerY },
    }));
  };
  const autoArrangeTables = () => {
    const positions = autoArrange(tables, relationships, settings);
    const positionById = new Map(positions.map((p) => [p.id, p]));

    const elements = [];
    const arrangedTables = tables.map((table) => {
      const pos = positionById.get(table.id);
      if (!pos || (pos.x === table.x && pos.y === table.y)) return table;
      elements.push({
        id: table.id,
        type: ObjectType.TABLE,
        undo: { x: table.x, y: table.y },
        redo: { x: pos.x, y: pos.y },
      });
      return { ...table, x: pos.x, y: pos.y };
    });

    if (elements.length === 0) return;

    for (const element of elements) {
      updateTable(element.id, element.redo);
    }
    setUndoStack((prev) => [
      ...prev,
      {
        action: Action.MOVE,
        bulk: true,
        message: t("auto_arrange"),
        elements,
      },
    ]);
    setRedoStack([]);
    fitToView(arrangedTables);
  };
  const autoConnectFKs = () => {
    if (layout.readOnly) return;
    setShowAutoConnectModal(true);
  };
  const confirmAutoConnectFKs = () => {
    setShowAutoConnectModal(false);
    const newRels = findAutoFKRelationships(tables, relationships);
    if (newRels.length === 0) {
      Toast.info(t("all_relations_already_connected"));
      return;
    }
    setRelationships((prev) => [...prev, ...newRels]);
    setUndoStack((prev) => [
      ...prev,
      {
        action: Action.ADD,
        element: ObjectType.RELATIONSHIP,
        bulk: true,
        message: t("auto_connect_fk"),
        relationships: newRels,
      },
    ]);
    setRedoStack([]);
    Toast.success(t("auto_connect_fk_success", { count: newRels.length }));
  };
  const edit = () => {
    if (selectedElement.element === ObjectType.TABLE) {
      if (!layout.sidebar) {
        setSelectedElement((prev) => ({
          ...prev,
          open: true,
        }));
      } else {
        setSelectedElement((prev) => ({
          ...prev,
          open: true,
          currentTab: Tab.TABLES,
        }));
        if (selectedElement.currentTab !== Tab.TABLES) return;
        document
          .getElementById(`scroll_table_${selectedElement.id}`)
          .scrollIntoView({ behavior: "smooth" });
      }
    } else if (selectedElement.element === ObjectType.VIEW) {
      if (!layout.sidebar) {
        setSelectedElement((prev) => ({ ...prev, open: true }));
      } else {
        setSelectedElement((prev) => ({
          ...prev,
          open: true,
          currentTab: Tab.VIEWS,
        }));
        if (selectedElement.currentTab !== Tab.VIEWS) return;
        document
          .getElementById(`scroll_view_${selectedElement.id}`)
          ?.scrollIntoView({ behavior: "smooth" });
      }
    } else if (selectedElement.element === ObjectType.AREA) {
      if (layout.sidebar) {
        setSelectedElement((prev) => ({
          ...prev,
          currentTab: Tab.AREAS,
        }));
        if (selectedElement.currentTab !== Tab.AREAS) return;
        document
          .getElementById(`scroll_area_${selectedElement.id}`)
          .scrollIntoView({ behavior: "smooth" });
      } else {
        setSelectedElement((prev) => ({
          ...prev,
          open: true,
          editFromToolbar: true,
        }));
      }
    } else if (selectedElement.element === ObjectType.NOTE) {
      if (layout.sidebar) {
        setSelectedElement((prev) => ({
          ...prev,
          currentTab: Tab.NOTES,
          open: false,
        }));
        if (selectedElement.currentTab !== Tab.NOTES) return;
        document
          .getElementById(`scroll_note_${selectedElement.id}`)
          .scrollIntoView({ behavior: "smooth" });
      } else {
        setSelectedElement((prev) => ({
          ...prev,
          open: true,
          editFromToolbar: true,
        }));
      }
    }
  };
  const del = () => {
    if (layout.readOnly) {
      return;
    }
    switch (selectedElement.element) {
      case ObjectType.TABLE:
        deleteTable(selectedElement.id);
        break;
      case ObjectType.NOTE:
        deleteNote(selectedElement.id);
        break;
      case ObjectType.AREA:
        deleteArea(selectedElement.id);
        break;
      case ObjectType.VIEW:
        deleteView(selectedElement.id);
        break;
      default:
        break;
    }
  };
  const duplicate = () => {
    if (layout.readOnly) {
      return;
    }
    switch (selectedElement.element) {
      case ObjectType.TABLE: {
        const copiedTable = tables.find((t) => t.id === selectedElement.id);
        addTable({
          table: {
            ...copiedTable,
            x: copiedTable.x + 20,
            y: copiedTable.y + 20,
            id: nanoid(),
          },
        });
        break;
      }
      case ObjectType.NOTE:
        addNote({
          ...notes[selectedElement.id],
          x: notes[selectedElement.id].x + 20,
          y: notes[selectedElement.id].y + 20,
          id: notes.length,
        });
        break;
      case ObjectType.AREA: {
        const copiedArea = areas.find((a) => a.id === selectedElement.id);
        addArea({
          ...copiedArea,
          x: copiedArea.x + 20,
          y: copiedArea.y + 20,
          id: nanoid(),
        });
        break;
      }
      case ObjectType.VIEW: {
        const copiedView = views.find((v) => v.id === selectedElement.id);
        addView({
          view: {
            ...copiedView,
            x: copiedView.x + 20,
            y: copiedView.y + 20,
            id: nanoid(),
            columns: copiedView.columns.map((c) => ({ ...c, id: nanoid() })),
            joins: copiedView.joins.map((j) => ({ ...j, id: nanoid() })),
            conditions: copiedView.conditions.map((c) => ({
              ...c,
              id: nanoid(),
            })),
          },
          index: views.length,
        });
        break;
      }
      default:
        break;
    }
  };
  const copy = () => {
    switch (selectedElement.element) {
      case ObjectType.TABLE:
        navigator.clipboard
          .writeText(
            JSON.stringify(tables.find((t) => t.id === selectedElement.id)),
          )
          .catch(() => Toast.error(t("oops_smth_went_wrong")));
        break;
      case ObjectType.NOTE:
        navigator.clipboard
          .writeText(JSON.stringify({ ...notes[selectedElement.id] }))
          .catch(() => Toast.error(t("oops_smth_went_wrong")));
        break;
      case ObjectType.AREA:
        navigator.clipboard
          .writeText(
            JSON.stringify(areas.find((a) => a.id === selectedElement.id)),
          )
          .catch(() => Toast.error(t("oops_smth_went_wrong")));
        break;
      case ObjectType.VIEW:
        navigator.clipboard
          .writeText(
            JSON.stringify(views.find((v) => v.id === selectedElement.id)),
          )
          .catch(() => Toast.error(t("oops_smth_went_wrong")));
        break;
      default:
        break;
    }
  };
  const paste = () => {
    if (layout.readOnly) {
      return;
    }
    navigator.clipboard.readText().then((text) => {
      let obj = null;
      try {
        obj = JSON.parse(text);
      } catch (error) {
        return;
      }
      const v = new Validator();
      if (v.validate(obj, viewSchema).valid) {
        addView({
          view: {
            ...obj,
            x: obj.x + 20,
            y: obj.y + 20,
            id: nanoid(),
            columns: (obj.columns ?? []).map((c) => ({ ...c, id: nanoid() })),
            joins: (obj.joins ?? []).map((j) => ({ ...j, id: nanoid() })),
            conditions: (obj.conditions ?? []).map((c) => ({
              ...c,
              id: nanoid(),
            })),
          },
          index: views.length,
        });
      } else if (v.validate(obj, tableSchema).valid) {
        addTable({
          table: {
            ...obj,
            x: obj.x + 20,
            y: obj.y + 20,
            id: nanoid(),
          },
        });
      } else if (v.validate(obj, areaSchema).valid) {
        addArea({
          ...obj,
          x: obj.x + 20,
          y: obj.y + 20,
          id: nanoid(),
        });
      } else if (v.validate(obj, noteSchema).valid) {
        addNote({
          ...obj,
          x: obj.x + 20,
          y: obj.y + 20,
          id: notes.length,
        });
      }
    });
  };
  const cut = () => {
    if (layout.readOnly) {
      return;
    }
    copy();
    del();
  };
  const toggleDBMLEditor = () => {
    setLayout((prev) => ({ ...prev, dbmlEditor: !prev.dbmlEditor }));
  };
  const save = async () => {
    if (typeof extensions.cloudSave === "function") {
      // TODO: dont have blank here have null
      const isNew = diagramId === "blank";
      const newId = isNew ? uuidv4() : diagramId;
      const diagramData = {
        diagramId: newId,
        database,
        name: title,
        gistId: gistId ?? "",
        lastModified: new Date(),
        tables,
        references: relationships,
        notes,
        areas,
        views,
        sqlHeader,
        pan: transform.pan,
        zoom: transform.zoom,
        ...(databases[database].hasEnums && { enums }),
        ...(databases[database].hasTypes && { types }),
      };
      try {
        await extensions.cloudSave(diagramData, { isNew });
        if (isNew) {
          navigate(`/editor/diagrams/${newId}`, { replace: true });
        }
        setSaveState(State.SAVED);
        if (typeof setLastSaved === "function") {
          setLastSaved(new Date().toLocaleString());
        }
      } catch (err) {
        if (err?.response?.status === 402) {
          setSaveState(State.NONE);
          navigate("/checkout?tier=solo_pro");
          return;
        }
        setSaveState(State.ERROR);
      }
      return;
    }
    setSaveState(State.SAVING);
  };
  const { cloud, local } = useDiagramList();
  const recentlyOpenedDiagrams = useMemo(() => {
    const sorted = sortDiagrams(mergeDiagrams(cloud, local), {
      key: "lastModified",
      dir: "desc",
    });
    const seen = new Set();
    const recent = [];
    for (const entry of sorted) {
      if (entry.diagramId == null || seen.has(entry.diagramId)) continue;
      seen.add(entry.diagramId);
      recent.push(entry);
      if (recent.length === 10) break;
    }
    return recent;
  }, [cloud, local]);

  const open = () => setModal(MODAL.OPEN);
  const saveDiagramAs = () => setModal(MODAL.SAVEAS);

  const saveAsCopy = async (newTitle) => {
    const newId = uuidv4();
    const diagramData = {
      diagramId: newId,
      database,
      name: newTitle,
      gistId: "",
      loadedFromGistId: "",
      lastModified: new Date(),
      tables,
      references: relationships,
      notes,
      areas,
      views,
      sqlHeader,
      pan: transform.pan,
      zoom: transform.zoom,
      ...(databases[database].hasEnums && { enums }),
      ...(databases[database].hasTypes && { types }),
    };

    if (typeof extensions.cloudSave === "function") {
      try {
        await extensions.cloudSave(diagramData, { isNew: true });
      } catch (err) {
        if (err?.response?.status === 402) {
          setSaveState(State.NONE);
          navigate("/checkout?tier=solo_pro");
          return;
        }
        setSaveState(State.ERROR);
        Toast.error(t("oops_smth_went_wrong"));
        return;
      }
    } else {
      try {
        await db.diagrams.add(diagramData);
      } catch (err) {
        console.error(err);
        setSaveState(State.ERROR);
        Toast.error(t("oops_smth_went_wrong"));
        return;
      }
    }

    let toastId;
    toastId = Toast.success({
      duration: 8,
      content: (
        <span>
          {t("saved_as_copy")}{" "}
          <Typography.Text
            link={{
              href: `/editor/diagrams/${newId}${window.location.search}`,
              target: "_blank",
              rel: "noopener noreferrer",
            }}
            underline
            onClick={() => Toast.close(toastId)}
          >
            {newTitle}
          </Typography.Text>
        </span>
      ),
    });
  };

  const fullscreen = useFullscreen();

  useEffect(() => {
    if (!fullscreen)
      setLayout((p) => ({ ...p, header: true, sidebar: true, toolbar: true }));
  }, [fullscreen, setLayout]);

  const menu = {
    file: {
      new: {
        function: () => window.open("/editor/templates/blank", "_blank"),
      },
      new_window: {
        function: () => window.open("/editor", "_blank"),
      },
      open: {
        function: open,
        shortcut: "Ctrl+O",
      },
      open_recent: {
        children: [
          ...(recentlyOpenedDiagrams && recentlyOpenedDiagrams.length > 0
            ? [
                ...recentlyOpenedDiagrams.map((diagram) => ({
                  name: diagram.name,
                  label: DateTime.fromJSDate(new Date(diagram.lastModified))
                    .setLocale(i18n.language)
                    .toRelative(),
                  function: () => {
                    navigate(`/editor/diagrams/${diagram.diagramId}`);
                  },
                })),
                { divider: true },
                {
                  name: t("see_all"),
                  function: () => open(),
                },
              ]
            : [
                {
                  name: t("no_saved_diagrams"),
                  disabled: true,
                },
              ]),
        ],

        function: () => {},
      },
      save: {
        function: save,
        shortcut: "Ctrl+S",
        disabled: layout.readOnly,
      },
      save_as: {
        function: saveDiagramAs,
        shortcut: "Ctrl+Shift+S",
        disabled: layout.readOnly,
      },
      save_as_template: {
        function: async () => {
          await db.templates
            .add({
              title: title,
              tables: tables,
              database: database,
              relationships: relationships,
              notes: notes,
              subjectAreas: areas,
              views: views,
              sqlHeader: sqlHeader,
              custom: 1,
              templateId: uuidv4(),
              ...(databases[database].hasEnums && { enums: enums }),
              ...(databases[database].hasTypes && { types: types }),
            })
            .then(() => {
              Toast.success(t("template_saved"));
            });
        },
      },
      rename: {
        function: () => {
          setModal(MODAL.RENAME);
        },
        disabled: layout.readOnly,
      },
      delete_diagram: {
        warning: {
          title: t("delete_diagram"),
          message: t("are_you_sure_delete_diagram"),
        },
        function: async () => {
          try {
            if (typeof extensions.cloudDelete === "function") {
              await extensions.cloudDelete(diagramId);
            } else {
              await db.diagrams.where("diagramId").equals(diagramId).delete();
            }
            setTitle("Untitled diagram");
            setTables([]);
            setRelationships([]);
            setAreas([]);
            setNotes([]);
            setTypes([]);
            setEnums([]);
            setViews([]);
            setUndoStack([]);
            setRedoStack([]);
            setGistId("");
            navigate("/editor/templates/blank", { replace: true });
          } catch {
            Toast.error(t("oops_smth_went_wrong"));
          }
        },
      },
      import_from: {
        children: [
          {
            function: () => {
              setModal(MODAL.IMPORT);
              setImportFrom(IMPORT_FROM.JSON);
            },
            name: "JSON",
            disabled: layout.readOnly,
          },
          {
            function: () => {
              setModal(MODAL.IMPORT);
              setImportFrom(IMPORT_FROM.DBML);
            },
            name: "DBML",
            disabled: layout.readOnly,
          },
        ],
      },
      import_from_source: {
        ...(database === DB.GENERIC && {
          children: [
            {
              function: () => {
                setModal(MODAL.IMPORT_SRC);
                setImportDb(DB.MYSQL);
              },
              name: "MySQL",
              disabled: layout.readOnly,
            },
            {
              function: () => {
                setModal(MODAL.IMPORT_SRC);
                setImportDb(DB.POSTGRES);
              },
              name: "PostgreSQL",
              disabled: layout.readOnly,
            },
            {
              function: () => {
                setModal(MODAL.IMPORT_SRC);
                setImportDb(DB.SQLITE);
              },
              name: "SQLite",
              disabled: layout.readOnly,
            },
            {
              function: () => {
                setModal(MODAL.IMPORT_SRC);
                setImportDb(DB.MARIADB);
              },
              name: "MariaDB",
              disabled: layout.readOnly,
            },
            {
              function: () => {
                setModal(MODAL.IMPORT_SRC);
                setImportDb(DB.MSSQL);
              },
              name: "MSSQL",
              disabled: layout.readOnly,
            },
            {
              function: () => {
                setModal(MODAL.IMPORT_SRC);
                setImportDb(DB.ORACLESQL);
              },
              name: "Oracle",
              label: "Beta",
              disabled: layout.readOnly,
            },
          ],
        }),
        function: () => {
          if (database === DB.GENERIC) return;

          setModal(MODAL.IMPORT_SRC);
        },
        disabled: layout.readOnly,
      },
      import_from_database: {
        is_new: true,
        ...(database === DB.GENERIC && {
          children: Object.keys(schemaQueries).map((db) => ({
            function: () => {
              setModal(MODAL.IMPORT_DB);
              setImportDb(db);
            },
            name: databases[db].name,
            disabled: layout.readOnly,
          })),
        }),
        function: () => {
          if (database === DB.GENERIC) return;

          setModal(MODAL.IMPORT_DB);
        },
        disabled: layout.readOnly,
      },
      export_source: {
        ...(database === DB.GENERIC && {
          children: [
            {
              name: "MySQL",
              function: () => {
                openExportModal(MODAL.CODE);
                const src = jsonToMySQL({
                  tables: tables,
                  references: relationships,
                  types: types,
                  database: database,
                  views: views,
                });
                setExportData((prev) => ({
                  ...prev,
                  data: src,
                  extension: "sql",
                }));
              },
            },
            {
              name: "PostgreSQL",
              function: () => {
                openExportModal(MODAL.CODE);
                const src = jsonToPostgreSQL({
                  tables: tables,
                  references: relationships,
                  types: types,
                  database: database,
                  views: views,
                });
                setExportData((prev) => ({
                  ...prev,
                  data: src,
                  extension: "sql",
                }));
              },
            },
            {
              name: "SQLite",
              function: () => {
                openExportModal(MODAL.CODE);
                const src = jsonToSQLite({
                  tables: tables,
                  references: relationships,
                  types: types,
                  database: database,
                  views: views,
                });
                setExportData((prev) => ({
                  ...prev,
                  data: src,
                  extension: "sql",
                }));
              },
            },
            {
              name: "MariaDB",
              function: () => {
                openExportModal(MODAL.CODE);
                const src = jsonToMariaDB({
                  tables: tables,
                  references: relationships,
                  types: types,
                  database: database,
                  views: views,
                });
                setExportData((prev) => ({
                  ...prev,
                  data: src,
                  extension: "sql",
                }));
              },
            },
            {
              name: "MSSQL",
              function: () => {
                openExportModal(MODAL.CODE);
                const src = jsonToSQLServer({
                  tables: tables,
                  references: relationships,
                  types: types,
                  database: database,
                  views: views,
                });
                setExportData((prev) => ({
                  ...prev,
                  data: src,
                  extension: "sql",
                }));
              },
            },
            {
              label: "Beta",
              name: "Oracle",
              function: () => {
                openExportModal(MODAL.CODE);
                const src = jsonToOracleSQL({
                  tables: tables,
                  references: relationships,
                  types: types,
                  database: database,
                  views: views,
                });
                setExportData((prev) => ({
                  ...prev,
                  data: src,
                  extension: "sql",
                }));
              },
            },
          ],
        }),
        function: () => {
          if (database === DB.GENERIC) return;
          openExportModal(MODAL.CODE);
          const src = exportSQL({
            tables: tables,
            references: relationships,
            types: types,
            database: database,
            enums: enums,
            views: views,
            sqlHeader: sqlHeader,
          });
          setExportData((prev) => ({
            ...prev,
            data: src,
            extension: "sql",
          }));
        },
      },
      export_as: {
        children: [
          {
            name: "PNG",
            function: () => {
              toPng(document.getElementById("canvas"), {
                pixelRatio: pngExportPixelRatio,
              }).then(function (dataUrl) {
                setExportData((prev) => ({
                  ...prev,
                  data: dataUrl,
                  extension: "png",
                }));
              });
              openExportModal(MODAL.IMG);
            },
          },
          {
            name: "JPEG",
            function: () => {
              toJpeg(document.getElementById("canvas"), { quality: 0.95 }).then(
                function (dataUrl) {
                  setExportData((prev) => ({
                    ...prev,
                    data: dataUrl,
                    extension: "jpeg",
                  }));
                },
              );
              openExportModal(MODAL.IMG);
            },
          },
          {
            name: "SVG",
            function: () => {
              const filter = (node) => node.tagName !== "i";
              toSvg(document.getElementById("canvas"), { filter: filter }).then(
                function (dataUrl) {
                  setExportData((prev) => ({
                    ...prev,
                    data: dataUrl,
                    extension: "svg",
                  }));
                },
              );
              openExportModal(MODAL.IMG);
            },
          },
          {
            name: "JSON",
            function: () => {
              openExportModal(MODAL.CODE);
              const result = JSON.stringify(
                {
                  tables: tables,
                  relationships: relationships,
                  notes: notes,
                  subjectAreas: areas,
                  views: views,
                  database: database,
                  ...(databases[database].hasTypes && { types: types }),
                  ...(databases[database].hasEnums && { enums: enums }),
                  ...(sqlHeader && { sqlHeader: sqlHeader }),
                  title: title,
                },
                null,
                2,
              );
              setExportData((prev) => ({
                ...prev,
                data: result,
                extension: "json",
              }));
            },
          },
          {
            name: "DBML",
            function: () => {
              openExportModal(MODAL.CODE);
              const result = toDBML({
                tables,
                relationships,
                enums,
                database,
              });
              setExportData((prev) => ({
                ...prev,
                data: result,
                extension: "dbml",
              }));
            },
          },
          {
            name: "PDF",
            function: () => {
              const canvas = document.getElementById("canvas");
              const filename = `${title}_${new Date().toISOString()}`;
              toJpeg(canvas).then(function (dataUrl) {
                const doc = new jsPDF("l", "px", [
                  canvas.offsetWidth,
                  canvas.offsetHeight,
                ]);
                doc.addImage(
                  dataUrl,
                  "jpeg",
                  0,
                  0,
                  canvas.offsetWidth,
                  canvas.offsetHeight,
                );
                doc.save(`${filename}.pdf`);
              });
            },
          },
          {
            name: "Mermaid",
            function: () => {
              openExportModal(MODAL.CODE);
              const result = jsonToMermaid({
                tables: tables,
                relationships: relationships,
                notes: notes,
                subjectAreas: areas,
                database: database,
                title: title,
              });
              setExportData((prev) => ({
                ...prev,
                data: result,
                extension: "md",
              }));
            },
          },
          {
            name: "Markdown",
            function: () => {
              openExportModal(MODAL.CODE);
              const result = jsonToDocumentation({
                tables: tables,
                relationships: relationships,
                notes: notes,
                subjectAreas: areas,
                views: views,
                database: database,
                title: title,
                ...(databases[database].hasTypes && { types: types }),
                ...(databases[database].hasEnums && { enums: enums }),
              });
              setExportData((prev) => ({
                ...prev,
                data: result,
                extension: "md",
              }));
            },
          },
        ],
        function: () => {},
      },
      exit: {
        function: () => {
          save();
          if (saveState === State.SAVED) navigate("/");
        },
      },
    },
    edit: {
      undo: {
        function: undo,
        shortcut: "Ctrl+Z",
        disabled: layout.readOnly || undoStack.length === 0,
      },
      redo: {
        function: redo,
        shortcut: "Ctrl+Y",
        disabled: layout.readOnly || redoStack.length === 0,
      },
      clear: {
        warning: {
          title: t("clear"),
          message: t("are_you_sure_clear"),
        },
        function: async () => {
          setTables([]);
          setRelationships([]);
          setAreas([]);
          setNotes([]);
          setEnums([]);
          setTypes([]);
          setViews([]);
          setUndoStack([]);
          setRedoStack([]);
        },
        disabled: layout.readOnly,
      },
      edit: {
        function: edit,
        shortcut: "Ctrl+E",
        disabled: layout.readOnly,
      },
      cut: {
        function: cut,
        shortcut: "Ctrl+X",
        disabled: layout.readOnly,
      },
      copy: {
        function: copy,
        shortcut: "Ctrl+C",
      },
      paste: {
        function: paste,
        shortcut: "Ctrl+V",
        disabled: layout.readOnly,
      },
      duplicate: {
        function: duplicate,
        shortcut: "Ctrl+D",
        disabled: layout.readOnly,
      },
      delete: {
        function: del,
        shortcut: "Del",
        disabled: layout.readOnly,
      },
      auto_arrange: {
        function: autoArrangeTables,
        disabled: layout.readOnly,
      },
      auto_connect_fk: {
        function: autoConnectFKs,
        disabled: layout.readOnly,
      },
      copy_as_image: {
        function: copyAsImage,
        shortcut: "Ctrl+Alt+C",
      },
    },
    view: {
      header: {
        state: layout.header ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setLayout((prev) => ({ ...prev, header: !prev.header })),
      },
      sidebar: {
        state: layout.sidebar ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setLayout((prev) => ({ ...prev, sidebar: !prev.sidebar })),
      },
      issues: {
        state: layout.issues ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setLayout((prev) => ({ ...prev, issues: !prev.issues })),
      },
      dbml_view: {
        state: layout.dbmlEditor ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: toggleDBMLEditor,
        shortcut: "Alt+E",
      },
      strict_mode: {
        state: settings.strictMode ? (
          <i className="bi bi-toggle-off" />
        ) : (
          <i className="bi bi-toggle-on" />
        ),
        function: viewStrictMode,
        shortcut: "Ctrl+Shift+M",
      },
      presentation_mode: {
        function: () => {
          setLayout((prev) => ({
            ...prev,
            header: false,
            sidebar: false,
            toolbar: false,
          }));
          enterFullscreen();
        },
      },
      field_details: {
        state: settings.showFieldSummary ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: viewFieldSummary,
        shortcut: "Ctrl+Shift+F",
      },
      reset_view: {
        function: resetView,
        shortcut: "Enter/Return",
      },
      show_comments: {
        state: settings.showComments ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setSettings((prev) => ({
            ...prev,
            showComments: !prev.showComments,
          })),
      },
      show_datatype: {
        state: settings.showDataTypes ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setSettings((prev) => ({
            ...prev,
            showDataTypes: !prev.showDataTypes,
          })),
      },
      show_grid: {
        state: settings.showGrid ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: viewGrid,
        shortcut: "Ctrl+Shift+G",
      },
      snap_to_grid: {
        state: settings.snapToGrid ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: snapToGrid,
      },
      show_cardinality: {
        state: settings.showCardinality ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setSettings((prev) => ({
            ...prev,
            showCardinality: !prev.showCardinality,
          })),
      },
      show_relationship_labels: {
        state: settings.showRelationshipLabels ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setSettings((prev) => ({
            ...prev,
            showRelationshipLabels: !prev.showRelationshipLabels,
          })),
      },
      show_debug_coordinates: {
        state: settings.showDebugCoordinates ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setSettings((prev) => ({
            ...prev,
            showDebugCoordinates: !prev.showDebugCoordinates,
          })),
      },
      theme: {
        children: [
          {
            name: t("light"),
            function: () => setSettings((prev) => ({ ...prev, mode: "light" })),
          },
          {
            name: t("dark"),
            function: () => setSettings((prev) => ({ ...prev, mode: "dark" })),
          },
        ],
        function: () => {},
      },
      zoom_in: {
        function: zoomIn,
        shortcut: "Ctrl+(Up/Wheel)",
      },
      zoom_out: {
        function: zoomOut,
        shortcut: "Ctrl+(Down/Wheel)",
      },
      fullscreen: {
        state: fullscreen ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: fullscreen ? exitFullscreen : enterFullscreen,
      },
    },
    settings: {
      show_timeline: {
        function: () => setSidesheet(SIDESHEET.TIMELINE),
      },
      autosave: {
        state: settings.autosave ? (
          <i className="bi bi-toggle-on" />
        ) : (
          <i className="bi bi-toggle-off" />
        ),
        function: () =>
          setSettings((prev) => ({ ...prev, autosave: !prev.autosave })),
      },
      configure_custom_types: {
        function: () => setModal(MODAL.CONFIG_CUSTOM_TYPES),
        disabled: layout.readOnly,
      },
      language: {
        function: () => setModal(MODAL.LANGUAGE),
      },
      export_saved_data: {
        function: exportSavedData,
      },
      clear_cache: {
        function: () => {
          deleteFromCache(gistId);
          Toast.success(t("cache_cleared"));
        },
      },
      flush_storage: {
        warning: {
          title: t("flush_storage"),
          message: t("are_you_sure_flush_storage"),
        },
        function: async () => {
          localStorage.removeItem(STORAGE_KEY);
          db.delete()
            .then(() => {
              Toast.success(t("storage_flushed"));
              navigate("/editor", { replace: true });
              window.location.reload();
            })
            .catch(() => {
              Toast.error(t("oops_smth_went_wrong"));
            });
        },
      },
    },
    help: {
      docs: {
        function: () => window.open(`${socials.docs}`, "_blank"),
        shortcut: "Ctrl+H",
      },
      shortcuts: {
        function: () => window.open(`${socials.docs}/shortcuts`, "_blank"),
      },
      ask_on_discord: {
        function: () => window.open(socials.discord, "_blank"),
      },
      report_bug: {
        function: () => window.open("/bug-report", "_blank"),
      },
    },
  };

  useHotkeys("mod+i", fileImport, EDITOR_HOTKEY);
  useHotkeys("mod+z", undo, EDITOR_HOTKEY);
  useHotkeys("mod+y", redo, EDITOR_HOTKEY);
  useHotkeys("mod+s", save, EDITOR_HOTKEY);
  useHotkeys("mod+o", open, EDITOR_HOTKEY);
  useHotkeys("mod+e", edit, EDITOR_HOTKEY);
  useHotkeys("mod+d", duplicate, EDITOR_HOTKEY);
  useHotkeys("mod+c", copy, EDITOR_HOTKEY);
  useHotkeys("mod+v", paste, EDITOR_HOTKEY);
  useHotkeys("mod+x", cut, EDITOR_HOTKEY);
  useHotkeys("delete", del, EDITOR_HOTKEY);
  useHotkeys("mod+shift+g", viewGrid, EDITOR_HOTKEY);
  useHotkeys("mod+up", zoomIn, EDITOR_HOTKEY);
  useHotkeys("mod+down", zoomOut, EDITOR_HOTKEY);
  useHotkeys("mod+shift+m", viewStrictMode, EDITOR_HOTKEY);
  useHotkeys("mod+shift+f", viewFieldSummary, EDITOR_HOTKEY);
  useHotkeys("mod+shift+s", saveDiagramAs, EDITOR_HOTKEY);
  useHotkeys("mod+alt+c", copyAsImage, EDITOR_HOTKEY);
  useHotkeys("enter", resetView, EDITOR_HOTKEY);
  useHotkeys("mod+h", () => window.open(socials.docs, "_blank"), EDITOR_HOTKEY);
  useHotkeys("mod+alt+w", fitWindow, EDITOR_HOTKEY);
  useHotkeys("alt+e", toggleDBMLEditor, EDITOR_HOTKEY);
  useHotkeys("left", panLeft, EDITOR_HOTKEY);
  useHotkeys("right", panRight, EDITOR_HOTKEY);
  useHotkeys("up", panUp, EDITOR_HOTKEY);
  useHotkeys("down", panDown, EDITOR_HOTKEY);

  return (
    <>
      <div>
        {layout.header && (
          <div
            className="flex justify-between items-center border-b border-color pb-2"
            style={isRtl(i18n.language) ? { direction: "rtl" } : {}}
          >
            {header()}
            <div className="flex items-center gap-2 me-7">
              <Slot name="header-actions-start" />
              {!isTemplate && (
                <Button
                  type="primary"
                  className="!text-base !pe-6 !ps-5 !py-[18px] !rounded-md"
                  size="default"
                  icon={<IconShareStroked />}
                  onClick={() => setModal(MODAL.SHARE)}
                >
                  {t("share")}
                </Button>
              )}
              <Slot name="header-actions-end" />
            </div>
          </div>
        )}
        {layout.toolbar &&
          toolbarContainer &&
          createPortal(toolbar(), toolbarContainer)}
      </div>
      <Modal
        modal={modal}
        exportData={exportData}
        setExportData={setExportData}
        title={title}
        setTitle={setTitle}
        setModal={setModal}
        importFrom={importFrom}
        importDb={importDb}
        saveAsCopy={saveAsCopy}
        fitToView={fitToView}
        onBack={
          openedFromStart
            ? () => {
                setModal(MODAL.NONE);
                onBackToStart();
              }
            : undefined
        }
      />
      <Sidesheet
        type={sidesheet}
        title={title}
        setTitle={setTitle}
        onClose={() => setSidesheet(SIDESHEET.NONE)}
      />
      <ConfigureCustomTypes
        open={modal === MODAL.CONFIG_CUSTOM_TYPES}
        onClose={() => setModal(MODAL.NONE)}
      />
      <SemiModal
        title={t("auto_connect_fk_modal_title")}
        centered
        visible={showAutoConnectModal}
        onOk={confirmAutoConnectFKs}
        onCancel={() => setShowAutoConnectModal(false)}
        okText={t("auto_connect_fk")}
        cancelText={t("cancel")}
      >
        <div className="space-y-3">
          <p className="text-sm">{t("auto_connect_fk_modal_description")}</p>
          <ol className="list-decimal ps-5 space-y-1 text-sm">
            <li>{t("auto_connect_fk_rule_1")}</li>
            <li>{t("auto_connect_fk_rule_2")}</li>
          </ol>
          <p className="text-sm font-medium mt-2">
            {t("auto_connect_fk_modal_question")}
          </p>
        </div>
      </SemiModal>
    </>
  );

  function toolbar() {
    return (
      <div
        className="py-1.5 px-3 flex items-center gap-1 rounded-xl select-none overflow-hidden toolbar-theme shadow-lg"
        style={isRtl(i18n.language) ? { direction: "rtl" } : {}}
      >
        <div className="flex justify-start items-center">
          <LayoutDropdown />
          <Divider layout="vertical" margin="8px" />
          <Tooltip content={t("zoom_out")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm text-lg"
              onClick={() =>
                setTransform((prev) => ({ ...prev, zoom: prev.zoom / 1.2 }))
              }
            >
              <i className="fa-solid fa-magnifying-glass-minus" />
            </button>
          </Tooltip>
          <Dropdown
            style={{ width: "240px" }}
            position={isRtl(i18n.language) ? "bottomRight" : "bottomLeft"}
            render={
              <Dropdown.Menu
                style={isRtl(i18n.language) ? { direction: "rtl" } : {}}
              >
                <Dropdown.Item
                  onClick={fitWindow}
                  style={{ display: "flex", justifyContent: "space-between" }}
                >
                  <div>{t("fit_window_reset")}</div>
                  <div className="text-gray-400">Ctrl+Alt+W</div>
                </Dropdown.Item>
                <Dropdown.Divider />
                {[0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 3.0].map((e, i) => (
                  <Dropdown.Item
                    key={i}
                    onClick={() => {
                      setTransform((prev) => ({ ...prev, zoom: e }));
                    }}
                  >
                    {Math.floor(e * 100)}%
                  </Dropdown.Item>
                ))}
                <Dropdown.Divider />
                <Dropdown.Item>
                  <InputNumber
                    field="zoom"
                    label={t("zoom")}
                    placeholder={t("zoom")}
                    suffix={<div className="p-1">%</div>}
                    onChange={(v) =>
                      setTransform((prev) => ({
                        ...prev,
                        zoom: parseFloat(v) * 0.01,
                      }))
                    }
                  />
                </Dropdown.Item>
              </Dropdown.Menu>
            }
            trigger="click"
          >
            <div className="py-1 px-2 hover-2 rounded-sm flex items-center justify-center">
              <div className="w-[40px]">
                {Math.floor(transform.zoom * 100)}%
              </div>
              <div>
                <IconCaretdown />
              </div>
            </div>
          </Dropdown>
          <Tooltip content={t("zoom_in")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm text-lg"
              onClick={() =>
                setTransform((prev) => ({ ...prev, zoom: prev.zoom * 1.2 }))
              }
            >
              <i className="fa-solid fa-magnifying-glass-plus" />
            </button>
          </Tooltip>
          <Divider layout="vertical" margin="8px" />
          <Tooltip content={t("undo")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm flex items-center disabled:opacity-50"
              disabled={undoStack.length === 0 || layout.readOnly}
              onClick={undo}
            >
              <IconUndo size="large" />
            </button>
          </Tooltip>
          <Tooltip content={t("redo")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm flex items-center disabled:opacity-50"
              disabled={redoStack.length === 0 || layout.readOnly}
              onClick={redo}
            >
              <IconRedo size="large" />
            </button>
          </Tooltip>
          <Divider layout="vertical" margin="8px" />
          <Tooltip content={t("add_table")} position="bottom">
            <button
              className="flex items-center py-1 px-2 hover-2 rounded-sm disabled:opacity-50"
              onClick={() => addTable()}
              disabled={layout.readOnly}
            >
              <IconAddTable />
            </button>
          </Tooltip>
          <Tooltip content={t("add_view")} position="bottom">
            <button
              className="flex items-center py-1 px-2 hover-2 rounded-sm disabled:opacity-50"
              onClick={() => addView()}
              disabled={layout.readOnly}
            >
              <IconAddView />
            </button>
          </Tooltip>
          <Tooltip content={t("add_area")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm flex items-center disabled:opacity-50"
              onClick={() => addArea()}
              disabled={layout.readOnly}
            >
              <IconAddArea />
            </button>
          </Tooltip>
          <Tooltip content={t("add_note")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm flex items-center disabled:opacity-50"
              onClick={() => addNote()}
              disabled={layout.readOnly}
            >
              <IconAddNote />
            </button>
          </Tooltip>
          <Divider layout="vertical" margin="8px" />
          <Tooltip content={t("auto_arrange")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm text-xl -mt-0.5 disabled:opacity-50"
              onClick={autoArrangeTables}
              disabled={layout.readOnly}
            >
              <i className="fa-solid fa-wand-magic-sparkles" />
            </button>
          </Tooltip>
          <Divider layout="vertical" margin="8px" />
          <Tooltip content={t("save")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm flex items-center disabled:opacity-50"
              onClick={save}
              disabled={layout.readOnly}
            >
              <IconSaveStroked size="extra-large" />
            </button>
          </Tooltip>
          <Divider layout="vertical" margin="8px" />
          <Tooltip content={t("versions")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm text-xl -mt-0.5"
              onClick={() => setSidesheet(SIDESHEET.VERSIONS)}
            >
              <i className="fa-solid fa-code-branch" />
            </button>
          </Tooltip>
          <Divider layout="vertical" margin="8px" />
          <Tooltip content={t("theme")} position="bottom">
            <button
              className="py-1 px-2 hover-2 rounded-sm text-xl -mt-0.5"
              onClick={() => {
                const body = document.body;
                if (body.hasAttribute("theme-mode")) {
                  if (body.getAttribute("theme-mode") === "light") {
                    menu["view"]["theme"].children[1].function();
                  } else {
                    menu["view"]["theme"].children[0].function();
                  }
                }
              }}
            >
              <i className="fa-solid fa-circle-half-stroke" />
            </button>
          </Tooltip>
        </div>
      </div>
    );
  }

  function getState() {
    switch (saveState) {
      case State.NONE:
        return t("no_changes");
      case State.LOADING:
        return t("loading");
      case State.SAVED:
        return `${t("last_saved")} ${lastSaved}`;
      case State.SAVING:
        return t("saving");
      case State.ERROR:
        return t("failed_to_save");
      case State.FAILED_TO_LOAD:
        return t("failed_to_load");
      default:
        return "";
    }
  }

  function header() {
    return (
      <nav
        className="flex justify-between pt-1 items-center whitespace-nowrap"
        style={isRtl(i18n.language) ? { direction: "rtl" } : {}}
      >
        <div className="flex justify-start items-center">
          <Link to="/">
            <img
              width={54}
              src={icon}
              alt={t("logo")}
              className="ms-7 min-w-[54px]"
            />
          </Link>
          <div className="ms-1 mt-1">
            <div className="flex items-center ms-3 gap-2">
              {databases[database].image && (
                <img
                  src={databases[database].image}
                  className="h-5"
                  style={{
                    filter:
                      "opacity(0.4) drop-shadow(0 0 0 white) drop-shadow(0 0 0 white)",
                  }}
                  alt={t("database_icon", {
                    databaseName: databases[database].name,
                  })}
                  title={t("database_diagram", {
                    databaseName: databases[database].name,
                  })}
                />
              )}
              <Slot name="diagram-title-prefix" />
              <div
                className="text-xl flex items-center gap-1 me-1"
                onPointerEnter={(e) => e.isPrimary && setShowEditName(true)}
                onPointerLeave={(e) => e.isPrimary && setShowEditName(false)}
                onPointerDown={(e) => {
                  // Required for onPointerLeave to trigger when a touch pointer leaves
                  // https://stackoverflow.com/a/70976017/1137077
                  e.target.releasePointerCapture(e.pointerId);
                }}
                onClick={!layout.readOnly && (() => setModal(MODAL.RENAME))}
              >
                <span>{isTemplate ? t("templates") : t("diagrams")}</span>
                <span className="select-none text-zinc-400 dark:text-zinc-500 mx-1">
                  /
                </span>
                <span>{title}</span>
                {version && (
                  <Tag className="mt-1" color="blue" size="small">
                    {version.substring(0, 7)}
                  </Tag>
                )}
              </div>
              {(showEditName || modal === MODAL.RENAME) && !layout.readOnly && (
                <IconEdit />
              )}
            </div>
            <div className="flex items-center">
              <div className="flex justify-start text-md select-none me-2">
                {Object.keys(menu).map((category) => (
                  <Dropdown
                    key={category}
                    position="bottomLeft"
                    onVisibleChange={(visible) => {
                      const tagged = Object.keys(menu[category]).filter(
                        (item) =>
                          (menu[category][item].is_new ||
                            menu[category][item].children?.some(
                              (child) => child.is_new,
                            )) &&
                          !seenMenuTags.has(item),
                      );
                      if (visible || !tagged.length) return;
                      const next = new Set([...seenMenuTags, ...tagged]);
                      setSeenMenuTags(next);
                      try {
                        localStorage.setItem(
                          "drawdb:seenMenuTags",
                          JSON.stringify([...next]),
                        );
                      } catch {
                        return;
                      }
                    }}
                    style={{
                      width: "240px",
                      direction: isRtl(i18n.language) ? "rtl" : "ltr",
                    }}
                    render={
                      <Dropdown.Menu className="menu max-h-[calc(100vh-80px)] overflow-auto">
                        {Object.keys(menu[category]).map((item, index) => {
                          if (menu[category][item].children) {
                            return (
                              <Dropdown
                                className="min-w-36 max-w-72"
                                key={item}
                                position="rightTop"
                                render={
                                  <Dropdown.Menu>
                                    {menu[category][item].children.map(
                                      (e, i) => {
                                        if (e.divider) {
                                          return (
                                            <Dropdown.Divider
                                              key={`divider-${i}`}
                                            />
                                          );
                                        }
                                        return (
                                          <Dropdown.Item
                                            key={i}
                                            onClick={e.function}
                                            className="flex w-full items-center justify-between gap-1"
                                            disabled={e.disabled}
                                          >
                                            <span className="truncate flex-1 min-w-0">
                                              {e.name}
                                            </span>
                                            {e.label && (
                                              <Tag
                                                size="small"
                                                className="flex-shrink-0"
                                              >
                                                {e.label}
                                              </Tag>
                                            )}
                                            {e.is_new && (
                                              <Tag
                                                size="small"
                                                color="blue"
                                                className="flex-shrink-0"
                                              >
                                                {t("new")}
                                              </Tag>
                                            )}
                                          </Dropdown.Item>
                                        );
                                      },
                                    )}
                                  </Dropdown.Menu>
                                }
                              >
                                <Dropdown.Item
                                  style={{
                                    display: "flex",
                                    justifyContent: "space-between",
                                    alignItems: "center",
                                  }}
                                  onClick={menu[category][item].function}
                                >
                                  <span className="flex items-center gap-2">
                                    {t(item)}
                                    {menu[category][item].is_new && (
                                      <Tag size="small" color="blue">
                                        {t("new")}
                                      </Tag>
                                    )}
                                  </span>

                                  {isRtl(i18n.language) ? (
                                    <IconChevronLeft />
                                  ) : (
                                    <IconChevronRight />
                                  )}
                                </Dropdown.Item>
                              </Dropdown>
                            );
                          }
                          if (
                            menu[category][item].warning &&
                            !menu[category][item].disabled
                          ) {
                            return (
                              <Popconfirm
                                key={index}
                                title={menu[category][item].warning.title}
                                content={menu[category][item].warning.message}
                                onConfirm={menu[category][item].function}
                                position="right"
                                okText={t("confirm")}
                                cancelText={t("cancel")}
                              >
                                <Dropdown.Item>{t(item)}</Dropdown.Item>
                              </Popconfirm>
                            );
                          }
                          return (
                            <Dropdown.Item
                              key={index}
                              disabled={menu[category][item].disabled}
                              onClick={menu[category][item].function}
                              style={
                                menu[category][item].shortcut && {
                                  display: "flex",
                                  justifyContent: "space-between",
                                  alignItems: "center",
                                }
                              }
                            >
                              <div className="w-full flex items-center justify-between">
                                <div className="flex items-center gap-2">
                                  {t(item)}
                                  {menu[category][item].is_new && (
                                    <Tag size="small" color="blue">
                                      {t("new")}
                                    </Tag>
                                  )}
                                </div>
                                <div className="flex items-center gap-1">
                                  {menu[category][item].shortcut && (
                                    <div className="text-gray-400">
                                      {menu[category][item].shortcut}
                                    </div>
                                  )}
                                  {menu[category][item].state &&
                                    menu[category][item].state}
                                </div>
                              </div>
                            </Dropdown.Item>
                          );
                        })}
                      </Dropdown.Menu>
                    }
                  >
                    <div className="px-3 py-1 hover-2 rounded-sm">
                      {Object.keys(menu[category]).some(
                        (item) =>
                          (menu[category][item].is_new ||
                            menu[category][item].children?.some(
                              (child) => child.is_new,
                            )) &&
                          !seenMenuTags.has(item),
                      ) ? (
                        <Badge
                          dot
                          type="primary"
                          countStyle={{ right: -7, top: 5 }}
                        >
                          {t(category)}
                        </Badge>
                      ) : (
                        t(category)
                      )}
                    </div>
                  </Dropdown>
                ))}
              </div>
              {layout.readOnly && <Tag size="small">{t("read_only")}</Tag>}
              {!layout.readOnly && (
                <Tag
                  size="small"
                  type="light"
                  prefixIcon={
                    saveState === State.LOADING ||
                    saveState === State.SAVING ? (
                      <Spin size="small" />
                    ) : null
                  }
                >
                  {getState()}
                </Tag>
              )}
            </div>
          </div>
        </div>
      </nav>
    );
  }
}