@tmagic/editor 1.0.0-beta.2 → 1.0.0-beta.5

package/src/utils/editor.ts

@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 
-import { cloneDeep, random } from 'lodash-es';
+import { random } from 'lodash-es';
 
 import { Id, MApp, MContainer, MNode, MPage } from '@tmagic/schema';
 import { getNodePath, isPop } from '@tmagic/utils';
@@ -223,22 +223,3 @@ export const Fixed2Other = async (node: MNode, root: MApp, getLayout: (node: MNo
 
   return toRelative(node);
 };
-
-export const defaults = (object: any, source: any) => {
-  let o = source;
-  if (Array.isArray(object)) {
-    o = object;
-  }
-
-  Object.entries(o).forEach(([key, value]: [string, any]) => {
-    if (typeof object[key] === 'undefined') {
-      object[key] = value;
-      return;
-    }
-
-    if (value && typeof value !== 'string' && Object.keys(value).length) {
-      object[key] = defaults(cloneDeep(object[key]), value);
-    }
-  });
-  return object;
-};

package/src/utils/scroll-viewer.ts

@@ -0,0 +1,214 @@
+import { Keys } from '@editor/type';
+
+interface ScrollViewerOptions {
+  container: HTMLDivElement;
+  target: HTMLDivElement;
+  zoom: number;
+}
+
+export class ScrollViewer {
+  private enter = false;
+  private targetEnter = false;
+  private keydown = false;
+  private container: HTMLDivElement;
+  private target: HTMLDivElement;
+  private zoom = 1;
+
+  private scrollLeft = 0;
+  private scrollTop = 0;
+
+  private x = 0;
+  private y = 0;
+
+  private resizeObserver = new ResizeObserver((entries) => {
+    for (const { contentRect } of entries) {
+      const { width, height } = contentRect;
+      const targetRect = this.target.getBoundingClientRect();
+      const targetWidth = targetRect.width * this.zoom;
+      const targetMarginTop = Number(this.target.style.marginTop) || 0;
+      const targetHeight = (targetRect.height + targetMarginTop) * this.zoom;
+
+      if (targetWidth < width) {
+        (this.target as any)._left = 0;
+      }
+      if (targetHeight < height) {
+        (this.target as any)._top = 0;
+      }
+
+      this.scroll();
+    }
+  });
+
+  constructor(options: ScrollViewerOptions) {
+    this.container = options.container;
+    this.target = options.target;
+    this.zoom = options.zoom;
+
+    globalThis.addEventListener('keydown', this.keydownHandler);
+    globalThis.addEventListener('keyup', this.keyupHandler);
+
+    this.container.addEventListener('mouseenter', this.mouseEnterHandler);
+    this.container.addEventListener('mouseleave', this.mouseLeaveHandler);
+    this.target.addEventListener('mouseenter', this.targetMouseEnterHandler);
+    this.target.addEventListener('mouseleave', this.targetMouseLeaveHandler);
+
+    this.container.addEventListener('wheel', this.wheelHandler);
+
+    this.resizeObserver.observe(this.container);
+  }
+
+  public destroy() {
+    this.resizeObserver.disconnect();
+
+    this.container.removeEventListener('mouseenter', this.mouseEnterHandler);
+    this.container.removeEventListener('mouseleave', this.mouseLeaveHandler);
+    this.target.removeEventListener('mouseenter', this.targetMouseEnterHandler);
+    this.target.removeEventListener('mouseleave', this.targetMouseLeaveHandler);
+    globalThis.removeEventListener('keydown', this.keydownHandler);
+    globalThis.removeEventListener('keyup', this.keyupHandler);
+  }
+
+  public setZoom(zoom: number) {
+    this.zoom = zoom;
+  }
+
+  private scroll() {
+    const scrollLeft = (this.target as any)._left;
+    const scrollTop = (this.target as any)._top;
+
+    this.target.style.transform = `translate(${scrollLeft}px, ${scrollTop}px)`;
+  }
+
+  private removeHandler() {
+    this.target.style.cursor = '';
+    this.target.removeEventListener('mousedown', this.mousedownHandler);
+    document.removeEventListener('mousemove', this.mousemoveHandler);
+    document.removeEventListener('mouseup', this.mouseupHandler);
+  }
+
+  private wheelHandler = (event: WheelEvent) => {
+    if (this.targetEnter) return;
+
+    const { deltaX, deltaY, currentTarget } = event;
+
+    if (currentTarget !== this.container) return;
+
+    this.setScrollOffset(deltaX, deltaY);
+    this.scroll();
+    this.scrollLeft = (this.target as any)._left;
+    this.scrollTop = (this.target as any)._top;
+  };
+
+  private mouseEnterHandler = () => {
+    this.enter = true;
+  };
+
+  private mouseLeaveHandler = () => {
+    this.enter = false;
+  };
+
+  private targetMouseEnterHandler = () => {
+    this.targetEnter = true;
+  };
+
+  private targetMouseLeaveHandler = () => {
+    this.targetEnter = false;
+  };
+
+  private mousedownHandler = (event: MouseEvent) => {
+    if (!this.keydown) return;
+
+    event.stopImmediatePropagation();
+    event.stopPropagation();
+
+    this.target.style.cursor = 'grabbing';
+
+    this.x = event.clientX;
+    this.y = event.clientY;
+
+    document.addEventListener('mousemove', this.mousemoveHandler);
+    document.addEventListener('mouseup', this.mouseupHandler);
+  };
+
+  private mouseupHandler = () => {
+    this.x = 0;
+    this.y = 0;
+
+    this.scrollLeft = (this.target as any)._left;
+    this.scrollTop = (this.target as any)._top;
+    this.removeHandler();
+  };
+
+  private mousemoveHandler = (event: MouseEvent) => {
+    event.stopImmediatePropagation();
+    event.stopPropagation();
+
+    const deltaX = event.clientX - this.x;
+    const deltaY = event.clientY - this.y;
+
+    this.setScrollOffset(deltaX, deltaY);
+    this.scroll();
+  };
+
+  private keydownHandler = (event: KeyboardEvent) => {
+    if (event.code === Keys.ESCAPE && this.enter) {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+    } else if (this.keydown) return;
+
+    this.keydown = true;
+
+    event.preventDefault();
+
+    this.target.style.cursor = 'grab';
+    this.container.addEventListener('mousedown', this.mousedownHandler);
+  };
+
+  private keyupHandler = (event: KeyboardEvent) => {
+    if (event.code !== Keys.ESCAPE || !this.keydown) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    event.stopPropagation();
+
+    this.keydown = false;
+
+    event.preventDefault();
+
+    this.removeHandler();
+  };
+
+  private setScrollOffset(deltaX: number, deltaY: number) {
+    const { width, height } = this.container.getBoundingClientRect();
+    const targetRect = this.target.getBoundingClientRect();
+
+    const targetWidth = targetRect.width * this.zoom;
+    const targetHeight = targetRect.height * this.zoom;
+
+    let y = 0;
+
+    if (targetHeight > height) {
+      if (deltaY > 0) {
+        y = this.scrollTop + Math.min(targetHeight - height - this.scrollTop, deltaY);
+      } else {
+        y = this.scrollTop + Math.max(-(targetHeight - height + this.scrollTop), deltaY);
+      }
+    }
+
+    let x = 0;
+
+    if (targetWidth > width) {
+      if (deltaX > 0) {
+        x = this.scrollLeft + Math.min(targetWidth - width - this.scrollLeft, deltaX);
+      } else {
+        x = this.scrollLeft + Math.max(-(targetWidth - width + this.scrollLeft), deltaX);
+      }
+    }
+
+    (this.target as any)._left = x;
+    (this.target as any)._top = y;
+  }
+}