@nasser-sw/fabric 7.0.0-beta1

package/dist/src/controls/skew.mjs

@@ -0,0 +1,181 @@
+import { resolveOrigin } from '../util/misc/resolveOrigin.mjs';
+import { Point } from '../Point.mjs';
+import { radiansToDegrees, degreesToRadians } from '../util/misc/radiansDegreesConversion.mjs';
+import { isLocked, NOT_ALLOWED_CURSOR, findCornerQuadrant, getLocalPoint } from './util.mjs';
+import { wrapWithFireEvent } from './wrapWithFireEvent.mjs';
+import { wrapWithFixedAnchor } from './wrapWithFixedAnchor.mjs';
+import { SKEW_Y, SCALE_Y, SKEW_X, SCALE_X, SKEWING, CENTER } from '../constants.mjs';
+
+const AXIS_KEYS = {
+  x: {
+    counterAxis: 'y',
+    scale: SCALE_X,
+    skew: SKEW_X,
+    lockSkewing: 'lockSkewingX',
+    origin: 'originX',
+    flip: 'flipX'
+  },
+  y: {
+    counterAxis: 'x',
+    scale: SCALE_Y,
+    skew: SKEW_Y,
+    lockSkewing: 'lockSkewingY',
+    origin: 'originY',
+    flip: 'flipY'
+  }
+};
+const skewMap = ['ns', 'nesw', 'ew', 'nwse'];
+
+/**
+ * return the correct cursor style for the skew action
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} a valid css string for the cursor
+ */
+const skewCursorStyleHandler = (eventData, control, fabricObject, coord) => {
+  if (control.x !== 0 && isLocked(fabricObject, 'lockSkewingY')) {
+    return NOT_ALLOWED_CURSOR;
+  }
+  if (control.y !== 0 && isLocked(fabricObject, 'lockSkewingX')) {
+    return NOT_ALLOWED_CURSOR;
+  }
+  const n = findCornerQuadrant(fabricObject, control, coord) % 4;
+  return `${skewMap[n]}-resize`;
+};
+
+/**
+ * Since skewing is applied before scaling, calculations are done in a scaleless plane
+ * @see https://github.com/fabricjs/fabric.js/pull/8380
+ */
+function skewObject(axis, _ref, pointer) {
+  let {
+    target,
+    ex,
+    ey,
+    skewingSide,
+    ...transform
+  } = _ref;
+  const {
+      skew: skewKey
+    } = AXIS_KEYS[axis],
+    offset = pointer.subtract(new Point(ex, ey)).divide(new Point(target.scaleX, target.scaleY))[axis],
+    skewingBefore = target[skewKey],
+    skewingStart = transform[skewKey],
+    shearingStart = Math.tan(degreesToRadians(skewingStart)),
+    // let a, b be the size of target
+    // let a' be the value of a after applying skewing
+    // then:
+    // a' = a + b * skewA => skewA = (a' - a) / b
+    // the value b is tricky since skewY is applied before skewX
+    b = axis === 'y' ? target._getTransformedDimensions({
+      scaleX: 1,
+      scaleY: 1,
+      // since skewY is applied before skewX, b (=width) is not affected by skewX
+      skewX: 0
+    }).x : target._getTransformedDimensions({
+      scaleX: 1,
+      scaleY: 1
+    }).y;
+  const shearing = 2 * offset * skewingSide /
+   // we max out fractions to safeguard from asymptotic behavior
+  Math.max(b, 1) +
+  // add starting state
+  shearingStart;
+  const skewing = radiansToDegrees(Math.atan(shearing));
+  target.set(skewKey, skewing);
+  const changed = skewingBefore !== target[skewKey];
+  if (changed && axis === 'y') {
+    // we don't want skewing to affect scaleX
+    // so we factor it by the inverse skewing diff to make it seem unchanged to the viewer
+    const {
+        skewX,
+        scaleX
+      } = target,
+      dimBefore = target._getTransformedDimensions({
+        skewY: skewingBefore
+      }),
+      dimAfter = target._getTransformedDimensions(),
+      compensationFactor = skewX !== 0 ? dimBefore.x / dimAfter.x : 1;
+    compensationFactor !== 1 && target.set(SCALE_X, compensationFactor * scaleX);
+  }
+  return changed;
+}
+
+/**
+ * Wrapped Action handler for skewing on a given axis, takes care of the
+ * skew direction and determines the correct transform origin for the anchor point
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+function skewHandler(axis, eventData, transform, x, y) {
+  const {
+      target
+    } = transform,
+    {
+      counterAxis,
+      origin: originKey,
+      lockSkewing: lockSkewingKey,
+      skew: skewKey,
+      flip: flipKey
+    } = AXIS_KEYS[axis];
+  if (isLocked(target, lockSkewingKey)) {
+    return false;
+  }
+  const {
+      origin: counterOriginKey,
+      flip: counterFlipKey
+    } = AXIS_KEYS[counterAxis],
+    counterOriginFactor = resolveOrigin(transform[counterOriginKey]) * (target[counterFlipKey] ? -1 : 1),
+    // if the counter origin is top/left (= -0.5) then we are skewing x/y values on the bottom/right side of target respectively.
+    // if the counter origin is bottom/right (= 0.5) then we are skewing x/y values on the top/left side of target respectively.
+    // skewing direction on the top/left side of target is OPPOSITE to the direction of the movement of the pointer,
+    // so we factor skewing direction by this value.
+    skewingSide = -Math.sign(counterOriginFactor) * (target[flipKey] ? -1 : 1),
+    skewingDirection = (target[skewKey] === 0 &&
+    // in case skewing equals 0 we use the pointer offset from target center to determine the direction of skewing
+    getLocalPoint(transform, CENTER, CENTER, x, y)[axis] > 0 ||
+    // in case target has skewing we use that as the direction
+    target[skewKey] > 0 ? 1 : -1) * skewingSide,
+    // anchor to the opposite side of the skewing direction
+    // normalize value from [-1, 1] to origin value [0, 1]
+    origin = -skewingDirection * 0.5 + 0.5;
+  const finalHandler = wrapWithFireEvent(SKEWING, wrapWithFixedAnchor((eventData, transform, x, y) => skewObject(axis, transform, new Point(x, y))));
+  return finalHandler(eventData, {
+    ...transform,
+    [originKey]: origin,
+    skewingSide
+  }, x, y);
+}
+
+/**
+ * Wrapped Action handler for skewing on the X axis, takes care of the
+ * skew direction and determines the correct transform origin for the anchor point
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+const skewHandlerX = (eventData, transform, x, y) => {
+  return skewHandler('x', eventData, transform, x, y);
+};
+
+/**
+ * Wrapped Action handler for skewing on the Y axis, takes care of the
+ * skew direction and determines the correct transform origin for the anchor point
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+const skewHandlerY = (eventData, transform, x, y) => {
+  return skewHandler('y', eventData, transform, x, y);
+};
+
+export { skewCursorStyleHandler, skewHandlerX, skewHandlerY };
+//# sourceMappingURL=skew.mjs.map

package/dist/src/controls/skew.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"skew.mjs","sources":["../../../src/controls/skew.ts"],"sourcesContent":["import type {\n  ControlCursorCallback,\n  TPointerEvent,\n  Transform,\n  TransformActionHandler,\n} from '../EventTypeDefs';\nimport { resolveOrigin } from '../util/misc/resolveOrigin';\nimport { Point } from '../Point';\nimport type { TAxis, TAxisKey } from '../typedefs';\nimport {\n  degreesToRadians,\n  radiansToDegrees,\n} from '../util/misc/radiansDegreesConversion';\nimport {\n  findCornerQuadrant,\n  getLocalPoint,\n  isLocked,\n  NOT_ALLOWED_CURSOR,\n} from './util';\nimport { wrapWithFireEvent } from './wrapWithFireEvent';\nimport { wrapWithFixedAnchor } from './wrapWithFixedAnchor';\nimport {\n  CENTER,\n  SCALE_X,\n  SCALE_Y,\n  SKEWING,\n  SKEW_X,\n  SKEW_Y,\n} from '../constants';\n\nexport type SkewTransform = Transform & { skewingSide: -1 | 1 };\n\nconst AXIS_KEYS: Record<\n  TAxis,\n  {\n    counterAxis: TAxis;\n    scale: TAxisKey<'scale'>;\n    skew: TAxisKey<'skew'>;\n    lockSkewing: TAxisKey<'lockSkewing'>;\n    origin: TAxisKey<'origin'>;\n    flip: TAxisKey<'flip'>;\n  }\n> = {\n  x: {\n    counterAxis: 'y',\n    scale: SCALE_X,\n    skew: SKEW_X,\n    lockSkewing: 'lockSkewingX',\n    origin: 'originX',\n    flip: 'flipX',\n  },\n  y: {\n    counterAxis: 'x',\n    scale: SCALE_Y,\n    skew: SKEW_Y,\n    lockSkewing: 'lockSkewingY',\n    origin: 'originY',\n    flip: 'flipY',\n  },\n};\n\nconst skewMap = ['ns', 'nesw', 'ew', 'nwse'];\n\n/**\n * return the correct cursor style for the skew action\n * @param {Event} eventData the javascript event that is causing the scale\n * @param {Control} control the control that is interested in the action\n * @param {FabricObject} fabricObject the fabric object that is interested in the action\n * @return {String} a valid css string for the cursor\n */\nexport const skewCursorStyleHandler: ControlCursorCallback = (\n  eventData,\n  control,\n  fabricObject,\n  coord,\n) => {\n  if (control.x !== 0 && isLocked(fabricObject, 'lockSkewingY')) {\n    return NOT_ALLOWED_CURSOR;\n  }\n  if (control.y !== 0 && isLocked(fabricObject, 'lockSkewingX')) {\n    return NOT_ALLOWED_CURSOR;\n  }\n  const n = findCornerQuadrant(fabricObject, control, coord) % 4;\n  return `${skewMap[n]}-resize`;\n};\n\n/**\n * Since skewing is applied before scaling, calculations are done in a scaleless plane\n * @see https://github.com/fabricjs/fabric.js/pull/8380\n */\nfunction skewObject(\n  axis: TAxis,\n  { target, ex, ey, skewingSide, ...transform }: SkewTransform,\n  pointer: Point,\n) {\n  const { skew: skewKey } = AXIS_KEYS[axis],\n    offset = pointer\n      .subtract(new Point(ex, ey))\n      .divide(new Point(target.scaleX, target.scaleY))[axis],\n    skewingBefore = target[skewKey],\n    skewingStart = transform[skewKey],\n    shearingStart = Math.tan(degreesToRadians(skewingStart)),\n    // let a, b be the size of target\n    // let a' be the value of a after applying skewing\n    // then:\n    // a' = a + b * skewA => skewA = (a' - a) / b\n    // the value b is tricky since skewY is applied before skewX\n    b =\n      axis === 'y'\n        ? target._getTransformedDimensions({\n            scaleX: 1,\n            scaleY: 1,\n            // since skewY is applied before skewX, b (=width) is not affected by skewX\n            skewX: 0,\n          }).x\n        : target._getTransformedDimensions({\n            scaleX: 1,\n            scaleY: 1,\n          }).y;\n\n  const shearing =\n    (2 * offset * skewingSide) /\n      // we max out fractions to safeguard from asymptotic behavior\n      Math.max(b, 1) +\n    // add starting state\n    shearingStart;\n\n  const skewing = radiansToDegrees(Math.atan(shearing));\n\n  target.set(skewKey, skewing);\n  const changed = skewingBefore !== target[skewKey];\n\n  if (changed && axis === 'y') {\n    // we don't want skewing to affect scaleX\n    // so we factor it by the inverse skewing diff to make it seem unchanged to the viewer\n    const { skewX, scaleX } = target,\n      dimBefore = target._getTransformedDimensions({ skewY: skewingBefore }),\n      dimAfter = target._getTransformedDimensions(),\n      compensationFactor = skewX !== 0 ? dimBefore.x / dimAfter.x : 1;\n    compensationFactor !== 1 &&\n      target.set(SCALE_X, compensationFactor * scaleX);\n  }\n\n  return changed;\n}\n\n/**\n * Wrapped Action handler for skewing on a given axis, takes care of the\n * skew direction and determines the correct transform origin for the anchor point\n * @param {Event} eventData javascript event that is doing the transform\n * @param {Object} transform javascript object containing a series of information around the current transform\n * @param {number} x current mouse x position, canvas normalized\n * @param {number} y current mouse y position, canvas normalized\n * @return {Boolean} true if some change happened\n */\nfunction skewHandler(\n  axis: TAxis,\n  eventData: TPointerEvent,\n  transform: Transform,\n  x: number,\n  y: number,\n) {\n  const { target } = transform,\n    {\n      counterAxis,\n      origin: originKey,\n      lockSkewing: lockSkewingKey,\n      skew: skewKey,\n      flip: flipKey,\n    } = AXIS_KEYS[axis];\n  if (isLocked(target, lockSkewingKey)) {\n    return false;\n  }\n\n  const { origin: counterOriginKey, flip: counterFlipKey } =\n      AXIS_KEYS[counterAxis],\n    counterOriginFactor =\n      resolveOrigin(transform[counterOriginKey]) *\n      (target[counterFlipKey] ? -1 : 1),\n    // if the counter origin is top/left (= -0.5) then we are skewing x/y values on the bottom/right side of target respectively.\n    // if the counter origin is bottom/right (= 0.5) then we are skewing x/y values on the top/left side of target respectively.\n    // skewing direction on the top/left side of target is OPPOSITE to the direction of the movement of the pointer,\n    // so we factor skewing direction by this value.\n    skewingSide = (-Math.sign(counterOriginFactor) *\n      (target[flipKey] ? -1 : 1)) as 1 | -1,\n    skewingDirection =\n      ((target[skewKey] === 0 &&\n        // in case skewing equals 0 we use the pointer offset from target center to determine the direction of skewing\n        getLocalPoint(transform, CENTER, CENTER, x, y)[axis] > 0) ||\n      // in case target has skewing we use that as the direction\n      target[skewKey] > 0\n        ? 1\n        : -1) * skewingSide,\n    // anchor to the opposite side of the skewing direction\n    // normalize value from [-1, 1] to origin value [0, 1]\n    origin = -skewingDirection * 0.5 + 0.5;\n\n  const finalHandler = wrapWithFireEvent<SkewTransform>(\n    SKEWING,\n    wrapWithFixedAnchor((eventData, transform, x, y) =>\n      skewObject(axis, transform, new Point(x, y)),\n    ),\n  );\n\n  return finalHandler(\n    eventData,\n    {\n      ...transform,\n      [originKey]: origin,\n      skewingSide,\n    },\n    x,\n    y,\n  );\n}\n\n/**\n * Wrapped Action handler for skewing on the X axis, takes care of the\n * skew direction and determines the correct transform origin for the anchor point\n * @param {Event} eventData javascript event that is doing the transform\n * @param {Object} transform javascript object containing a series of information around the current transform\n * @param {number} x current mouse x position, canvas normalized\n * @param {number} y current mouse y position, canvas normalized\n * @return {Boolean} true if some change happened\n */\nexport const skewHandlerX: TransformActionHandler = (\n  eventData,\n  transform,\n  x,\n  y,\n) => {\n  return skewHandler('x', eventData, transform, x, y);\n};\n\n/**\n * Wrapped Action handler for skewing on the Y axis, takes care of the\n * skew direction and determines the correct transform origin for the anchor point\n * @param {Event} eventData javascript event that is doing the transform\n * @param {Object} transform javascript object containing a series of information around the current transform\n * @param {number} x current mouse x position, canvas normalized\n * @param {number} y current mouse y position, canvas normalized\n * @return {Boolean} true if some change happened\n */\nexport const skewHandlerY: TransformActionHandler = (\n  eventData,\n  transform,\n  x,\n  y,\n) => {\n  return skewHandler('y', eventData, transform, x, y);\n};\n"],"names":["AXIS_KEYS","x","counterAxis","scale","SCALE_X","skew","SKEW_X","lockSkewing","origin","flip","y","SCALE_Y","SKEW_Y","skewMap","skewCursorStyleHandler","eventData","control","fabricObject","coord","isLocked","NOT_ALLOWED_CURSOR","n","findCornerQuadrant","skewObject","axis","_ref","pointer","target","ex","ey","skewingSide","transform","skewKey","offset","subtract","Point","divide","scaleX","scaleY","skewingBefore","skewingStart","shearingStart","Math","tan","degreesToRadians","b","_getTransformedDimensions","skewX","shearing","max","skewing","radiansToDegrees","atan","set","changed","dimBefore","skewY","dimAfter","compensationFactor","skewHandler","originKey","lockSkewingKey","flipKey","counterOriginKey","counterFlipKey","counterOriginFactor","resolveOrigin","sign","skewingDirection","getLocalPoint","CENTER","finalHandler","wrapWithFireEvent","SKEWING","wrapWithFixedAnchor","skewHandlerX","skewHandlerY"],"mappings":"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"}

package/dist/src/controls/util.d.ts

@@ -0,0 +1,42 @@
+import type { TPointerEvent, Transform, TransformAction, BasicTransformEvent } from '../EventTypeDefs';
+import { Point } from '../Point';
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import type { TOriginX, TOriginY } from '../typedefs';
+import type { Control } from './Control';
+import type { TOCoord } from '../shapes/Object/InteractiveObject';
+export declare const NOT_ALLOWED_CURSOR = "not-allowed";
+/**
+ * @param {Boolean} alreadySelected true if target is already selected
+ * @param {String} corner a string representing the corner ml, mr, tl ...
+ * @param {Event} e Event object
+ * @param {FabricObject} [target] inserted back to help overriding. Unused
+ */
+export declare const getActionFromCorner: (alreadySelected: boolean, corner: string | undefined, e: TPointerEvent, target: FabricObject) => string;
+/**
+ * Checks if transform is centered
+ * @param {Object} transform transform data
+ * @return {Boolean} true if transform is centered
+ */
+export declare function isTransformCentered(transform: Transform): boolean;
+export declare function invertOrigin(origin: TOriginX | TOriginY): number;
+export declare const isLocked: (target: FabricObject, lockingKey: "lockMovementX" | "lockMovementY" | "lockRotation" | "lockScalingX" | "lockScalingY" | "lockSkewingX" | "lockSkewingY" | "lockScalingFlip") => boolean;
+export declare const commonEventInfo: TransformAction<Transform, BasicTransformEvent>;
+/**
+ * Combine control position and object angle to find the control direction compared
+ * to the object center.
+ * @param {FabricObject} fabricObject the fabric object for which we are rendering controls
+ * @param {Control} control the control class
+ * @return {Number} 0 - 7 a quadrant number
+ */
+export declare function findCornerQuadrant(fabricObject: FabricObject, control: Control, coord: TOCoord): number;
+/**
+ * Transforms a point to the offset from the given origin
+ * @param {Object} transform
+ * @param {String} originX
+ * @param {String} originY
+ * @param {number} x
+ * @param {number} y
+ * @return {Fabric.Point} the normalized point
+ */
+export declare function getLocalPoint({ target, corner }: Transform, originX: TOriginX, originY: TOriginY, x: number, y: number): Point;
+//# sourceMappingURL=util.d.ts.map

package/dist/src/controls/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/controls/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,eAAe,EACf,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAGlE,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC9B,iBAAiB,OAAO,EACxB,QAAQ,MAAM,GAAG,SAAS,EAC1B,GAAG,aAAa,EAChB,QAAQ,YAAY,WAOrB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,WAKvD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,UAEvD;AAED,eAAO,MAAM,QAAQ,GACnB,QAAQ,YAAY,EACpB,YACI,eAAe,GACf,eAAe,GACf,cAAc,GACd,cAAc,GACd,cAAc,GACd,cAAc,GACd,cAAc,GACd,iBAAiB,YACA,CAAC;AAExB,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,SAAS,EACT,mBAAmB,CAOpB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,GACb,MAAM,CASR;AA4BD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,EAC7B,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,QAAQ,EACjB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,SAqBV"}

package/dist/src/controls/util.min.mjs

@@ -0,0 +1,2 @@
+import{resolveOrigin as n}from"../util/misc/resolveOrigin.min.mjs";import{Point as t}from"../Point.min.mjs";import{degreesToRadians as o}from"../util/misc/radiansDegreesConversion.min.mjs";import{twoMathPi as r,quarterPI as i,CENTER as e}from"../constants.min.mjs";import{calcVectorRotation as s,createVector as m}from"../util/misc/vectors.min.mjs";import{sendPointToPlane as a}from"../util/misc/planeChange.min.mjs";const c="not-allowed",f=(n,t,o,r)=>{if(!t||!n)return"drag";const i=r.controls[t];return i.getActionName(o,i,r)};function u(t){return n(t.originX)===n(e)&&n(t.originY)===n(e)}function l(t){return.5-n(t)}const g=(n,t)=>n[t],v=(n,o,r,i)=>({e:n,transform:o,pointer:new t(r,i)});function p(n,t,o){const e=o,c=a(n.getCenterPoint(),n.canvas.viewportTransform,void 0),f=s(m(c,e))+r;return Math.round(f%r/i)}function d(n,r,i,s,m){var a;let{target:c,corner:f}=n;const u=c.controls[f],l=(null===(a=c.canvas)||void 0===a?void 0:a.getZoom())||1,g=c.padding/l,v=function(n,r,i,s){const m=n.getRelativeCenterPoint(),a=void 0!==i&&void 0!==s?n.translateToGivenOrigin(m,e,e,i,s):new t(n.left,n.top);return(n.angle?r.rotate(-o(n.angle),m):r).subtract(a)}(c,new t(s,m),r,i);return v.x>=g&&(v.x-=g),v.x<=-g&&(v.x+=g),v.y>=g&&(v.y-=g),v.y<=g&&(v.y+=g),v.x-=u.offsetX,v.y-=u.offsetY,v}export{c as NOT_ALLOWED_CURSOR,v as commonEventInfo,p as findCornerQuadrant,f as getActionFromCorner,d as getLocalPoint,l as invertOrigin,g as isLocked,u as isTransformCentered};
+//# sourceMappingURL=util.min.mjs.map

package/dist/src/controls/util.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.min.mjs","sources":["../../../src/controls/util.ts"],"sourcesContent":["import type {\n  TPointerEvent,\n  Transform,\n  TransformAction,\n  BasicTransformEvent,\n} from '../EventTypeDefs';\nimport { resolveOrigin } from '../util/misc/resolveOrigin';\nimport { Point } from '../Point';\nimport type { FabricObject } from '../shapes/Object/FabricObject';\nimport type { TOriginX, TOriginY } from '../typedefs';\nimport { degreesToRadians } from '../util/misc/radiansDegreesConversion';\nimport type { Control } from './Control';\nimport { CENTER, quarterPI, twoMathPi } from '../constants';\nimport { calcVectorRotation, createVector } from '../util/misc/vectors';\nimport type { TOCoord } from '../shapes/Object/InteractiveObject';\nimport { sendPointToPlane } from '../util/misc/planeChange';\n\nexport const NOT_ALLOWED_CURSOR = 'not-allowed';\n\n/**\n * @param {Boolean} alreadySelected true if target is already selected\n * @param {String} corner a string representing the corner ml, mr, tl ...\n * @param {Event} e Event object\n * @param {FabricObject} [target] inserted back to help overriding. Unused\n */\nexport const getActionFromCorner = (\n  alreadySelected: boolean,\n  corner: string | undefined,\n  e: TPointerEvent,\n  target: FabricObject,\n) => {\n  if (!corner || !alreadySelected) {\n    return 'drag';\n  }\n  const control = target.controls[corner];\n  return control.getActionName(e, control, target);\n};\n\n/**\n * Checks if transform is centered\n * @param {Object} transform transform data\n * @return {Boolean} true if transform is centered\n */\nexport function isTransformCentered(transform: Transform) {\n  return (\n    resolveOrigin(transform.originX) === resolveOrigin(CENTER) &&\n    resolveOrigin(transform.originY) === resolveOrigin(CENTER)\n  );\n}\n\nexport function invertOrigin(origin: TOriginX | TOriginY) {\n  return -resolveOrigin(origin) + 0.5;\n}\n\nexport const isLocked = (\n  target: FabricObject,\n  lockingKey:\n    | 'lockMovementX'\n    | 'lockMovementY'\n    | 'lockRotation'\n    | 'lockScalingX'\n    | 'lockScalingY'\n    | 'lockSkewingX'\n    | 'lockSkewingY'\n    | 'lockScalingFlip',\n) => target[lockingKey];\n\nexport const commonEventInfo: TransformAction<\n  Transform,\n  BasicTransformEvent\n> = (eventData, transform, x, y) => {\n  return {\n    e: eventData,\n    transform,\n    pointer: new Point(x, y),\n  };\n};\n\n/**\n * Combine control position and object angle to find the control direction compared\n * to the object center.\n * @param {FabricObject} fabricObject the fabric object for which we are rendering controls\n * @param {Control} control the control class\n * @return {Number} 0 - 7 a quadrant number\n */\nexport function findCornerQuadrant(\n  fabricObject: FabricObject,\n  control: Control,\n  coord: TOCoord,\n): number {\n  const target = coord;\n  const center = sendPointToPlane(\n    fabricObject.getCenterPoint(),\n    fabricObject.canvas!.viewportTransform,\n    undefined,\n  );\n  const angle = calcVectorRotation(createVector(center, target)) + twoMathPi;\n  return Math.round((angle % twoMathPi) / quarterPI);\n}\n\n/**\n * @returns the normalized point (rotated relative to center) in local coordinates\n */\nfunction normalizePoint(\n  target: FabricObject,\n  point: Point,\n  originX: TOriginX,\n  originY: TOriginY,\n): Point {\n  const center = target.getRelativeCenterPoint(),\n    p =\n      typeof originX !== 'undefined' && typeof originY !== 'undefined'\n        ? target.translateToGivenOrigin(\n            center,\n            CENTER,\n            CENTER,\n            originX,\n            originY,\n          )\n        : new Point(target.left, target.top),\n    p2 = target.angle\n      ? point.rotate(-degreesToRadians(target.angle), center)\n      : point;\n  return p2.subtract(p);\n}\n\n/**\n * Transforms a point to the offset from the given origin\n * @param {Object} transform\n * @param {String} originX\n * @param {String} originY\n * @param {number} x\n * @param {number} y\n * @return {Fabric.Point} the normalized point\n */\nexport function getLocalPoint(\n  { target, corner }: Transform,\n  originX: TOriginX,\n  originY: TOriginY,\n  x: number,\n  y: number,\n) {\n  const control = target.controls[corner],\n    zoom = target.canvas?.getZoom() || 1,\n    padding = target.padding / zoom,\n    localPoint = normalizePoint(target, new Point(x, y), originX, originY);\n  if (localPoint.x >= padding) {\n    localPoint.x -= padding;\n  }\n  if (localPoint.x <= -padding) {\n    localPoint.x += padding;\n  }\n  if (localPoint.y >= padding) {\n    localPoint.y -= padding;\n  }\n  if (localPoint.y <= padding) {\n    localPoint.y += padding;\n  }\n  localPoint.x -= control.offsetX;\n  localPoint.y -= control.offsetY;\n  return localPoint;\n}\n"],"names":["NOT_ALLOWED_CURSOR","getActionFromCorner","alreadySelected","corner","e","target","control","controls","getActionName","isTransformCentered","transform","resolveOrigin","originX","CENTER","originY","invertOrigin","origin","isLocked","lockingKey","commonEventInfo","eventData","x","y","pointer","Point","findCornerQuadrant","fabricObject","coord","center","sendPointToPlane","getCenterPoint","canvas","viewportTransform","undefined","angle","calcVectorRotation","createVector","twoMathPi","Math","round","quarterPI","getLocalPoint","_ref","_target$canvas","zoom","getZoom","padding","localPoint","point","getRelativeCenterPoint","p","translateToGivenOrigin","left","top","rotate","degreesToRadians","subtract","normalizePoint","offsetX","offsetY"],"mappings":"iaAiBO,MAAMA,EAAqB,cAQrBC,EAAsBA,CACjCC,EACAC,EACAC,EACAC,KAEA,IAAKF,IAAWD,EACd,MAAO,OAET,MAAMI,EAAUD,EAAOE,SAASJ,GAChC,OAAOG,EAAQE,cAAcJ,EAAGE,EAASD,IAQpC,SAASI,EAAoBC,GAClC,OACEC,EAAcD,EAAUE,WAAaD,EAAcE,IACnDF,EAAcD,EAAUI,WAAaH,EAAcE,EAEvD,CAEO,SAASE,EAAaC,GAC3B,MAAgC,GAAxBL,EAAcK,EACxB,CAEO,MAAMC,EAAWA,CACtBZ,EACAa,IASGb,EAAOa,GAECC,EAGTA,CAACC,EAAWV,EAAWW,EAAGC,KACrB,CACLlB,EAAGgB,EACHV,YACAa,QAAS,IAAIC,EAAMH,EAAGC,KAWnB,SAASG,EACdC,EACApB,EACAqB,GAEA,MAAMtB,EAASsB,EACTC,EAASC,EACbH,EAAaI,iBACbJ,EAAaK,OAAQC,uBACrBC,GAEIC,EAAQC,EAAmBC,EAAaR,EAAQvB,IAAWgC,EACjE,OAAOC,KAAKC,MAAOL,EAAQG,EAAaG,EAC1C,CAqCO,SAASC,EAAaC,EAE3B9B,EACAE,EACAO,EACAC,GACA,IAAAqB,EAAA,IALAtC,OAAEA,EAAMF,OAAEA,GAAmBuC,EAM7B,MAAMpC,EAAUD,EAAOE,SAASJ,GAC9ByC,GAAoB,QAAbD,EAAAtC,EAAO0B,cAAM,IAAAY,OAAA,EAAbA,EAAeE,YAAa,EACnCC,EAAUzC,EAAOyC,QAAUF,EAC3BG,EA1CJ,SACE1C,EACA2C,EACApC,EACAE,GAEA,MAAMc,EAASvB,EAAO4C,yBACpBC,OACqB,IAAZtC,QAA8C,IAAZE,EACrCT,EAAO8C,uBACLvB,EACAf,EACAA,EACAD,EACAE,GAEF,IAAIU,EAAMnB,EAAO+C,KAAM/C,EAAOgD,KAItC,OAHOhD,EAAO6B,MACRc,EAAMM,QAAQC,EAAiBlD,EAAO6B,OAAQN,GAC9CoB,GACIQ,SAASN,EACrB,CAqBiBO,CAAepD,EAAQ,IAAImB,EAAMH,EAAGC,GAAIV,EAASE,GAehE,OAdIiC,EAAW1B,GAAKyB,IAClBC,EAAW1B,GAAKyB,GAEdC,EAAW1B,IAAMyB,IACnBC,EAAW1B,GAAKyB,GAEdC,EAAWzB,GAAKwB,IAClBC,EAAWzB,GAAKwB,GAEdC,EAAWzB,GAAKwB,IAClBC,EAAWzB,GAAKwB,GAElBC,EAAW1B,GAAKf,EAAQoD,QACxBX,EAAWzB,GAAKhB,EAAQqD,QACjBZ,CACT"}

package/dist/src/controls/util.mjs

@@ -0,0 +1,105 @@
+import { resolveOrigin } from '../util/misc/resolveOrigin.mjs';
+import { Point } from '../Point.mjs';
+import { degreesToRadians } from '../util/misc/radiansDegreesConversion.mjs';
+import { twoMathPi, quarterPI, CENTER } from '../constants.mjs';
+import { calcVectorRotation, createVector } from '../util/misc/vectors.mjs';
+import { sendPointToPlane } from '../util/misc/planeChange.mjs';
+
+const NOT_ALLOWED_CURSOR = 'not-allowed';
+
+/**
+ * @param {Boolean} alreadySelected true if target is already selected
+ * @param {String} corner a string representing the corner ml, mr, tl ...
+ * @param {Event} e Event object
+ * @param {FabricObject} [target] inserted back to help overriding. Unused
+ */
+const getActionFromCorner = (alreadySelected, corner, e, target) => {
+  if (!corner || !alreadySelected) {
+    return 'drag';
+  }
+  const control = target.controls[corner];
+  return control.getActionName(e, control, target);
+};
+
+/**
+ * Checks if transform is centered
+ * @param {Object} transform transform data
+ * @return {Boolean} true if transform is centered
+ */
+function isTransformCentered(transform) {
+  return resolveOrigin(transform.originX) === resolveOrigin(CENTER) && resolveOrigin(transform.originY) === resolveOrigin(CENTER);
+}
+function invertOrigin(origin) {
+  return -resolveOrigin(origin) + 0.5;
+}
+const isLocked = (target, lockingKey) => target[lockingKey];
+const commonEventInfo = (eventData, transform, x, y) => {
+  return {
+    e: eventData,
+    transform,
+    pointer: new Point(x, y)
+  };
+};
+
+/**
+ * Combine control position and object angle to find the control direction compared
+ * to the object center.
+ * @param {FabricObject} fabricObject the fabric object for which we are rendering controls
+ * @param {Control} control the control class
+ * @return {Number} 0 - 7 a quadrant number
+ */
+function findCornerQuadrant(fabricObject, control, coord) {
+  const target = coord;
+  const center = sendPointToPlane(fabricObject.getCenterPoint(), fabricObject.canvas.viewportTransform, undefined);
+  const angle = calcVectorRotation(createVector(center, target)) + twoMathPi;
+  return Math.round(angle % twoMathPi / quarterPI);
+}
+
+/**
+ * @returns the normalized point (rotated relative to center) in local coordinates
+ */
+function normalizePoint(target, point, originX, originY) {
+  const center = target.getRelativeCenterPoint(),
+    p = typeof originX !== 'undefined' && typeof originY !== 'undefined' ? target.translateToGivenOrigin(center, CENTER, CENTER, originX, originY) : new Point(target.left, target.top),
+    p2 = target.angle ? point.rotate(-degreesToRadians(target.angle), center) : point;
+  return p2.subtract(p);
+}
+
+/**
+ * Transforms a point to the offset from the given origin
+ * @param {Object} transform
+ * @param {String} originX
+ * @param {String} originY
+ * @param {number} x
+ * @param {number} y
+ * @return {Fabric.Point} the normalized point
+ */
+function getLocalPoint(_ref, originX, originY, x, y) {
+  var _target$canvas;
+  let {
+    target,
+    corner
+  } = _ref;
+  const control = target.controls[corner],
+    zoom = ((_target$canvas = target.canvas) === null || _target$canvas === void 0 ? void 0 : _target$canvas.getZoom()) || 1,
+    padding = target.padding / zoom,
+    localPoint = normalizePoint(target, new Point(x, y), originX, originY);
+  if (localPoint.x >= padding) {
+    localPoint.x -= padding;
+  }
+  if (localPoint.x <= -padding) {
+    localPoint.x += padding;
+  }
+  if (localPoint.y >= padding) {
+    localPoint.y -= padding;
+  }
+  if (localPoint.y <= padding) {
+    localPoint.y += padding;
+  }
+  localPoint.x -= control.offsetX;
+  localPoint.y -= control.offsetY;
+  return localPoint;
+}
+
+export { NOT_ALLOWED_CURSOR, commonEventInfo, findCornerQuadrant, getActionFromCorner, getLocalPoint, invertOrigin, isLocked, isTransformCentered };
+//# sourceMappingURL=util.mjs.map

package/dist/src/controls/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","sources":["../../../src/controls/util.ts"],"sourcesContent":["import type {\n  TPointerEvent,\n  Transform,\n  TransformAction,\n  BasicTransformEvent,\n} from '../EventTypeDefs';\nimport { resolveOrigin } from '../util/misc/resolveOrigin';\nimport { Point } from '../Point';\nimport type { FabricObject } from '../shapes/Object/FabricObject';\nimport type { TOriginX, TOriginY } from '../typedefs';\nimport { degreesToRadians } from '../util/misc/radiansDegreesConversion';\nimport type { Control } from './Control';\nimport { CENTER, quarterPI, twoMathPi } from '../constants';\nimport { calcVectorRotation, createVector } from '../util/misc/vectors';\nimport type { TOCoord } from '../shapes/Object/InteractiveObject';\nimport { sendPointToPlane } from '../util/misc/planeChange';\n\nexport const NOT_ALLOWED_CURSOR = 'not-allowed';\n\n/**\n * @param {Boolean} alreadySelected true if target is already selected\n * @param {String} corner a string representing the corner ml, mr, tl ...\n * @param {Event} e Event object\n * @param {FabricObject} [target] inserted back to help overriding. Unused\n */\nexport const getActionFromCorner = (\n  alreadySelected: boolean,\n  corner: string | undefined,\n  e: TPointerEvent,\n  target: FabricObject,\n) => {\n  if (!corner || !alreadySelected) {\n    return 'drag';\n  }\n  const control = target.controls[corner];\n  return control.getActionName(e, control, target);\n};\n\n/**\n * Checks if transform is centered\n * @param {Object} transform transform data\n * @return {Boolean} true if transform is centered\n */\nexport function isTransformCentered(transform: Transform) {\n  return (\n    resolveOrigin(transform.originX) === resolveOrigin(CENTER) &&\n    resolveOrigin(transform.originY) === resolveOrigin(CENTER)\n  );\n}\n\nexport function invertOrigin(origin: TOriginX | TOriginY) {\n  return -resolveOrigin(origin) + 0.5;\n}\n\nexport const isLocked = (\n  target: FabricObject,\n  lockingKey:\n    | 'lockMovementX'\n    | 'lockMovementY'\n    | 'lockRotation'\n    | 'lockScalingX'\n    | 'lockScalingY'\n    | 'lockSkewingX'\n    | 'lockSkewingY'\n    | 'lockScalingFlip',\n) => target[lockingKey];\n\nexport const commonEventInfo: TransformAction<\n  Transform,\n  BasicTransformEvent\n> = (eventData, transform, x, y) => {\n  return {\n    e: eventData,\n    transform,\n    pointer: new Point(x, y),\n  };\n};\n\n/**\n * Combine control position and object angle to find the control direction compared\n * to the object center.\n * @param {FabricObject} fabricObject the fabric object for which we are rendering controls\n * @param {Control} control the control class\n * @return {Number} 0 - 7 a quadrant number\n */\nexport function findCornerQuadrant(\n  fabricObject: FabricObject,\n  control: Control,\n  coord: TOCoord,\n): number {\n  const target = coord;\n  const center = sendPointToPlane(\n    fabricObject.getCenterPoint(),\n    fabricObject.canvas!.viewportTransform,\n    undefined,\n  );\n  const angle = calcVectorRotation(createVector(center, target)) + twoMathPi;\n  return Math.round((angle % twoMathPi) / quarterPI);\n}\n\n/**\n * @returns the normalized point (rotated relative to center) in local coordinates\n */\nfunction normalizePoint(\n  target: FabricObject,\n  point: Point,\n  originX: TOriginX,\n  originY: TOriginY,\n): Point {\n  const center = target.getRelativeCenterPoint(),\n    p =\n      typeof originX !== 'undefined' && typeof originY !== 'undefined'\n        ? target.translateToGivenOrigin(\n            center,\n            CENTER,\n            CENTER,\n            originX,\n            originY,\n          )\n        : new Point(target.left, target.top),\n    p2 = target.angle\n      ? point.rotate(-degreesToRadians(target.angle), center)\n      : point;\n  return p2.subtract(p);\n}\n\n/**\n * Transforms a point to the offset from the given origin\n * @param {Object} transform\n * @param {String} originX\n * @param {String} originY\n * @param {number} x\n * @param {number} y\n * @return {Fabric.Point} the normalized point\n */\nexport function getLocalPoint(\n  { target, corner }: Transform,\n  originX: TOriginX,\n  originY: TOriginY,\n  x: number,\n  y: number,\n) {\n  const control = target.controls[corner],\n    zoom = target.canvas?.getZoom() || 1,\n    padding = target.padding / zoom,\n    localPoint = normalizePoint(target, new Point(x, y), originX, originY);\n  if (localPoint.x >= padding) {\n    localPoint.x -= padding;\n  }\n  if (localPoint.x <= -padding) {\n    localPoint.x += padding;\n  }\n  if (localPoint.y >= padding) {\n    localPoint.y -= padding;\n  }\n  if (localPoint.y <= padding) {\n    localPoint.y += padding;\n  }\n  localPoint.x -= control.offsetX;\n  localPoint.y -= control.offsetY;\n  return localPoint;\n}\n"],"names":["NOT_ALLOWED_CURSOR","getActionFromCorner","alreadySelected","corner","e","target","control","controls","getActionName","isTransformCentered","transform","resolveOrigin","originX","CENTER","originY","invertOrigin","origin","isLocked","lockingKey","commonEventInfo","eventData","x","y","pointer","Point","findCornerQuadrant","fabricObject","coord","center","sendPointToPlane","getCenterPoint","canvas","viewportTransform","undefined","angle","calcVectorRotation","createVector","twoMathPi","Math","round","quarterPI","normalizePoint","point","getRelativeCenterPoint","p","translateToGivenOrigin","left","top","p2","rotate","degreesToRadians","subtract","getLocalPoint","_ref","_target$canvas","zoom","getZoom","padding","localPoint","offsetX","offsetY"],"mappings":"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"}

package/dist/src/controls/wrapWithFireEvent.d.ts

@@ -0,0 +1,10 @@
+import type { TModificationEvents, Transform, TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Wrap an action handler with firing an event if the action is performed
+ * @param {TModificationEvents} eventName the event we want to fire
+ * @param {TransformActionHandler<T>} actionHandler the function to wrap
+ * @param {object} extraEventInfo extra information to pas to the event handler
+ * @return {TransformActionHandler<T>} a function with an action handler signature
+ */
+export declare const wrapWithFireEvent: <T extends Transform, P extends object = Record<string, never>>(eventName: TModificationEvents, actionHandler: TransformActionHandler<T>, extraEventInfo?: P) => TransformActionHandler<T>;
+//# sourceMappingURL=wrapWithFireEvent.d.ts.map

package/dist/src/controls/wrapWithFireEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFireEvent.d.ts","sourceRoot":"","sources":["../../../src/controls/wrapWithFireEvent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,SAAS,EACT,sBAAsB,EACvB,MAAM,kBAAkB,CAAC;AAI1B;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAExC,WAAW,mBAAmB,EAC9B,eAAe,sBAAsB,CAAC,CAAC,CAAC,EACxC,iBAAiB,CAAC,KAWZ,sBAAsB,CAAC,CAAC,CAC/B,CAAC"}

package/dist/src/controls/wrapWithFireEvent.min.mjs

@@ -0,0 +1,2 @@
+import{fireEvent as m}from"./fireEvent.min.mjs";import{commonEventInfo as r}from"./util.min.mjs";const t=(t,o,i)=>(n,e,s,f)=>{const p=o(n,e,s,f);return p&&m(t,{...r(n,e,s,f),...i}),p};export{t as wrapWithFireEvent};
+//# sourceMappingURL=wrapWithFireEvent.min.mjs.map

package/dist/src/controls/wrapWithFireEvent.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFireEvent.min.mjs","sources":["../../../src/controls/wrapWithFireEvent.ts"],"sourcesContent":["import type {\n  TModificationEvents,\n  Transform,\n  TransformActionHandler,\n} from '../EventTypeDefs';\nimport { fireEvent } from './fireEvent';\nimport { commonEventInfo } from './util';\n\n/**\n * Wrap an action handler with firing an event if the action is performed\n * @param {TModificationEvents} eventName the event we want to fire\n * @param {TransformActionHandler<T>} actionHandler the function to wrap\n * @param {object} extraEventInfo extra information to pas to the event handler\n * @return {TransformActionHandler<T>} a function with an action handler signature\n */\nexport const wrapWithFireEvent = <\n  T extends Transform,\n  P extends object = Record<string, never>,\n>(\n  eventName: TModificationEvents,\n  actionHandler: TransformActionHandler<T>,\n  extraEventInfo?: P,\n) => {\n  return ((eventData, transform, x, y) => {\n    const actionPerformed = actionHandler(eventData, transform, x, y);\n    if (actionPerformed) {\n      fireEvent(eventName, {\n        ...commonEventInfo(eventData, transform, x, y),\n        ...extraEventInfo,\n      });\n    }\n    return actionPerformed;\n  }) as TransformActionHandler<T>;\n};\n"],"names":["wrapWithFireEvent","eventName","actionHandler","extraEventInfo","eventData","transform","x","y","actionPerformed","fireEvent","commonEventInfo"],"mappings":"iGAeO,MAAMA,EAAoBA,CAI/BC,EACAC,EACAC,IAEQ,CAACC,EAAWC,EAAWC,EAAGC,KAChC,MAAMC,EAAkBN,EAAcE,EAAWC,EAAWC,EAAGC,GAO/D,OANIC,GACFC,EAAUR,EAAW,IAChBS,EAAgBN,EAAWC,EAAWC,EAAGC,MACzCJ,IAGAK"}

package/dist/src/controls/wrapWithFireEvent.mjs

@@ -0,0 +1,25 @@
+import { fireEvent } from './fireEvent.mjs';
+import { commonEventInfo } from './util.mjs';
+
+/**
+ * Wrap an action handler with firing an event if the action is performed
+ * @param {TModificationEvents} eventName the event we want to fire
+ * @param {TransformActionHandler<T>} actionHandler the function to wrap
+ * @param {object} extraEventInfo extra information to pas to the event handler
+ * @return {TransformActionHandler<T>} a function with an action handler signature
+ */
+const wrapWithFireEvent = (eventName, actionHandler, extraEventInfo) => {
+  return (eventData, transform, x, y) => {
+    const actionPerformed = actionHandler(eventData, transform, x, y);
+    if (actionPerformed) {
+      fireEvent(eventName, {
+        ...commonEventInfo(eventData, transform, x, y),
+        ...extraEventInfo
+      });
+    }
+    return actionPerformed;
+  };
+};
+
+export { wrapWithFireEvent };
+//# sourceMappingURL=wrapWithFireEvent.mjs.map

package/dist/src/controls/wrapWithFireEvent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFireEvent.mjs","sources":["../../../src/controls/wrapWithFireEvent.ts"],"sourcesContent":["import type {\n  TModificationEvents,\n  Transform,\n  TransformActionHandler,\n} from '../EventTypeDefs';\nimport { fireEvent } from './fireEvent';\nimport { commonEventInfo } from './util';\n\n/**\n * Wrap an action handler with firing an event if the action is performed\n * @param {TModificationEvents} eventName the event we want to fire\n * @param {TransformActionHandler<T>} actionHandler the function to wrap\n * @param {object} extraEventInfo extra information to pas to the event handler\n * @return {TransformActionHandler<T>} a function with an action handler signature\n */\nexport const wrapWithFireEvent = <\n  T extends Transform,\n  P extends object = Record<string, never>,\n>(\n  eventName: TModificationEvents,\n  actionHandler: TransformActionHandler<T>,\n  extraEventInfo?: P,\n) => {\n  return ((eventData, transform, x, y) => {\n    const actionPerformed = actionHandler(eventData, transform, x, y);\n    if (actionPerformed) {\n      fireEvent(eventName, {\n        ...commonEventInfo(eventData, transform, x, y),\n        ...extraEventInfo,\n      });\n    }\n    return actionPerformed;\n  }) as TransformActionHandler<T>;\n};\n"],"names":["wrapWithFireEvent","eventName","actionHandler","extraEventInfo","eventData","transform","x","y","actionPerformed","fireEvent","commonEventInfo"],"mappings":";;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,iBAAiB,GAAGA,CAI/BC,SAA8B,EAC9BC,aAAwC,EACxCC,cAAkB,KACf;EACH,OAAQ,CAACC,SAAS,EAAEC,SAAS,EAAEC,CAAC,EAAEC,CAAC,KAAK;IACtC,MAAMC,eAAe,GAAGN,aAAa,CAACE,SAAS,EAAEC,SAAS,EAAEC,CAAC,EAAEC,CAAC,CAAC;AACjE,IAAA,IAAIC,eAAe,EAAE;MACnBC,SAAS,CAACR,SAAS,EAAE;QACnB,GAAGS,eAAe,CAACN,SAAS,EAAEC,SAAS,EAAEC,CAAC,EAAEC,CAAC,CAAC;QAC9C,GAAGJ;AACL,OAAC,CAAC;AACJ,IAAA;AACA,IAAA,OAAOK,eAAe;EACxB,CAAC;AACH;;;;"}

package/dist/src/controls/wrapWithFixedAnchor.d.ts

@@ -0,0 +1,9 @@
+import type { Transform, TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Wrap an action handler with saving/restoring object position on the transform.
+ * this is the code that permits to objects to keep their position while transforming.
+ * @param {Function} actionHandler the function to wrap
+ * @return {Function} a function with an action handler signature
+ */
+export declare function wrapWithFixedAnchor<T extends Transform>(actionHandler: TransformActionHandler<T>): TransformActionHandler<T>;
+//# sourceMappingURL=wrapWithFixedAnchor.d.ts.map

package/dist/src/controls/wrapWithFixedAnchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFixedAnchor.d.ts","sourceRoot":"","sources":["../../../src/controls/wrapWithFixedAnchor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE1E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,SAAS,EACrD,aAAa,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAelC,sBAAsB,CAAC,CAAC,CAAC,CAChC"}

package/dist/src/controls/wrapWithFixedAnchor.min.mjs

@@ -0,0 +1,2 @@
+function i(i){return(n,t,r,o)=>{const{target:e,originX:g,originY:a}=t,s=e.getRelativeCenterPoint(),u=e.translateToOriginPoint(s,g,a),P=i(n,t,r,o);return e.setPositionByOrigin(u,t.originX,t.originY),P}}export{i as wrapWithFixedAnchor};
+//# sourceMappingURL=wrapWithFixedAnchor.min.mjs.map

package/dist/src/controls/wrapWithFixedAnchor.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFixedAnchor.min.mjs","sources":["../../../src/controls/wrapWithFixedAnchor.ts"],"sourcesContent":["import type { Transform, TransformActionHandler } from '../EventTypeDefs';\n\n/**\n * Wrap an action handler with saving/restoring object position on the transform.\n * this is the code that permits to objects to keep their position while transforming.\n * @param {Function} actionHandler the function to wrap\n * @return {Function} a function with an action handler signature\n */\nexport function wrapWithFixedAnchor<T extends Transform>(\n  actionHandler: TransformActionHandler<T>,\n) {\n  return ((eventData, transform, x, y) => {\n    const { target, originX, originY } = transform,\n      centerPoint = target.getRelativeCenterPoint(),\n      constraint = target.translateToOriginPoint(centerPoint, originX, originY),\n      actionPerformed = actionHandler(eventData, transform, x, y);\n    // flipping requires to change the transform origin, so we read from the mutated transform\n    // instead of leveraging the one destructured before\n    target.setPositionByOrigin(\n      constraint,\n      transform.originX,\n      transform.originY,\n    );\n    return actionPerformed;\n  }) as TransformActionHandler<T>;\n}\n"],"names":["wrapWithFixedAnchor","actionHandler","eventData","transform","x","y","target","originX","originY","centerPoint","getRelativeCenterPoint","constraint","translateToOriginPoint","actionPerformed","setPositionByOrigin"],"mappings":"AAQO,SAASA,EACdC,GAEA,MAAQ,CAACC,EAAWC,EAAWC,EAAGC,KAChC,MAAMC,OAAEA,EAAMC,QAAEA,EAAOC,QAAEA,GAAYL,EACnCM,EAAcH,EAAOI,yBACrBC,EAAaL,EAAOM,uBAAuBH,EAAaF,EAASC,GACjEK,EAAkBZ,EAAcC,EAAWC,EAAWC,EAAGC,GAQ3D,OALAC,EAAOQ,oBACLH,EACAR,EAAUI,QACVJ,EAAUK,SAELK,EAEX"}

package/dist/src/controls/wrapWithFixedAnchor.mjs

@@ -0,0 +1,25 @@
+/**
+ * Wrap an action handler with saving/restoring object position on the transform.
+ * this is the code that permits to objects to keep their position while transforming.
+ * @param {Function} actionHandler the function to wrap
+ * @return {Function} a function with an action handler signature
+ */
+function wrapWithFixedAnchor(actionHandler) {
+  return (eventData, transform, x, y) => {
+    const {
+        target,
+        originX,
+        originY
+      } = transform,
+      centerPoint = target.getRelativeCenterPoint(),
+      constraint = target.translateToOriginPoint(centerPoint, originX, originY),
+      actionPerformed = actionHandler(eventData, transform, x, y);
+    // flipping requires to change the transform origin, so we read from the mutated transform
+    // instead of leveraging the one destructured before
+    target.setPositionByOrigin(constraint, transform.originX, transform.originY);
+    return actionPerformed;
+  };
+}
+
+export { wrapWithFixedAnchor };
+//# sourceMappingURL=wrapWithFixedAnchor.mjs.map

package/dist/src/controls/wrapWithFixedAnchor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFixedAnchor.mjs","sources":["../../../src/controls/wrapWithFixedAnchor.ts"],"sourcesContent":["import type { Transform, TransformActionHandler } from '../EventTypeDefs';\n\n/**\n * Wrap an action handler with saving/restoring object position on the transform.\n * this is the code that permits to objects to keep their position while transforming.\n * @param {Function} actionHandler the function to wrap\n * @return {Function} a function with an action handler signature\n */\nexport function wrapWithFixedAnchor<T extends Transform>(\n  actionHandler: TransformActionHandler<T>,\n) {\n  return ((eventData, transform, x, y) => {\n    const { target, originX, originY } = transform,\n      centerPoint = target.getRelativeCenterPoint(),\n      constraint = target.translateToOriginPoint(centerPoint, originX, originY),\n      actionPerformed = actionHandler(eventData, transform, x, y);\n    // flipping requires to change the transform origin, so we read from the mutated transform\n    // instead of leveraging the one destructured before\n    target.setPositionByOrigin(\n      constraint,\n      transform.originX,\n      transform.originY,\n    );\n    return actionPerformed;\n  }) as TransformActionHandler<T>;\n}\n"],"names":["wrapWithFixedAnchor","actionHandler","eventData","transform","x","y","target","originX","originY","centerPoint","getRelativeCenterPoint","constraint","translateToOriginPoint","actionPerformed","setPositionByOrigin"],"mappings":"AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,mBAAmBA,CACjCC,aAAwC,EACxC;EACA,OAAQ,CAACC,SAAS,EAAEC,SAAS,EAAEC,CAAC,EAAEC,CAAC,KAAK;IACtC,MAAM;QAAEC,MAAM;QAAEC,OAAO;AAAEC,QAAAA;AAAQ,OAAC,GAAGL,SAAS;AAC5CM,MAAAA,WAAW,GAAGH,MAAM,CAACI,sBAAsB,EAAE;MAC7CC,UAAU,GAAGL,MAAM,CAACM,sBAAsB,CAACH,WAAW,EAAEF,OAAO,EAAEC,OAAO,CAAC;MACzEK,eAAe,GAAGZ,aAAa,CAACC,SAAS,EAAEC,SAAS,EAAEC,CAAC,EAAEC,CAAC,CAAC;AAC7D;AACA;AACAC,IAAAA,MAAM,CAACQ,mBAAmB,CACxBH,UAAU,EACVR,SAAS,CAACI,OAAO,EACjBJ,SAAS,CAACK,OACZ,CAAC;AACD,IAAA,OAAOK,eAAe;EACxB,CAAC;AACH;;;;"}

package/dist/src/env/browser.d.ts

@@ -0,0 +1,3 @@
+import type { TFabricEnv } from './types';
+export declare const getEnv: () => TFabricEnv;
+//# sourceMappingURL=browser.d.ts.map

package/dist/src/env/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/env/browser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,UAAU,EAAE,MAAM,SAAS,CAAC;AAI1D,eAAO,MAAM,MAAM,QAAO,UAczB,CAAC"}

package/dist/src/env/browser.min.mjs

@@ -0,0 +1,2 @@
+import{WebGLProbe as o}from"../filters/GLProbes/WebGLProbe.min.mjs";const n={},t=()=>({document:document,window:window,isTouchSupported:"ontouchstart"in window||"ontouchstart"in document||window&&window.navigator&&window.navigator.maxTouchPoints>0,WebGLProbe:new o,dispose(){},copyPasteData:n});export{t as getEnv};
+//# sourceMappingURL=browser.min.mjs.map

package/dist/src/env/browser.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.min.mjs","sources":["../../../src/env/browser.ts"],"sourcesContent":["/* eslint-disable no-restricted-globals */\nimport { WebGLProbe } from '../filters/GLProbes/WebGLProbe';\nimport type { TCopyPasteData, TFabricEnv } from './types';\n\nconst copyPasteData: TCopyPasteData = {};\n\nexport const getEnv = (): TFabricEnv => {\n  return {\n    document,\n    window,\n    isTouchSupported:\n      'ontouchstart' in window ||\n      'ontouchstart' in document ||\n      (window && window.navigator && window.navigator.maxTouchPoints > 0),\n    WebGLProbe: new WebGLProbe(),\n    dispose() {\n      // noop\n    },\n    copyPasteData,\n  };\n};\n"],"names":["copyPasteData","getEnv","document","window","isTouchSupported","navigator","maxTouchPoints","WebGLProbe","dispose"],"mappings":"oEAIA,MAAMA,EAAgC,CAAA,EAEzBC,EAASA,KACb,CACLC,kBACAC,cACAC,iBACE,iBAAkBD,QAClB,iBAAkBD,UACjBC,QAAUA,OAAOE,WAAaF,OAAOE,UAAUC,eAAiB,EACnEC,WAAY,IAAIA,EAChBC,OAAAA,GACE,EAEFR"}

package/dist/src/env/browser.mjs

@@ -0,0 +1,19 @@
+import { WebGLProbe } from '../filters/GLProbes/WebGLProbe.mjs';
+
+/* eslint-disable no-restricted-globals */
+const copyPasteData = {};
+const getEnv = () => {
+  return {
+    document,
+    window,
+    isTouchSupported: 'ontouchstart' in window || 'ontouchstart' in document || window && window.navigator && window.navigator.maxTouchPoints > 0,
+    WebGLProbe: new WebGLProbe(),
+    dispose() {
+      // noop
+    },
+    copyPasteData
+  };
+};
+
+export { getEnv };
+//# sourceMappingURL=browser.mjs.map

package/dist/src/env/browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.mjs","sources":["../../../src/env/browser.ts"],"sourcesContent":["/* eslint-disable no-restricted-globals */\nimport { WebGLProbe } from '../filters/GLProbes/WebGLProbe';\nimport type { TCopyPasteData, TFabricEnv } from './types';\n\nconst copyPasteData: TCopyPasteData = {};\n\nexport const getEnv = (): TFabricEnv => {\n  return {\n    document,\n    window,\n    isTouchSupported:\n      'ontouchstart' in window ||\n      'ontouchstart' in document ||\n      (window && window.navigator && window.navigator.maxTouchPoints > 0),\n    WebGLProbe: new WebGLProbe(),\n    dispose() {\n      // noop\n    },\n    copyPasteData,\n  };\n};\n"],"names":["copyPasteData","getEnv","document","window","isTouchSupported","navigator","maxTouchPoints","WebGLProbe","dispose"],"mappings":";;AAAA;AAIA,MAAMA,aAA6B,GAAG,EAAE;AAEjC,MAAMC,MAAM,GAAGA,MAAkB;EACtC,OAAO;IACLC,QAAQ;IACRC,MAAM;IACNC,gBAAgB,EACd,cAAc,IAAID,MAAM,IACxB,cAAc,IAAID,QAAQ,IACzBC,MAAM,IAAIA,MAAM,CAACE,SAAS,IAAIF,MAAM,CAACE,SAAS,CAACC,cAAc,GAAG,CAAE;AACrEC,IAAAA,UAAU,EAAE,IAAIA,UAAU,EAAE;AAC5BC,IAAAA,OAAOA,GAAG;AACR;IAAA,CACD;AACDR,IAAAA;GACD;AACH;;;;"}

package/dist/src/env/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * This file is consumed by fabric.
+ * The `./node` and `./browser` files define the env variable that is used by this module.
+ * The `./browser` module is defined to be the default env and doesn't set the env at all.
+ * This is done in order to support isomorphic usage for browser and node applications
+ * since window and document aren't defined at time of import in SSR, we can't set env so we avoid it by deferring to the default env.
+ */
+import type { TFabricEnv } from './types';
+import type { DOMWindow } from 'jsdom';
+/**
+ * Sets the environment variables used by fabric.\
+ * This is exposed for special cases, such as configuring a test environment, and should be used with care.
+ *
+ * **CAUTION**: Must be called before using the package.
+ *
+ * @example
+ * <caption>Passing `window` and `document` objects to fabric (in case they are mocked or something)</caption>
+ * import { getEnv, setEnv } from 'fabric';
+ * // we want fabric to use the `window` and `document` objects exposed by the environment we are running in.
+ * setEnv({ ...getEnv(), window, document });
+ * // done with setup, using fabric is now safe
+ */
+export declare const setEnv: (value: TFabricEnv) => void;
+/**
+ * In order to support SSR we **MUST** access the browser env only after the window has loaded
+ */
+export declare const getEnv: () => TFabricEnv;
+export declare const getFabricDocument: () => Document;
+export declare const getFabricWindow: () => (Window & typeof globalThis) | DOMWindow;
+/**
+ * @returns the config value if defined, fallbacks to the environment value
+ */
+export declare const getDevicePixelRatio: () => number;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/env/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/env/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,UAAU,SAEvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,kBAAuC,CAAC;AAE3D,eAAO,MAAM,iBAAiB,QAAO,QAA6B,CAAC;AAEnE,eAAO,MAAM,eAAe,QAAO,CAAC,MAAM,GAAG,OAAO,UAAU,CAAC,GAAG,SACjD,CAAC;AAElB;;GAEG;AACH,eAAO,MAAM,mBAAmB,cAC4C,CAAC"}

package/dist/src/env/index.min.mjs

@@ -0,0 +1,2 @@
+import{config as i}from"../config.min.mjs";import{getEnv as o}from"./browser.min.mjs";let e;const t=i=>{e=i},m=()=>e||(e=o()),r=()=>m().document,n=()=>m().window,a=()=>{var o;return Math.max(null!==(o=i.devicePixelRatio)&&void 0!==o?o:n().devicePixelRatio,1)};export{a as getDevicePixelRatio,m as getEnv,r as getFabricDocument,n as getFabricWindow,t as setEnv};
+//# sourceMappingURL=index.min.mjs.map