microboard-temp 0.11.9 → 0.12.1

package/dist/cjs/browser.js

@@ -18214,6 +18214,16 @@ class Transformation {
       shearY: 0
     }, timeStamp);
   }
+  applyMatrixSilent(matrixData) {
+    this.previous = this._matrix.copy();
+    this._matrix.scale(matrixData.scaleX, matrixData.scaleY);
+    this._matrix.translate(matrixData.translateX, matrixData.translateY);
+    this.subject.publish(this, {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: [{ id: this.id, matrix: matrixData }]
+    });
+  }
   setIsLocked(isLocked, timestamp) {
     if (isLocked) {
       this.emit({
@@ -54286,6 +54296,123 @@ class BoardSelection {
     });
   }
 }
+// src/Gravity/GravityEngine.ts
+class GravityEngine {
+  board;
+  velocities = new Map;
+  tickTimer = null;
+  syncTimer = null;
+  lastSyncedPositions = new Map;
+  G = 500;
+  DAMPING = 0.98;
+  TICK_MS = 33;
+  SYNC_MS = 300;
+  MAX_DISTANCE = 3000;
+  SOFTENING_SQ = 50 * 50;
+  MIN_MOVE_PX = 0.1;
+  constructor(board) {
+    this.board = board;
+  }
+  start() {
+    if (this.tickTimer !== null)
+      return;
+    for (const item of this.board.items.listAll()) {
+      this.velocities.set(item.getId(), { vx: 0, vy: 0 });
+    }
+    this.tickTimer = setInterval(() => this.tick(), this.TICK_MS);
+    this.syncTimer = setInterval(() => this.syncPositions(), this.SYNC_MS);
+  }
+  stop() {
+    if (this.tickTimer !== null) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.syncTimer !== null) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    this.velocities.clear();
+    this.lastSyncedPositions.clear();
+  }
+  tick() {
+    const dt = this.TICK_MS / 1000;
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length < 2)
+      return;
+    for (const item of items) {
+      const id = item.getId();
+      if (!this.velocities.has(id)) {
+        this.velocities.set(id, { vx: 0, vy: 0 });
+      }
+      const vel = this.velocities.get(id);
+      const pos1 = item.transformation.getTranslation();
+      const mbr1 = item.getMbr();
+      const mass1 = mbr1.getWidth() * mbr1.getHeight();
+      const nearby = this.board.items.getEnclosedOrCrossed(pos1.x - this.MAX_DISTANCE, pos1.y - this.MAX_DISTANCE, pos1.x + this.MAX_DISTANCE * 2, pos1.y + this.MAX_DISTANCE * 2).filter((other) => other.getId() !== id);
+      let ax = 0;
+      let ay = 0;
+      for (const other of nearby) {
+        const pos2 = other.transformation.getTranslation();
+        const mbr2 = other.getMbr();
+        const mass2 = mbr2.getWidth() * mbr2.getHeight();
+        const dx2 = pos2.x - pos1.x;
+        const dy2 = pos2.y - pos1.y;
+        const distSq = dx2 * dx2 + dy2 * dy2 + this.SOFTENING_SQ;
+        const dist = Math.sqrt(distSq);
+        const acc = this.G * mass2 / distSq;
+        ax += acc * dx2 / dist;
+        ay += acc * dy2 / dist;
+      }
+      vel.vx = (vel.vx + ax * dt) * this.DAMPING;
+      vel.vy = (vel.vy + ay * dt) * this.DAMPING;
+      const dx = vel.vx * dt;
+      const dy = vel.vy * dt;
+      if (Math.abs(dx) >= this.MIN_MOVE_PX || Math.abs(dy) >= this.MIN_MOVE_PX) {
+        item.transformation.applyMatrixSilent({
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        });
+      }
+    }
+  }
+  syncPositions() {
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length === 0)
+      return;
+    const movedItems = items.map((item) => {
+      const id = item.getId();
+      const pos = item.transformation.getTranslation();
+      const last = this.lastSyncedPositions.get(id);
+      const dx = last ? pos.x - last.x : 0;
+      const dy = last ? pos.y - last.y : 0;
+      this.lastSyncedPositions.set(id, { x: pos.x, y: pos.y });
+      return { id, dx, dy };
+    }).filter(({ dx, dy }) => Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5);
+    if (movedItems.length === 0)
+      return;
+    const operation = {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: movedItems.map(({ id, dx, dy }) => ({
+        id,
+        matrix: {
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        }
+      }))
+    };
+    this.board.events.emit(operation);
+  }
+}
+
 // src/Board.ts
 class Board {
   boardId;
@@ -55308,6 +55435,22 @@ class Board {
     this.selection.quickAddButtons.clear();
     this.presence.cleanup();
   }
+  gravity = null;
+  enableGravity() {
+    if (this.gravity)
+      return;
+    this.gravity = new GravityEngine(this);
+    this.gravity.start();
+  }
+  disableGravity() {
+    if (!this.gravity)
+      return;
+    this.gravity.stop();
+    this.gravity = null;
+  }
+  isGravityEnabled() {
+    return this.gravity !== null;
+  }
 }
 // src/Events/Merge.ts
 var import_slate36 = require("slate");

package/dist/cjs/index.js

@@ -18214,6 +18214,16 @@ class Transformation {
       shearY: 0
     }, timeStamp);
   }
+  applyMatrixSilent(matrixData) {
+    this.previous = this._matrix.copy();
+    this._matrix.scale(matrixData.scaleX, matrixData.scaleY);
+    this._matrix.translate(matrixData.translateX, matrixData.translateY);
+    this.subject.publish(this, {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: [{ id: this.id, matrix: matrixData }]
+    });
+  }
   setIsLocked(isLocked, timestamp) {
     if (isLocked) {
       this.emit({
@@ -54286,6 +54296,123 @@ class BoardSelection {
     });
   }
 }
+// src/Gravity/GravityEngine.ts
+class GravityEngine {
+  board;
+  velocities = new Map;
+  tickTimer = null;
+  syncTimer = null;
+  lastSyncedPositions = new Map;
+  G = 500;
+  DAMPING = 0.98;
+  TICK_MS = 33;
+  SYNC_MS = 300;
+  MAX_DISTANCE = 3000;
+  SOFTENING_SQ = 50 * 50;
+  MIN_MOVE_PX = 0.1;
+  constructor(board) {
+    this.board = board;
+  }
+  start() {
+    if (this.tickTimer !== null)
+      return;
+    for (const item of this.board.items.listAll()) {
+      this.velocities.set(item.getId(), { vx: 0, vy: 0 });
+    }
+    this.tickTimer = setInterval(() => this.tick(), this.TICK_MS);
+    this.syncTimer = setInterval(() => this.syncPositions(), this.SYNC_MS);
+  }
+  stop() {
+    if (this.tickTimer !== null) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.syncTimer !== null) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    this.velocities.clear();
+    this.lastSyncedPositions.clear();
+  }
+  tick() {
+    const dt = this.TICK_MS / 1000;
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length < 2)
+      return;
+    for (const item of items) {
+      const id = item.getId();
+      if (!this.velocities.has(id)) {
+        this.velocities.set(id, { vx: 0, vy: 0 });
+      }
+      const vel = this.velocities.get(id);
+      const pos1 = item.transformation.getTranslation();
+      const mbr1 = item.getMbr();
+      const mass1 = mbr1.getWidth() * mbr1.getHeight();
+      const nearby = this.board.items.getEnclosedOrCrossed(pos1.x - this.MAX_DISTANCE, pos1.y - this.MAX_DISTANCE, pos1.x + this.MAX_DISTANCE * 2, pos1.y + this.MAX_DISTANCE * 2).filter((other) => other.getId() !== id);
+      let ax = 0;
+      let ay = 0;
+      for (const other of nearby) {
+        const pos2 = other.transformation.getTranslation();
+        const mbr2 = other.getMbr();
+        const mass2 = mbr2.getWidth() * mbr2.getHeight();
+        const dx2 = pos2.x - pos1.x;
+        const dy2 = pos2.y - pos1.y;
+        const distSq = dx2 * dx2 + dy2 * dy2 + this.SOFTENING_SQ;
+        const dist = Math.sqrt(distSq);
+        const acc = this.G * mass2 / distSq;
+        ax += acc * dx2 / dist;
+        ay += acc * dy2 / dist;
+      }
+      vel.vx = (vel.vx + ax * dt) * this.DAMPING;
+      vel.vy = (vel.vy + ay * dt) * this.DAMPING;
+      const dx = vel.vx * dt;
+      const dy = vel.vy * dt;
+      if (Math.abs(dx) >= this.MIN_MOVE_PX || Math.abs(dy) >= this.MIN_MOVE_PX) {
+        item.transformation.applyMatrixSilent({
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        });
+      }
+    }
+  }
+  syncPositions() {
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length === 0)
+      return;
+    const movedItems = items.map((item) => {
+      const id = item.getId();
+      const pos = item.transformation.getTranslation();
+      const last = this.lastSyncedPositions.get(id);
+      const dx = last ? pos.x - last.x : 0;
+      const dy = last ? pos.y - last.y : 0;
+      this.lastSyncedPositions.set(id, { x: pos.x, y: pos.y });
+      return { id, dx, dy };
+    }).filter(({ dx, dy }) => Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5);
+    if (movedItems.length === 0)
+      return;
+    const operation = {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: movedItems.map(({ id, dx, dy }) => ({
+        id,
+        matrix: {
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        }
+      }))
+    };
+    this.board.events.emit(operation);
+  }
+}
+
 // src/Board.ts
 class Board {
   boardId;
@@ -55308,6 +55435,22 @@ class Board {
     this.selection.quickAddButtons.clear();
     this.presence.cleanup();
   }
+  gravity = null;
+  enableGravity() {
+    if (this.gravity)
+      return;
+    this.gravity = new GravityEngine(this);
+    this.gravity.start();
+  }
+  disableGravity() {
+    if (!this.gravity)
+      return;
+    this.gravity.stop();
+    this.gravity = null;
+  }
+  isGravityEnabled() {
+    return this.gravity !== null;
+  }
 }
 // src/Events/Merge.ts
 var import_slate36 = require("slate");

package/dist/cjs/node.js

@@ -20754,6 +20754,16 @@ class Transformation {
       shearY: 0
     }, timeStamp);
   }
+  applyMatrixSilent(matrixData) {
+    this.previous = this._matrix.copy();
+    this._matrix.scale(matrixData.scaleX, matrixData.scaleY);
+    this._matrix.translate(matrixData.translateX, matrixData.translateY);
+    this.subject.publish(this, {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: [{ id: this.id, matrix: matrixData }]
+    });
+  }
   setIsLocked(isLocked, timestamp) {
     if (isLocked) {
       this.emit({
@@ -56759,6 +56769,123 @@ class BoardSelection {
     });
   }
 }
+// src/Gravity/GravityEngine.ts
+class GravityEngine {
+  board;
+  velocities = new Map;
+  tickTimer = null;
+  syncTimer = null;
+  lastSyncedPositions = new Map;
+  G = 500;
+  DAMPING = 0.98;
+  TICK_MS = 33;
+  SYNC_MS = 300;
+  MAX_DISTANCE = 3000;
+  SOFTENING_SQ = 50 * 50;
+  MIN_MOVE_PX = 0.1;
+  constructor(board) {
+    this.board = board;
+  }
+  start() {
+    if (this.tickTimer !== null)
+      return;
+    for (const item of this.board.items.listAll()) {
+      this.velocities.set(item.getId(), { vx: 0, vy: 0 });
+    }
+    this.tickTimer = setInterval(() => this.tick(), this.TICK_MS);
+    this.syncTimer = setInterval(() => this.syncPositions(), this.SYNC_MS);
+  }
+  stop() {
+    if (this.tickTimer !== null) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.syncTimer !== null) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    this.velocities.clear();
+    this.lastSyncedPositions.clear();
+  }
+  tick() {
+    const dt = this.TICK_MS / 1000;
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length < 2)
+      return;
+    for (const item of items) {
+      const id = item.getId();
+      if (!this.velocities.has(id)) {
+        this.velocities.set(id, { vx: 0, vy: 0 });
+      }
+      const vel = this.velocities.get(id);
+      const pos1 = item.transformation.getTranslation();
+      const mbr1 = item.getMbr();
+      const mass1 = mbr1.getWidth() * mbr1.getHeight();
+      const nearby = this.board.items.getEnclosedOrCrossed(pos1.x - this.MAX_DISTANCE, pos1.y - this.MAX_DISTANCE, pos1.x + this.MAX_DISTANCE * 2, pos1.y + this.MAX_DISTANCE * 2).filter((other) => other.getId() !== id);
+      let ax = 0;
+      let ay = 0;
+      for (const other of nearby) {
+        const pos2 = other.transformation.getTranslation();
+        const mbr2 = other.getMbr();
+        const mass2 = mbr2.getWidth() * mbr2.getHeight();
+        const dx2 = pos2.x - pos1.x;
+        const dy2 = pos2.y - pos1.y;
+        const distSq = dx2 * dx2 + dy2 * dy2 + this.SOFTENING_SQ;
+        const dist = Math.sqrt(distSq);
+        const acc = this.G * mass2 / distSq;
+        ax += acc * dx2 / dist;
+        ay += acc * dy2 / dist;
+      }
+      vel.vx = (vel.vx + ax * dt) * this.DAMPING;
+      vel.vy = (vel.vy + ay * dt) * this.DAMPING;
+      const dx = vel.vx * dt;
+      const dy = vel.vy * dt;
+      if (Math.abs(dx) >= this.MIN_MOVE_PX || Math.abs(dy) >= this.MIN_MOVE_PX) {
+        item.transformation.applyMatrixSilent({
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        });
+      }
+    }
+  }
+  syncPositions() {
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length === 0)
+      return;
+    const movedItems = items.map((item) => {
+      const id = item.getId();
+      const pos = item.transformation.getTranslation();
+      const last = this.lastSyncedPositions.get(id);
+      const dx = last ? pos.x - last.x : 0;
+      const dy = last ? pos.y - last.y : 0;
+      this.lastSyncedPositions.set(id, { x: pos.x, y: pos.y });
+      return { id, dx, dy };
+    }).filter(({ dx, dy }) => Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5);
+    if (movedItems.length === 0)
+      return;
+    const operation = {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: movedItems.map(({ id, dx, dy }) => ({
+        id,
+        matrix: {
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        }
+      }))
+    };
+    this.board.events.emit(operation);
+  }
+}
+
 // src/Board.ts
 class Board {
   boardId;
@@ -57781,6 +57908,22 @@ class Board {
     this.selection.quickAddButtons.clear();
     this.presence.cleanup();
   }
+  gravity = null;
+  enableGravity() {
+    if (this.gravity)
+      return;
+    this.gravity = new GravityEngine(this);
+    this.gravity.start();
+  }
+  disableGravity() {
+    if (!this.gravity)
+      return;
+    this.gravity.stop();
+    this.gravity = null;
+  }
+  isGravityEnabled() {
+    return this.gravity !== null;
+  }
 }
 // src/Events/Merge.ts
 var import_slate35 = require("slate");

package/dist/esm/browser.js

@@ -18043,6 +18043,16 @@ class Transformation {
       shearY: 0
     }, timeStamp);
   }
+  applyMatrixSilent(matrixData) {
+    this.previous = this._matrix.copy();
+    this._matrix.scale(matrixData.scaleX, matrixData.scaleY);
+    this._matrix.translate(matrixData.translateX, matrixData.translateY);
+    this.subject.publish(this, {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: [{ id: this.id, matrix: matrixData }]
+    });
+  }
   setIsLocked(isLocked, timestamp) {
     if (isLocked) {
       this.emit({
@@ -54115,6 +54125,123 @@ class BoardSelection {
     });
   }
 }
+// src/Gravity/GravityEngine.ts
+class GravityEngine {
+  board;
+  velocities = new Map;
+  tickTimer = null;
+  syncTimer = null;
+  lastSyncedPositions = new Map;
+  G = 500;
+  DAMPING = 0.98;
+  TICK_MS = 33;
+  SYNC_MS = 300;
+  MAX_DISTANCE = 3000;
+  SOFTENING_SQ = 50 * 50;
+  MIN_MOVE_PX = 0.1;
+  constructor(board) {
+    this.board = board;
+  }
+  start() {
+    if (this.tickTimer !== null)
+      return;
+    for (const item of this.board.items.listAll()) {
+      this.velocities.set(item.getId(), { vx: 0, vy: 0 });
+    }
+    this.tickTimer = setInterval(() => this.tick(), this.TICK_MS);
+    this.syncTimer = setInterval(() => this.syncPositions(), this.SYNC_MS);
+  }
+  stop() {
+    if (this.tickTimer !== null) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.syncTimer !== null) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    this.velocities.clear();
+    this.lastSyncedPositions.clear();
+  }
+  tick() {
+    const dt = this.TICK_MS / 1000;
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length < 2)
+      return;
+    for (const item of items) {
+      const id = item.getId();
+      if (!this.velocities.has(id)) {
+        this.velocities.set(id, { vx: 0, vy: 0 });
+      }
+      const vel = this.velocities.get(id);
+      const pos1 = item.transformation.getTranslation();
+      const mbr1 = item.getMbr();
+      const mass1 = mbr1.getWidth() * mbr1.getHeight();
+      const nearby = this.board.items.getEnclosedOrCrossed(pos1.x - this.MAX_DISTANCE, pos1.y - this.MAX_DISTANCE, pos1.x + this.MAX_DISTANCE * 2, pos1.y + this.MAX_DISTANCE * 2).filter((other) => other.getId() !== id);
+      let ax = 0;
+      let ay = 0;
+      for (const other of nearby) {
+        const pos2 = other.transformation.getTranslation();
+        const mbr2 = other.getMbr();
+        const mass2 = mbr2.getWidth() * mbr2.getHeight();
+        const dx2 = pos2.x - pos1.x;
+        const dy2 = pos2.y - pos1.y;
+        const distSq = dx2 * dx2 + dy2 * dy2 + this.SOFTENING_SQ;
+        const dist = Math.sqrt(distSq);
+        const acc = this.G * mass2 / distSq;
+        ax += acc * dx2 / dist;
+        ay += acc * dy2 / dist;
+      }
+      vel.vx = (vel.vx + ax * dt) * this.DAMPING;
+      vel.vy = (vel.vy + ay * dt) * this.DAMPING;
+      const dx = vel.vx * dt;
+      const dy = vel.vy * dt;
+      if (Math.abs(dx) >= this.MIN_MOVE_PX || Math.abs(dy) >= this.MIN_MOVE_PX) {
+        item.transformation.applyMatrixSilent({
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        });
+      }
+    }
+  }
+  syncPositions() {
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length === 0)
+      return;
+    const movedItems = items.map((item) => {
+      const id = item.getId();
+      const pos = item.transformation.getTranslation();
+      const last = this.lastSyncedPositions.get(id);
+      const dx = last ? pos.x - last.x : 0;
+      const dy = last ? pos.y - last.y : 0;
+      this.lastSyncedPositions.set(id, { x: pos.x, y: pos.y });
+      return { id, dx, dy };
+    }).filter(({ dx, dy }) => Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5);
+    if (movedItems.length === 0)
+      return;
+    const operation = {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: movedItems.map(({ id, dx, dy }) => ({
+        id,
+        matrix: {
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        }
+      }))
+    };
+    this.board.events.emit(operation);
+  }
+}
+
 // src/Board.ts
 class Board {
   boardId;
@@ -55137,6 +55264,22 @@ class Board {
     this.selection.quickAddButtons.clear();
     this.presence.cleanup();
   }
+  gravity = null;
+  enableGravity() {
+    if (this.gravity)
+      return;
+    this.gravity = new GravityEngine(this);
+    this.gravity.start();
+  }
+  disableGravity() {
+    if (!this.gravity)
+      return;
+    this.gravity.stop();
+    this.gravity = null;
+  }
+  isGravityEnabled() {
+    return this.gravity !== null;
+  }
 }
 // src/Events/Merge.ts
 import { Path as Path15 } from "slate";

package/dist/esm/index.js

@@ -18036,6 +18036,16 @@ class Transformation {
       shearY: 0
     }, timeStamp);
   }
+  applyMatrixSilent(matrixData) {
+    this.previous = this._matrix.copy();
+    this._matrix.scale(matrixData.scaleX, matrixData.scaleY);
+    this._matrix.translate(matrixData.translateX, matrixData.translateY);
+    this.subject.publish(this, {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: [{ id: this.id, matrix: matrixData }]
+    });
+  }
   setIsLocked(isLocked, timestamp) {
     if (isLocked) {
       this.emit({
@@ -54108,6 +54118,123 @@ class BoardSelection {
     });
   }
 }
+// src/Gravity/GravityEngine.ts
+class GravityEngine {
+  board;
+  velocities = new Map;
+  tickTimer = null;
+  syncTimer = null;
+  lastSyncedPositions = new Map;
+  G = 500;
+  DAMPING = 0.98;
+  TICK_MS = 33;
+  SYNC_MS = 300;
+  MAX_DISTANCE = 3000;
+  SOFTENING_SQ = 50 * 50;
+  MIN_MOVE_PX = 0.1;
+  constructor(board) {
+    this.board = board;
+  }
+  start() {
+    if (this.tickTimer !== null)
+      return;
+    for (const item of this.board.items.listAll()) {
+      this.velocities.set(item.getId(), { vx: 0, vy: 0 });
+    }
+    this.tickTimer = setInterval(() => this.tick(), this.TICK_MS);
+    this.syncTimer = setInterval(() => this.syncPositions(), this.SYNC_MS);
+  }
+  stop() {
+    if (this.tickTimer !== null) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.syncTimer !== null) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    this.velocities.clear();
+    this.lastSyncedPositions.clear();
+  }
+  tick() {
+    const dt = this.TICK_MS / 1000;
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length < 2)
+      return;
+    for (const item of items) {
+      const id = item.getId();
+      if (!this.velocities.has(id)) {
+        this.velocities.set(id, { vx: 0, vy: 0 });
+      }
+      const vel = this.velocities.get(id);
+      const pos1 = item.transformation.getTranslation();
+      const mbr1 = item.getMbr();
+      const mass1 = mbr1.getWidth() * mbr1.getHeight();
+      const nearby = this.board.items.getEnclosedOrCrossed(pos1.x - this.MAX_DISTANCE, pos1.y - this.MAX_DISTANCE, pos1.x + this.MAX_DISTANCE * 2, pos1.y + this.MAX_DISTANCE * 2).filter((other) => other.getId() !== id);
+      let ax = 0;
+      let ay = 0;
+      for (const other of nearby) {
+        const pos2 = other.transformation.getTranslation();
+        const mbr2 = other.getMbr();
+        const mass2 = mbr2.getWidth() * mbr2.getHeight();
+        const dx2 = pos2.x - pos1.x;
+        const dy2 = pos2.y - pos1.y;
+        const distSq = dx2 * dx2 + dy2 * dy2 + this.SOFTENING_SQ;
+        const dist = Math.sqrt(distSq);
+        const acc = this.G * mass2 / distSq;
+        ax += acc * dx2 / dist;
+        ay += acc * dy2 / dist;
+      }
+      vel.vx = (vel.vx + ax * dt) * this.DAMPING;
+      vel.vy = (vel.vy + ay * dt) * this.DAMPING;
+      const dx = vel.vx * dt;
+      const dy = vel.vy * dt;
+      if (Math.abs(dx) >= this.MIN_MOVE_PX || Math.abs(dy) >= this.MIN_MOVE_PX) {
+        item.transformation.applyMatrixSilent({
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        });
+      }
+    }
+  }
+  syncPositions() {
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length === 0)
+      return;
+    const movedItems = items.map((item) => {
+      const id = item.getId();
+      const pos = item.transformation.getTranslation();
+      const last = this.lastSyncedPositions.get(id);
+      const dx = last ? pos.x - last.x : 0;
+      const dy = last ? pos.y - last.y : 0;
+      this.lastSyncedPositions.set(id, { x: pos.x, y: pos.y });
+      return { id, dx, dy };
+    }).filter(({ dx, dy }) => Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5);
+    if (movedItems.length === 0)
+      return;
+    const operation = {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: movedItems.map(({ id, dx, dy }) => ({
+        id,
+        matrix: {
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        }
+      }))
+    };
+    this.board.events.emit(operation);
+  }
+}
+
 // src/Board.ts
 class Board {
   boardId;
@@ -55130,6 +55257,22 @@ class Board {
     this.selection.quickAddButtons.clear();
     this.presence.cleanup();
   }
+  gravity = null;
+  enableGravity() {
+    if (this.gravity)
+      return;
+    this.gravity = new GravityEngine(this);
+    this.gravity.start();
+  }
+  disableGravity() {
+    if (!this.gravity)
+      return;
+    this.gravity.stop();
+    this.gravity = null;
+  }
+  isGravityEnabled() {
+    return this.gravity !== null;
+  }
 }
 // src/Events/Merge.ts
 import { Path as Path15 } from "slate";

package/dist/esm/node.js

@@ -20571,6 +20571,16 @@ class Transformation {
       shearY: 0
     }, timeStamp);
   }
+  applyMatrixSilent(matrixData) {
+    this.previous = this._matrix.copy();
+    this._matrix.scale(matrixData.scaleX, matrixData.scaleY);
+    this._matrix.translate(matrixData.translateX, matrixData.translateY);
+    this.subject.publish(this, {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: [{ id: this.id, matrix: matrixData }]
+    });
+  }
   setIsLocked(isLocked, timestamp) {
     if (isLocked) {
       this.emit({
@@ -56576,6 +56586,123 @@ class BoardSelection {
     });
   }
 }
+// src/Gravity/GravityEngine.ts
+class GravityEngine {
+  board;
+  velocities = new Map;
+  tickTimer = null;
+  syncTimer = null;
+  lastSyncedPositions = new Map;
+  G = 500;
+  DAMPING = 0.98;
+  TICK_MS = 33;
+  SYNC_MS = 300;
+  MAX_DISTANCE = 3000;
+  SOFTENING_SQ = 50 * 50;
+  MIN_MOVE_PX = 0.1;
+  constructor(board) {
+    this.board = board;
+  }
+  start() {
+    if (this.tickTimer !== null)
+      return;
+    for (const item of this.board.items.listAll()) {
+      this.velocities.set(item.getId(), { vx: 0, vy: 0 });
+    }
+    this.tickTimer = setInterval(() => this.tick(), this.TICK_MS);
+    this.syncTimer = setInterval(() => this.syncPositions(), this.SYNC_MS);
+  }
+  stop() {
+    if (this.tickTimer !== null) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.syncTimer !== null) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    this.velocities.clear();
+    this.lastSyncedPositions.clear();
+  }
+  tick() {
+    const dt = this.TICK_MS / 1000;
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length < 2)
+      return;
+    for (const item of items) {
+      const id = item.getId();
+      if (!this.velocities.has(id)) {
+        this.velocities.set(id, { vx: 0, vy: 0 });
+      }
+      const vel = this.velocities.get(id);
+      const pos1 = item.transformation.getTranslation();
+      const mbr1 = item.getMbr();
+      const mass1 = mbr1.getWidth() * mbr1.getHeight();
+      const nearby = this.board.items.getEnclosedOrCrossed(pos1.x - this.MAX_DISTANCE, pos1.y - this.MAX_DISTANCE, pos1.x + this.MAX_DISTANCE * 2, pos1.y + this.MAX_DISTANCE * 2).filter((other) => other.getId() !== id);
+      let ax = 0;
+      let ay = 0;
+      for (const other of nearby) {
+        const pos2 = other.transformation.getTranslation();
+        const mbr2 = other.getMbr();
+        const mass2 = mbr2.getWidth() * mbr2.getHeight();
+        const dx2 = pos2.x - pos1.x;
+        const dy2 = pos2.y - pos1.y;
+        const distSq = dx2 * dx2 + dy2 * dy2 + this.SOFTENING_SQ;
+        const dist = Math.sqrt(distSq);
+        const acc = this.G * mass2 / distSq;
+        ax += acc * dx2 / dist;
+        ay += acc * dy2 / dist;
+      }
+      vel.vx = (vel.vx + ax * dt) * this.DAMPING;
+      vel.vy = (vel.vy + ay * dt) * this.DAMPING;
+      const dx = vel.vx * dt;
+      const dy = vel.vy * dt;
+      if (Math.abs(dx) >= this.MIN_MOVE_PX || Math.abs(dy) >= this.MIN_MOVE_PX) {
+        item.transformation.applyMatrixSilent({
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        });
+      }
+    }
+  }
+  syncPositions() {
+    const items = this.board.items.listAll().filter((item) => !item.transformation.isLocked);
+    if (items.length === 0)
+      return;
+    const movedItems = items.map((item) => {
+      const id = item.getId();
+      const pos = item.transformation.getTranslation();
+      const last = this.lastSyncedPositions.get(id);
+      const dx = last ? pos.x - last.x : 0;
+      const dy = last ? pos.y - last.y : 0;
+      this.lastSyncedPositions.set(id, { x: pos.x, y: pos.y });
+      return { id, dx, dy };
+    }).filter(({ dx, dy }) => Math.abs(dx) > 0.5 || Math.abs(dy) > 0.5);
+    if (movedItems.length === 0)
+      return;
+    const operation = {
+      class: "Transformation",
+      method: "applyMatrix",
+      items: movedItems.map(({ id, dx, dy }) => ({
+        id,
+        matrix: {
+          translateX: dx,
+          translateY: dy,
+          scaleX: 1,
+          scaleY: 1,
+          shearX: 0,
+          shearY: 0
+        }
+      }))
+    };
+    this.board.events.emit(operation);
+  }
+}
+
 // src/Board.ts
 class Board {
   boardId;
@@ -57598,6 +57725,22 @@ class Board {
     this.selection.quickAddButtons.clear();
     this.presence.cleanup();
   }
+  gravity = null;
+  enableGravity() {
+    if (this.gravity)
+      return;
+    this.gravity = new GravityEngine(this);
+    this.gravity.start();
+  }
+  disableGravity() {
+    if (!this.gravity)
+      return;
+    this.gravity.stop();
+    this.gravity = null;
+  }
+  isGravityEnabled() {
+    return this.gravity !== null;
+  }
 }
 // src/Events/Merge.ts
 import { Path as Path14 } from "slate";

package/dist/types/Board.d.ts

@@ -133,6 +133,10 @@ export declare class Board {
     setIsOpen(isOpen: boolean): void;
     getIsOpen(): boolean;
     cleanup(): void;
+    private gravity;
+    enableGravity(): void;
+    disableGravity(): void;
+    isGravityEnabled(): boolean;
 }
 export interface BoardSnapshot {
     items: (ItemData & {

package/dist/types/Gravity/GravityEngine.d.ts

@@ -0,0 +1,20 @@
+import { Board } from '../Board';
+export declare class GravityEngine {
+    private board;
+    private velocities;
+    private tickTimer;
+    private syncTimer;
+    private lastSyncedPositions;
+    readonly G = 500;
+    readonly DAMPING = 0.98;
+    readonly TICK_MS = 33;
+    readonly SYNC_MS = 300;
+    readonly MAX_DISTANCE = 3000;
+    readonly SOFTENING_SQ: number;
+    readonly MIN_MOVE_PX = 0.1;
+    constructor(board: Board);
+    start(): void;
+    stop(): void;
+    private tick;
+    private syncPositions;
+}

package/dist/types/Items/Transformation/Transformation.d.ts

@@ -61,6 +61,7 @@ export declare class Transformation {
     rotateBy(degree: number, timeStamp?: number): void;
     scaleToRelativeTo(x: number, y: number, _point: Point, timeStamp?: number): void;
     scaleByRelativeTo(x: number, y: number, point: Point, timeStamp?: number): void;
+    applyMatrixSilent(matrixData: MatrixData): void;
     setIsLocked(isLocked: boolean, timestamp?: number): void;
     apply(op: Operation): void;
     /** @deprecated Only for replaying legacy events. Do not call directly. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "microboard-temp",
-  "version": "0.11.9",
+  "version": "0.12.1",
   "description": "A flexible interactive whiteboard library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",