@anu3ev/fabric-image-editor 0.9.9 → 0.9.10

package/dist/main.js

@@ -13573,208 +13573,200 @@ var cs = ({ anchors: e, bounds: t }) => {
 		this._cacheAnchors({ activeObject: t });
 	}
 	_handleObjectMoving(e) {
-		let { target: t, e: n, transform: r } = e;
+		let { target: t, transform: n } = e;
 		if (!t) {
 			this._clearSpacingContexts(), this._clearGuides();
 			return;
 		}
-		if (n?.ctrlKey) {
-			this._clearSpacingContexts(), this._clearGuides();
-			return;
-		}
+		if (this._shouldAbortObjectMoving({
+			target: t,
+			event: e
+		})) return;
 		is({
 			target: t,
-			transform: r
+			transform: n
 		}), !this.anchors.vertical.length && !this.anchors.horizontal.length && this._cacheAnchors({ activeObject: t });
-		let i = W({ object: t });
-		if (!i) {
+		let r = W({ object: t });
+		if (!r) {
 			this._clearSpacingContexts(), this._clearGuides();
 			return;
 		}
-		let { canvas: a } = this, o = a.getZoom() || 1, s = 5 / o, { deltaX: c, deltaY: l } = Xo({
-			activeBounds: i,
-			threshold: s,
+		let i = 5 / (this.canvas.getZoom() || 1), a = Xo({
+			activeBounds: r,
+			threshold: i,
 			anchors: this.anchors
 		});
-		if (c !== 0 || l !== 0) {
-			let { left: e = 0, top: n = 0 } = t;
-			t.set({
-				left: e + c,
-				top: n + l
-			}), t.setCoords(), i = W({ object: t }) ?? i;
-		}
-		let u = this._resolveCurrentTargetBounds({ activeObject: t }), d = this.spacingContexts.vertical || this.spacingContexts.horizontal ? 10 / o : s, f = $o({
-			activeBounds: i,
-			candidates: u,
-			threshold: d,
-			spacingPatterns: this.spacingPatterns,
-			previousContexts: this.spacingContexts,
-			switchDistance: 5
-		});
-		this.spacingContexts = f.contexts;
-		let p = f.deltaX !== 0 || f.deltaY !== 0;
-		if (p) {
-			let { left: e = 0, top: n = 0 } = t;
-			t.set({
-				left: e + f.deltaX,
-				top: n + f.deltaY
-			}), t.setCoords(), i = W({ object: t }) ?? i;
-		}
-		p || is({
+		r = this._applyMovementDelta({
 			target: t,
-			transform: r
-		});
-		let m = W({ object: t }) ?? i, h = Xo({
-			activeBounds: m,
-			threshold: s,
-			anchors: this.anchors
-		}), g = $o({
-			activeBounds: m,
-			candidates: u,
-			threshold: s,
-			spacingPatterns: this.spacingPatterns,
-			previousContexts: this.spacingContexts,
-			switchDistance: 5
+			activeBounds: r,
+			deltaX: a.deltaX,
+			deltaY: a.deltaY
+		});
+		let o = this._resolveCurrentTargetBounds({ activeObject: t }), s = this._calculateSpacingResult({
+			activeBounds: r,
+			candidateBounds: o,
+			threshold: i
+		});
+		this.spacingContexts = s.contexts;
+		let c = s.deltaX !== 0 || s.deltaY !== 0;
+		r = this._applyMovementDelta({
+			target: t,
+			activeBounds: r,
+			deltaX: s.deltaX,
+			deltaY: s.deltaY
+		}), c || is({
+			target: t,
+			transform: n
 		});
-		this.spacingContexts = g.contexts;
-		let _ = g.deltaX === 0 && g.deltaY === 0;
-		this._applyGuides({
-			guides: h.guides,
-			spacingGuides: _ ? g.guides : []
+		let l = W({ object: t }) ?? r;
+		this._applyMovementVisualGuides({
+			activeBounds: l,
+			candidateBounds: o,
+			threshold: i
 		});
 	}
 	_handleObjectScaling(t) {
-		let { target: n, e: r, transform: i } = t;
-		if (!n || !i) {
+		let { target: n, transform: r } = t;
+		if (!n || !r) {
 			this._clearGuides();
 			return;
 		}
-		let a = rs({ target: n });
-		if (r?.ctrlKey) {
-			this._clearGuides(), a && ss({
-				target: n,
-				transform: i
-			});
-			return;
-		}
-		a && ss({
+		let i = rs({ target: n });
+		if (this._shouldAbortObjectScaling({
 			target: n,
-			transform: i
-		});
-		let { shouldSnapX: o, shouldSnapY: s, isCornerHandle: c } = e._resolveScalingAxisState({ transform: i });
-		if (!o && !s) {
+			transform: r,
+			event: t,
+			canApplyPixelScalingStep: i
+		})) {
 			this._clearGuides();
 			return;
 		}
-		let { anchors: l } = this, { vertical: u, horizontal: d } = l;
-		!u.length && !d.length && this._cacheAnchors({ activeObject: n });
-		let f = W({ object: n });
-		if (!f) {
+		let { shouldSnapX: a, shouldSnapY: o, isCornerHandle: s } = e._resolveScalingAxisState({ transform: r });
+		if (!a && !o) {
 			this._clearGuides();
 			return;
 		}
-		let { canvas: p } = this, m = 5 / (p.getZoom() || 1), { originX: h, originY: g } = i, { originX: _ = "left", originY: v = "top", scaleX: y = 1, scaleY: b = 1 } = n, x = h ?? _, S = g ?? v, C = e._collectVerticalSnapCandidates({
-			bounds: f,
-			originX: x,
-			shouldSnapX: o
-		}), w = e._collectHorizontalSnapCandidates({
-			bounds: f,
-			originY: S,
-			shouldSnapY: s
-		}), T = e._findAxisSnapCandidate({
-			anchors: u,
-			candidates: C,
-			threshold: m
-		}), E = e._findAxisSnapCandidate({
-			anchors: d,
-			candidates: w,
-			threshold: m
-		}), { guidePosition: D } = T, { guidePosition: O } = E, k = D !== null, A = O !== null;
-		if (!k && !A) {
+		let { anchors: c } = this, { vertical: l, horizontal: u } = c;
+		!l.length && !u.length && this._cacheAnchors({ activeObject: n });
+		let d = W({ object: n });
+		if (!d) {
 			this._clearGuides();
 			return;
 		}
-		let j = [], M = null, N = null;
-		if (c) {
-			let t = e._resolveUniformScale({
-				bounds: f,
-				originX: x,
-				originY: S,
-				verticalSnap: T,
-				horizontalSnap: E
-			});
-			if (t) {
-				let { scaleFactor: e, guide: n } = t;
-				M = y * e, N = b * e, j.push(n);
-			}
-		}
-		if (!c) {
-			let { angle: t = 0 } = n, { width: r, height: i } = e._resolveBaseDimensions({ target: n }), a = Math.abs(y) || 1, o = Math.abs(b) || 1;
-			if (k) {
-				let n = e._resolveDesiredWidth({
-					bounds: f,
-					originX: x,
-					snap: T
-				});
-				if (n !== null) {
-					let a = e._resolveScaleForWidth({
-						desiredWidth: n,
-						baseWidth: r,
-						baseHeight: i,
-						scaleY: o,
-						angle: t
-					});
-					a !== null && (M = a * (y < 0 ? -1 : 1), D !== null && j.push({
-						type: "vertical",
-						position: D
-					}));
-				}
-			}
-			if (A) {
-				let n = e._resolveDesiredHeight({
-					bounds: f,
-					originY: S,
-					snap: E
-				});
-				if (n !== null) {
-					let o = e._resolveScaleForHeight({
-						desiredHeight: n,
-						baseWidth: r,
-						baseHeight: i,
-						scaleX: a,
-						angle: t
-					});
-					o !== null && (N = o * (b < 0 ? -1 : 1), O !== null && j.push({
-						type: "horizontal",
-						position: O
-					}));
-				}
-			}
-		}
-		let P = M !== null || N !== null;
-		if (!P && !j.length) {
+		let f = 5 / (this.canvas.getZoom() || 1), { originX: p, originY: m, scaleX: h, scaleY: g } = e._resolveScalingTransformState({
+			target: n,
+			transform: r
+		}), _ = e._resolveScaleAxisSnaps({
+			bounds: d,
+			originX: p,
+			originY: m,
+			shouldSnapX: a,
+			shouldSnapY: o,
+			threshold: f,
+			anchors: this.anchors
+		});
+		if (!_) {
 			this._clearGuides();
 			return;
 		}
-		if (P) {
-			let e = this.editor.canvasManager.getObjectPlacement({
-				object: n,
-				originX: x,
-				originY: S
-			}), t = {};
-			M !== null && (t.scaleX = M, i.scaleX = M), N !== null && (t.scaleY = N, i.scaleY = N), Object.keys(t).length && (n.set(t), this.editor.canvasManager.applyObjectPlacement({
-				object: n,
-				placement: e
-			}), n.setCoords());
+		let v = e._resolveScaleUpdatePlan({
+			target: n,
+			bounds: d,
+			originX: p,
+			originY: m,
+			scaleX: h,
+			scaleY: g,
+			isCornerHandle: s,
+			verticalSnap: _.verticalSnap,
+			horizontalSnap: _.horizontalSnap
+		});
+		if (!v) {
+			this._clearGuides();
+			return;
 		}
-		a && ss({
+		this._applyScaleUpdatePlan({
 			target: n,
-			transform: i
+			transform: r,
+			originX: p,
+			originY: m,
+			plan: v
+		}), i && ss({
+			target: n,
+			transform: r
 		}), this._applyGuides({
-			guides: j,
+			guides: v.guides,
 			spacingGuides: []
 		});
 	}
+	_shouldAbortObjectMoving({ target: e, event: t }) {
+		return t.e?.ctrlKey ? (this._clearSpacingContexts(), this._clearGuides(), !0) : this._shouldHideOverflowingCropFrameGuides({
+			target: e,
+			clearSpacingContexts: !0
+		});
+	}
+	_shouldAbortObjectScaling({ target: e, transform: t, event: n, canApplyPixelScalingStep: r }) {
+		return n.e?.ctrlKey ? (this._clearGuides(), r && ss({
+			target: e,
+			transform: t
+		}), !0) : (r && ss({
+			target: e,
+			transform: t
+		}), this._shouldHideOverflowingCropFrameGuides({ target: e }));
+	}
+	_shouldHideOverflowingCropFrameGuides({ target: e, clearSpacingContexts: t = !1 }) {
+		return this.editor.cropManager.isFrameOverflowingSource({ target: e }) ? (t && this._clearSpacingContexts(), this._clearGuides(), !0) : !1;
+	}
+	_applyMovementDelta({ target: e, activeBounds: t, deltaX: n, deltaY: r }) {
+		if (n === 0 && r === 0) return t;
+		let { left: i = 0, top: a = 0 } = e;
+		return e.set({
+			left: i + n,
+			top: a + r
+		}), e.setCoords(), W({ object: e }) ?? t;
+	}
+	_calculateSpacingResult({ activeBounds: e, candidateBounds: t, threshold: n }) {
+		return $o({
+			activeBounds: e,
+			candidates: t,
+			threshold: this.spacingContexts.vertical || this.spacingContexts.horizontal ? 10 / (this.canvas.getZoom() || 1) : n,
+			spacingPatterns: this.spacingPatterns,
+			previousContexts: this.spacingContexts,
+			switchDistance: 5
+		});
+	}
+	_applyMovementVisualGuides({ activeBounds: e, candidateBounds: t, threshold: n }) {
+		let r = Xo({
+			activeBounds: e,
+			threshold: n,
+			anchors: this.anchors
+		}), i = $o({
+			activeBounds: e,
+			candidates: t,
+			threshold: n,
+			spacingPatterns: this.spacingPatterns,
+			previousContexts: this.spacingContexts,
+			switchDistance: 5
+		});
+		this.spacingContexts = i.contexts;
+		let a = i.deltaX === 0 && i.deltaY === 0;
+		this._applyGuides({
+			guides: r.guides,
+			spacingGuides: a ? i.guides : []
+		});
+	}
+	_applyScaleUpdatePlan({ target: e, transform: t, originX: n, originY: r, plan: i }) {
+		let { nextScaleX: a, nextScaleY: o } = i;
+		if (a === null && o === null) return;
+		let s = this.editor.canvasManager.getObjectPlacement({
+			object: e,
+			originX: n,
+			originY: r
+		}), c = {};
+		a !== null && (c.scaleX = a, t.scaleX = a), o !== null && (c.scaleY = o, t.scaleY = o), e.set(c), this.editor.canvasManager.applyObjectPlacement({
+			object: e,
+			placement: s
+		}), e.setCoords();
+	}
 	applyTextResizingSnap({ target: t, transform: n, event: r }) {
 		if (!t || !(t instanceof v)) return;
 		if (!n) {
@@ -13901,6 +13893,102 @@ var cs = ({ anchors: e, bounds: t }) => {
 			shouldSnapY: i || a
 		};
 	}
+	static _resolveScalingTransformState({ target: e, transform: t }) {
+		let { originX: n, originY: r } = t, { originX: i = "left", originY: a = "top", scaleX: o = 1, scaleY: s = 1 } = e;
+		return {
+			originX: n ?? i,
+			originY: r ?? a,
+			scaleX: o,
+			scaleY: s
+		};
+	}
+	static _resolveScaleAxisSnaps({ bounds: t, originX: n, originY: r, shouldSnapX: i, shouldSnapY: a, threshold: o, anchors: s }) {
+		let c = e._collectVerticalSnapCandidates({
+			bounds: t,
+			originX: n,
+			shouldSnapX: i
+		}), l = e._collectHorizontalSnapCandidates({
+			bounds: t,
+			originY: r,
+			shouldSnapY: a
+		}), u = e._findAxisSnapCandidate({
+			anchors: s.vertical,
+			candidates: c,
+			threshold: o
+		}), d = e._findAxisSnapCandidate({
+			anchors: s.horizontal,
+			candidates: l,
+			threshold: o
+		});
+		return u.guidePosition === null && d.guidePosition === null ? null : {
+			verticalSnap: u,
+			horizontalSnap: d
+		};
+	}
+	static _resolveScaleUpdatePlan({ target: t, bounds: n, originX: r, originY: i, scaleX: a, scaleY: o, isCornerHandle: s, verticalSnap: c, horizontalSnap: l }) {
+		let { guidePosition: u } = c, { guidePosition: d } = l, f = u !== null, p = d !== null, m = [], h = null, g = null;
+		if (s) {
+			let t = e._resolveUniformScale({
+				bounds: n,
+				originX: r,
+				originY: i,
+				verticalSnap: c,
+				horizontalSnap: l
+			});
+			if (t) {
+				let { scaleFactor: e, guide: n } = t;
+				h = a * e, g = o * e, m.push(n);
+			}
+		}
+		if (!s) {
+			let { angle: s = 0 } = t, { width: _, height: v } = e._resolveBaseDimensions({ target: t }), y = Math.abs(a) || 1, b = Math.abs(o) || 1;
+			if (f) {
+				let t = e._resolveDesiredWidth({
+					bounds: n,
+					originX: r,
+					snap: c
+				});
+				if (t !== null) {
+					let n = e._resolveScaleForWidth({
+						desiredWidth: t,
+						baseWidth: _,
+						baseHeight: v,
+						scaleY: b,
+						angle: s
+					});
+					n !== null && (h = n * (a < 0 ? -1 : 1), m.push({
+						type: "vertical",
+						position: u
+					}));
+				}
+			}
+			if (p) {
+				let t = e._resolveDesiredHeight({
+					bounds: n,
+					originY: i,
+					snap: l
+				});
+				if (t !== null) {
+					let n = e._resolveScaleForHeight({
+						desiredHeight: t,
+						baseWidth: _,
+						baseHeight: v,
+						scaleX: y,
+						angle: s
+					});
+					n !== null && (g = n * (o < 0 ? -1 : 1), m.push({
+						type: "horizontal",
+						position: d
+					}));
+				}
+			}
+		}
+		return h === null && g === null && !m.length ? null : {
+			guides: m,
+			nextScaleX: h,
+			nextScaleY: g
+		};
+	}
 	static _collectVerticalSnapCandidates({ bounds: e, originX: t, shouldSnapX: n }) {
 		let r = [];
 		if (!n) return r;
@@ -14987,6 +15075,15 @@ var Fc = {
 			rect: xc({ session: e })
 		} : null;
 	}
+	isFrameOverflowingSource({ target: e }) {
+		let { _session: t } = this;
+		if (!t || !e || t.options.allowFrameOverflow || t.frame !== e) return !1;
+		let n = ws({
+			source: t.source,
+			frame: t.frame
+		}), r = Cs({ source: t.source }), i = -r.width / 2, a = -r.height / 2, o = r.width / 2, s = r.height / 2;
+		return n.left < i || n.top < a || n.left + n.width > o || n.top + n.height > s;
+	}
 	startCanvasCrop(e = {}) {
 		this.cancel();
 		let t = this._createCanvasSession({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anu3ev/fabric-image-editor",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "TypeScript image editor library built on FabricJS, allowing you to create instances with an integrated montage area and providing an API to modify and manage state.",
   "module": "dist/main.js",
   "files": [