fabric 7.3.1 → 7.5.0-beta.1

package/dist/src/Intersection.mjs

@@ -1,189 +0,0 @@
-import { Point } from "./Point.mjs";
-import { createVector } from "./util/misc/vectors.mjs";
-//#region src/Intersection.ts
-var Intersection = class Intersection {
-	constructor(status) {
-		this.status = status;
-		this.points = [];
-	}
-	/**
-	* Used to verify if a point is alredy in the collection
-	* @param {Point} point
-	* @returns {boolean}
-	*/
-	includes(point) {
-		return this.points.some((p) => p.eq(point));
-	}
-	/**
-	* Appends points of intersection
-	* @param {...Point[]} points
-	* @return {Intersection} thisArg
-	*/
-	append(...points) {
-		this.points = this.points.concat(points.filter((point) => {
-			return !this.includes(point);
-		}));
-		return this;
-	}
-	/**
-	* check if point T is on the segment or line defined between A and B
-	*
-	* @param {Point} T the point we are checking for
-	* @param {Point} A one extremity of the segment
-	* @param {Point} B the other extremity of the segment
-	* @param [infinite] if true checks if `T` is on the line defined by `A` and `B`
-	* @returns true if `T` is contained
-	*/
-	static isPointContained(T, A, B, infinite = false) {
-		if (A.eq(B)) return T.eq(A);
-		else if (A.x === B.x) return T.x === A.x && (infinite || T.y >= Math.min(A.y, B.y) && T.y <= Math.max(A.y, B.y));
-		else if (A.y === B.y) return T.y === A.y && (infinite || T.x >= Math.min(A.x, B.x) && T.x <= Math.max(A.x, B.x));
-		else {
-			const AB = createVector(A, B);
-			const s = createVector(A, T).divide(AB);
-			return infinite ? Math.abs(s.x) === Math.abs(s.y) : s.x === s.y && s.x >= 0 && s.x <= 1;
-		}
-	}
-	/**
-	* Use the ray casting algorithm to determine if point is in the polygon defined by points
-	* @see https://en.wikipedia.org/wiki/Point_in_polygon
-	* @param point
-	* @param points polygon points
-	* @returns
-	*/
-	static isPointInPolygon(point, points) {
-		const other = new Point(point).setX(Math.min(point.x - 1, ...points.map((p) => p.x)));
-		let hits = 0;
-		for (let index = 0; index < points.length; index++) {
-			const inter = this.intersectSegmentSegment(points[index], points[(index + 1) % points.length], point, other);
-			if (inter.includes(point)) return true;
-			hits += Number(inter.status === "Intersection");
-		}
-		return hits % 2 === 1;
-	}
-	/**
-	* Checks if a line intersects another
-	* @see {@link https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection line intersection}
-	* @see {@link https://en.wikipedia.org/wiki/Cramer%27s_rule Cramer's rule}
-	* @param {Point} a1
-	* @param {Point} a2
-	* @param {Point} b1
-	* @param {Point} b2
-	* @param {boolean} [aInfinite=true] check segment intersection by passing `false`
-	* @param {boolean} [bInfinite=true] check segment intersection by passing `false`
-	* @return {Intersection}
-	*/
-	static intersectLineLine(a1, a2, b1, b2, aInfinite = true, bInfinite = true) {
-		const a2xa1x = a2.x - a1.x, a2ya1y = a2.y - a1.y, b2xb1x = b2.x - b1.x, b2yb1y = b2.y - b1.y, a1xb1x = a1.x - b1.x, a1yb1y = a1.y - b1.y, uaT = b2xb1x * a1yb1y - b2yb1y * a1xb1x, ubT = a2xa1x * a1yb1y - a2ya1y * a1xb1x, uB = b2yb1y * a2xa1x - b2xb1x * a2ya1y;
-		if (uB !== 0) {
-			const ua = uaT / uB, ub = ubT / uB;
-			if ((aInfinite || 0 <= ua && ua <= 1) && (bInfinite || 0 <= ub && ub <= 1)) return new Intersection("Intersection").append(new Point(a1.x + ua * a2xa1x, a1.y + ua * a2ya1y));
-			else return new Intersection();
-		} else if (uaT === 0 || ubT === 0) return new Intersection(aInfinite || bInfinite || Intersection.isPointContained(a1, b1, b2) || Intersection.isPointContained(a2, b1, b2) || Intersection.isPointContained(b1, a1, a2) || Intersection.isPointContained(b2, a1, a2) ? "Coincident" : void 0);
-		else return new Intersection("Parallel");
-	}
-	/**
-	* Checks if a segment intersects a line
-	* @see {@link intersectLineLine} for line intersection
-	* @param {Point} s1 boundary point of segment
-	* @param {Point} s2 other boundary point of segment
-	* @param {Point} l1 point on line
-	* @param {Point} l2 other point on line
-	* @return {Intersection}
-	*/
-	static intersectSegmentLine(s1, s2, l1, l2) {
-		return Intersection.intersectLineLine(s1, s2, l1, l2, false, true);
-	}
-	/**
-	* Checks if a segment intersects another
-	* @see {@link intersectLineLine} for line intersection
-	* @param {Point} a1 boundary point of segment
-	* @param {Point} a2 other boundary point of segment
-	* @param {Point} b1 boundary point of segment
-	* @param {Point} b2 other boundary point of segment
-	* @return {Intersection}
-	*/
-	static intersectSegmentSegment(a1, a2, b1, b2) {
-		return Intersection.intersectLineLine(a1, a2, b1, b2, false, false);
-	}
-	/**
-	* Checks if line intersects polygon
-	*
-	* @todo account for stroke
-	*
-	* @see {@link intersectSegmentPolygon} for segment intersection
-	* @param {Point} a1 point on line
-	* @param {Point} a2 other point on line
-	* @param {Point[]} points polygon points
-	* @param {boolean} [infinite=true] check segment intersection by passing `false`
-	* @return {Intersection}
-	*/
-	static intersectLinePolygon(a1, a2, points, infinite = true) {
-		const result = new Intersection();
-		const length = points.length;
-		for (let i = 0, b1, b2, inter; i < length; i++) {
-			b1 = points[i];
-			b2 = points[(i + 1) % length];
-			inter = Intersection.intersectLineLine(a1, a2, b1, b2, infinite, false);
-			if (inter.status === "Coincident") return inter;
-			result.append(...inter.points);
-		}
-		if (result.points.length > 0) result.status = "Intersection";
-		return result;
-	}
-	/**
-	* Checks if segment intersects polygon
-	* @see {@link intersectLinePolygon} for line intersection
-	* @param {Point} a1 boundary point of segment
-	* @param {Point} a2 other boundary point of segment
-	* @param {Point[]} points polygon points
-	* @return {Intersection}
-	*/
-	static intersectSegmentPolygon(a1, a2, points) {
-		return Intersection.intersectLinePolygon(a1, a2, points, false);
-	}
-	/**
-	* Checks if polygon intersects another polygon
-	*
-	* @todo account for stroke
-	*
-	* @param {Point[]} points1
-	* @param {Point[]} points2
-	* @return {Intersection}
-	*/
-	static intersectPolygonPolygon(points1, points2) {
-		const result = new Intersection(), length = points1.length;
-		const coincidences = [];
-		for (let i = 0; i < length; i++) {
-			const a1 = points1[i], a2 = points1[(i + 1) % length], inter = Intersection.intersectSegmentPolygon(a1, a2, points2);
-			if (inter.status === "Coincident") {
-				coincidences.push(inter);
-				result.append(a1, a2);
-			} else result.append(...inter.points);
-		}
-		if (coincidences.length > 0 && coincidences.length === points1.length) return new Intersection("Coincident");
-		else if (result.points.length > 0) result.status = "Intersection";
-		return result;
-	}
-	/**
-	* Checks if polygon intersects rectangle
-	* @see {@link intersectPolygonPolygon} for polygon intersection
-	* @param {Point[]} points polygon points
-	* @param {Point} r1 top left point of rect
-	* @param {Point} r2 bottom right point of rect
-	* @return {Intersection}
-	*/
-	static intersectPolygonRectangle(points, r1, r2) {
-		const min = r1.min(r2), max = r1.max(r2), topRight = new Point(max.x, min.y), bottomLeft = new Point(min.x, max.y);
-		return Intersection.intersectPolygonPolygon(points, [
-			min,
-			topRight,
-			max,
-			bottomLeft
-		]);
-	}
-};
-//#endregion
-export { Intersection };
-
-//# sourceMappingURL=Intersection.mjs.map

package/dist/src/Intersection.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Intersection.mjs","names":[],"sources":["../../src/Intersection.ts"],"sourcesContent":["import { Point } from './Point';\nimport { createVector } from './util/misc/vectors';\n\n/* Adaptation of work of Kevin Lindsey (kevin@kevlindev.com) */\n\nexport type IntersectionType = 'Intersection' | 'Coincident' | 'Parallel';\n\nexport class Intersection {\n  declare points: Point[];\n\n  declare status?: IntersectionType;\n\n  constructor(status?: IntersectionType) {\n    this.status = status;\n    this.points = [];\n  }\n\n  /**\n   * Used to verify if a point is alredy in the collection\n   * @param {Point} point\n   * @returns {boolean}\n   */\n  private includes(point: Point): boolean {\n    return this.points.some((p) => p.eq(point));\n  }\n\n  /**\n   * Appends points of intersection\n   * @param {...Point[]} points\n   * @return {Intersection} thisArg\n   */\n  private append(...points: Point[]): Intersection {\n    this.points = this.points.concat(\n      points.filter((point) => {\n        return !this.includes(point);\n      }),\n    );\n    return this;\n  }\n\n  /**\n   * check if point T is on the segment or line defined between A and B\n   *\n   * @param {Point} T the point we are checking for\n   * @param {Point} A one extremity of the segment\n   * @param {Point} B the other extremity of the segment\n   * @param [infinite] if true checks if `T` is on the line defined by `A` and `B`\n   * @returns true if `T` is contained\n   */\n  static isPointContained(T: Point, A: Point, B: Point, infinite = false) {\n    if (A.eq(B)) {\n      // Edge case: the segment is a point, we check for coincidence,\n      // infinite param has no meaning because there are infinite lines to consider\n      return T.eq(A);\n    } else if (A.x === B.x) {\n      // Edge case: horizontal line.\n      // we first check if T.x has the same value, and then if T.y is contained between A.y and B.y\n      return (\n        T.x === A.x &&\n        (infinite || (T.y >= Math.min(A.y, B.y) && T.y <= Math.max(A.y, B.y)))\n      );\n    } else if (A.y === B.y) {\n      // Edge case: vertical line.\n      // we first check if T.y has the same value, and then if T.x is contained between A.x and B.x\n      return (\n        T.y === A.y &&\n        (infinite || (T.x >= Math.min(A.x, B.x) && T.x <= Math.max(A.x, B.x)))\n      );\n    } else {\n      // Generic case: sloped line.\n      // we check that AT has the same slope as AB\n      // for the segment case we need both the vectors to have the same direction and for AT to be lte AB in size\n      // for the infinite case we check the absolute value of the slope, since direction is meaningless\n      const AB = createVector(A, B);\n      const AT = createVector(A, T);\n      const s = AT.divide(AB);\n      return infinite\n        ? Math.abs(s.x) === Math.abs(s.y)\n        : s.x === s.y && s.x >= 0 && s.x <= 1;\n    }\n  }\n\n  /**\n   * Use the ray casting algorithm to determine if point is in the polygon defined by points\n   * @see https://en.wikipedia.org/wiki/Point_in_polygon\n   * @param point\n   * @param points polygon points\n   * @returns\n   */\n  static isPointInPolygon(point: Point, points: Point[]) {\n    const other = new Point(point).setX(\n      Math.min(point.x - 1, ...points.map((p) => p.x)),\n    );\n    let hits = 0;\n    for (let index = 0; index < points.length; index++) {\n      const inter = this.intersectSegmentSegment(\n        // polygon side\n        points[index],\n        points[(index + 1) % points.length],\n        // ray\n        point,\n        other,\n      );\n      if (inter.includes(point)) {\n        // point is on the polygon side\n        return true;\n      }\n      hits += Number(inter.status === 'Intersection');\n    }\n    return hits % 2 === 1;\n  }\n\n  /**\n   * Checks if a line intersects another\n   * @see {@link https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection line intersection}\n   * @see {@link https://en.wikipedia.org/wiki/Cramer%27s_rule Cramer's rule}\n   * @param {Point} a1\n   * @param {Point} a2\n   * @param {Point} b1\n   * @param {Point} b2\n   * @param {boolean} [aInfinite=true] check segment intersection by passing `false`\n   * @param {boolean} [bInfinite=true] check segment intersection by passing `false`\n   * @return {Intersection}\n   */\n  static intersectLineLine(\n    a1: Point,\n    a2: Point,\n    b1: Point,\n    b2: Point,\n    aInfinite = true,\n    bInfinite = true,\n  ): Intersection {\n    const a2xa1x = a2.x - a1.x,\n      a2ya1y = a2.y - a1.y,\n      b2xb1x = b2.x - b1.x,\n      b2yb1y = b2.y - b1.y,\n      a1xb1x = a1.x - b1.x,\n      a1yb1y = a1.y - b1.y,\n      uaT = b2xb1x * a1yb1y - b2yb1y * a1xb1x,\n      ubT = a2xa1x * a1yb1y - a2ya1y * a1xb1x,\n      uB = b2yb1y * a2xa1x - b2xb1x * a2ya1y;\n    if (uB !== 0) {\n      const ua = uaT / uB,\n        ub = ubT / uB;\n      if (\n        (aInfinite || (0 <= ua && ua <= 1)) &&\n        (bInfinite || (0 <= ub && ub <= 1))\n      ) {\n        return new Intersection('Intersection').append(\n          new Point(a1.x + ua * a2xa1x, a1.y + ua * a2ya1y),\n        );\n      } else {\n        return new Intersection();\n      }\n    } else {\n      if (uaT === 0 || ubT === 0) {\n        const segmentsCoincide =\n          aInfinite ||\n          bInfinite ||\n          Intersection.isPointContained(a1, b1, b2) ||\n          Intersection.isPointContained(a2, b1, b2) ||\n          Intersection.isPointContained(b1, a1, a2) ||\n          Intersection.isPointContained(b2, a1, a2);\n        return new Intersection(segmentsCoincide ? 'Coincident' : undefined);\n      } else {\n        return new Intersection('Parallel');\n      }\n    }\n  }\n\n  /**\n   * Checks if a segment intersects a line\n   * @see {@link intersectLineLine} for line intersection\n   * @param {Point} s1 boundary point of segment\n   * @param {Point} s2 other boundary point of segment\n   * @param {Point} l1 point on line\n   * @param {Point} l2 other point on line\n   * @return {Intersection}\n   */\n  static intersectSegmentLine(\n    s1: Point,\n    s2: Point,\n    l1: Point,\n    l2: Point,\n  ): Intersection {\n    return Intersection.intersectLineLine(s1, s2, l1, l2, false, true);\n  }\n\n  /**\n   * Checks if a segment intersects another\n   * @see {@link intersectLineLine} for line intersection\n   * @param {Point} a1 boundary point of segment\n   * @param {Point} a2 other boundary point of segment\n   * @param {Point} b1 boundary point of segment\n   * @param {Point} b2 other boundary point of segment\n   * @return {Intersection}\n   */\n  static intersectSegmentSegment(\n    a1: Point,\n    a2: Point,\n    b1: Point,\n    b2: Point,\n  ): Intersection {\n    return Intersection.intersectLineLine(a1, a2, b1, b2, false, false);\n  }\n\n  /**\n   * Checks if line intersects polygon\n   *\n   * @todo account for stroke\n   *\n   * @see {@link intersectSegmentPolygon} for segment intersection\n   * @param {Point} a1 point on line\n   * @param {Point} a2 other point on line\n   * @param {Point[]} points polygon points\n   * @param {boolean} [infinite=true] check segment intersection by passing `false`\n   * @return {Intersection}\n   */\n  static intersectLinePolygon(\n    a1: Point,\n    a2: Point,\n    points: Point[],\n    infinite = true,\n  ): Intersection {\n    const result = new Intersection();\n    const length = points.length;\n\n    for (let i = 0, b1, b2, inter; i < length; i++) {\n      b1 = points[i];\n      b2 = points[(i + 1) % length];\n      inter = Intersection.intersectLineLine(a1, a2, b1, b2, infinite, false);\n      if (inter.status === 'Coincident') {\n        return inter;\n      }\n      result.append(...inter.points);\n    }\n\n    if (result.points.length > 0) {\n      result.status = 'Intersection';\n    }\n\n    return result;\n  }\n\n  /**\n   * Checks if segment intersects polygon\n   * @see {@link intersectLinePolygon} for line intersection\n   * @param {Point} a1 boundary point of segment\n   * @param {Point} a2 other boundary point of segment\n   * @param {Point[]} points polygon points\n   * @return {Intersection}\n   */\n  static intersectSegmentPolygon(\n    a1: Point,\n    a2: Point,\n    points: Point[],\n  ): Intersection {\n    return Intersection.intersectLinePolygon(a1, a2, points, false);\n  }\n\n  /**\n   * Checks if polygon intersects another polygon\n   *\n   * @todo account for stroke\n   *\n   * @param {Point[]} points1\n   * @param {Point[]} points2\n   * @return {Intersection}\n   */\n  static intersectPolygonPolygon(\n    points1: Point[],\n    points2: Point[],\n  ): Intersection {\n    const result = new Intersection(),\n      length = points1.length;\n    const coincidences: Intersection[] = [];\n\n    for (let i = 0; i < length; i++) {\n      const a1 = points1[i],\n        a2 = points1[(i + 1) % length],\n        inter = Intersection.intersectSegmentPolygon(a1, a2, points2);\n      if (inter.status === 'Coincident') {\n        coincidences.push(inter);\n        result.append(a1, a2);\n      } else {\n        result.append(...inter.points);\n      }\n    }\n\n    if (coincidences.length > 0 && coincidences.length === points1.length) {\n      return new Intersection('Coincident');\n    } else if (result.points.length > 0) {\n      result.status = 'Intersection';\n    }\n\n    return result;\n  }\n\n  /**\n   * Checks if polygon intersects rectangle\n   * @see {@link intersectPolygonPolygon} for polygon intersection\n   * @param {Point[]} points polygon points\n   * @param {Point} r1 top left point of rect\n   * @param {Point} r2 bottom right point of rect\n   * @return {Intersection}\n   */\n  static intersectPolygonRectangle(\n    points: Point[],\n    r1: Point,\n    r2: Point,\n  ): Intersection {\n    const min = r1.min(r2),\n      max = r1.max(r2),\n      topRight = new Point(max.x, min.y),\n      bottomLeft = new Point(min.x, max.y);\n\n    return Intersection.intersectPolygonPolygon(points, [\n      min,\n      topRight,\n      max,\n      bottomLeft,\n    ]);\n  }\n}\n"],"mappings":"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"}

package/dist/src/LayoutManager/ActiveSelectionLayoutManager.d.ts

@@ -1,22 +0,0 @@
-import { LayoutManager } from './LayoutManager';
-import type { RegistrationContext, StrictLayoutContext } from './types';
-/**
- * Today the LayoutManager class also takes care of subscribing event handlers
- * to update the group layout when the group is interactive and a transform is applied
- * to a child object.
- * The ActiveSelection is never interactive, but it could contain objects from
- * groups that are.
- * The standard LayoutManager would subscribe the children of the activeSelection to
- * perform layout changes to the active selection itself, what we need instead is that
- * the transformation applied to the active selection will trigger changes to the
- * original group of the children ( the one referenced under the parent property )
- * This subclass of the LayoutManager has a single duty to fill the gap of this difference.`
- */
-export declare class ActiveSelectionLayoutManager extends LayoutManager {
-    subscribeTargets(context: RegistrationContext & Partial<StrictLayoutContext>): void;
-    /**
-     * unsubscribe from parent only if all its children were deselected
-     */
-    unsubscribeTargets(context: RegistrationContext & Partial<StrictLayoutContext>): void;
-}
-//# sourceMappingURL=ActiveSelectionLayoutManager.d.ts.map

package/dist/src/LayoutManager/ActiveSelectionLayoutManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ActiveSelectionLayoutManager.d.ts","sourceRoot":"","sources":["../../../src/LayoutManager/ActiveSelectionLayoutManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGxE;;;;;;;;;;;GAWG;AACH,qBAAa,4BAA6B,SAAQ,aAAa;IAC7D,gBAAgB,CACd,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,GAC1D,IAAI;IAcP;;OAEG;IACH,kBAAkB,CAChB,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,GAC1D,IAAI;CAeR"}

package/dist/src/LayoutManager/ActiveSelectionLayoutManager.min.mjs

@@ -1,2 +0,0 @@
-import{LayoutManager as e}from"./LayoutManager.min.mjs";var t=class extends e{subscribeTargets(e){let t=e.target;e.targets.reduce((e,t)=>(t.parent&&e.add(t.parent),e),new Set).forEach(e=>{e.layoutManager.subscribeTargets({target:e,targets:[t]})})}unsubscribeTargets(e){let t=e.target,n=t.getObjects();e.targets.reduce((e,t)=>(t.parent&&e.add(t.parent),e),new Set).forEach(e=>{!n.some(t=>t.parent===e)&&e.layoutManager.unsubscribeTargets({target:e,targets:[t]})})}};export{t as ActiveSelectionLayoutManager};
-//# sourceMappingURL=ActiveSelectionLayoutManager.min.mjs.map

package/dist/src/LayoutManager/ActiveSelectionLayoutManager.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ActiveSelectionLayoutManager.min.mjs","names":[],"sources":["../../../src/LayoutManager/ActiveSelectionLayoutManager.ts"],"sourcesContent":["import { LayoutManager } from './LayoutManager';\nimport type { RegistrationContext, StrictLayoutContext } from './types';\nimport type { Group } from '../shapes/Group';\n\n/**\n * Today the LayoutManager class also takes care of subscribing event handlers\n * to update the group layout when the group is interactive and a transform is applied\n * to a child object.\n * The ActiveSelection is never interactive, but it could contain objects from\n * groups that are.\n * The standard LayoutManager would subscribe the children of the activeSelection to\n * perform layout changes to the active selection itself, what we need instead is that\n * the transformation applied to the active selection will trigger changes to the\n * original group of the children ( the one referenced under the parent property )\n * This subclass of the LayoutManager has a single duty to fill the gap of this difference.`\n */\nexport class ActiveSelectionLayoutManager extends LayoutManager {\n  subscribeTargets(\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ): void {\n    const activeSelection = context.target;\n    const parents = context.targets.reduce((parents, target) => {\n      target.parent && parents.add(target.parent);\n      return parents;\n    }, new Set<Group>());\n    parents.forEach((parent) => {\n      parent.layoutManager.subscribeTargets({\n        target: parent,\n        targets: [activeSelection],\n      });\n    });\n  }\n\n  /**\n   * unsubscribe from parent only if all its children were deselected\n   */\n  unsubscribeTargets(\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ): void {\n    const activeSelection = context.target;\n    const selectedObjects = activeSelection.getObjects();\n    const parents = context.targets.reduce((parents, target) => {\n      target.parent && parents.add(target.parent);\n      return parents;\n    }, new Set<Group>());\n    parents.forEach((parent) => {\n      !selectedObjects.some((object) => object.parent === parent) &&\n        parent.layoutManager.unsubscribeTargets({\n          target: parent,\n          targets: [activeSelection],\n        });\n    });\n  }\n}\n"],"mappings":"wDAgBA,IAAa,EAAb,cAAkD,CAAA,CAChD,iBACE,EAAA,CAEA,IAAM,EAAkB,EAAQ,OAChB,EAAQ,QAAQ,QAAQ,EAAS,KAC/C,EAAO,QAAU,EAAQ,IAAI,EAAO,OAAA,CAC7B,GACN,IAAI,IAAA,CACC,QAAS,GAAA,CACf,EAAO,cAAc,iBAAiB,CACpC,OAAQ,EACR,QAAS,CAAC,EAAA,CAAA,CAAA,EAAA,CAQhB,mBACE,EAAA,CAEA,IAAM,EAAkB,EAAQ,OAC1B,EAAkB,EAAgB,YAAA,CACxB,EAAQ,QAAQ,QAAQ,EAAS,KAC/C,EAAO,QAAU,EAAQ,IAAI,EAAO,OAAA,CAC7B,GACN,IAAI,IAAA,CACC,QAAS,GAAA,CAAA,CACd,EAAgB,KAAM,GAAW,EAAO,SAAW,EAAA,EAClD,EAAO,cAAc,mBAAmB,CACtC,OAAQ,EACR,QAAS,CAAC,EAAA,CAAA,CAAA,EAAA,GAAA,OAAA,KAAA"}

package/dist/src/LayoutManager/ActiveSelectionLayoutManager.mjs

@@ -1,48 +0,0 @@
-import { LayoutManager } from "./LayoutManager.mjs";
-//#region src/LayoutManager/ActiveSelectionLayoutManager.ts
-/**
-* Today the LayoutManager class also takes care of subscribing event handlers
-* to update the group layout when the group is interactive and a transform is applied
-* to a child object.
-* The ActiveSelection is never interactive, but it could contain objects from
-* groups that are.
-* The standard LayoutManager would subscribe the children of the activeSelection to
-* perform layout changes to the active selection itself, what we need instead is that
-* the transformation applied to the active selection will trigger changes to the
-* original group of the children ( the one referenced under the parent property )
-* This subclass of the LayoutManager has a single duty to fill the gap of this difference.`
-*/
-var ActiveSelectionLayoutManager = class extends LayoutManager {
-	subscribeTargets(context) {
-		const activeSelection = context.target;
-		context.targets.reduce((parents, target) => {
-			target.parent && parents.add(target.parent);
-			return parents;
-		}, /* @__PURE__ */ new Set()).forEach((parent) => {
-			parent.layoutManager.subscribeTargets({
-				target: parent,
-				targets: [activeSelection]
-			});
-		});
-	}
-	/**
-	* unsubscribe from parent only if all its children were deselected
-	*/
-	unsubscribeTargets(context) {
-		const activeSelection = context.target;
-		const selectedObjects = activeSelection.getObjects();
-		context.targets.reduce((parents, target) => {
-			target.parent && parents.add(target.parent);
-			return parents;
-		}, /* @__PURE__ */ new Set()).forEach((parent) => {
-			!selectedObjects.some((object) => object.parent === parent) && parent.layoutManager.unsubscribeTargets({
-				target: parent,
-				targets: [activeSelection]
-			});
-		});
-	}
-};
-//#endregion
-export { ActiveSelectionLayoutManager };
-
-//# sourceMappingURL=ActiveSelectionLayoutManager.mjs.map

package/dist/src/LayoutManager/ActiveSelectionLayoutManager.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ActiveSelectionLayoutManager.mjs","names":[],"sources":["../../../src/LayoutManager/ActiveSelectionLayoutManager.ts"],"sourcesContent":["import { LayoutManager } from './LayoutManager';\nimport type { RegistrationContext, StrictLayoutContext } from './types';\nimport type { Group } from '../shapes/Group';\n\n/**\n * Today the LayoutManager class also takes care of subscribing event handlers\n * to update the group layout when the group is interactive and a transform is applied\n * to a child object.\n * The ActiveSelection is never interactive, but it could contain objects from\n * groups that are.\n * The standard LayoutManager would subscribe the children of the activeSelection to\n * perform layout changes to the active selection itself, what we need instead is that\n * the transformation applied to the active selection will trigger changes to the\n * original group of the children ( the one referenced under the parent property )\n * This subclass of the LayoutManager has a single duty to fill the gap of this difference.`\n */\nexport class ActiveSelectionLayoutManager extends LayoutManager {\n  subscribeTargets(\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ): void {\n    const activeSelection = context.target;\n    const parents = context.targets.reduce((parents, target) => {\n      target.parent && parents.add(target.parent);\n      return parents;\n    }, new Set<Group>());\n    parents.forEach((parent) => {\n      parent.layoutManager.subscribeTargets({\n        target: parent,\n        targets: [activeSelection],\n      });\n    });\n  }\n\n  /**\n   * unsubscribe from parent only if all its children were deselected\n   */\n  unsubscribeTargets(\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ): void {\n    const activeSelection = context.target;\n    const selectedObjects = activeSelection.getObjects();\n    const parents = context.targets.reduce((parents, target) => {\n      target.parent && parents.add(target.parent);\n      return parents;\n    }, new Set<Group>());\n    parents.forEach((parent) => {\n      !selectedObjects.some((object) => object.parent === parent) &&\n        parent.layoutManager.unsubscribeTargets({\n          target: parent,\n          targets: [activeSelection],\n        });\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,IAAa,+BAAb,cAAkD,cAAc;CAC9D,iBACE,SACM;EACN,MAAM,kBAAkB,QAAQ;AAChB,UAAQ,QAAQ,QAAQ,SAAS,WAAW;AAC1D,UAAO,UAAU,QAAQ,IAAI,OAAO,OAAO;AAC3C,UAAO;qBACN,IAAI,KAAY,CAAC,CACZ,SAAS,WAAW;AAC1B,UAAO,cAAc,iBAAiB;IACpC,QAAQ;IACR,SAAS,CAAC,gBAAgB;IAC3B,CAAC;IACF;;;;;CAMJ,mBACE,SACM;EACN,MAAM,kBAAkB,QAAQ;EAChC,MAAM,kBAAkB,gBAAgB,YAAY;AACpC,UAAQ,QAAQ,QAAQ,SAAS,WAAW;AAC1D,UAAO,UAAU,QAAQ,IAAI,OAAO,OAAO;AAC3C,UAAO;qBACN,IAAI,KAAY,CAAC,CACZ,SAAS,WAAW;AAC1B,IAAC,gBAAgB,MAAM,WAAW,OAAO,WAAW,OAAO,IACzD,OAAO,cAAc,mBAAmB;IACtC,QAAQ;IACR,SAAS,CAAC,gBAAgB;IAC3B,CAAC;IACJ"}

package/dist/src/LayoutManager/LayoutManager.d.ts

@@ -1,56 +0,0 @@
-import type { FabricObject } from '../shapes/Object/FabricObject';
-import type { LayoutStrategy } from './LayoutStrategies/LayoutStrategy';
-import type { LayoutContext, LayoutResult, RegistrationContext, StrictLayoutContext } from './types';
-export type SerializedLayoutManager = {
-    type: string;
-    strategy: string;
-};
-export declare class LayoutManager {
-    private _prevLayoutStrategy?;
-    protected _subscriptions: Map<FabricObject, VoidFunction[]>;
-    strategy: LayoutStrategy;
-    constructor(strategy?: LayoutStrategy);
-    performLayout(context: LayoutContext): void;
-    /**
-     * Attach handlers for events that we know will invalidate the layout when
-     * performed on child objects ( general transforms ).
-     * Returns the disposers for later unsubscribing and cleanup
-     * @param {FabricObject} object
-     * @param {RegistrationContext & Partial<StrictLayoutContext>} context
-     * @returns {VoidFunction[]} disposers remove the handlers
-     */
-    protected attachHandlers(object: FabricObject, context: RegistrationContext & Partial<StrictLayoutContext>): VoidFunction[];
-    /**
-     * Subscribe an object to transform events that will trigger a layout change on the parent
-     * This is important only for interactive groups.
-     * @param object
-     * @param context
-     */
-    protected subscribe(object: FabricObject, context: RegistrationContext & Partial<StrictLayoutContext>): void;
-    /**
-     * unsubscribe object layout triggers
-     */
-    protected unsubscribe(object: FabricObject, _context?: RegistrationContext & Partial<StrictLayoutContext>): void;
-    unsubscribeTargets(context: RegistrationContext & Partial<StrictLayoutContext>): void;
-    subscribeTargets(context: RegistrationContext & Partial<StrictLayoutContext>): void;
-    protected onBeforeLayout(context: StrictLayoutContext): void;
-    protected getLayoutResult(context: StrictLayoutContext): Required<LayoutResult> | undefined;
-    protected commitLayout(context: StrictLayoutContext, layoutResult: Required<LayoutResult>): void;
-    protected layoutObjects(context: StrictLayoutContext, layoutResult: Required<LayoutResult>): void;
-    /**
-     * @param {FabricObject} object
-     * @param {Point} offset
-     */
-    protected layoutObject(context: StrictLayoutContext, { offset }: Required<LayoutResult>, object: FabricObject): void;
-    protected onAfterLayout(context: StrictLayoutContext, layoutResult?: LayoutResult): void;
-    dispose(): void;
-    toObject(): {
-        type: string;
-        strategy: string;
-    };
-    toJSON(): {
-        type: string;
-        strategy: string;
-    };
-}
-//# sourceMappingURL=LayoutManager.d.ts.map

package/dist/src/LayoutManager/LayoutManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LayoutManager.d.ts","sourceRoot":"","sources":["../../../src/LayoutManager/LayoutManager.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAIlE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AASxE,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAMjB,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,qBAAa,aAAa;IACxB,QAAgB,mBAAmB,CAAC,CAAiB;IACrD,UAAkB,cAAc,EAAE,GAAG,CAAC,YAAY,EAAE,YAAY,EAAE,CAAC,CAAC;IAEpE,QAAQ,EAAE,cAAc,CAAC;gBAEb,QAAQ,GAAE,cAAuC;IAKtD,aAAa,CAAC,OAAO,EAAE,aAAa;IAsB3C;;;;;;;OAOG;IACH,SAAS,CAAC,cAAc,CACtB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,GAC1D,YAAY,EAAE;IAmCjB;;;;;OAKG;IACH,SAAS,CAAC,SAAS,CACjB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAO7D;;OAEG;IACH,SAAS,CAAC,WAAW,CACnB,MAAM,EAAE,YAAY,EACpB,QAAQ,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAM/D,kBAAkB,CAChB,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAK7D,gBAAgB,CACd,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAK7D,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,mBAAmB;IAmCrD,SAAS,CAAC,eAAe,CACvB,OAAO,EAAE,mBAAmB,GAC3B,QAAQ,CAAC,YAAY,CAAC,GAAG,SAAS;IAuCrC,SAAS,CAAC,YAAY,CACpB,OAAO,EAAE,mBAAmB,EAC5B,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC;IA4BtC,SAAS,CAAC,aAAa,CACrB,OAAO,EAAE,mBAAmB,EAC5B,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC;IAatC;;;OAGG;IACH,SAAS,CAAC,YAAY,CACpB,OAAO,EAAE,mBAAmB,EAC5B,EAAE,MAAM,EAAE,EAAE,QAAQ,CAAC,YAAY,CAAC,EAClC,MAAM,EAAE,YAAY;IAWtB,SAAS,CAAC,aAAa,CACrB,OAAO,EAAE,mBAAmB,EAC5B,YAAY,CAAC,EAAE,YAAY;IAqC7B,OAAO;IAMP,QAAQ;;;;IAOR,MAAM;;;;CAGP"}

package/dist/src/LayoutManager/LayoutManager.min.mjs

@@ -1,2 +0,0 @@
-import{_defineProperty as e}from"../../_virtual/_@oxc-project_runtime@0.122.0/helpers/defineProperty.min.mjs";import{CENTER as t,CHANGED as n,MODIFIED as r,MODIFY_PATH as i,MODIFY_POLY as a,MOVING as o,RESIZING as s,ROTATING as c,SCALING as l,SKEWING as u,iMatrix as d}from"../constants.min.mjs";import{classRegistry as f}from"../ClassRegistry.min.mjs";import{Point as p}from"../Point.min.mjs";import{invertTransform as m}from"../util/misc/matrix.min.mjs";import{resolveOrigin as h}from"../util/misc/resolveOrigin.min.mjs";import{LAYOUT_TYPE_OBJECT_MODIFIED as g,LAYOUT_TYPE_OBJECT_MODIFYING as _}from"./constants.min.mjs";import{FitContentLayout as v}from"./LayoutStrategies/FitContentLayout.min.mjs";const y=`layoutManager`;var b=class{constructor(t=new v){e(this,`strategy`,void 0),this.strategy=t,this._subscriptions=new Map}performLayout(e){let t={bubbles:!0,strategy:this.strategy,...e,prevStrategy:this._prevLayoutStrategy,stopPropagation(){this.bubbles=!1}};this.onBeforeLayout(t);let n=this.getLayoutResult(t);n&&this.commitLayout(t,n),this.onAfterLayout(t,n),this._prevLayoutStrategy=t.strategy}attachHandlers(e,t){let{target:d}=t;return[r,o,s,c,l,u,n,a,i].map(t=>e.on(t,e=>this.performLayout(t===`modified`?{type:g,trigger:t,e,target:d}:{type:_,trigger:t,e,target:d})))}subscribe(e,t){this.unsubscribe(e,t);let n=this.attachHandlers(e,t);this._subscriptions.set(e,n)}unsubscribe(e,t){(this._subscriptions.get(e)||[]).forEach(e=>e()),this._subscriptions.delete(e)}unsubscribeTargets(e){e.targets.forEach(t=>this.unsubscribe(t,e))}subscribeTargets(e){e.targets.forEach(t=>this.subscribe(t,e))}onBeforeLayout(e){let{target:t,type:n}=e,{canvas:r}=t;if(n===`initialization`||n===`added`?this.subscribeTargets(e):n===`removed`&&this.unsubscribeTargets(e),t.fire(`layout:before`,{context:e}),r&&r.fire(`object:layout:before`,{target:t,context:e}),n===`imperative`&&e.deep){let{strategy:n,...r}=e;t.forEachObject(e=>e.layoutManager&&e.layoutManager.performLayout({...r,bubbles:!1,target:e}))}}getLayoutResult(e){let{target:t,strategy:n,type:r}=e,i=n.calcLayoutResult(e,t.getObjects());if(!i)return;let a=r===`initialization`?new p:t.getRelativeCenterPoint(),{center:o,correction:s=new p,relativeCorrection:c=new p}=i;return{result:i,prevCenter:a,nextCenter:o,offset:a.subtract(o).add(s).transform(r===`initialization`?d:m(t.calcOwnMatrix()),!0).add(c)}}commitLayout(e,n){let{target:r}=e,{result:{size:i},nextCenter:a}=n;var o,s;r.set({width:i.x,height:i.y}),this.layoutObjects(e,n),e.type===`initialization`?r.set({left:(o=e.x)==null?a.x+i.x*h(r.originX):o,top:(s=e.y)==null?a.y+i.y*h(r.originY):s}):(r.setPositionByOrigin(a,t,t),r.setCoords(),r.set(`dirty`,!0))}layoutObjects(e,t){let{target:n}=e;n.forEachObject(r=>{r.group===n&&this.layoutObject(e,t,r)}),e.strategy.shouldLayoutClipPath(e)&&this.layoutObject(e,t,n.clipPath)}layoutObject(e,{offset:t},n){n.set({left:n.left+t.x,top:n.top+t.y})}onAfterLayout(e,t){let{target:n,strategy:r,bubbles:i,prevStrategy:a,...o}=e,{canvas:s}=n;n.fire(`layout:after`,{context:e,result:t}),s&&s.fire(`object:layout:after`,{context:e,result:t,target:n});let c=n.parent;i&&c!=null&&c.layoutManager&&((o.path||(o.path=[])).push(n),c.layoutManager.performLayout({...o,target:c})),n.set(`dirty`,!0)}dispose(){let{_subscriptions:e}=this;e.forEach(e=>e.forEach(e=>e())),e.clear()}toObject(){return{type:y,strategy:this.strategy.constructor.type}}toJSON(){return this.toObject()}};f.setClass(b,y);export{b as LayoutManager};
-//# sourceMappingURL=LayoutManager.min.mjs.map

package/dist/src/LayoutManager/LayoutManager.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"LayoutManager.min.mjs","names":[],"sources":["../../../src/LayoutManager/LayoutManager.ts"],"sourcesContent":["import { Point } from '../Point';\nimport {\n  CENTER,\n  CHANGED,\n  MODIFIED,\n  MODIFY_PATH,\n  MODIFY_POLY,\n  MOVING,\n  RESIZING,\n  ROTATING,\n  SCALING,\n  SKEWING,\n  iMatrix,\n} from '../constants';\nimport type { Group } from '../shapes/Group';\nimport type { FabricObject } from '../shapes/Object/FabricObject';\nimport { invertTransform } from '../util/misc/matrix';\nimport { resolveOrigin } from '../util/misc/resolveOrigin';\nimport { FitContentLayout } from './LayoutStrategies/FitContentLayout';\nimport type { LayoutStrategy } from './LayoutStrategies/LayoutStrategy';\nimport {\n  LAYOUT_TYPE_INITIALIZATION,\n  LAYOUT_TYPE_ADDED,\n  LAYOUT_TYPE_REMOVED,\n  LAYOUT_TYPE_IMPERATIVE,\n  LAYOUT_TYPE_OBJECT_MODIFIED,\n  LAYOUT_TYPE_OBJECT_MODIFYING,\n} from './constants';\nimport type {\n  LayoutContext,\n  LayoutResult,\n  RegistrationContext,\n  StrictLayoutContext,\n} from './types';\nimport { classRegistry } from '../ClassRegistry';\nimport type { TModificationEvents } from '../EventTypeDefs';\n\nconst LAYOUT_MANAGER = 'layoutManager';\n\nexport type SerializedLayoutManager = {\n  type: string;\n  strategy: string;\n};\n\nexport class LayoutManager {\n  declare private _prevLayoutStrategy?: LayoutStrategy;\n  declare protected _subscriptions: Map<FabricObject, VoidFunction[]>;\n\n  strategy: LayoutStrategy;\n\n  constructor(strategy: LayoutStrategy = new FitContentLayout()) {\n    this.strategy = strategy;\n    this._subscriptions = new Map();\n  }\n\n  public performLayout(context: LayoutContext) {\n    const strictContext: StrictLayoutContext = {\n      bubbles: true,\n      strategy: this.strategy,\n      ...context,\n      prevStrategy: this._prevLayoutStrategy,\n      stopPropagation() {\n        this.bubbles = false;\n      },\n    };\n\n    this.onBeforeLayout(strictContext);\n\n    const layoutResult = this.getLayoutResult(strictContext);\n    if (layoutResult) {\n      this.commitLayout(strictContext, layoutResult);\n    }\n\n    this.onAfterLayout(strictContext, layoutResult);\n    this._prevLayoutStrategy = strictContext.strategy;\n  }\n\n  /**\n   * Attach handlers for events that we know will invalidate the layout when\n   * performed on child objects ( general transforms ).\n   * Returns the disposers for later unsubscribing and cleanup\n   * @param {FabricObject} object\n   * @param {RegistrationContext & Partial<StrictLayoutContext>} context\n   * @returns {VoidFunction[]} disposers remove the handlers\n   */\n  protected attachHandlers(\n    object: FabricObject,\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ): VoidFunction[] {\n    const { target } = context;\n    return (\n      [\n        MODIFIED,\n        MOVING,\n        RESIZING,\n        ROTATING,\n        SCALING,\n        SKEWING,\n        CHANGED,\n        MODIFY_POLY,\n        MODIFY_PATH,\n      ] as (TModificationEvents & 'modified')[]\n    ).map((key) =>\n      object.on(key, (e) =>\n        this.performLayout(\n          key === MODIFIED\n            ? {\n                type: LAYOUT_TYPE_OBJECT_MODIFIED,\n                trigger: key,\n                e,\n                target,\n              }\n            : {\n                type: LAYOUT_TYPE_OBJECT_MODIFYING,\n                trigger: key,\n                e,\n                target,\n              },\n        ),\n      ),\n    );\n  }\n\n  /**\n   * Subscribe an object to transform events that will trigger a layout change on the parent\n   * This is important only for interactive groups.\n   * @param object\n   * @param context\n   */\n  protected subscribe(\n    object: FabricObject,\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ) {\n    this.unsubscribe(object, context);\n    const disposers = this.attachHandlers(object, context);\n    this._subscriptions.set(object, disposers);\n  }\n\n  /**\n   * unsubscribe object layout triggers\n   */\n  protected unsubscribe(\n    object: FabricObject,\n    _context?: RegistrationContext & Partial<StrictLayoutContext>,\n  ) {\n    (this._subscriptions.get(object) || []).forEach((d) => d());\n    this._subscriptions.delete(object);\n  }\n\n  unsubscribeTargets(\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ) {\n    context.targets.forEach((object) => this.unsubscribe(object, context));\n  }\n\n  subscribeTargets(\n    context: RegistrationContext & Partial<StrictLayoutContext>,\n  ) {\n    context.targets.forEach((object) => this.subscribe(object, context));\n  }\n\n  protected onBeforeLayout(context: StrictLayoutContext) {\n    const { target, type } = context;\n    const { canvas } = target;\n    // handle layout triggers subscription\n    // @TODO: gate the registration when the group is interactive\n    if (type === LAYOUT_TYPE_INITIALIZATION || type === LAYOUT_TYPE_ADDED) {\n      this.subscribeTargets(context);\n    } else if (type === LAYOUT_TYPE_REMOVED) {\n      this.unsubscribeTargets(context);\n    }\n    // fire layout event (event will fire only for layouts after initialization layout)\n    target.fire('layout:before', {\n      context,\n    });\n    canvas &&\n      canvas.fire('object:layout:before', {\n        target,\n        context,\n      });\n\n    if (type === LAYOUT_TYPE_IMPERATIVE && context.deep) {\n      const { strategy: _, ...tricklingContext } = context;\n      // traverse the tree\n      target.forEachObject(\n        (object) =>\n          (object as Group).layoutManager &&\n          (object as Group).layoutManager.performLayout({\n            ...tricklingContext,\n            bubbles: false,\n            target: object as Group,\n          }),\n      );\n    }\n  }\n\n  protected getLayoutResult(\n    context: StrictLayoutContext,\n  ): Required<LayoutResult> | undefined {\n    const { target, strategy, type } = context;\n\n    const result = strategy.calcLayoutResult(context, target.getObjects());\n\n    if (!result) {\n      return;\n    }\n\n    const prevCenter =\n      type === LAYOUT_TYPE_INITIALIZATION\n        ? new Point()\n        : target.getRelativeCenterPoint();\n\n    const {\n      center: nextCenter,\n      correction = new Point(),\n      relativeCorrection = new Point(),\n    } = result;\n    const offset = prevCenter\n      .subtract(nextCenter)\n      .add(correction)\n      .transform(\n        // in `initialization` we do not account for target's transformation matrix\n        type === LAYOUT_TYPE_INITIALIZATION\n          ? iMatrix\n          : invertTransform(target.calcOwnMatrix()),\n        true,\n      )\n      .add(relativeCorrection);\n\n    return {\n      result,\n      prevCenter,\n      nextCenter,\n      offset,\n    };\n  }\n\n  protected commitLayout(\n    context: StrictLayoutContext,\n    layoutResult: Required<LayoutResult>,\n  ) {\n    const { target } = context;\n    const {\n      result: { size },\n      nextCenter,\n    } = layoutResult;\n    // set dimensions\n    target.set({ width: size.x, height: size.y });\n    // layout descendants\n    this.layoutObjects(context, layoutResult);\n    //  set position\n    // in `initialization` we do not account for target's transformation matrix\n    if (context.type === LAYOUT_TYPE_INITIALIZATION) {\n      // TODO: what about strokeWidth?\n      target.set({\n        left:\n          context.x ?? nextCenter.x + size.x * resolveOrigin(target.originX),\n        top: context.y ?? nextCenter.y + size.y * resolveOrigin(target.originY),\n      });\n    } else {\n      target.setPositionByOrigin(nextCenter, CENTER, CENTER);\n      // invalidate\n      target.setCoords();\n      target.set('dirty', true);\n    }\n  }\n\n  protected layoutObjects(\n    context: StrictLayoutContext,\n    layoutResult: Required<LayoutResult>,\n  ) {\n    const { target } = context;\n    //  adjust objects to account for new center\n    target.forEachObject((object) => {\n      object.group === target &&\n        this.layoutObject(context, layoutResult, object);\n    });\n    // adjust clip path to account for new center\n    context.strategy.shouldLayoutClipPath(context) &&\n      this.layoutObject(context, layoutResult, target.clipPath as FabricObject);\n  }\n\n  /**\n   * @param {FabricObject} object\n   * @param {Point} offset\n   */\n  protected layoutObject(\n    context: StrictLayoutContext,\n    { offset }: Required<LayoutResult>,\n    object: FabricObject,\n  ) {\n    // TODO: this is here for cache invalidation.\n    // verify if this is necessary since we have explicit\n    // cache invalidation at the end of commitLayout\n    object.set({\n      left: object.left + offset.x,\n      top: object.top + offset.y,\n    });\n  }\n\n  protected onAfterLayout(\n    context: StrictLayoutContext,\n    layoutResult?: LayoutResult,\n  ) {\n    const {\n      target,\n      strategy,\n      bubbles,\n      prevStrategy: _,\n      ...bubblingContext\n    } = context;\n    const { canvas } = target;\n\n    //  fire layout event (event will fire only for layouts after initialization layout)\n    target.fire('layout:after', {\n      context,\n      result: layoutResult,\n    });\n    canvas &&\n      canvas.fire('object:layout:after', {\n        context,\n        result: layoutResult,\n        target,\n      });\n\n    //  bubble\n    const parent = target.parent;\n    if (bubbles && parent?.layoutManager) {\n      //  add target to context#path\n      (bubblingContext.path || (bubblingContext.path = [])).push(target);\n      //  all parents should invalidate their layout\n      parent.layoutManager.performLayout({\n        ...bubblingContext,\n        target: parent,\n      });\n    }\n    target.set('dirty', true);\n  }\n\n  dispose() {\n    const { _subscriptions } = this;\n    _subscriptions.forEach((disposers) => disposers.forEach((d) => d()));\n    _subscriptions.clear();\n  }\n\n  toObject() {\n    return {\n      type: LAYOUT_MANAGER,\n      strategy: (this.strategy.constructor as typeof LayoutStrategy).type,\n    };\n  }\n\n  toJSON() {\n    return this.toObject();\n  }\n}\n\nclassRegistry.setClass(LayoutManager, LAYOUT_MANAGER);\n"],"mappings":"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"}

package/dist/src/LayoutManager/LayoutManager.mjs

@@ -1,199 +0,0 @@
-import { _defineProperty } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/defineProperty.mjs";
-import { CENTER, CHANGED, MODIFIED, MODIFY_PATH, MODIFY_POLY, MOVING, RESIZING, ROTATING, SCALING, SKEWING, iMatrix } from "../constants.mjs";
-import { classRegistry } from "../ClassRegistry.mjs";
-import { Point } from "../Point.mjs";
-import { invertTransform } from "../util/misc/matrix.mjs";
-import { resolveOrigin } from "../util/misc/resolveOrigin.mjs";
-import { LAYOUT_TYPE_OBJECT_MODIFIED, LAYOUT_TYPE_OBJECT_MODIFYING } from "./constants.mjs";
-import { FitContentLayout } from "./LayoutStrategies/FitContentLayout.mjs";
-//#region src/LayoutManager/LayoutManager.ts
-const LAYOUT_MANAGER = "layoutManager";
-var LayoutManager = class {
-	constructor(strategy = new FitContentLayout()) {
-		_defineProperty(this, "strategy", void 0);
-		this.strategy = strategy;
-		this._subscriptions = /* @__PURE__ */ new Map();
-	}
-	performLayout(context) {
-		const strictContext = {
-			bubbles: true,
-			strategy: this.strategy,
-			...context,
-			prevStrategy: this._prevLayoutStrategy,
-			stopPropagation() {
-				this.bubbles = false;
-			}
-		};
-		this.onBeforeLayout(strictContext);
-		const layoutResult = this.getLayoutResult(strictContext);
-		if (layoutResult) this.commitLayout(strictContext, layoutResult);
-		this.onAfterLayout(strictContext, layoutResult);
-		this._prevLayoutStrategy = strictContext.strategy;
-	}
-	/**
-	* Attach handlers for events that we know will invalidate the layout when
-	* performed on child objects ( general transforms ).
-	* Returns the disposers for later unsubscribing and cleanup
-	* @param {FabricObject} object
-	* @param {RegistrationContext & Partial<StrictLayoutContext>} context
-	* @returns {VoidFunction[]} disposers remove the handlers
-	*/
-	attachHandlers(object, context) {
-		const { target } = context;
-		return [
-			MODIFIED,
-			MOVING,
-			RESIZING,
-			ROTATING,
-			SCALING,
-			SKEWING,
-			CHANGED,
-			MODIFY_POLY,
-			MODIFY_PATH
-		].map((key) => object.on(key, (e) => this.performLayout(key === "modified" ? {
-			type: LAYOUT_TYPE_OBJECT_MODIFIED,
-			trigger: key,
-			e,
-			target
-		} : {
-			type: LAYOUT_TYPE_OBJECT_MODIFYING,
-			trigger: key,
-			e,
-			target
-		})));
-	}
-	/**
-	* Subscribe an object to transform events that will trigger a layout change on the parent
-	* This is important only for interactive groups.
-	* @param object
-	* @param context
-	*/
-	subscribe(object, context) {
-		this.unsubscribe(object, context);
-		const disposers = this.attachHandlers(object, context);
-		this._subscriptions.set(object, disposers);
-	}
-	/**
-	* unsubscribe object layout triggers
-	*/
-	unsubscribe(object, _context) {
-		(this._subscriptions.get(object) || []).forEach((d) => d());
-		this._subscriptions.delete(object);
-	}
-	unsubscribeTargets(context) {
-		context.targets.forEach((object) => this.unsubscribe(object, context));
-	}
-	subscribeTargets(context) {
-		context.targets.forEach((object) => this.subscribe(object, context));
-	}
-	onBeforeLayout(context) {
-		const { target, type } = context;
-		const { canvas } = target;
-		if (type === "initialization" || type === "added") this.subscribeTargets(context);
-		else if (type === "removed") this.unsubscribeTargets(context);
-		target.fire("layout:before", { context });
-		canvas && canvas.fire("object:layout:before", {
-			target,
-			context
-		});
-		if (type === "imperative" && context.deep) {
-			const { strategy: _, ...tricklingContext } = context;
-			target.forEachObject((object) => object.layoutManager && object.layoutManager.performLayout({
-				...tricklingContext,
-				bubbles: false,
-				target: object
-			}));
-		}
-	}
-	getLayoutResult(context) {
-		const { target, strategy, type } = context;
-		const result = strategy.calcLayoutResult(context, target.getObjects());
-		if (!result) return;
-		const prevCenter = type === "initialization" ? new Point() : target.getRelativeCenterPoint();
-		const { center: nextCenter, correction = new Point(), relativeCorrection = new Point() } = result;
-		return {
-			result,
-			prevCenter,
-			nextCenter,
-			offset: prevCenter.subtract(nextCenter).add(correction).transform(type === "initialization" ? iMatrix : invertTransform(target.calcOwnMatrix()), true).add(relativeCorrection)
-		};
-	}
-	commitLayout(context, layoutResult) {
-		const { target } = context;
-		const { result: { size }, nextCenter } = layoutResult;
-		target.set({
-			width: size.x,
-			height: size.y
-		});
-		this.layoutObjects(context, layoutResult);
-		if (context.type === "initialization") {
-			var _context$x, _context$y;
-			target.set({
-				left: (_context$x = context.x) !== null && _context$x !== void 0 ? _context$x : nextCenter.x + size.x * resolveOrigin(target.originX),
-				top: (_context$y = context.y) !== null && _context$y !== void 0 ? _context$y : nextCenter.y + size.y * resolveOrigin(target.originY)
-			});
-		} else {
-			target.setPositionByOrigin(nextCenter, CENTER, CENTER);
-			target.setCoords();
-			target.set("dirty", true);
-		}
-	}
-	layoutObjects(context, layoutResult) {
-		const { target } = context;
-		target.forEachObject((object) => {
-			object.group === target && this.layoutObject(context, layoutResult, object);
-		});
-		context.strategy.shouldLayoutClipPath(context) && this.layoutObject(context, layoutResult, target.clipPath);
-	}
-	/**
-	* @param {FabricObject} object
-	* @param {Point} offset
-	*/
-	layoutObject(context, { offset }, object) {
-		object.set({
-			left: object.left + offset.x,
-			top: object.top + offset.y
-		});
-	}
-	onAfterLayout(context, layoutResult) {
-		const { target, strategy, bubbles, prevStrategy: _, ...bubblingContext } = context;
-		const { canvas } = target;
-		target.fire("layout:after", {
-			context,
-			result: layoutResult
-		});
-		canvas && canvas.fire("object:layout:after", {
-			context,
-			result: layoutResult,
-			target
-		});
-		const parent = target.parent;
-		if (bubbles && (parent === null || parent === void 0 ? void 0 : parent.layoutManager)) {
-			(bubblingContext.path || (bubblingContext.path = [])).push(target);
-			parent.layoutManager.performLayout({
-				...bubblingContext,
-				target: parent
-			});
-		}
-		target.set("dirty", true);
-	}
-	dispose() {
-		const { _subscriptions } = this;
-		_subscriptions.forEach((disposers) => disposers.forEach((d) => d()));
-		_subscriptions.clear();
-	}
-	toObject() {
-		return {
-			type: LAYOUT_MANAGER,
-			strategy: this.strategy.constructor.type
-		};
-	}
-	toJSON() {
-		return this.toObject();
-	}
-};
-classRegistry.setClass(LayoutManager, LAYOUT_MANAGER);
-//#endregion
-export { LayoutManager };
-
-//# sourceMappingURL=LayoutManager.mjs.map