seat-editor 3.4.7 → 3.5.0

package/dist/features/view-only-7/index.jsx

@@ -0,0 +1,724 @@
+"use client";
+import React, { useEffect, useMemo, useRef, useState, useImperativeHandle, useCallback, } from "react";
+import { TransformWrapper, TransformComponent, } from "react-zoom-pan-pinch";
+import { useAppDispatch, useAppSelector } from "../../hooks/use-redux";
+import Layers from "../../components/layer-v5";
+import { getTranslate } from "../board-v3/utils";
+import { Spin } from "antd";
+import { rotatePoint } from "./utils";
+import { renderElements } from "../view-only-4/utils";
+import { useConnectionGraph } from "./use-connection-graph";
+import { ConnectionLayer } from "./connection-layer";
+import { ConnectHandle } from "./connect-handle";
+const LayerView = (props) => {
+    const { componentProps, extraComponentProps, onSelectComponent, onDoubleClick, 
+    // onCurrentStateChange,
+    mappingKey, statusKey, defaultBackground, defaultBoundingBox, iconTags, tooltipProps, onRightClick, allowTooltip = true, tableMatchKey, eventMatchTable, ghostAttributes, onDrop, onSwitch, refs, privilegedTags, loadingRender, actionPrivileged = {
+        select: true,
+        move: true,
+        switch: true,
+        drop: true,
+        rightClick: true,
+        double: true,
+    }, } = props;
+    const widthTooltip = (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.minWidth) || 168;
+    const tableGhost = useRef(null);
+    const hoverUnderghostId = useRef(null);
+    const transformRef = useRef(null);
+    const containerRef = useRef(null);
+    const svgRef = useRef(null);
+    const hasBoundingBoxRef = useRef(false);
+    const [tooltip, setTooltip] = useState({
+        x: 0,
+        y: 0,
+        visible: false,
+    });
+    const isDragging = useRef(false);
+    const [panningGroup, setPanningGroup] = useState(false);
+    const [scale, setScale] = useState(1);
+    const [selectedTable, setSelectedTable] = useState(null);
+    const { components: componentsEditor, extraComponents: extraComponentsEditor, boundingBox: boundingBoxProps, } = useAppSelector((state) => state.board);
+    const backgroundColor = useAppSelector((state) => state.board.backgroundColor);
+    const { loading } = useAppSelector((state) => state.panel);
+    useImperativeHandle(refs, () => ({
+        svgRef: svgRef === null || svgRef === void 0 ? void 0 : svgRef.current,
+        transformRef: transformRef === null || transformRef === void 0 ? void 0 : transformRef.current,
+        containerRef: containerRef === null || containerRef === void 0 ? void 0 : containerRef.current,
+        tableGhost: tableGhost === null || tableGhost === void 0 ? void 0 : tableGhost.current,
+        hoverUnderghost: originalData({
+            id: hoverUnderghostId === null || hoverUnderghostId === void 0 ? void 0 : hoverUnderghostId.current,
+            type: "find",
+        }),
+    }));
+    const dispatch = useAppDispatch();
+    useEffect(() => {
+        if (!loading && (loadingRender === null || loadingRender === void 0 ? void 0 : loadingRender.state)) {
+            dispatch({ type: "panel/setLoading", payload: true });
+        }
+        // check in null
+        const isEmptyComponents = (componentProps === null || componentProps === void 0 ? void 0 : componentProps.length) === 0;
+        const isEmptyExtraComponents = (extraComponentProps === null || extraComponentProps === void 0 ? void 0 : extraComponentProps.length) === 0;
+        // const isEmptyBoundingBox = boundingBox === null;
+        if (isEmptyComponents) {
+            dispatch({
+                type: "board/setNewComponents",
+                payload: [],
+            });
+            setTooltip(Object.assign(Object.assign({}, tooltip), { visible: false }));
+        }
+        if (isEmptyExtraComponents) {
+            dispatch({
+                type: "board/setNewExtraComponents",
+                payload: [],
+            });
+        }
+        if ((componentProps === null || componentProps === void 0 ? void 0 : componentProps.length) > 0) {
+            dispatch({
+                type: "board/setNewComponents",
+                payload: componentProps,
+            });
+            setTooltip(Object.assign(Object.assign({}, tooltip), { visible: false }));
+        }
+        if ((extraComponentProps === null || extraComponentProps === void 0 ? void 0 : extraComponentProps.length) > 0) {
+            dispatch({
+                type: "board/setNewExtraComponents",
+                payload: extraComponentProps,
+            });
+        }
+        if (defaultBackground) {
+            dispatch({
+                type: "board/setBackgroundColor",
+                payload: defaultBackground,
+            });
+        }
+        // if(boundingBoxProps) {
+        dispatch({
+            type: "board/setBoundingBox",
+            payload: defaultBoundingBox,
+        });
+        // }
+        // if (loading) {
+        setTimeout(() => {
+            dispatch({ type: "panel/setLoading", payload: false });
+        }, 1000);
+        // }
+    }, [
+        componentProps,
+        extraComponentProps,
+        defaultBackground,
+        loadingRender === null || loadingRender === void 0 ? void 0 : loadingRender.state,
+        props === null || props === void 0 ? void 0 : props.viewOnly,
+        defaultBoundingBox,
+    ]);
+    useEffect(() => {
+        setTooltip(Object.assign(Object.assign({}, tooltip), { visible: false }));
+    }, [privilegedTags]);
+    // useEffect(() => {
+    //   onCurrentStateChange &&
+    //     onCurrentStateChange({
+    //       components: componentsEditor as ComponentProps[],
+    //       extraComponents: extraComponentsEditor as ComponentProps[],
+    //       background: backgroundColor,
+    //       boundingBox: boundingBoxProps,
+    //     });
+    // }, [componentsEditor, extraComponentsEditor, boundingBoxProps]);
+    const originalData = ({ id, type, dataParams, }) => {
+        let data;
+        if (type === "find") {
+            data = componentsEditor.find((item) => {
+                if (mappingKey && (item === null || item === void 0 ? void 0 : item[mappingKey])) {
+                    return item[mappingKey].id == id;
+                }
+                return (item === null || item === void 0 ? void 0 : item.id) == id;
+            });
+        }
+        if (type === "get" && dataParams) {
+            const mapped = mappingKey ? dataParams[mappingKey] : undefined;
+            data = mapped !== undefined ? mapped : dataParams;
+        }
+        return data;
+    };
+    const handleDoubleClick = (items, e) => {
+        const find = componentsEditor.find((item) => {
+            var _a;
+            if (mappingKey && (item === null || item === void 0 ? void 0 : item[mappingKey])) {
+                return item[mappingKey].id == ((_a = items[mappingKey]) === null || _a === void 0 ? void 0 : _a.id);
+            }
+            return (item === null || item === void 0 ? void 0 : item.id) == (items === null || items === void 0 ? void 0 : items.id);
+        });
+        onDoubleClick && (actionPrivileged === null || actionPrivileged === void 0 ? void 0 : actionPrivileged.double) && onDoubleClick(find);
+        const seletedTable = mappingKey ? find[mappingKey] : find;
+        setSelectedTable(seletedTable);
+    };
+    const handleSelectComponent = (items, e) => {
+        const find = componentsEditor.find((item) => {
+            var _a;
+            if (mappingKey && (item === null || item === void 0 ? void 0 : item[mappingKey])) {
+                return item[mappingKey].id == ((_a = items[mappingKey]) === null || _a === void 0 ? void 0 : _a.id);
+            }
+            return (item === null || item === void 0 ? void 0 : item.id) == (items === null || items === void 0 ? void 0 : items.id);
+        });
+        const rightClick = e.button === 2;
+        onRightClick &&
+            rightClick &&
+            (actionPrivileged === null || actionPrivileged === void 0 ? void 0 : actionPrivileged.rightClick) &&
+            onRightClick(e, find);
+        onSelectComponent &&
+            !rightClick &&
+            (actionPrivileged === null || actionPrivileged === void 0 ? void 0 : actionPrivileged.select) &&
+            onSelectComponent(find);
+        const seletedTable = mappingKey ? find[mappingKey] : find;
+        setSelectedTable(seletedTable);
+    };
+    const boundingBox = useMemo(() => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        if (!componentsEditor && (componentsEditor === null || componentsEditor === void 0 ? void 0 : componentsEditor.length) === 0) {
+            return { minX: 0, minY: 0, width: 500, height: 500 };
+        }
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        componentsEditor === null || componentsEditor === void 0 ? void 0 : componentsEditor.forEach((_, i) => {
+            let values = mappingKey ? _[mappingKey] : _;
+            if (!values)
+                return;
+            if (values === null || values === void 0 ? void 0 : values.shape) {
+                minX = Math.min(minX, values.x);
+                minY = Math.min(minY, values.y);
+                maxX = Math.max(maxX, values.x + values.width);
+                maxY = Math.max(maxY, values.y + values.height);
+            }
+            if (i === componentsEditor.length - 1 &&
+                (extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor.length) === 0) {
+                const centerX = (minX + maxX) / 2;
+                const centerY = (minY + maxY) / 2;
+                const padding = 20;
+                const width = maxX - minX + padding * 2;
+                const height = maxY - minY + padding * 2;
+                minX = centerX - width / 2;
+                minY = centerY - height / 2;
+                maxX = maxX - minX + padding * 2;
+                maxY = maxY - minY + padding * 2;
+            }
+        });
+        extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor.forEach((values) => {
+            var _a, _b, _c, _d, _e;
+            if (values === null || values === void 0 ? void 0 : values.shape) {
+                minX = Math.min(minX, values.x);
+                minY = Math.min(minY, values.y);
+                maxX = Math.max(maxX, values.x + values.width);
+                maxY = Math.max(maxY, values.y + values.height);
+            }
+            if ((_a = values === null || values === void 0 ? void 0 : values.shape) === null || _a === void 0 ? void 0 : _a.includes("polygon")) {
+                minX = Math.min(minX, (_b = values === null || values === void 0 ? void 0 : values.points) === null || _b === void 0 ? void 0 : _b.reduce((min, point) => Math.min(min, point.x), Infinity));
+                minY = Math.min(minY, (_c = values === null || values === void 0 ? void 0 : values.points) === null || _c === void 0 ? void 0 : _c.reduce((min, point) => Math.min(min, point.y), Infinity));
+                maxX = Math.max(maxX, (_d = values === null || values === void 0 ? void 0 : values.points) === null || _d === void 0 ? void 0 : _d.reduce((max, point) => Math.max(max, point.x), -Infinity));
+                maxY = Math.max(maxY, (_e = values === null || values === void 0 ? void 0 : values.points) === null || _e === void 0 ? void 0 : _e.reduce((max, point) => Math.max(max, point.y), -Infinity));
+            }
+        });
+        let backgroundHasOne = false;
+        if ((extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor.length) === 1 &&
+            ((_b = (_a = extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor[0]) === null || _a === void 0 ? void 0 : _a.shape) === null || _b === void 0 ? void 0 : _b.includes("background"))) {
+            backgroundHasOne = true;
+            // console.log({ backgroundHasOne },"shini")
+            minX = (_c = extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor[0]) === null || _c === void 0 ? void 0 : _c.x;
+            minY = (_d = extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor[0]) === null || _d === void 0 ? void 0 : _d.y;
+            maxX = (_e = extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor[0]) === null || _e === void 0 ? void 0 : _e.width;
+            maxY = (_f = extraComponentsEditor === null || extraComponentsEditor === void 0 ? void 0 : extraComponentsEditor[0]) === null || _f === void 0 ? void 0 : _f.height;
+        }
+        const hasBoundingBox = boundingBoxProps;
+        // const paddingY =
+        //   maxY * (props?.viewStyles?.paddingY || 0) +
+        //   minY * (props?.viewStyles?.paddingY || 0);
+        // const paddingX =
+        //   maxX * (props?.viewStyles?.paddingX || 0) +
+        //   minX * (props?.viewStyles?.paddingX || 0);
+        if (hasBoundingBox) {
+            hasBoundingBoxRef.current = true;
+            return {
+                minX: boundingBoxProps.x - (((_g = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _g === void 0 ? void 0 : _g.paddingLeft) || 0),
+                minY: boundingBoxProps.y - (((_h = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _h === void 0 ? void 0 : _h.paddingTop) || 0),
+                width: boundingBoxProps.width + (((_j = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _j === void 0 ? void 0 : _j.paddingRight) || 0),
+                height: boundingBoxProps.height + (((_k = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _k === void 0 ? void 0 : _k.paddingBottom) || 0),
+            };
+        }
+        // return {
+        //   minX: minX - paddingX - (minX - paddingX) * 0.5,
+        //   minY: minY - paddingY * 2,
+        //   width: maxX + paddingX * 2,
+        //   height: maxY + paddingY + (maxY + paddingY) * 0.5,
+        // };
+        // console.log(minX, minY, maxX, maxY, props?.viewStyles, "bounding box");
+        return {
+            minX: minX - (((_l = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _l === void 0 ? void 0 : _l.paddingLeft) || 0),
+            minY: minY - (((_m = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _m === void 0 ? void 0 : _m.paddingTop) || 0),
+            width: maxX + (((_o = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _o === void 0 ? void 0 : _o.paddingRight) || 0),
+            height: maxY + (((_p = props === null || props === void 0 ? void 0 : props.viewStyles) === null || _p === void 0 ? void 0 : _p.paddingBottom) || 0),
+        };
+    }, [componentsEditor, extraComponentsEditor, boundingBoxProps]);
+    const [fingerCount, setFingerCount] = useState(0);
+    useEffect(() => {
+        const container = document.getElementById("workspace");
+        const handleTouchStart = (e) => {
+            const count = e.touches.length;
+            setFingerCount(count);
+        };
+        const handleTouchEnd = () => {
+            setFingerCount(0);
+        };
+        if (container) {
+            container.addEventListener("touchstart", handleTouchStart);
+            container.addEventListener("touchend", handleTouchEnd);
+        }
+        return () => {
+            if (container) {
+                container.removeEventListener("touchstart", handleTouchStart);
+                container.removeEventListener("touchend", handleTouchEnd);
+            }
+        };
+    }, []);
+    const handleTableEvent = (event, type) => {
+        var _a;
+        event.preventDefault();
+        // cari elemen yg diklik
+        const elementTarget = event.target;
+        if (!elementTarget)
+            return;
+        // cari group data-id terdekat
+        const group = elementTarget.closest("g[data-id]");
+        if (!group)
+            return;
+        try {
+            const tableId = JSON.parse(group.getAttribute("data-id") || "{}");
+            const dragEvent = event;
+            const dataTransfer = JSON.parse(((_a = dragEvent.dataTransfer) === null || _a === void 0 ? void 0 : _a.getData("application/json")) || "{}");
+            const data = {
+                targetTable: originalData({ id: tableId, type: "find" }),
+                sourceTable: originalData({ dataParams: dataTransfer, type: "get" }),
+            };
+            // drop from out layout editor
+            if (type === "drop") {
+                onDrop && (actionPrivileged === null || actionPrivileged === void 0 ? void 0 : actionPrivileged.drop) && onDrop(event, data);
+            }
+            // cari elemen bentuk (rect / circle / path)
+            const shape = group.querySelector("rect") ||
+                group.querySelector("circle") ||
+                group.querySelector("path");
+            if (!shape)
+                return;
+        }
+        catch (err) {
+            console.error("Invalid data-id JSON:", err);
+        }
+    };
+    const getSvgCoords = (e) => {
+        var _a;
+        const svg = svgRef.current;
+        const point = svg.createSVGPoint();
+        point.x = e.clientX;
+        point.y = e.clientY;
+        const transformed = point.matrixTransform((_a = svg.getScreenCTM()) === null || _a === void 0 ? void 0 : _a.inverse());
+        return { x: transformed.x, y: transformed.y };
+    };
+    const lastClickRef = useRef(0);
+    const clickTimerRef = useRef(null);
+    const ignoreNextRef = useRef(false);
+    const DOUBLE_DELAY = 250;
+    const handlePointerDown = (e) => {
+        var _a;
+        const svg = svgRef.current;
+        if (!e.isPrimary)
+            return;
+        if (!svg)
+            return;
+        isDragging.current = false;
+        let hasMoved = false;
+        const startX = e.clientX;
+        const startY = e.clientY;
+        const { x, y } = getSvgCoords(e);
+        const targetGroup = e.target.closest("g[data-id]");
+        if (!targetGroup) {
+            setTooltip((prev) => (Object.assign(Object.assign({}, prev), { visible: false })));
+            return;
+        }
+        setPanningGroup(true);
+        // clone element yang diklik
+        let ghost = targetGroup.cloneNode(true);
+        const ghostId = JSON.parse(targetGroup.getAttribute("data-id") || "{}");
+        const allowedDrag = (!(props === null || props === void 0 ? void 0 : props.dragTableBlockKey)
+            ? true
+            : !((_a = props === null || props === void 0 ? void 0 : props.dragTableBlockKey) === null || _a === void 0 ? void 0 : _a.some((_) => {
+                const dataRaw = originalData({ id: ghostId, type: "find" });
+                return _.value === (dataRaw === null || dataRaw === void 0 ? void 0 : dataRaw[_.key]);
+            }))) &&
+            (actionPrivileged === null || actionPrivileged === void 0 ? void 0 : actionPrivileged.move) &&
+            (actionPrivileged === null || actionPrivileged === void 0 ? void 0 : actionPrivileged.switch);
+        if (ghostAttributes) {
+            Object.keys(ghostAttributes).forEach((key) => {
+                ghost.setAttribute(key, ghostAttributes[key]);
+            });
+        }
+        ghost.setAttribute("opacity", "0.5");
+        ghost.setAttribute("pointer-events", "none");
+        ghost.setAttribute("stroke-width", "1");
+        svg.appendChild(ghost);
+        tableGhost.current = ghost;
+        const pt = svg.createSVGPoint();
+        pt.x = e.clientX;
+        pt.y = e.clientY;
+        const startBox = getTranslate(targetGroup);
+        const groupCTM = targetGroup.getCTM();
+        if (!groupCTM) {
+            setTooltip((prev) => (Object.assign(Object.assign({}, prev), { visible: false })));
+            return;
+        }
+        const offset = {
+            x: x - startBox.x,
+            y: y - startBox.y,
+        };
+        const pointerMoveGhost = (ev) => {
+            var _a;
+            if (allowedDrag) {
+                isDragging.current = true;
+                const p = svg.createSVGPoint();
+                p.x = ev.clientX;
+                p.y = ev.clientY;
+                const dx = ev.clientX - startX;
+                const dy = ev.clientY - startY;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                onPanning(ev);
+                if (!hasMoved && distance > 0) {
+                    // transformRef?.current?.instance
+                    // only move ghost if the mouse has moved more than 5 pixels
+                    hasMoved = true;
+                    isDragging.current = true;
+                }
+                // ✅ DETEKSI ELEMEN YANG DILEWATI POINTER
+                ghost.style.display = "none";
+                const elemUnderPointer = document.elementFromPoint(ev.clientX, ev.clientY);
+                ghost.style.display = "";
+                const hoveredGroup = elemUnderPointer === null || elemUnderPointer === void 0 ? void 0 : elemUnderPointer.closest("g[data-id]");
+                const dataHoveredGhostId = JSON.parse((hoveredGroup === null || hoveredGroup === void 0 ? void 0 : hoveredGroup.getAttribute("data-id")) || "{}");
+                const dataGhostId = JSON.parse(ghost.getAttribute("data-id") || "{}");
+                if (dataHoveredGhostId !== dataGhostId) {
+                    hoverUnderghostId.current = dataHoveredGhostId;
+                }
+                const posSVG = p.matrixTransform((_a = svg.getScreenCTM()) === null || _a === void 0 ? void 0 : _a.inverse());
+                // posisi awal ghost di bawah kursor tanpa matrix dulu
+                const newX = posSVG.x - offset.x;
+                const newY = posSVG.y - offset.y;
+                ghost.setAttribute("transform", `translate(${newX}, ${newY})`);
+            }
+        };
+        // tampilkan ghost di posisi awal
+        pointerMoveGhost(e.nativeEvent);
+        const pointerHandleUp = (e) => {
+            var _a;
+            if (!hasMoved) {
+                const dataId = JSON.parse(targetGroup.getAttribute("data-id") || "{}");
+                isDragging.current = false;
+                const dataGroupEmty = !dataId;
+                // TOOLTIP ACTION
+                const svgSize = svg.getBoundingClientRect();
+                const widthScreeen = svgSize.width;
+                const heightScreen = svgSize.height;
+                const clientX = e.clientX;
+                const clientY = e.clientY;
+                const relX = clientX - svgSize.left;
+                const relY = clientY - svgSize.top;
+                const centerX = widthScreeen / 2;
+                const centerY = heightScreen / 2;
+                let newX = 0;
+                let newY = 0;
+                if (relX > centerX) {
+                    newX = relX - widthTooltip;
+                }
+                else if (relX < centerX) {
+                    newX = relX;
+                }
+                else if (relX === centerX) {
+                    newX = relX;
+                }
+                if (relY > centerY) {
+                    newY = relY;
+                }
+                else if (relY < centerY) {
+                    newY = relY;
+                }
+                else if (relY === centerY) {
+                    newY = relY;
+                }
+                const rightClick = e.button === 2 && !dataGroupEmty && allowTooltip;
+                setTooltip({
+                    x: newX / scale,
+                    y: newY / scale,
+                    visible: rightClick,
+                });
+                const findDayaById = originalData({ id: dataId, type: "find" });
+                const now = Date.now();
+                if (ignoreNextRef.current) {
+                    ignoreNextRef.current = false;
+                    return;
+                }
+                const diff = now - lastClickRef.current;
+                if (diff < DOUBLE_DELAY) {
+                    if (clickTimerRef.current) {
+                        handleDoubleClick(findDayaById, e);
+                        clearTimeout(clickTimerRef.current);
+                        clickTimerRef.current = null;
+                    }
+                    ignoreNextRef.current = true;
+                    lastClickRef.current = 0;
+                    return;
+                }
+                lastClickRef.current = now;
+                clickTimerRef.current = window.setTimeout(() => {
+                    handleSelectComponent(findDayaById, e);
+                    clickTimerRef.current = null;
+                }, DOUBLE_DELAY);
+            }
+            if (isDragging.current && hasMoved && allowedDrag) {
+                // drag between group
+                // console.log("drag between group");
+                const dataHoveredGhost = hoverUnderghostId.current;
+                const sourceTable = JSON.parse(targetGroup.getAttribute("data-id") || "{}");
+                const data = {
+                    targetTable: originalData({ id: dataHoveredGhost, type: "find" }),
+                    sourceTable: originalData({ id: sourceTable, type: "find" }),
+                };
+                const allowToSwitch = onSwitch && (data === null || data === void 0 ? void 0 : data.sourceTable) && (data === null || data === void 0 ? void 0 : data.targetTable);
+                allowToSwitch && onSwitch(e, data);
+                ghost.remove();
+                isDragging.current = false;
+                (_a = tableGhost.current) === null || _a === void 0 ? void 0 : _a.remove();
+                tableGhost.current = null;
+                hoverUnderghostId.current = null;
+            }
+            setPanningGroup(false);
+            tableGhost.current = null;
+            isDragging.current = false;
+            window.removeEventListener("pointermove", pointerMoveGhost);
+            window.removeEventListener("pointerup", pointerHandleUp);
+        };
+        window.addEventListener("pointermove", pointerMoveGhost);
+        window.addEventListener("pointerup", pointerHandleUp);
+    };
+    const handleMouseUp = () => {
+        var _a;
+        // isDragging.current = false;
+        (_a = tableGhost.current) === null || _a === void 0 ? void 0 : _a.remove();
+        tableGhost.current = null;
+    };
+    useEffect(() => {
+        return () => {
+            var _a;
+            (_a = tableGhost.current) === null || _a === void 0 ? void 0 : _a.remove();
+        };
+    }, []);
+    const handlePan = (dx, dy) => {
+        var _a, _b;
+        const instance = (_a = transformRef.current) === null || _a === void 0 ? void 0 : _a.instance;
+        const setTransform = (_b = transformRef === null || transformRef === void 0 ? void 0 : transformRef.current) === null || _b === void 0 ? void 0 : _b.setTransform;
+        if (!instance)
+            return;
+        const bounds = instance.bounds;
+        const { positionX, positionY, scale } = instance.transformState;
+        let x = positionX + dx;
+        let y = positionY + dy;
+        if (x >= bounds.maxPositionX)
+            x = bounds.maxPositionX;
+        if (y >= bounds.maxPositionY)
+            y = bounds.maxPositionY;
+        if (y <= bounds.minPositionY)
+            y = bounds.minPositionY;
+        if (x <= bounds.minPositionX)
+            x = bounds.minPositionX;
+        setTransform(x, y, scale, 100, "linear");
+    };
+    // const instance = transformRef.current?.instance;
+    // console.log({ instance })
+    const getCoords = (e) => {
+        var _a;
+        const svg = svgRef.current;
+        const instance = (_a = transformRef.current) === null || _a === void 0 ? void 0 : _a.instance;
+        if (!svg || !instance)
+            return null;
+        const { positionX, positionY, scale } = instance.transformState;
+        let clientX, clientY;
+        if ("touches" in e && e.touches.length > 0) {
+            clientX = e.touches[0].clientX;
+            clientY = e.touches[0].clientY;
+        }
+        else if ("clientX" in e) {
+            clientX = e.clientX;
+            clientY = e.clientY;
+        }
+        else {
+            return null;
+        }
+        const svgRect = svg.getBoundingClientRect();
+        // const viewBox = svg.viewBox.baseVal;
+        const xLeft = (clientX - svgRect.left + positionX) / scale;
+        const yTop = (clientY - svgRect.top + positionY) / scale;
+        const xRight = clientX - svgRect.left + positionX - svgRect.width / scale;
+        const yBottom = clientY - svgRect.top + positionY - svgRect.height / scale;
+        const minX = svgRect.left + positionX;
+        const minY = svgRect.top + positionY;
+        const maxX = svgRect.right;
+        const maxY = svgRect.bottom;
+        return [
+            xLeft,
+            yTop,
+            Math.abs(xRight),
+            Math.abs(yBottom),
+            minX,
+            minY,
+            maxX,
+            maxY,
+        ];
+    };
+    const onPanning = (e) => {
+        const [xLeft, yTop, xRight, yBottom, minX, minY, maxX, maxY] = getCoords(e);
+        const edgeThreshold = 100;
+        const speedPanning = 50;
+        if (scale !== 1) {
+            if (xLeft < edgeThreshold)
+                handlePan(speedPanning, 0);
+            if (xRight < edgeThreshold)
+                handlePan(-speedPanning, 0);
+            if (yTop < edgeThreshold)
+                handlePan(0, speedPanning);
+            if (yBottom < edgeThreshold)
+                handlePan(0, -speedPanning);
+        }
+    };
+    const hasBoundingBox = hasBoundingBoxRef.current;
+    const isValidBoundingBox = Number.isFinite(boundingBox.minX) &&
+        Number.isFinite(boundingBox.minY) &&
+        Number.isFinite(boundingBox.width) &&
+        Number.isFinite(boundingBox.height) &&
+        boundingBox.width > 0 &&
+        boundingBox.height > 0;
+    const viewBox = isValidBoundingBox
+        ? `${boundingBox.minX} ${boundingBox.minY} ${boundingBox.width} ${boundingBox.height}`
+        : "0 0 1000 1000";
+    const getNodeById = useCallback((id) => {
+        var _a, _b, _c;
+        const comp = componentsEditor.find((item) => {
+            if (mappingKey && (item === null || item === void 0 ? void 0 : item[mappingKey]))
+                return item[mappingKey].id == id;
+            return (item === null || item === void 0 ? void 0 : item.id) == id;
+        });
+        if (!comp)
+            return null;
+        const v = mappingKey ? comp[mappingKey] : comp;
+        const w = (_a = v.width) !== null && _a !== void 0 ? _a : 100;
+        const h = (_b = v.height) !== null && _b !== void 0 ? _b : 50;
+        const rotation = (_c = v.rotation) !== null && _c !== void 0 ? _c : 0;
+        // Center node relatif ke (0,0) sebelum rotate
+        const localCx = w / 2;
+        const localCy = h / 2;
+        // Apply rotate(rotation, 0, 0) → rotate center sekitar top-left
+        const rotated = rotatePoint(localCx, localCy, rotation);
+        return {
+            id: v.id,
+            x: v.x + rotated.x, // center absolut X
+            y: v.y + rotated.y, // center absolut Y
+            width: w,
+            height: h,
+            rotation,
+        };
+    }, [componentsEditor, mappingKey]);
+    const graph = useConnectionGraph({
+        svgRef,
+        getNodeById,
+        // onEdgesChange: props.onEdgesChange,
+        // keyNode: props.keyNode,
+        // mappingKey,
+        // tableMatchKey,
+        // statusKey,
+    });
+    return (<div className="relative w-full h-full flex-1" ref={containerRef} style={{
+            overflow: "auto",
+            WebkitOverflowScrolling: "touch",
+        }} {...props.containerProps}>
+      {loading && (<div className="absolute z-10 top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2 bg-opacity-50 bg-white w-full h-full flex items-center justify-center">
+          {(loadingRender === null || loadingRender === void 0 ? void 0 : loadingRender.element) || <Spin />}
+        </div>)}
+
+      {/* {isDragging?.current && (
+          <div className="absolute bottom-1/2 left-1  flex gap-4 z-[10]">
+            <button className="p-4 bg-gray-400">+</button>
+          </div>
+        )} */}
+
+      <TransformWrapper ref={transformRef} 
+    // disabled={fingerCount === 1 && scale === 1}
+    disablePadding={true} centerZoomedOut={true} panning={{
+            disabled: panningGroup,
+            wheelPanning: true,
+        }} wheel={{
+            disabled: false,
+        }} 
+    // doubleClick={{
+    //   disabled: true,
+    // }}
+    onTransformed={({ state: { scale } }) => setScale(scale)} minScale={1} maxScale={1000} initialScale={1} smooth={true} centerOnInit={true} {...props.transformProps}>
+        <TransformComponent wrapperStyle={{
+            width: "100%",
+            height: "100%",
+            // overflow: "visible",
+            // pointerEvents: disabled ? "none" : "auto",
+        }} contentStyle={{
+            width: "100%",
+            height: "100%",
+            // pointerEvents: disabled ? "none" : "auto",
+        }}>
+          <svg id="workspace" onContextMenu={(e) => e.preventDefault()} onDrop={(e) => handleTableEvent(e, "drop")} onPointerDown={handlePointerDown} onPointerUp={handleMouseUp} onMouseMove={(e) => graph.onMouseMove(e)} // ← tambah ini
+     
+    // onMouseUp={() => graph.onMouseUp()} // ← tambah ini
+    onClick={() => {
+            graph.clearSelection();
+            if (graph.connecting)
+                graph.cancelConnect();
+        }} ref={svgRef} width="100%" height="100%" 
+    // scale={5}
+    overflow="hidden" viewBox={viewBox} className={"h-full"} xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid meet" style={{
+            background: backgroundColor !== null && backgroundColor !== void 0 ? backgroundColor : defaultBackground,
+            display: "block",
+            // pointerEvents: disabled ? "none" : "all",
+            touchAction: "none",
+            userSelect: "none",
+        }} {...props.svgProps}>
+            <rect width="100%" height="100%" fill="url(#biggrid)"/>
+
+            {hasBoundingBox && (<defs>
+                <clipPath id="contentCrop">
+                  <rect x={boundingBox.minX} y={boundingBox.minY} width={boundingBox.width} height={boundingBox.height}/>
+                </clipPath>
+              </defs>)}
+            <g id="main-layer" clipPath="url(#contentCrop)">
+              <Layers components={[
+            ...extraComponentsEditor,
+            ...renderElements(componentsEditor, mappingKey, tableMatchKey, statusKey),
+        ]} selectedTable={selectedTable} iconTags={iconTags} eventMatchTable={eventMatchTable} privilegedTags={privilegedTags}/>
+            </g>
+            {/* Connection graph layer */}
+            <ConnectionLayer edges={graph.edges} selectedEdge={graph.selectedEdge} connecting={graph.connecting} mousePos={graph.mousePos} getNodeById={getNodeById} onSelectEdge={graph.selectEdge}/>
+
+            {...renderElements(componentsEditor, mappingKey, tableMatchKey, statusKey).map((item) => {
+            var _a, _b, _c, _d;
+            const values = item;
+            const rotated = rotatePoint(values.width / 2, values.height / 2, (_a = values.rotation) !== null && _a !== void 0 ? _a : 0);
+            return (<ConnectHandle key={values.id} cx={values.x + rotated.x} // center absolut X
+             cy={values.y + rotated.y} width={(_b = values.width) !== null && _b !== void 0 ? _b : 100} rotation={(_c = values.rotation) !== null && _c !== void 0 ? _c : 0} // ← p
+             height={(_d = values.height) !== null && _d !== void 0 ? _d : 50} nodeId={String(values.id)} isConnecting={!!graph.connecting} onStartConnect={graph.startConnect} onEndConnect={graph.endConnect}/>);
+        })}
+            {/* 🧠 Ghost universal */}
+          </svg>
+          {tooltip.visible && (<div className={`seat-editor tooltip-container ${tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.className}`} style={Object.assign({ top: tooltip.y, left: tooltip.x, transform: `scale(${1 / scale})`, transformOrigin: "top left", minWidth: widthTooltip + "px" }, tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.style)}>
+              {tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.children}
+            </div>)}
+        </TransformComponent>
+      </TransformWrapper>
+    </div>);
+};
+export default LayerView;