@sepveneto/free-dom 0.6.0 → 0.7.2

package/dist/index.js

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,463 +16,77 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  freeDom: () => freeDom,
-  freeScene: () => freeScene
+  FreeDom: () => FreeDom,
+  FreeScene: () => FreeScene,
+  GridLayout: () => GridLayout2
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/components/freeDom.ts
-var import_vue_demi2 = require("vue-demi");
-
-// src/hooks/use-normalize-style.ts
-var import_vue_demi = require("vue-demi");
-function useNormalizeStyle(style) {
-  const _style = (0, import_vue_demi.ref)({
-    transition: "inherit"
-  });
-  (0, import_vue_demi.watch)(() => style, (data) => {
-    const res = Object.entries((0, import_vue_demi.unref)(data)).reduce(
-      (obj, _style2) => {
-        const [key, value] = _style2;
-        if (typeof value === "number") {
-          obj[key] = `${value}px`;
-        } else {
-          obj[key] = value;
-        }
-        return obj;
-      },
-      {}
-    );
-    _style.value = {
-      ..._style.value,
-      ...res
-    };
-  }, { deep: true });
-  return _style;
-}
-
-// src/util/EventBus.ts
-var _EventBus = class {
-  static on(name, callback) {
-    if (!Array.isArray(_EventBus._callbacks[name])) {
-      _EventBus._callbacks[name] = [];
-    }
-    _EventBus._callbacks[name].push(callback);
-  }
-  static emit(name, ...args) {
-    _EventBus._callbacks[name]?.forEach((item) => item.apply(this, args));
-  }
-  static off(name) {
-    _EventBus._callbacks[name].length = 0;
-  }
-};
-var EventBus = _EventBus;
-__publicField(EventBus, "_callbacks", {});
+// src/components/freeDomWrap.ts
+var import_vue_demi14 = require("vue-demi");
 
 // src/util/tokens.ts
 var SceneToken = Symbol("Scene");
 
-// src/util/index.ts
-function clamp(value, min, max = Infinity) {
-  return Math.max(Math.min(value, max), min);
-}
-function snapToGrid(grid, pendingX, pendingY) {
-  const x = Math.round(pendingX / grid[0]) * grid[0];
-  const y = Math.round(pendingY / grid[1]) * grid[1];
-  return [x, y];
-}
-
-// src/hooks/use-resize.ts
-var MIN_SIZE = 20;
-function useResize(startX, startY, rect, dot, diagonal, snapGrid, callbacks) {
-  const isT = dot ? /t/.test(dot) : false;
-  const isL = dot ? /l/.test(dot) : false;
-  const isB = dot ? /b/.test(dot) : false;
-  const isR = dot ? /r/.test(dot) : false;
-  const isDiagonal = dot ? dot.length === 2 : false;
-  const { width: cWidth, height: cHeight, x, y } = rect;
-  const move = (mouseEvt) => {
-    const { clientX, clientY } = mouseEvt;
-    let deltaX = clientX - startX;
-    let deltaY = clientY - startY;
-    if (Array.isArray(snapGrid)) {
-      [deltaX, deltaY] = snapToGrid(snapGrid, deltaX, deltaY);
-    }
-    const rate = cWidth / cHeight;
-    const newWidth = cWidth + (isL ? -deltaX : isR ? deltaX : 0);
-    const newHeight = cHeight + (isT ? -deltaY : isB ? deltaY : 0);
-    if (isDiagonal && diagonal) {
-      if (Math.abs(deltaX) >= Math.abs(deltaY)) {
-        rect.x = x + (isL ? deltaX : 0);
-        rect.width = clamp(newWidth, MIN_SIZE);
-        rect.height = clamp(newWidth / rate, MIN_SIZE);
+// src/util/render.ts
+var import_lodash = require("lodash");
+var import_vue_demi = require("vue-demi");
+function createRender(comp, attrs = {}, props = {}, listeners = {}) {
+  if (!comp)
+    return () => null;
+  const options = import_vue_demi.isVue2 ? {
+    ...attrs,
+    props,
+    on: listeners
+  } : {
+    ...attrs,
+    ...props
+  };
+  if (import_vue_demi.isVue2 && typeof comp === "object" && !("render" in comp)) {
+    (0, import_lodash.merge)(comp.data, options);
+    return comp;
+  }
+  return (slots) => {
+    if (import_vue_demi.isVue2) {
+      if (Object.prototype.toString.call(slots) === "[object Object]") {
+        return (0, import_vue_demi.h)(comp, { ...options, scopedSlots: slots });
       } else {
-        rect.y = y + (isT ? deltaY : 0);
-        rect.height = clamp(newHeight, MIN_SIZE);
-        rect.width = clamp(newHeight * rate, MIN_SIZE);
+        return (0, import_vue_demi.h)(comp, options, Array.isArray(slots) ? slots : [slots]);
       }
     } else {
-      rect.x = x + (isL ? deltaX : 0);
-      rect.y = y + (isT ? deltaY : 0);
-      rect.width = clamp(newWidth, MIN_SIZE);
-      rect.height = clamp(newHeight, MIN_SIZE);
+      return (0, import_vue_demi.h)(comp, options, slots);
     }
-    callbacks && callbacks.onMove && callbacks.onMove();
-  };
-  const up = () => {
-    document.removeEventListener("mousemove", move);
-    document.removeEventListener("mouseup", up);
-    callbacks && callbacks.onMove && callbacks.onUp();
   };
-  document.addEventListener("mousemove", move);
-  document.addEventListener("mouseup", up);
 }
 
-// src/components/freeDom.ts
-var import_core = require("@vueuse/core");
-var import_uuid = require("uuid");
-var Dots = ["t", "r", "l", "b", "lt", "lb", "rt", "rb"];
-var FreeDom = (0, import_vue_demi2.defineComponent)({
-  name: "FreeDom",
-  props: {
-    x: {
-      type: Number,
-      default: void 0
-    },
-    y: {
-      type: Number,
-      default: void 0
-    },
-    width: {
-      type: Number,
-      default: void 0
-    },
-    height: {
-      type: Number,
-      default: void 0
-    },
-    absolute: {
-      type: Boolean,
-      default: void 0
-    },
-    scale: {
-      type: [Boolean, Array],
-      default: void 0
-    },
-    move: Boolean,
-    preview: Boolean,
-    limitWidth: {
-      type: Number,
-      default: void 0
-    },
-    limitHeight: {
-      type: Number,
-      default: void 0
-    },
-    handler: {
-      type: String,
-      default: void 0
-    },
-    diagonal: {
-      type: Boolean,
-      default: void 0
-    },
-    grid: {
-      type: Object,
-      default: void 0
-    },
-    onDragStart: {
-      type: Function,
-      default: void 0
-    },
-    onDragEnd: {
-      type: Function,
-      default: void 0
-    }
-  },
-  emits: ["update:x", "update:y", "update:width", "update:height", "select"],
-  setup(props, { emit }) {
-    const active = (0, import_vue_demi2.ref)(false);
-    const SceneContext = (0, import_vue_demi2.inject)(SceneToken, void 0);
-    const _preview = (0, import_vue_demi2.computed)(() => SceneContext?.preview || props.preview);
-    const canScale = (0, import_vue_demi2.computed)(() => !_preview.value && (SceneContext?.scale || props.scale));
-    const canMove = (0, import_vue_demi2.computed)(() => !_preview.value && (SceneContext?.move || props.move));
-    const isAbsolute = (0, import_vue_demi2.computed)(() => props.absolute ?? SceneContext?.absolute ?? true);
-    const handlerType = (0, import_vue_demi2.computed)(() => props.handler ?? SceneContext?.handler ?? "dot");
-    const snapGrid = (0, import_vue_demi2.computed)(() => props.grid ?? SceneContext?.grid);
-    const diagonal = (0, import_vue_demi2.computed)(() => props.diagonal ?? SceneContext?.diagonal ?? true);
-    const widgetRef = (0, import_vue_demi2.shallowRef)();
-    const _style = (0, import_vue_demi2.ref)({});
-    const wrapStyle = useNormalizeStyle(_style);
-    const uuid = (0, import_uuid.v4)();
-    const isScale = (0, import_vue_demi2.ref)(false);
-    const isMove = (0, import_vue_demi2.ref)(false);
-    const _rect = (0, import_vue_demi2.reactive)({});
-    const context = {
-      _rect,
-      trigger
-    };
-    (0, import_core.onClickOutside)(widgetRef, () => {
-      active.value = false;
-    });
-    let rectSize = (0, import_vue_demi2.reactive)((0, import_core.useElementSize)(widgetRef));
-    let autoWidth = true;
-    let autoHeight = true;
-    const unwatch = (0, import_vue_demi2.watch)(rectSize, ({ width, height }) => {
-      if (autoWidth && width) {
-        _rect.width = width;
-      }
-      if (autoHeight && height) {
-        _rect.height = height;
-      }
-    });
-    (0, import_vue_demi2.watch)(
-      [
-        () => props.width,
-        () => props.height,
-        () => props.x,
-        () => props.y
-      ],
-      ([width, height, x, y]) => {
-        autoWidth = width === _rect.width;
-        autoHeight = height === _rect.height;
-        if (!autoHeight && !autoWidth) {
-          unwatch();
-          rectSize = null;
-        }
-        width && (_rect.width = width);
-        height && (_rect.height = height);
-        x != null && (_rect.x = x);
-        y != null && (_rect.y = y);
-        trigger();
-      },
-      { immediate: true }
-    );
-    (0, import_vue_demi2.onMounted)(async () => {
-      SceneContext?.register(uuid, context);
-      const { offsetTop, offsetLeft } = widgetRef.value;
-      _rect.x = _rect.x == null ? offsetLeft : _rect.x;
-      _rect.y = _rect.y == null ? offsetTop : _rect.y;
-      trigger();
-    });
-    function trigger() {
-      const { x, y, width, height } = _rect;
-      _style.value = {
-        transform: `translate(${x}px, ${y}px)`,
-        width,
-        height
-      };
-    }
-    const _dots = (0, import_vue_demi2.computed)(() => {
-      return SceneContext && Array.isArray(SceneContext.scale) ? SceneContext.scale : props.scale;
-    });
-    const dots = (0, import_vue_demi2.computed)(() => {
-      if (!isActive.value)
-        return [];
-      return Array.isArray(_dots.value) ? _dots.value : Dots;
-    });
-    const direct = {
-      l: "w",
-      r: "e",
-      t: "n",
-      b: "s"
-    };
-    const isActive = (0, import_vue_demi2.shallowRef)(true);
-    function onMousedownDot(evt, dot) {
-      evt.stopPropagation();
-      evt.preventDefault();
-      if (isMove.value)
-        return;
-      isScale.value = true;
-      active.value = true;
-      const shouldUpdate = props.onDragStart?.();
-      if (shouldUpdate === false)
-        return;
-      const { clientX, clientY } = evt;
-      useResize(clientX, clientY, _rect, dot, diagonal.value, snapGrid.value, {
-        onMove() {
-          if (!checkValid(_rect))
-            return;
-          EventBus.emit("move", uuid);
-          trigger();
-        },
-        onUp() {
-          props.onDragEnd?.();
-          isScale.value = false;
-          EventBus.emit("moveup", uuid);
-          emitPos();
-        }
-      });
-    }
-    function emitPos() {
-      emit("update:x", _rect.x);
-      emit("update:y", _rect.y);
-      emit("update:width", _rect.width);
-      emit("update:height", _rect.height);
-    }
-    function getDotPos(dot) {
-      const { width, height } = _rect;
-      const isL = /l/.test(dot);
-      const isR = /r/.test(dot);
-      const isT = /t/.test(dot);
-      let left, top;
-      if (dot.length === 2) {
-        left = isL ? 0 : width;
-        top = isT ? 0 : height;
-      } else {
-        if (isL || isR) {
-          left = isL ? 0 : width;
-          top = Number(height) / 2;
-        } else {
-          left = Number(width) / 2;
-          top = isT ? 0 : height;
-        }
-      }
-      return {
-        top: `${handlerType.value === "dot" ? top : top - 3}px`,
-        left: `${handlerType.value === "dot" ? left : left - 3}px`,
-        cursor: dot.split("").reverse().map((item) => direct[item]).join("") + "-resize"
-      };
-    }
-    function onMousedown(evt) {
-      evt.stopPropagation();
-      if (isScale.value || !canMove.value)
-        return;
-      isMove.value = true;
-      active.value = true;
-      const shouldUpdate = props.onDragStart?.();
-      if (shouldUpdate === false)
-        return;
-      const pos = { ..._rect };
-      const move = (mouseEvt) => {
-        const { clientX, clientY } = mouseEvt;
-        const x = clientX - evt.clientX + pos.x;
-        const y = clientY - evt.clientY + pos.y;
-        _rect.x = x;
-        _rect.y = y;
-        _rect.width = pos.width;
-        _rect.height = pos.height;
-        if (!checkValid(_rect))
-          return;
-        EventBus.emit("move", uuid);
-        trigger();
-      };
-      const up = () => {
-        props.onDragEnd?.();
-        isMove.value = false;
-        EventBus.emit("moveup", uuid);
-        document.removeEventListener("mousemove", move);
-        document.removeEventListener("mouseup", up);
-        emitPos();
-        emit("select", _rect);
-      };
-      document.addEventListener("mousemove", move);
-      document.addEventListener("mouseup", up);
-    }
-    function checkValid(rect) {
-      if (SceneContext) {
-        return SceneContext.checkValid(rect);
-      } else if (props.limitWidth && props.limitHeight) {
-        const { x, y, width, height } = rect;
-        return x >= 0 && x + width <= props.limitWidth && y >= 0 && y + height <= props.limitHeight;
-      } else {
-        return true;
-      }
-    }
-    return {
-      widgetRef,
-      canMove,
-      wrapStyle,
-      canScale,
-      dots,
-      active,
-      isAbsolute,
-      isScale,
-      handlerType,
-      getDotPos,
-      onMousedown,
-      onMousedownDot
-    };
-  },
-  render() {
-    const dots = this.canScale ? this.dots.map((dot) => {
-      if (import_vue_demi2.isVue2) {
-        return (0, import_vue_demi2.h)("div", {
-          class: "free-dom__widget-dot",
-          style: this.getDotPos(dot),
-          on: {
-            mousedown: (evt) => this.onMousedownDot(evt, dot)
-          }
-        });
-      }
-      return (0, import_vue_demi2.h)("div", {
-        class: this.handlerType === "dot" ? "free-dom__widget-dot" : "free-dom__resizable-handler",
-        style: this.getDotPos(dot),
-        onMousedown: (evt) => this.onMousedownDot(evt, dot)
-      });
-    }) : null;
-    const defaultSlot = typeof this.$slots.default === "function" ? this.$slots.default() : this.$slots.default;
-    if (import_vue_demi2.isVue2) {
-      return (0, import_vue_demi2.h)(
-        "section",
-        {
-          class: [
-            "free-dom__widget-wrapper",
-            { "is-scale": this.isScale },
-            { "is-absolute": this.isAbsolute },
-            { "can-move": this.canMove },
-            { "is-active": this.active }
-          ],
-          style: this.wrapStyle,
-          ref: "widgetRef",
-          on: {
-            mousedown: this.onMousedown
-          }
-        },
-        [dots, defaultSlot]
-      );
-    }
-    return (0, import_vue_demi2.h)(
-      "section",
-      {
-        ref: "widgetRef",
-        class: [
-          "free-dom__widget-wrapper",
-          { "is-scale": this.isScale },
-          { "is-absolute": this.isAbsolute },
-          { "can-move": this.canMove },
-          { "is-active": this.active }
-        ],
-        style: this.wrapStyle,
-        onMousedown: this.onMousedown
-      },
-      [defaultSlot, dots]
-    );
-  }
-});
-
-// src/components/freeDomWrap.ts
-var import_vue_demi4 = require("vue-demi");
-var import_core2 = require("@vueuse/core");
+// src/util/index.ts
+var isProduction = process.env.NODE_ENV === "production";
+function clamp(value, min, max = Infinity) {
+  return Math.max(Math.min(value, max), min);
+}
+function log(...args) {
+  if (isProduction)
+    return;
+  console.log("[grid-layout]", ...args);
+}
 
 // src/components/markLine.ts
-var import_vue_demi3 = require("vue-demi");
+var import_vue_demi2 = require("vue-demi");
 var lineType = ["xt", "xc", "xb", "yl", "yc", "yr"];
-var markLine_default = (0, import_vue_demi3.defineComponent)({
+var markLine_default = (0, import_vue_demi2.defineComponent)({
+  props: {
+    showLine: Boolean
+  },
   setup() {
-    const SceneContext = (0, import_vue_demi3.inject)(SceneToken);
-    const lines = (0, import_vue_demi3.shallowRef)(lineType);
-    const diff = (0, import_vue_demi3.ref)(SceneContext.diff);
+    const SceneContext = (0, import_vue_demi2.inject)(SceneToken);
+    const lines = (0, import_vue_demi2.shallowRef)(lineType);
+    const diff = (0, import_vue_demi2.ref)(SceneContext.diff);
     const nodes = SceneContext.nodes;
-    const lineStatus = (0, import_vue_demi3.reactive)({
+    const lineStatus = (0, import_vue_demi2.reactive)({
       xt: {
         show: false,
         pos: 0
@@ -499,7 +112,7 @@ var markLine_default = (0, import_vue_demi3.defineComponent)({
         pos: 0
       }
     });
-    EventBus.on("move", async (uuid) => {
+    const runConstraints = (uuid) => {
       const current = nodes.find((node) => node.uuid === uuid)?.node ?? {};
       clearStatus();
       nodes.forEach((node) => {
@@ -578,11 +191,12 @@ var markLine_default = (0, import_vue_demi3.defineComponent)({
           current._rect.x = _target.right - _current.width;
         }
       });
-    });
-    EventBus.on("moveup", clearStatus);
-    (0, import_vue_demi3.onBeforeUnmount)(() => {
-      EventBus.off("move");
-      EventBus.off("moveup");
+    };
+    SceneContext?.on("move", runConstraints);
+    SceneContext?.on("moveup", clearStatus);
+    (0, import_vue_demi2.onBeforeUnmount)(() => {
+      SceneContext?.off("move");
+      SceneContext?.off("moveup");
     });
     function clearStatus() {
       lineStatus.xt.show = false;
@@ -594,6 +208,8 @@ var markLine_default = (0, import_vue_demi3.defineComponent)({
     }
     function normalize(rect) {
       return {
+        deltaX: rect.deltaX,
+        deltaY: rect.deltaY,
         top: rect.y,
         bottom: rect.y + rect.height,
         left: rect.x,
@@ -614,83 +230,1524 @@ var markLine_default = (0, import_vue_demi3.defineComponent)({
     };
   },
   render() {
-    const _line = (line, info) => (0, import_vue_demi3.h)("div", {
+    const _line = (line, info) => (0, import_vue_demi2.h)("div", {
       style: { [line.includes("x") ? "top" : "left"]: info.pos + "px" },
-      class: [line.includes("x") ? "free-dom__xline" : "free-dom__yline", "free-dom__line"]
+      class: [line.includes("x") ? "vv-free-dom--xline" : "vv-free-dom--yline", "vv-free-dom--line"]
     });
-    const _lines = this.lines.filter((line) => this.lineStatus[line].show).map((line) => _line(line, this.lineStatus[line]));
-    return (0, import_vue_demi3.h)("div", {
-      class: "free-dom__mark-line"
+    const _lines = this.showLine ? this.lines.filter((line) => this.lineStatus[line].show).map((line) => _line(line, this.lineStatus[line])) : [];
+    return (0, import_vue_demi2.h)("div", {
+      class: "vv-free-dom--markline"
     }, _lines);
   }
 });
 
-// src/components/freeDomWrap.ts
-var freeDomWrapProps = {
-  absolute: {
+// src/hooks/use-normalize-style.ts
+var import_vue_demi3 = require("vue-demi");
+
+// src/hooks/use-default-slot.ts
+var import_vue_demi4 = require("vue-demi");
+function useDefaultSlot() {
+  const slots = (0, import_vue_demi4.useSlots)();
+  const slotList = (0, import_vue_demi4.computed)(() => {
+    return typeof slots.default === "function" ? slots.default() : slots.default;
+  });
+  const only = (0, import_vue_demi4.computed)(() => slotList.value?.[0]);
+  return {
+    slots: slotList,
+    only
+  };
+}
+
+// src/hooks/use-core-date.ts
+var import_vue_demi5 = require("vue-demi");
+function useCoreData(node) {
+  const lastX = (0, import_vue_demi5.ref)(NaN);
+  const lastY = (0, import_vue_demi5.ref)(NaN);
+  function create(x, y) {
+    const isStart = isNaN(lastX.value);
+    const _node = (0, import_vue_demi5.unref)(node);
+    if (!_node) {
+      throw new Error("drag node does not exist");
+    }
+    if (isStart) {
+      return {
+        node: _node,
+        deltaX: 0,
+        deltaY: 0,
+        lastX: x,
+        lastY: y,
+        x,
+        y
+      };
+    } else {
+      return {
+        node: _node,
+        deltaX: x - lastX.value,
+        deltaY: y - lastY.value,
+        lastX: lastX.value,
+        lastY: lastY.value,
+        x,
+        y
+      };
+    }
+  }
+  return {
+    lastX,
+    lastY,
+    create
+  };
+}
+
+// src/hooks/use-draggable-data.ts
+var import_vue_demi6 = require("vue-demi");
+function useDraggableData(props) {
+  const x = (0, import_vue_demi6.ref)(props.x || props.modelValue.x || 0);
+  const y = (0, import_vue_demi6.ref)(props.y || props.modelValue.y || 0);
+  const deltaX = (0, import_vue_demi6.ref)(0);
+  const deltaY = (0, import_vue_demi6.ref)(0);
+  const dragData = (0, import_vue_demi6.ref)();
+  (0, import_vue_demi6.watchEffect)(() => {
+    x.value = props.x || props.modelValue.x || 0;
+  });
+  (0, import_vue_demi6.watchEffect)(() => {
+    y.value = props.y || props.modelValue.y || 0;
+  });
+  const handleDrag = (evt, data) => {
+    x.value = data.x;
+    y.value = data.y;
+    deltaX.value = data.deltaX;
+    deltaY.value = data.deltaY;
+    props.dargFn(evt, data);
+  };
+  const handleDragStop = (evt, coreData) => {
+    const data = dragData.value = create(coreData);
+    props.dragStopFn(evt, data);
+  };
+  function create(coreData) {
+    return {
+      node: coreData.node,
+      x: x.value + coreData.deltaX,
+      y: y.value + coreData.deltaY,
+      deltaX: coreData.deltaX,
+      deltaY: coreData.deltaY,
+      lastX: x.value,
+      lastY: y.value
+    };
+  }
+  return {
+    x,
+    y,
+    deltaX,
+    deltaY,
+    create,
+    handleDrag,
+    handleDragStop
+  };
+}
+
+// src/hooks/use-scene-context.ts
+var import_vue_demi7 = require("vue-demi");
+var id = 0;
+function useSceneContext(context, props) {
+  const SceneContext = (0, import_vue_demi7.inject)(SceneToken, void 0);
+  const uuid = id++;
+  const lockAspectRatio = (0, import_vue_demi7.computed)(() => SceneContext?.lockAspectRatio || props.lockAspectRatio);
+  const minWidth = (0, import_vue_demi7.computed)(() => SceneContext?.minWidth || props.minWidth);
+  const minHeight = (0, import_vue_demi7.computed)(() => SceneContext?.minHeight || props.minHeight);
+  const disabledDrag = (0, import_vue_demi7.computed)(() => SceneContext?.disabledDrag || props.disabledDrag);
+  const disabledResize = (0, import_vue_demi7.computed)(() => SceneContext?.disabledResize || props.disabledResize);
+  const scale = (0, import_vue_demi7.computed)(() => SceneContext?.scale || props.scale);
+  const fixNonMonospaced = (0, import_vue_demi7.computed)(() => {
+    return SceneContext?.fixNonMonospaced || props.fixNonMonospaced;
+  });
+  (0, import_vue_demi7.onMounted)(() => {
+    SceneContext?.register(uuid, context);
+  });
+  function check(pos) {
+    if (!SceneContext)
+      return true;
+    return SceneContext.checkValid(pos);
+  }
+  return {
+    emit: (name) => SceneContext?.emit(name, uuid),
+    check,
+    width: SceneContext?.width,
+    height: SceneContext?.height,
+    scale,
+    lockAspectRatio,
+    minWidth,
+    minHeight,
+    disabledDrag,
+    disabledResize,
+    fixNonMonospaced
+  };
+}
+
+// src/hooks/use-event-bus.ts
+var import_vue_demi8 = require("vue-demi");
+function useEventBus() {
+  const callbacks = (0, import_vue_demi8.ref)({});
+  const on = (name, cb) => {
+    if (!callbacks.value[name]) {
+      callbacks.value[name] = [cb];
+    } else {
+      callbacks.value[name].push(cb);
+    }
+  };
+  const off = (name) => {
+    callbacks.value[name].length = 0;
+  };
+  const emit = (name, args) => {
+    const fns = callbacks.value[name] || [];
+    fns.forEach((fn) => fn(args));
+  };
+  return {
+    on,
+    off,
+    emit
+  };
+}
+
+// src/hooks/use-resizable-data.ts
+var import_vue_demi9 = require("vue-demi");
+function useResizableData(props, domRef) {
+  const width = (0, import_vue_demi9.ref)(getWidth());
+  const height = (0, import_vue_demi9.ref)(getHeight());
+  (0, import_vue_demi9.watchEffect)(() => {
+    width.value = getWidth();
+  });
+  (0, import_vue_demi9.watchEffect)(() => {
+    height.value = getHeight();
+  });
+  function getWidth() {
+    return props.width || props.modelValue.w;
+  }
+  function getHeight() {
+    return props.height || props.modelValue.h;
+  }
+  async function syncSize(fixNonMonospaced, minWidth, minHeight) {
+    if (props.width && props.height || props.modelValue.w && props.modelValue.h)
+      return;
+    if (!domRef.value)
+      return [0, 0];
+    if (fixNonMonospaced) {
+      await document.fonts.ready;
+    }
+    const { width: w, height: h5 } = window.getComputedStyle(domRef.value.$el);
+    width.value = Math.max(Math.ceil(parseFloat(w)), minWidth);
+    height.value = Math.max(Math.ceil(parseFloat(h5)), minHeight);
+  }
+  return {
+    width,
+    height,
+    syncSize
+  };
+}
+
+// src/hooks/use-layout.ts
+var import_vue_demi10 = require("vue-demi");
+function useLayout(props) {
+  const layout = (0, import_vue_demi10.shallowRef)(props.modelValue);
+  (0, import_vue_demi10.watchEffect)(() => {
+    layout.value = props.modelValue;
+  });
+  const cellWidth = (0, import_vue_demi10.computed)(
+    () => (props.width - margin.value[0] * (cols.value - 1) - (containerPadding.value?.[0] || margin.value[0]) * 2) / props.cols
+  );
+  const cols = (0, import_vue_demi10.computed)(() => props.cols);
+  const rowHeight = (0, import_vue_demi10.computed)(() => props.rowHeight);
+  const margin = (0, import_vue_demi10.computed)(() => props.margin);
+  const maxRows = (0, import_vue_demi10.computed)(() => props.maxRows);
+  const containerPadding = (0, import_vue_demi10.computed)(() => props.containerPadding);
+  const minW = (0, import_vue_demi10.computed)(() => props.minW);
+  const minH = (0, import_vue_demi10.computed)(() => props.minH);
+  function getItem(key) {
+    return layout.value.find((item) => item.i === key);
+  }
+  function getFull() {
+    return layout.value;
+  }
+  function _moveElement(layout2, config, x, y, isUserAction, preventCollision) {
+    if (config.static)
+      return layout2;
+    if (config.y === y && config.x === x)
+      return layout2;
+    log(
+      `Moving element ${config.i} to [${String(x)},${String(y)}] from [${config.x},${config.y}]`
+    );
+    const oldX = config.x;
+    const oldY = config.y;
+    if (typeof x === "number")
+      config.x = x;
+    if (typeof y === "number")
+      config.y = y;
+    config.moved = true;
+    const sortable = _sortLayoutItems(layout2);
+    const collisions = sortable.filter((l) => _collides(l, config));
+    const hasCollsions = collisions.length > 0;
+    if (hasCollsions && preventCollision) {
+      config.x = oldX;
+      config.y = oldY;
+      config.moved = false;
+      return layout2;
+    }
+    collisions.forEach((collision) => {
+      log(
+        `Resolving collision between ${config.i} at [${config.x},${config.y}] and ${collision.i} at [${collision.x},${collision.y}]`,
+        collision.moved,
+        collision.i
+      );
+      if (collision.moved)
+        return;
+      if (collision.static) {
+        layout2 = _moveElementAwayFromCollision(
+          layout2,
+          collision,
+          config,
+          isUserAction
+        );
+      } else {
+        layout2 = _moveElementAwayFromCollision(
+          layout2,
+          config,
+          collision,
+          isUserAction
+        );
+      }
+    });
+    return layout2;
+  }
+  function _moveElementAwayFromCollision(layout2, collideWith, itemToMove, isUserAction) {
+    const preventCollision = collideWith.static;
+    if (isUserAction) {
+      isUserAction = false;
+      const fakeItem = {
+        x: itemToMove.x,
+        y: Math.max(collideWith.y - itemToMove.h, 0),
+        w: itemToMove.w,
+        h: itemToMove.h,
+        i: "-1"
+      };
+      if (!_getFirstCollision(layout2, fakeItem)) {
+        log(
+          `Doing reverse collision on ${itemToMove.i} up to [${fakeItem.x},${fakeItem.y}].`
+        );
+        return _moveElement(
+          layout2,
+          itemToMove,
+          void 0,
+          fakeItem.y,
+          isUserAction,
+          preventCollision
+        );
+      }
+    }
+    return _moveElement(
+      layout2,
+      itemToMove,
+      void 0,
+      itemToMove.y + 1,
+      isUserAction,
+      preventCollision
+    );
+  }
+  function moveTo(item, x, y) {
+    const isUserAction = true;
+    const _layout = _moveElement(layout.value, item, x, y, isUserAction, !props.collision);
+    layout.value = _normalize(_layout);
+    return layout.value;
+  }
+  function resizeTo(item, w, h5) {
+    let hasCollisions = false;
+    if (!props.collision) {
+      const collisions = layout.value.filter((l) => _collides(l, { ...item, w, h: h5 }));
+      hasCollisions = collisions.length > 0;
+      if (hasCollisions) {
+        let leastX = Infinity;
+        let leastY = Infinity;
+        collisions.forEach((collision) => {
+          if (collision.x > item.x)
+            leastX = Math.min(collision.x, leastX);
+          if (collision.y > item.y)
+            leastY = Math.min(collision.y, leastY);
+        });
+        if (Number.isFinite(leastX))
+          item.w = leastX - item.x;
+        if (Number.isFinite(leastY))
+          item.h = leastY - item.y;
+      }
+    }
+    if (!hasCollisions) {
+      item.w = w;
+      item.h = h5;
+    }
+    layout.value = _normalize([...layout.value]);
+  }
+  function _sortLayoutItems(layout2) {
+    return layout2.slice(0).sort((a, b) => {
+      if (a.y > b.y || a.y === b.y && a.x > b.x) {
+        return 1;
+      } else if (a.y === b.y && a.x === b.x) {
+        return 0;
+      } else {
+        return -1;
+      }
+    });
+  }
+  function _collides(l1, l2) {
+    if (l1.i === l2.i)
+      return false;
+    else if (l1.x + l1.w <= l2.x)
+      return false;
+    else if (l1.x >= l2.x + l2.w)
+      return false;
+    else if (l1.y + l1.h <= l2.y)
+      return false;
+    else if (l1.y >= l2.y + l2.h)
+      return false;
+    else
+      return true;
+  }
+  function _getFirstCollision(layout2, layoutItem) {
+    for (let i = 0; i < layout2.length; ++i) {
+      if (_collides(layout2[i], layoutItem))
+        return layout2[i];
+    }
+  }
+  function _normalize(layout2) {
+    const compareWith = layout2.filter((item) => item.static);
+    const sorted = _sortLayoutItems(layout2);
+    const _layout = new Array(layout2.length);
+    sorted.forEach((item, index) => {
+      let l = JSON.parse(JSON.stringify(item));
+      if (!l.static) {
+        l = _normalizeItem(compareWith, l, sorted);
+        compareWith.push(l);
+      }
+      _layout[layout2.indexOf(sorted[index])] = l;
+      l.moved = false;
+    });
+    return _layout;
+  }
+  function _normalizeItem(compareWith, l, layout2) {
+    if (props.collision) {
+      l.y = Math.min(_calBottom(compareWith), l.y);
+      while (l.y > 0 && !_getFirstCollision(compareWith, l)) {
+        --l.y;
+      }
+    }
+    let collides;
+    while ((collides = _getFirstCollision(compareWith, l)) && props.collision) {
+      resolveCompactionCollision(layout2, l, collides.y + collides.h, "y");
+    }
+    return l;
+  }
+  function _calBottom(layout2) {
+    let max = 0;
+    layout2.forEach((l) => {
+      const val = l.y + l.h;
+      if (val > max)
+        max = val;
+    });
+    return max;
+  }
+  function calContainerHeight() {
+    if (!props.autoHeight)
+      return;
+    const rows = _calBottom(layout.value);
+    return `${rows * props.rowHeight + margin.value[1] * (rows - 1) + (containerPadding.value?.[1] || margin.value[1]) * 2}px`;
+  }
+  const heightWidth = { x: "w", y: "h" };
+  function resolveCompactionCollision(layout2, item, position, axis) {
+    const sizeProp = heightWidth[axis];
+    item[axis] += 1;
+    const itemIndex = layout2.findIndex((each) => each === item);
+    for (let i = itemIndex + 1; i < layout2.length; ++i) {
+      const otherItem = layout2[i];
+      if (otherItem.y > item.y + item.h)
+        break;
+      if (_collides(item, otherItem)) {
+        resolveCompactionCollision(
+          layout2,
+          otherItem,
+          position + item[sizeProp],
+          axis
+        );
+      }
+    }
+    item[axis] = position;
+  }
+  return {
+    cellWidth,
+    cols,
+    rowHeight,
+    margin,
+    maxRows,
+    containerPadding,
+    minW,
+    minH,
+    calContainerHeight,
+    moveTo,
+    resizeTo,
+    getItem,
+    getFull
+  };
+}
+function useLayoutItem(props, layout) {
+  const { cellWidth, margin, rowHeight, cols, maxRows, containerPadding: cPadding } = layout;
+  const dragging = (0, import_vue_demi10.ref)();
+  const resizing = (0, import_vue_demi10.ref)();
+  const containerPadding = (0, import_vue_demi10.computed)(() => cPadding.value || margin.value);
+  const x = (0, import_vue_demi10.computed)(() => {
+    if (!dragging.value) {
+      return Math.round(props.x * (cellWidth.value + margin.value[0]) + containerPadding.value[0]);
+    } else {
+      return Math.round(dragging.value.x);
+    }
+  });
+  const y = (0, import_vue_demi10.computed)(() => {
+    if (!dragging.value) {
+      return Math.round(props.y * (rowHeight.value + margin.value[1]) + containerPadding.value[1]);
+    } else {
+      return Math.round(dragging.value.y);
+    }
+  });
+  const width = (0, import_vue_demi10.computed)(() => {
+    if (!resizing.value) {
+      return Math.round(cellWidth.value * props.width + Math.max(0, props.width - 1) * margin.value[0]);
+    } else {
+      return Math.round(resizing.value.width);
+    }
+  });
+  const height = (0, import_vue_demi10.computed)(() => {
+    if (!resizing.value) {
+      return Math.round(rowHeight.value * props.height + Math.max(0, props.height - 1) * margin.value[1]);
+    } else {
+      return Math.round(resizing.value.height);
+    }
+  });
+  const minWidth = (0, import_vue_demi10.computed)(() => {
+    const minW = layout.minW.value;
+    return Math.round(cellWidth.value * minW + Math.max(0, minW - 1) * margin.value[0]);
+  });
+  const minHeight = (0, import_vue_demi10.computed)(() => {
+    const minH = layout.minH.value;
+    return Math.round(rowHeight.value * minH + Math.max(0, minH - 1) * margin.value[1]);
+  });
+  const style = (0, import_vue_demi10.computed)(() => {
+    return {
+      position: "absolute",
+      width: `${width.value}px`,
+      height: `${height.value}px`,
+      transform: `translate(${x.value}px, ${y.value}px)`
+    };
+  });
+  const onDragStart = (evt, { node }) => {
+    const parentRect = node.offsetParent.getBoundingClientRect();
+    const clientRect = node.getBoundingClientRect();
+    dragging.value = {
+      x: clientRect.left - parentRect.left + node.offsetParent.scrollLeft,
+      y: clientRect.top - parentRect.top + node.offsetParent.scrollTop
+    };
+  };
+  const onDrag = (evt, coreData) => {
+    if (!dragging.value) {
+      throw new Error("onDrag called before onDragStart");
+    }
+    const { deltaX, deltaY } = coreData;
+    const dragX = dragging.value.x + deltaX;
+    const dragY = dragging.value.y + deltaY;
+    dragging.value = { x: dragX, y: dragY };
+    const { x: x2, y: y2 } = _calcXY(dragX, dragY);
+    props.dragFn(evt, { x: x2, y: y2 });
+  };
+  const onDragStop = (evt) => {
+    if (!dragging.value) {
+      throw new Error("onDragStop called before onDratStart");
+    }
+    const { x: _x, y: _y } = dragging.value;
+    const { x: x2, y: y2 } = _calcXY(_x, _y);
+    dragging.value = void 0;
+    props.dragEndFn(evt, { x: x2, y: y2 });
+  };
+  const onResizeStart = (evt, { width: width2, height: height2 }) => {
+    resizing.value = { width: width2, height: height2 };
+  };
+  const onResize = (evt, coreData) => {
+    const { width: width2, height: height2 } = coreData;
+    const { w, h: h5 } = _calcWH(width2, height2);
+    resizing.value = { width: width2, height: height2 };
+    props.resizeFn(evt, { w, h: h5 });
+  };
+  const onResizeStop = (evt, coreData) => {
+    resizing.value = void 0;
+    const { width: width2, height: height2 } = coreData;
+    const { w, h: h5 } = _calcWH(width2, height2);
+    props.resizeStopFn(evt, { w, h: h5 });
+  };
+  function _calcXY(left, top) {
+    let x2 = Math.round((left - margin.value[0]) / (cellWidth.value + margin.value[0]));
+    let y2 = Math.round((top - margin.value[1]) / (rowHeight.value + margin.value[1]));
+    x2 = clamp(x2, 0, cols.value - props.width);
+    y2 = clamp(y2, 0, maxRows.value - props.height);
+    return { x: x2, y: y2 };
+  }
+  function _calcWH(width2, height2) {
+    let w = Math.round((width2 + margin.value[0]) / (cellWidth.value + margin.value[0]));
+    let h5 = Math.round((height2 + margin.value[1]) / (rowHeight.value + margin.value[1]));
+    w = clamp(w, 0, cols.value - props.x);
+    h5 = clamp(h5, 0, maxRows.value - props.y);
+    return { w, h: h5 };
+  }
+  return {
+    x,
+    y,
+    width,
+    height,
+    dragging,
+    resizing,
+    style,
+    minWidth,
+    minHeight,
+    onDragStart,
+    onDrag,
+    onDragStop,
+    onResizeStart,
+    onResize,
+    onResizeStop
+  };
+}
+
+// src/components/freeDom.ts
+var import_vue_demi13 = require("vue-demi");
+
+// src/components/freeDomCore.ts
+var import_vue_demi11 = require("vue-demi");
+function noop() {
+}
+var freeDomCoreProps = {
+  userSelectHack: {
     type: Boolean,
+    default: true
+  },
+  startFn: {
+    type: Function,
+    default: noop
+  },
+  stopFn: {
+    type: Function,
+    default: noop
+  },
+  dragFn: {
+    type: Function,
+    default: noop
+  },
+  disabled: Boolean
+};
+var freeDomCore = (0, import_vue_demi11.defineComponent)({
+  name: "FreeDomCore",
+  props: freeDomCoreProps,
+  setup(props) {
+    const { only } = useDefaultSlot();
+    const dragging = (0, import_vue_demi11.ref)(false);
+    const coreRef = (0, import_vue_demi11.ref)();
+    const node = (0, import_vue_demi11.computed)(() => coreRef.value?.$el || coreRef.value);
+    const ownerDoc = (0, import_vue_demi11.computed)(() => node.value?.ownerDocument);
+    const { lastX, lastY, create } = useCoreData(node);
+    let parentNode;
+    let parentRect;
+    (0, import_vue_demi11.onUnmounted)(() => {
+      if (!ownerDoc.value)
+        return;
+      if (props.userSelectHack)
+        _removeUserSelectStyle(ownerDoc.value);
+      ownerDoc.value.removeEventListener("mousemove", _handleDrag);
+      ownerDoc.value.removeEventListener("mouseup", _handleDragStop);
+    });
+    function mousedownFn(evt) {
+      return _handleDragstart(evt);
+    }
+    function mouseupFn(evt) {
+      _handleDragStop(evt);
+    }
+    function _addUserSelectStyle(doc) {
+      if (!doc)
+        return;
+      if (!doc.getElementById("free-dom-style-el")) {
+        const styleEl = doc.createElement("style");
+        styleEl.id = "free-dom-style-el";
+        styleEl.innerHTML = ".free-dom-transparent-selection *::selection {all: inherit;}";
+        doc.getElementsByTagName("head")[0].appendChild(styleEl);
+      }
+      if (doc.body)
+        doc.body.classList.add("free-dom-transparent-selection");
+    }
+    function _removeUserSelectStyle(doc) {
+      if (!doc)
+        return;
+      if (doc.body) {
+        doc.body.classList.remove("free-dom-transparent-selection");
+      }
+      const selection = doc.getSelection();
+      if (selection) {
+        selection.removeAllRanges();
+      }
+    }
+    function _handleDragstart(evt) {
+      if (props.disabled || !evt.target || !(evt.target instanceof node.value.ownerDocument.defaultView.Node))
+        return;
+      const { x, y } = _offsetFormat(evt);
+      const coreEvent = create(x, y);
+      props.startFn(evt, coreEvent);
+      lastX.value = x;
+      lastY.value = y;
+      dragging.value = true;
+      if (props.userSelectHack)
+        _addUserSelectStyle(ownerDoc.value);
+      ownerDoc.value?.addEventListener("mousemove", _handleDrag);
+      ownerDoc.value?.addEventListener("mouseup", _handleDragStop);
+    }
+    function _handleDragStop(evt) {
+      if (!dragging.value)
+        return;
+      const { x, y } = _offsetFormat(evt);
+      const coreEvent = create(x, y);
+      props.stopFn(evt, coreEvent);
+      if (props.userSelectHack)
+        _removeUserSelectStyle(ownerDoc.value);
+      dragging.value = false;
+      lastX.value = NaN;
+      lastY.value = NaN;
+      ownerDoc.value?.removeEventListener("mousemove", _handleDrag);
+      ownerDoc.value?.removeEventListener("mouseup", _handleDragStop);
+    }
+    function _handleDrag(evt) {
+      const { x, y } = _offsetFormat(evt);
+      const coreEvent = create(x, y);
+      props.dragFn(evt, coreEvent);
+      lastX.value = x;
+      lastY.value = y;
+    }
+    function _offsetFormat(evt) {
+      const parent = node.value?.offsetParent || ownerDoc.value.body;
+      const isBody = parent === parent.ownerDocument.body;
+      if (!parentNode || parentNode !== parent) {
+        parentNode = parent;
+        parentRect = isBody ? { left: 0, top: 0 } : parent.getBoundingClientRect();
+      }
+      const x = evt.clientX + parent.scrollLeft - parentRect.left;
+      const y = evt.clientY + parent.scrollTop - parentRect.top;
+      return { x, y };
+    }
+    return {
+      only,
+      coreRef,
+      mousedownFn,
+      mouseupFn
+    };
+  },
+  render() {
+    const vue2Props = {
+      on: {
+        mousedown: (evt) => {
+          evt.stopPropagation();
+          this.mousedownFn(evt);
+        },
+        mouseup: this.mouseupFn
+      }
+    };
+    const vue3Props = {
+      onMousedown: (evt) => {
+        evt.stopPropagation();
+        this.mousedownFn(evt);
+      },
+      onMouseup: this.mouseupFn
+    };
+    const res = createRender(
+      // @ts-expect-error: maybe vue2
+      this.only,
+      { ref: (el) => {
+        this.coreRef = el;
+      } },
+      import_vue_demi11.isVue2 ? {} : vue3Props,
+      import_vue_demi11.isVue2 ? vue2Props.on : {}
+    );
+    if (typeof res === "function") {
+      return res();
+    } else {
+      return res;
+    }
+  }
+});
+var freeDomCore_default = freeDomCore;
+
+// src/components/resizeDomCore.ts
+var import_vue_demi12 = require("vue-demi");
+var Dots = ["t", "r", "l", "b", "lt", "lb", "rt", "rb"];
+function noop2() {
+}
+var resizeDomCoreProps = {
+  dragOpts: {
+    type: Object,
+    default: () => ({})
+  },
+  width: {
+    type: Number,
+    default: 0
+  },
+  height: {
+    type: Number,
+    default: 0
+  },
+  scale: {
+    type: [Boolean, Array],
     default: void 0
   },
-  preview: Boolean,
-  move: Boolean,
-  scale: [Boolean, Array],
-  diff: {
+  startFn: {
+    type: Function,
+    default: noop2
+  },
+  stopFn: {
+    type: Function,
+    default: noop2
+  },
+  resizeFn: {
+    type: Function,
+    default: noop2
+  },
+  minWidth: {
+    type: Number,
+    default: 50
+  },
+  minHeight: {
     type: Number,
-    default: 3
+    default: 50
   },
-  handler: {
-    type: String,
+  lockAspectRatio: Boolean
+};
+var resizeDomCore = (0, import_vue_demi12.defineComponent)({
+  name: "ResizeDomCore",
+  props: resizeDomCoreProps,
+  setup(props, { slots }) {
+    const { slots: _slots } = useDefaultSlot();
+    const dots = (0, import_vue_demi12.computed)(() => {
+      const _dots = props.scale;
+      return Array.isArray(_dots) ? _dots : Dots;
+    });
+    const lastRect = (0, import_vue_demi12.shallowRef)();
+    function runConstraints(width, height) {
+      const { lockAspectRatio } = props;
+      if (!props.minHeight && !props.minWidth && !lockAspectRatio)
+        return [width, height];
+      if (lockAspectRatio) {
+        const ratio = props.width / props.height;
+        const deltaW = width - props.width;
+        const deltaH = height - props.height;
+        if (Math.abs(deltaW) > Math.abs(deltaH * ratio)) {
+          height = width / ratio;
+        } else {
+          width = height * ratio;
+        }
+      }
+      width = Math.max(width, props.minWidth);
+      height = Math.max(height, props.minHeight);
+      return [width, height];
+    }
+    function handleResize(handleName, axis) {
+      return (evt, { node, deltaX, deltaY }) => {
+        if (handleName === "start")
+          lastRect.value = void 0;
+        const canDragX = axis !== "t" && axis !== "b";
+        const canDragY = axis !== "l" && axis !== "r";
+        const axisH = axis[0];
+        const axisV = axis[axis.length - 1];
+        const handleRect = node.getBoundingClientRect();
+        lastRect.value = handleRect;
+        if (axisH === "l")
+          deltaX = -deltaX;
+        if (axisV === "t")
+          deltaY = -deltaY;
+        let width = props.width + (canDragX ? deltaX : 0);
+        let height = props.height + (canDragY ? deltaY : 0);
+        [width, height] = runConstraints(width, height);
+        const sizeChanged = width !== props.width || height !== props.height;
+        const fnName = `${handleName}Fn`;
+        const cb = typeof props[fnName] === "function" ? props[fnName] : null;
+        const shouldSkipCb = handleName === "resize" && !sizeChanged;
+        if (cb && !shouldSkipCb) {
+          cb(evt, { node, width, height, handle: axis });
+        }
+        if (handleName === "stop")
+          lastRect.value = void 0;
+      };
+    }
+    function renderResizehandler(axis) {
+      if (!slots.handler) {
+        return () => (0, import_vue_demi12.h)("i", {
+          class: [
+            "vv-resize-dom--handler",
+            `vv-resize-dom--handler__${axis}`
+          ]
+        });
+      }
+      return () => slots.handler?.(axis);
+    }
+    return {
+      dots,
+      children: _slots,
+      handleResize,
+      renderResizehandler
+    };
+  },
+  render() {
+    const slots = [
+      ...this.children || [],
+      this.dots.map((dot) => {
+        return createRender(
+          freeDomCore_default,
+          { class: [this.dragOpts.disabled && "vv-resize-dom--disabled"] },
+          {
+            ...this.dragOpts,
+            stopFn: this.handleResize("stop", dot),
+            startFn: this.handleResize("start", dot),
+            dragFn: this.handleResize("resize", dot)
+          }
+        )(this.renderResizehandler(dot));
+      })
+    ];
+    return createRender(
+      "div",
+      { class: "vv-resize-dom--box" }
+    )(slots);
+  }
+});
+var resizeDomCore_default = resizeDomCore;
+
+// src/components/freeDom.ts
+function noop3() {
+}
+var freeDomProps = {
+  modelValue: {
+    type: Object,
+    default: () => ({})
+  },
+  x: {
+    type: Number,
+    default: 0
+  },
+  y: {
+    type: Number,
+    default: 0
+  },
+  width: {
+    type: Number,
+    default: void 0
+  },
+  height: {
+    type: Number,
     default: void 0
   },
-  diagonal: {
+  lockAspectRatio: Boolean,
+  dragStartFn: {
+    type: Function,
+    default: noop3
+  },
+  dragStopFn: {
+    type: Function,
+    default: noop3
+  },
+  dargFn: {
+    type: Function,
+    default: noop3
+  },
+  resizeStartFn: {
+    type: Function,
+    default: noop3
+  },
+  resizeFn: {
+    type: Function,
+    default: noop3
+  },
+  resizeStopFn: {
+    type: Function,
+    default: noop3
+  },
+  autoSize: {
     type: Boolean,
+    default: true
+  },
+  minWidth: resizeDomCoreProps.minWidth,
+  minHeight: resizeDomCoreProps.minHeight,
+  disabledDrag: Boolean,
+  disabledResize: Boolean,
+  scale: resizeDomCoreProps.scale,
+  fixNonMonospaced: Boolean
+};
+var freeDom = (0, import_vue_demi13.defineComponent)({
+  name: "FreeDom",
+  props: freeDomProps,
+  emits: [
+    "update:width",
+    "update:height",
+    "update:x",
+    "update:y",
+    "update:modelValue"
+  ],
+  setup(props, { emit, expose, slots }) {
+    const domRef = (0, import_vue_demi13.ref)();
+    const {
+      x,
+      y,
+      deltaX,
+      deltaY,
+      create,
+      handleDrag,
+      handleDragStop
+    } = useDraggableData(props);
+    const { width, height, syncSize: _syncSize } = useResizableData(props, domRef);
+    const context = {
+      _rect: (0, import_vue_demi13.reactive)({
+        x,
+        y,
+        width,
+        height,
+        deltaX,
+        deltaY
+      }),
+      trigger: () => {
+      }
+    };
+    const sceneContext = useSceneContext(context, props);
+    const syncSize = () => {
+      _syncSize(
+        sceneContext.fixNonMonospaced.value,
+        sceneContext.minWidth.value,
+        sceneContext.minHeight.value
+      );
+    };
+    (0, import_vue_demi13.onMounted)(() => {
+      props.autoSize && syncSize();
+    });
+    const style = (0, import_vue_demi13.computed)(() => ({
+      position: "absolute",
+      width: `${width.value}px`,
+      height: `${height.value}px`,
+      transform: `translate(${x.value}px, ${y.value}px)`
+    }));
+    const onDrag = (evt, coreData) => {
+      const data = create(coreData);
+      const newPos = {
+        x: data.x,
+        y: data.y,
+        width: width.value,
+        height: height.value
+      };
+      const isValid = sceneContext.check?.(newPos);
+      if (!isValid)
+        return;
+      handleDrag(evt, data);
+      sceneContext.emit("move");
+    };
+    const onDragStop = (evt, coreData) => {
+      const newPos = {
+        x: x.value,
+        y: y.value,
+        width: width.value,
+        height: height.value
+      };
+      const isValid = sceneContext.check?.(newPos);
+      if (!isValid) {
+        x.value = clamp(x.value, 0, sceneContext.width);
+        y.value = clamp(y.value, 0, sceneContext.height);
+      }
+      handleDragStop(evt, coreData);
+      sceneContext.emit("moveup");
+      emit("update:x", x.value);
+      emit("update:y", y.value);
+      emit("update:modelValue", { x: x.value, y: y.value, w: width.value, h: height.value });
+    };
+    const onResize = (evt, { node, width: w, height: h5, handle: axis }) => {
+      const offsetW = -(w - width.value);
+      const offsetH = -(h5 - height.value);
+      const axisH = axis[0];
+      const axisV = axis[axis.length - 1];
+      let _x = x.value;
+      let _y = y.value;
+      if (axisH === "l") {
+        _x += offsetW;
+      }
+      if (axisV === "t") {
+        _y += offsetH;
+      }
+      const isValid = sceneContext.check?.({ x: _x, y: _y, width: w, height: h5 });
+      if (!isValid)
+        return;
+      width.value = w;
+      height.value = h5;
+      x.value = _x;
+      y.value = _y;
+      props.resizeFn(evt, { node, width: w, height: h5, handle: axis });
+      sceneContext?.emit("move");
+    };
+    const onResizeStop = () => {
+      const isValid = sceneContext.check?.({ x: x.value, y: y.value, width: width.value, height: height.value });
+      if (!isValid) {
+        x.value = clamp(x.value, 0, sceneContext.width);
+        y.value = clamp(y.value, 0, sceneContext.height);
+      }
+      emit("update:width", width.value);
+      emit("update:height", height.value);
+      emit("update:modelValue", { x: x.value, y: y.value, w: width.value, h: height.value });
+      sceneContext.emit("moveup");
+    };
+    const resizeNode = () => {
+      const props2 = {
+        width: width.value,
+        height: height.value,
+        lockAspectRatio: sceneContext.lockAspectRatio.value,
+        dragOpts: { disabled: sceneContext.disabledResize.value },
+        resizeFn: onResize,
+        stopFn: onResizeStop,
+        minHeight: sceneContext.minHeight.value,
+        minWidth: sceneContext.minWidth.value,
+        scale: sceneContext.scale.value
+      };
+      return createRender(resizeDomCore_default, {}, props2)(slots);
+    };
+    expose?.({
+      syncSize
+    });
+    return {
+      domRef,
+      style,
+      onDragStop,
+      onDrag,
+      resizeNode,
+      disabled: sceneContext.disabledDrag
+    };
+  },
+  render() {
+    const props = {
+      stopFn: this.onDragStop,
+      dragFn: this.onDrag,
+      disabled: this.disabled
+    };
+    const slots = () => this.resizeNode();
+    return createRender(
+      freeDomCore_default,
+      {
+        ref: "domRef",
+        class: "vv-free-dom--draggable",
+        style: this.style
+      },
+      props
+    )?.(slots);
+  }
+});
+var freeDom_default = freeDom;
+
+// src/components/freeDomWrap.ts
+var freeDomWrapProps = {
+  width: {
+    type: Number,
     default: void 0
   },
-  grid: {
-    type: Object,
+  height: {
+    type: Number,
     default: void 0
-  }
+  },
+  diff: {
+    type: Number,
+    default: 2
+  },
+  showLine: {
+    type: Boolean,
+    default: true
+  },
+  minWidth: freeDomProps.minWidth,
+  minHeight: freeDomProps.minHeight,
+  lockAspectRatio: freeDomProps.lockAspectRatio,
+  disabledDrag: freeDomProps.disabledDrag,
+  disabledResize: freeDomProps.disabledResize,
+  scale: freeDomProps.scale,
+  fixNonMonospaced: freeDomProps.fixNonMonospaced
 };
-var FreeDomWrap = (0, import_vue_demi4.defineComponent)({
+var FreeDomWrap = (0, import_vue_demi14.defineComponent)({
   name: "FreeDomWrap",
   props: freeDomWrapProps,
   setup(props) {
-    const rectRef = (0, import_vue_demi4.shallowRef)(null);
-    const rect = (0, import_core2.useElementBounding)(rectRef);
-    const nodes = (0, import_vue_demi4.ref)([]);
+    const { slots } = useDefaultSlot();
+    const eventBus = useEventBus();
+    const rectRef = (0, import_vue_demi14.shallowRef)();
+    const nodes = (0, import_vue_demi14.ref)([]);
+    const width = (0, import_vue_demi14.ref)(props.width);
+    const height = (0, import_vue_demi14.ref)(props.height);
+    (0, import_vue_demi14.watchEffect)(() => {
+      width.value = props.width;
+    });
+    (0, import_vue_demi14.watchEffect)(() => {
+      height.value = props.height;
+    });
+    (0, import_vue_demi14.onMounted)(() => {
+      if (!props.width || !props.height) {
+        if (!rectRef.value)
+          console.warn("[free-dom] cannot find element, width or height may be set to 0");
+        const { width: w, height: h5 } = rectRef.value?.getBoundingClientRect() || {};
+        if (!props.width)
+          width.value = w || 0;
+        if (!props.height)
+          height.value = h5 || 0;
+      }
+    });
     function register(uuid, node) {
       nodes.value.push({ uuid, node });
     }
     function checkValid(pos) {
-      const { x, y, width, height } = pos;
-      return x >= 0 && x + width <= rect.width.value && y >= 0 && y + height <= rect.height.value;
+      const { x, y, width: w, height: h5 } = pos;
+      return x >= 0 && // @ts-expect-error: trigger after mounted
+      x + w <= width.value && y >= 0 && // @ts-expect-error: trigger after mounted
+      y + h5 <= height.value;
     }
-    (0, import_vue_demi4.provide)(
+    (0, import_vue_demi14.provide)(
       SceneToken,
-      (0, import_vue_demi4.reactive)({
-        ...(0, import_vue_demi4.toRefs)(props),
+      (0, import_vue_demi14.reactive)({
+        ...(0, import_vue_demi14.toRefs)(props),
         nodes,
+        width,
+        height,
         register,
-        checkValid
+        checkValid,
+        on: eventBus.on,
+        off: eventBus.off,
+        emit: eventBus.emit
       })
     );
+    const style = (0, import_vue_demi14.computed)(() => ({
+      width: `${props.width}px`,
+      height: `${props.height}px`
+    }));
     return {
-      rectRef
+      rectRef,
+      style,
+      slots
     };
   },
   render() {
-    const defaultSlot = typeof this.$slots.default === "function" ? this.$slots.default() : this.$slots.default;
-    return (0, import_vue_demi4.h)("section", {
-      ref: "rectRef"
-    }, [defaultSlot, (0, import_vue_demi4.h)(markLine_default)]);
+    const marklineComp = createRender(markLine_default, {}, { showLine: this.showLine })();
+    const slots = [this.slots, marklineComp];
+    return createRender(
+      "section",
+      {
+        ref: "rectRef",
+        class: "vv-free-dom--scene",
+        style: this.style
+      }
+    )(slots);
+  }
+});
+
+// src/components/gridLayout.ts
+var import_vue_demi16 = require("vue-demi");
+
+// src/components/gridItem.ts
+var import_vue_demi15 = require("vue-demi");
+
+// src/components/tokens.ts
+var gridLayoutContextKey = Symbol("gridLayoutContext");
+
+// src/components/gridItem.ts
+var noop4 = () => {
+};
+var gridItemProps = {
+  x: {
+    type: Number,
+    required: true
+  },
+  y: {
+    type: Number,
+    required: true
+  },
+  width: {
+    type: Number,
+    required: true
+  },
+  height: {
+    type: Number,
+    required: true
+  },
+  dragStartFn: {
+    type: Function,
+    default: noop4
+  },
+  dragFn: {
+    type: Function,
+    default: noop4
+  },
+  dragEndFn: {
+    type: Function,
+    default: noop4
+  },
+  resizeStartFn: {
+    type: Function,
+    default: noop4
+  },
+  resizeFn: {
+    type: Function,
+    default: noop4
+  },
+  resizeStopFn: {
+    type: Function,
+    default: noop4
+  },
+  isDraggable: Boolean,
+  isResizable: Boolean,
+  scale: {
+    type: resizeDomCoreProps.scale.type,
+    default: () => ["rb"]
+  }
+};
+var gridItemEmits = ["dragMove"];
+var GridItem = (0, import_vue_demi15.defineComponent)({
+  name: "GridItem",
+  props: gridItemProps,
+  emits: gridItemEmits,
+  setup(props) {
+    const layout = (0, import_vue_demi15.inject)(gridLayoutContextKey);
+    if (!layout) {
+      throw new Error("TODO");
+    }
+    const {
+      x,
+      y,
+      width,
+      height,
+      dragging,
+      style,
+      minWidth,
+      minHeight,
+      onDragStart,
+      onDrag,
+      onDragStop,
+      onResizeStart,
+      onResize,
+      onResizeStop
+    } = useLayoutItem(props, layout);
+    const { only, slots } = useDefaultSlot();
+    const resizeNode = (child) => {
+      const _props = {
+        width: width.value,
+        height: height.value,
+        scale: props.scale,
+        dragOpts: {
+          disabled: !props.isResizable
+        },
+        minWidth: minWidth.value,
+        minHeight: minHeight.value,
+        startFn: onResizeStart,
+        resizeFn: onResize,
+        stopFn: onResizeStop
+      };
+      return createRender(resizeDomCore_default, {}, _props)(() => child);
+    };
+    const dragNode = (child) => {
+      const _attrs = {
+        class: [
+          dragging.value && "vv-grid-layout--item__draggable",
+          "vv-grid-layout--item",
+          !props.isDraggable && "vv-grid-layout--item__disabled"
+        ],
+        style: style.value
+      };
+      const _props = {
+        disabled: !props.isDraggable,
+        startFn: onDragStart,
+        stopFn: onDragStop,
+        dragFn: onDrag
+      };
+      return createRender(freeDomCore_default, _attrs, _props)(() => resizeNode(child));
+    };
+    return {
+      x,
+      y,
+      width,
+      height,
+      child: only,
+      slots,
+      style,
+      dragging,
+      onDragStart,
+      onDrag,
+      onDragStop,
+      onResizeStart,
+      onResize,
+      onResizeStop,
+      dragNode
+    };
+  },
+  render() {
+    const node = this.slots;
+    return this.dragNode(node);
+  }
+});
+
+// src/components/gridLayout.ts
+var gridLayoutProps = {
+  modelValue: {
+    type: Array,
+    required: true,
+    default: () => []
+  },
+  autoHeight: {
+    type: Boolean,
+    default: true
+  },
+  cols: {
+    type: Number,
+    default: 12
+  },
+  maxRows: {
+    type: Number,
+    default: Infinity
+  },
+  minW: {
+    type: Number,
+    default: 1
+  },
+  minH: {
+    type: Number,
+    default: 1
+  },
+  rowHeight: {
+    type: Number,
+    default: 150
+  },
+  width: {
+    type: Number,
+    default: 1200
+  },
+  margin: {
+    type: Array,
+    default: () => [10, 10]
+  },
+  containerPadding: {
+    type: Array,
+    default: void 0
+  },
+  disabledDrag: Boolean,
+  disabledResize: Boolean,
+  collision: Boolean
+};
+var GridLayout = (0, import_vue_demi16.defineComponent)({
+  name: "GridLayout",
+  inheritAttrs: false,
+  props: gridLayoutProps,
+  emits: ["update:modelValue"],
+  setup(props, { emit }) {
+    const layout = useLayout(props);
+    (0, import_vue_demi16.provide)(gridLayoutContextKey, layout);
+    const activeDrag = (0, import_vue_demi16.ref)(null);
+    function processItem(node) {
+      const key = node.key;
+      if (!key)
+        return;
+      const config = layout.getItem(String(key));
+      if (!config)
+        return;
+      const isDraggable = !config.static && !props.disabledDrag;
+      const isResizable = !config.static && !props.disabledResize;
+      const _props = {
+        x: config.x,
+        y: config.y,
+        width: config.w,
+        height: config.h,
+        isDraggable,
+        isResizable,
+        scale: config.scale,
+        dragEndFn: (evt, rect) => {
+          const { x, y } = rect;
+          const _layout = layout.moveTo(config, x, y);
+          emit("update:modelValue", _layout);
+          activeDrag.value = null;
+        },
+        dragStartFn: () => {
+        },
+        dragFn: (evt, data) => {
+          if (!config)
+            return;
+          const placeholder2 = {
+            x: config.x,
+            y: config.y,
+            width: config.w,
+            height: config.h
+          };
+          const { x, y } = data;
+          layout.moveTo(config, x, y);
+          activeDrag.value = placeholder2;
+        },
+        resizeFn: (evt, data) => {
+          const placeholder2 = {
+            x: config.x,
+            y: config.y,
+            width: config.w,
+            height: config.h
+          };
+          activeDrag.value = placeholder2;
+          const { w, h: h5 } = data;
+          layout.resizeTo(config, w, h5);
+        },
+        resizeStopFn: (evt, data) => {
+          const { w, h: h5 } = data;
+          layout.resizeTo(config, w, h5);
+          activeDrag.value = null;
+        }
+      };
+      return createRender(GridItem, {}, _props)({ default: () => node });
+    }
+    function placeholder() {
+      if (!activeDrag.value)
+        return null;
+      const { x, y, width, height } = activeDrag.value;
+      const _props = {
+        x,
+        y,
+        width,
+        height,
+        move: false
+      };
+      return createRender(GridItem, {
+        class: "vv-grid-layout--placeholder"
+      }, _props)();
+    }
+    return {
+      processItem,
+      placeholder,
+      layout
+    };
+  },
+  render() {
+    const mergedStyle = {
+      ...this.$attrs.style || {},
+      height: this.layout.calContainerHeight()
+    };
+    const defaultSlot = typeof this.$slots.default === "function" ? this.$slots.default() : this.$slots.default || [];
+    return (0, import_vue_demi16.h)("div", {
+      class: "vv-grid-layout",
+      style: mergedStyle
+    }, [
+      defaultSlot.map(this.processItem),
+      this.placeholder()
+    ]);
   }
 });
+var gridLayout_default = GridLayout;
 
 // src/index.ts
-var freeDom = FreeDom;
-var freeScene = FreeDomWrap;
+var FreeScene = FreeDomWrap;
+var GridLayout2 = gridLayout_default;
+var FreeDom = freeDom_default;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  freeDom,
-  freeScene
+  FreeDom,
+  FreeScene,
+  GridLayout
 });