@nasser-sw/fabric 7.0.0-beta1

package/dist/src/Intersection.mjs

@@ -0,0 +1,257 @@
+import { Point } from './Point.mjs';
+import { createVector } from './util/misc/vectors.mjs';
+
+/* Adaptation of work of Kevin Lindsey (kevin@kevlindev.com) */
+
+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() {
+    for (var _len = arguments.length, points = new Array(_len), _key = 0; _key < _len; _key++) {
+      points[_key] = arguments[_key];
+    }
+    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) {
+    let infinite = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    if (A.eq(B)) {
+      // Edge case: the segment is a point, we check for coincidence,
+      // infinite param has no meaning because there are infinite lines to consider
+      return T.eq(A);
+    } else if (A.x === B.x) {
+      // Edge case: horizontal line.
+      // we first check if T.x has the same value, and then if T.y is contained between A.y and B.y
+      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) {
+      // Edge case: vertical line.
+      // we first check if T.y has the same value, and then if T.x is contained between A.x and B.x
+      return T.y === A.y && (infinite || T.x >= Math.min(A.x, B.x) && T.x <= Math.max(A.x, B.x));
+    } else {
+      // Generic case: sloped line.
+      // we check that AT has the same slope as AB
+      // for the segment case we need both the vectors to have the same direction and for AT to be lte AB in size
+      // for the infinite case we check the absolute value of the slope, since direction is meaningless
+      const AB = createVector(A, B);
+      const AT = createVector(A, T);
+      const s = AT.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(
+      // polygon side
+      points[index], points[(index + 1) % points.length],
+      // ray
+      point, other);
+      if (inter.includes(point)) {
+        // point is on the polygon side
+        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) {
+    let aInfinite = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+    let bInfinite = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 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) {
+        const segmentsCoincide = aInfinite || bInfinite || Intersection.isPointContained(a1, b1, b2) || Intersection.isPointContained(a2, b1, b2) || Intersection.isPointContained(b1, a1, a2) || Intersection.isPointContained(b2, a1, a2);
+        return new Intersection(segmentsCoincide ? 'Coincident' : undefined);
+      } 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) {
+    let infinite = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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]);
+  }
+}
+
+export { Intersection };
+//# sourceMappingURL=Intersection.mjs.map

package/dist/src/Intersection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Intersection.mjs","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"],"names":["Intersection","constructor","status","points","includes","point","some","p","eq","append","_len","arguments","length","Array","_key","concat","filter","isPointContained","T","A","B","infinite","undefined","x","y","Math","min","max","AB","createVector","AT","s","divide","abs","isPointInPolygon","other","Point","setX","map","hits","index","inter","intersectSegmentSegment","Number","intersectLineLine","a1","a2","b1","b2","aInfinite","bInfinite","a2xa1x","a2ya1y","b2xb1x","b2yb1y","a1xb1x","a1yb1y","uaT","ubT","uB","ua","ub","segmentsCoincide","intersectSegmentLine","s1","s2","l1","l2","intersectLinePolygon","result","i","intersectSegmentPolygon","intersectPolygonPolygon","points1","points2","coincidences","push","intersectPolygonRectangle","r1","r2","topRight","bottomLeft"],"mappings":";;;AAGA;;AAIO,MAAMA,YAAY,CAAC;EAKxBC,WAAWA,CAACC,MAAyB,EAAE;IACrC,IAAI,CAACA,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,MAAM,GAAG,EAAE;AAClB,EAAA;;AAEA;AACF;AACA;AACA;AACA;EACUC,QAAQA,CAACC,KAAY,EAAW;AACtC,IAAA,OAAO,IAAI,CAACF,MAAM,CAACG,IAAI,CAAEC,CAAC,IAAKA,CAAC,CAACC,EAAE,CAACH,KAAK,CAAC,CAAC;AAC7C,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACUI,EAAAA,MAAMA,GAAmC;AAAA,IAAA,KAAA,IAAAC,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAA/BT,MAAM,GAAA,IAAAU,KAAA,CAAAH,IAAA,GAAAI,IAAA,GAAA,CAAA,EAAAA,IAAA,GAAAJ,IAAA,EAAAI,IAAA,EAAA,EAAA;AAANX,MAAAA,MAAM,CAAAW,IAAA,CAAA,GAAAH,SAAA,CAAAG,IAAA,CAAA;AAAA,IAAA;AACtB,IAAA,IAAI,CAACX,MAAM,GAAG,IAAI,CAACA,MAAM,CAACY,MAAM,CAC9BZ,MAAM,CAACa,MAAM,CAAEX,KAAK,IAAK;AACvB,MAAA,OAAO,CAAC,IAAI,CAACD,QAAQ,CAACC,KAAK,CAAC;AAC9B,IAAA,CAAC,CACH,CAAC;AACD,IAAA,OAAO,IAAI;AACb,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE,EAAA,OAAOY,gBAAgBA,CAACC,CAAQ,EAAEC,CAAQ,EAAEC,CAAQ,EAAoB;AAAA,IAAA,IAAlBC,QAAQ,GAAAV,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAW,SAAA,GAAAX,SAAA,CAAA,CAAA,CAAA,GAAG,KAAK;AACpE,IAAA,IAAIQ,CAAC,CAACX,EAAE,CAACY,CAAC,CAAC,EAAE;AACX;AACA;AACA,MAAA,OAAOF,CAAC,CAACV,EAAE,CAACW,CAAC,CAAC;IAChB,CAAC,MAAM,IAAIA,CAAC,CAACI,CAAC,KAAKH,CAAC,CAACG,CAAC,EAAE;AACtB;AACA;AACA,MAAA,OACEL,CAAC,CAACK,CAAC,KAAKJ,CAAC,CAACI,CAAC,KACVF,QAAQ,IAAKH,CAAC,CAACM,CAAC,IAAIC,IAAI,CAACC,GAAG,CAACP,CAAC,CAACK,CAAC,EAAEJ,CAAC,CAACI,CAAC,CAAC,IAAIN,CAAC,CAACM,CAAC,IAAIC,IAAI,CAACE,GAAG,CAACR,CAAC,CAACK,CAAC,EAAEJ,CAAC,CAACI,CAAC,CAAE,CAAC;IAE1E,CAAC,MAAM,IAAIL,CAAC,CAACK,CAAC,KAAKJ,CAAC,CAACI,CAAC,EAAE;AACtB;AACA;AACA,MAAA,OACEN,CAAC,CAACM,CAAC,KAAKL,CAAC,CAACK,CAAC,KACVH,QAAQ,IAAKH,CAAC,CAACK,CAAC,IAAIE,IAAI,CAACC,GAAG,CAACP,CAAC,CAACI,CAAC,EAAEH,CAAC,CAACG,CAAC,CAAC,IAAIL,CAAC,CAACK,CAAC,IAAIE,IAAI,CAACE,GAAG,CAACR,CAAC,CAACI,CAAC,EAAEH,CAAC,CAACG,CAAC,CAAE,CAAC;AAE1E,IAAA,CAAC,MAAM;AACL;AACA;AACA;AACA;AACA,MAAA,MAAMK,EAAE,GAAGC,YAAY,CAACV,CAAC,EAAEC,CAAC,CAAC;AAC7B,MAAA,MAAMU,EAAE,GAAGD,YAAY,CAACV,CAAC,EAAED,CAAC,CAAC;AAC7B,MAAA,MAAMa,CAAC,GAAGD,EAAE,CAACE,MAAM,CAACJ,EAAE,CAAC;AACvB,MAAA,OAAOP,QAAQ,GACXI,IAAI,CAACQ,GAAG,CAACF,CAAC,CAACR,CAAC,CAAC,KAAKE,IAAI,CAACQ,GAAG,CAACF,CAAC,CAACP,CAAC,CAAC,GAC/BO,CAAC,CAACR,CAAC,KAAKQ,CAAC,CAACP,CAAC,IAAIO,CAAC,CAACR,CAAC,IAAI,CAAC,IAAIQ,CAAC,CAACR,CAAC,IAAI,CAAC;AACzC,IAAA;AACF,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACE,EAAA,OAAOW,gBAAgBA,CAAC7B,KAAY,EAAEF,MAAe,EAAE;AACrD,IAAA,MAAMgC,KAAK,GAAG,IAAIC,KAAK,CAAC/B,KAAK,CAAC,CAACgC,IAAI,CACjCZ,IAAI,CAACC,GAAG,CAACrB,KAAK,CAACkB,CAAC,GAAG,CAAC,EAAE,GAAGpB,MAAM,CAACmC,GAAG,CAAE/B,CAAC,IAAKA,CAAC,CAACgB,CAAC,CAAC,CACjD,CAAC;IACD,IAAIgB,IAAI,GAAG,CAAC;AACZ,IAAA,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGrC,MAAM,CAACS,MAAM,EAAE4B,KAAK,EAAE,EAAE;AAClD,MAAA,MAAMC,KAAK,GAAG,IAAI,CAACC,uBAAuB;AACxC;AACAvC,MAAAA,MAAM,CAACqC,KAAK,CAAC,EACbrC,MAAM,CAAC,CAACqC,KAAK,GAAG,CAAC,IAAIrC,MAAM,CAACS,MAAM,CAAC;AACnC;MACAP,KAAK,EACL8B,KACF,CAAC;AACD,MAAA,IAAIM,KAAK,CAACrC,QAAQ,CAACC,KAAK,CAAC,EAAE;AACzB;AACA,QAAA,OAAO,IAAI;AACb,MAAA;MACAkC,IAAI,IAAII,MAAM,CAACF,KAAK,CAACvC,MAAM,KAAK,cAAc,CAAC;AACjD,IAAA;AACA,IAAA,OAAOqC,IAAI,GAAG,CAAC,KAAK,CAAC;AACvB,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,OAAOK,iBAAiBA,CACtBC,EAAS,EACTC,EAAS,EACTC,EAAS,EACTC,EAAS,EAGK;AAAA,IAAA,IAFdC,SAAS,GAAAtC,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAW,SAAA,GAAAX,SAAA,CAAA,CAAA,CAAA,GAAG,IAAI;AAAA,IAAA,IAChBuC,SAAS,GAAAvC,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAW,SAAA,GAAAX,SAAA,CAAA,CAAA,CAAA,GAAG,IAAI;IAEhB,MAAMwC,MAAM,GAAGL,EAAE,CAACvB,CAAC,GAAGsB,EAAE,CAACtB,CAAC;AACxB6B,MAAAA,MAAM,GAAGN,EAAE,CAACtB,CAAC,GAAGqB,EAAE,CAACrB,CAAC;AACpB6B,MAAAA,MAAM,GAAGL,EAAE,CAACzB,CAAC,GAAGwB,EAAE,CAACxB,CAAC;AACpB+B,MAAAA,MAAM,GAAGN,EAAE,CAACxB,CAAC,GAAGuB,EAAE,CAACvB,CAAC;AACpB+B,MAAAA,MAAM,GAAGV,EAAE,CAACtB,CAAC,GAAGwB,EAAE,CAACxB,CAAC;AACpBiC,MAAAA,MAAM,GAAGX,EAAE,CAACrB,CAAC,GAAGuB,EAAE,CAACvB,CAAC;AACpBiC,MAAAA,GAAG,GAAGJ,MAAM,GAAGG,MAAM,GAAGF,MAAM,GAAGC,MAAM;AACvCG,MAAAA,GAAG,GAAGP,MAAM,GAAGK,MAAM,GAAGJ,MAAM,GAAGG,MAAM;AACvCI,MAAAA,EAAE,GAAGL,MAAM,GAAGH,MAAM,GAAGE,MAAM,GAAGD,MAAM;IACxC,IAAIO,EAAE,KAAK,CAAC,EAAE;AACZ,MAAA,MAAMC,EAAE,GAAGH,GAAG,GAAGE,EAAE;QACjBE,EAAE,GAAGH,GAAG,GAAGC,EAAE;MACf,IACE,CAACV,SAAS,IAAK,CAAC,IAAIW,EAAE,IAAIA,EAAE,IAAI,CAAE,MACjCV,SAAS,IAAK,CAAC,IAAIW,EAAE,IAAIA,EAAE,IAAI,CAAE,CAAC,EACnC;QACA,OAAO,IAAI7D,YAAY,CAAC,cAAc,CAAC,CAACS,MAAM,CAC5C,IAAI2B,KAAK,CAACS,EAAE,CAACtB,CAAC,GAAGqC,EAAE,GAAGT,MAAM,EAAEN,EAAE,CAACrB,CAAC,GAAGoC,EAAE,GAAGR,MAAM,CAClD,CAAC;AACH,MAAA,CAAC,MAAM;QACL,OAAO,IAAIpD,YAAY,EAAE;AAC3B,MAAA;AACF,IAAA,CAAC,MAAM;AACL,MAAA,IAAIyD,GAAG,KAAK,CAAC,IAAIC,GAAG,KAAK,CAAC,EAAE;QAC1B,MAAMI,gBAAgB,GACpBb,SAAS,IACTC,SAAS,IACTlD,YAAY,CAACiB,gBAAgB,CAAC4B,EAAE,EAAEE,EAAE,EAAEC,EAAE,CAAC,IACzChD,YAAY,CAACiB,gBAAgB,CAAC6B,EAAE,EAAEC,EAAE,EAAEC,EAAE,CAAC,IACzChD,YAAY,CAACiB,gBAAgB,CAAC8B,EAAE,EAAEF,EAAE,EAAEC,EAAE,CAAC,IACzC9C,YAAY,CAACiB,gBAAgB,CAAC+B,EAAE,EAAEH,EAAE,EAAEC,EAAE,CAAC;QAC3C,OAAO,IAAI9C,YAAY,CAAC8D,gBAAgB,GAAG,YAAY,GAAGxC,SAAS,CAAC;AACtE,MAAA,CAAC,MAAM;AACL,QAAA,OAAO,IAAItB,YAAY,CAAC,UAAU,CAAC;AACrC,MAAA;AACF,IAAA;AACF,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,OAAO+D,oBAAoBA,CACzBC,EAAS,EACTC,EAAS,EACTC,EAAS,EACTC,EAAS,EACK;AACd,IAAA,OAAOnE,YAAY,CAAC4C,iBAAiB,CAACoB,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC;AACpE,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,OAAOzB,uBAAuBA,CAC5BG,EAAS,EACTC,EAAS,EACTC,EAAS,EACTC,EAAS,EACK;AACd,IAAA,OAAOhD,YAAY,CAAC4C,iBAAiB,CAACC,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC;AACrE,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE,EAAA,OAAOoB,oBAAoBA,CACzBvB,EAAS,EACTC,EAAS,EACT3C,MAAe,EAED;AAAA,IAAA,IADdkB,QAAQ,GAAAV,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAW,SAAA,GAAAX,SAAA,CAAA,CAAA,CAAA,GAAG,IAAI;AAEf,IAAA,MAAM0D,MAAM,GAAG,IAAIrE,YAAY,EAAE;AACjC,IAAA,MAAMY,MAAM,GAAGT,MAAM,CAACS,MAAM;AAE5B,IAAA,KAAK,IAAI0D,CAAC,GAAG,CAAC,EAAEvB,EAAE,EAAEC,EAAE,EAAEP,KAAK,EAAE6B,CAAC,GAAG1D,MAAM,EAAE0D,CAAC,EAAE,EAAE;AAC9CvB,MAAAA,EAAE,GAAG5C,MAAM,CAACmE,CAAC,CAAC;MACdtB,EAAE,GAAG7C,MAAM,CAAC,CAACmE,CAAC,GAAG,CAAC,IAAI1D,MAAM,CAAC;AAC7B6B,MAAAA,KAAK,GAAGzC,YAAY,CAAC4C,iBAAiB,CAACC,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAE3B,QAAQ,EAAE,KAAK,CAAC;AACvE,MAAA,IAAIoB,KAAK,CAACvC,MAAM,KAAK,YAAY,EAAE;AACjC,QAAA,OAAOuC,KAAK;AACd,MAAA;AACA4B,MAAAA,MAAM,CAAC5D,MAAM,CAAC,GAAGgC,KAAK,CAACtC,MAAM,CAAC;AAChC,IAAA;AAEA,IAAA,IAAIkE,MAAM,CAAClE,MAAM,CAACS,MAAM,GAAG,CAAC,EAAE;MAC5ByD,MAAM,CAACnE,MAAM,GAAG,cAAc;AAChC,IAAA;AAEA,IAAA,OAAOmE,MAAM;AACf,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACE,EAAA,OAAOE,uBAAuBA,CAC5B1B,EAAS,EACTC,EAAS,EACT3C,MAAe,EACD;IACd,OAAOH,YAAY,CAACoE,oBAAoB,CAACvB,EAAE,EAAEC,EAAE,EAAE3C,MAAM,EAAE,KAAK,CAAC;AACjE,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE,EAAA,OAAOqE,uBAAuBA,CAC5BC,OAAgB,EAChBC,OAAgB,EACF;AACd,IAAA,MAAML,MAAM,GAAG,IAAIrE,YAAY,EAAE;MAC/BY,MAAM,GAAG6D,OAAO,CAAC7D,MAAM;IACzB,MAAM+D,YAA4B,GAAG,EAAE;IAEvC,KAAK,IAAIL,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG1D,MAAM,EAAE0D,CAAC,EAAE,EAAE;AAC/B,MAAA,MAAMzB,EAAE,GAAG4B,OAAO,CAACH,CAAC,CAAC;QACnBxB,EAAE,GAAG2B,OAAO,CAAC,CAACH,CAAC,GAAG,CAAC,IAAI1D,MAAM,CAAC;QAC9B6B,KAAK,GAAGzC,YAAY,CAACuE,uBAAuB,CAAC1B,EAAE,EAAEC,EAAE,EAAE4B,OAAO,CAAC;AAC/D,MAAA,IAAIjC,KAAK,CAACvC,MAAM,KAAK,YAAY,EAAE;AACjCyE,QAAAA,YAAY,CAACC,IAAI,CAACnC,KAAK,CAAC;AACxB4B,QAAAA,MAAM,CAAC5D,MAAM,CAACoC,EAAE,EAAEC,EAAE,CAAC;AACvB,MAAA,CAAC,MAAM;AACLuB,QAAAA,MAAM,CAAC5D,MAAM,CAAC,GAAGgC,KAAK,CAACtC,MAAM,CAAC;AAChC,MAAA;AACF,IAAA;AAEA,IAAA,IAAIwE,YAAY,CAAC/D,MAAM,GAAG,CAAC,IAAI+D,YAAY,CAAC/D,MAAM,KAAK6D,OAAO,CAAC7D,MAAM,EAAE;AACrE,MAAA,OAAO,IAAIZ,YAAY,CAAC,YAAY,CAAC;IACvC,CAAC,MAAM,IAAIqE,MAAM,CAAClE,MAAM,CAACS,MAAM,GAAG,CAAC,EAAE;MACnCyD,MAAM,CAACnE,MAAM,GAAG,cAAc;AAChC,IAAA;AAEA,IAAA,OAAOmE,MAAM;AACf,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACE,EAAA,OAAOQ,yBAAyBA,CAC9B1E,MAAe,EACf2E,EAAS,EACTC,EAAS,EACK;AACd,IAAA,MAAMrD,GAAG,GAAGoD,EAAE,CAACpD,GAAG,CAACqD,EAAE,CAAC;AACpBpD,MAAAA,GAAG,GAAGmD,EAAE,CAACnD,GAAG,CAACoD,EAAE,CAAC;MAChBC,QAAQ,GAAG,IAAI5C,KAAK,CAACT,GAAG,CAACJ,CAAC,EAAEG,GAAG,CAACF,CAAC,CAAC;MAClCyD,UAAU,GAAG,IAAI7C,KAAK,CAACV,GAAG,CAACH,CAAC,EAAEI,GAAG,CAACH,CAAC,CAAC;AAEtC,IAAA,OAAOxB,YAAY,CAACwE,uBAAuB,CAACrE,MAAM,EAAE,CAClDuB,GAAG,EACHsD,QAAQ,EACRrD,GAAG,EACHsD,UAAU,CACX,CAAC;AACJ,EAAA;AACF;;;;"}

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,2 @@
+import{LayoutManager as e}from"./LayoutManager.min.mjs";class t extends e{subscribeTargets(e){const 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){const t=e.target,a=t.getObjects();e.targets.reduce((e,t)=>(t.parent&&e.add(t.parent),e),new Set).forEach(e=>{!a.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

@@ -0,0 +1 @@
+{"version":3,"file":"ActiveSelectionLayoutManager.min.mjs","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"],"names":["ActiveSelectionLayoutManager","LayoutManager","subscribeTargets","context","activeSelection","target","targets","reduce","parents","parent","add","Set","forEach","layoutManager","unsubscribeTargets","selectedObjects","getObjects","some","object"],"mappings":"wDAgBO,MAAMA,UAAqCC,EAChDC,gBAAAA,CACEC,GAEA,MAAMC,EAAkBD,EAAQE,OAChBF,EAAQG,QAAQC,OAAO,CAACC,EAASH,KAC/CA,EAAOI,QAAUD,EAAQE,IAAIL,EAAOI,QAC7BD,GACN,IAAIG,KACCC,QAASH,IACfA,EAAOI,cAAcX,iBAAiB,CACpCG,OAAQI,EACRH,QAAS,CAACF,MAGhB,CAKAU,kBAAAA,CACEX,GAEA,MAAMC,EAAkBD,EAAQE,OAC1BU,EAAkBX,EAAgBY,aACxBb,EAAQG,QAAQC,OAAO,CAACC,EAASH,KAC/CA,EAAOI,QAAUD,EAAQE,IAAIL,EAAOI,QAC7BD,GACN,IAAIG,KACCC,QAASH,KACdM,EAAgBE,KAAMC,GAAWA,EAAOT,SAAWA,IAClDA,EAAOI,cAAcC,mBAAmB,CACtCT,OAAQI,EACRH,QAAS,CAACF,MAGlB"}

package/dist/src/LayoutManager/ActiveSelectionLayoutManager.mjs

@@ -0,0 +1,50 @@
+import { LayoutManager } from './LayoutManager.mjs';
+
+/**
+ * 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.`
+ */
+class ActiveSelectionLayoutManager extends LayoutManager {
+  subscribeTargets(context) {
+    const activeSelection = context.target;
+    const parents = context.targets.reduce((parents, target) => {
+      target.parent && parents.add(target.parent);
+      return parents;
+    }, new Set());
+    parents.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();
+    const parents = context.targets.reduce((parents, target) => {
+      target.parent && parents.add(target.parent);
+      return parents;
+    }, new Set());
+    parents.forEach(parent => {
+      !selectedObjects.some(object => object.parent === parent) && parent.layoutManager.unsubscribeTargets({
+        target: parent,
+        targets: [activeSelection]
+      });
+    });
+  }
+}
+
+export { ActiveSelectionLayoutManager };
+//# sourceMappingURL=ActiveSelectionLayoutManager.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ActiveSelectionLayoutManager.mjs","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"],"names":["ActiveSelectionLayoutManager","LayoutManager","subscribeTargets","context","activeSelection","target","parents","targets","reduce","parent","add","Set","forEach","layoutManager","unsubscribeTargets","selectedObjects","getObjects","some","object"],"mappings":";;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,4BAA4B,SAASC,aAAa,CAAC;EAC9DC,gBAAgBA,CACdC,OAA2D,EACrD;AACN,IAAA,MAAMC,eAAe,GAAGD,OAAO,CAACE,MAAM;AACtC,IAAA,MAAMC,OAAO,GAAGH,OAAO,CAACI,OAAO,CAACC,MAAM,CAAC,CAACF,OAAO,EAAED,MAAM,KAAK;MAC1DA,MAAM,CAACI,MAAM,IAAIH,OAAO,CAACI,GAAG,CAACL,MAAM,CAACI,MAAM,CAAC;AAC3C,MAAA,OAAOH,OAAO;AAChB,IAAA,CAAC,EAAE,IAAIK,GAAG,EAAS,CAAC;AACpBL,IAAAA,OAAO,CAACM,OAAO,CAAEH,MAAM,IAAK;AAC1BA,MAAAA,MAAM,CAACI,aAAa,CAACX,gBAAgB,CAAC;AACpCG,QAAAA,MAAM,EAAEI,MAAM;QACdF,OAAO,EAAE,CAACH,eAAe;AAC3B,OAAC,CAAC;AACJ,IAAA,CAAC,CAAC;AACJ,EAAA;;AAEA;AACF;AACA;EACEU,kBAAkBA,CAChBX,OAA2D,EACrD;AACN,IAAA,MAAMC,eAAe,GAAGD,OAAO,CAACE,MAAM;AACtC,IAAA,MAAMU,eAAe,GAAGX,eAAe,CAACY,UAAU,EAAE;AACpD,IAAA,MAAMV,OAAO,GAAGH,OAAO,CAACI,OAAO,CAACC,MAAM,CAAC,CAACF,OAAO,EAAED,MAAM,KAAK;MAC1DA,MAAM,CAACI,MAAM,IAAIH,OAAO,CAACI,GAAG,CAACL,MAAM,CAACI,MAAM,CAAC;AAC3C,MAAA,OAAOH,OAAO;AAChB,IAAA,CAAC,EAAE,IAAIK,GAAG,EAAS,CAAC;AACpBL,IAAAA,OAAO,CAACM,OAAO,CAAEH,MAAM,IAAK;AAC1B,MAAA,CAACM,eAAe,CAACE,IAAI,CAAEC,MAAM,IAAKA,MAAM,CAACT,MAAM,KAAKA,MAAM,CAAC,IACzDA,MAAM,CAACI,aAAa,CAACC,kBAAkB,CAAC;AACtCT,QAAAA,MAAM,EAAEI,MAAM;QACdF,OAAO,EAAE,CAACH,eAAe;AAC3B,OAAC,CAAC;AACN,IAAA,CAAC,CAAC;AACJ,EAAA;AACF;;;;"}

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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutManager.min.mjs","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"],"names":["LAYOUT_MANAGER","LayoutManager","constructor","strategy","arguments","length","undefined","FitContentLayout","_defineProperty","this","_subscriptions","Map","performLayout","context","strictContext","bubbles","prevStrategy","_prevLayoutStrategy","stopPropagation","onBeforeLayout","layoutResult","getLayoutResult","commitLayout","onAfterLayout","attachHandlers","object","target","MODIFIED","MOVING","RESIZING","ROTATING","SCALING","SKEWING","CHANGED","MODIFY_POLY","MODIFY_PATH","map","key","on","e","type","LAYOUT_TYPE_OBJECT_MODIFIED","trigger","LAYOUT_TYPE_OBJECT_MODIFYING","subscribe","unsubscribe","disposers","set","_context","get","forEach","d","delete","unsubscribeTargets","targets","subscribeTargets","canvas","LAYOUT_TYPE_INITIALIZATION","LAYOUT_TYPE_ADDED","LAYOUT_TYPE_REMOVED","fire","LAYOUT_TYPE_IMPERATIVE","deep","_","tricklingContext","forEachObject","layoutManager","result","calcLayoutResult","getObjects","prevCenter","Point","getRelativeCenterPoint","center","nextCenter","correction","relativeCorrection","offset","subtract","add","transform","iMatrix","invertTransform","calcOwnMatrix","size","_context$x","_context$y","width","x","height","y","layoutObjects","left","resolveOrigin","originX","top","originY","setPositionByOrigin","CENTER","setCoords","group","layoutObject","shouldLayoutClipPath","clipPath","_ref","bubblingContext","parent","path","push","dispose","clear","toObject","toJSON","classRegistry","setClass"],"mappings":"8wBAqCA,MAAMA,EAAiB,gBAOhB,MAAMC,EAMXC,WAAAA,GAA+D,IAAnDC,EAAwBC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,IAAIG,EAAkBC,EAAAC,KAAA,gBAAA,GAC3DA,KAAKN,SAAWA,EAChBM,KAAKC,eAAiB,IAAIC,GAC5B,CAEOC,aAAAA,CAAcC,GACnB,MAAMC,EAAqC,CACzCC,SAAS,EACTZ,SAAUM,KAAKN,YACZU,EACHG,aAAcP,KAAKQ,oBACnBC,eAAAA,GACET,KAAKM,SAAU,CACjB,GAGFN,KAAKU,eAAeL,GAEpB,MAAMM,EAAeX,KAAKY,gBAAgBP,GACtCM,GACFX,KAAKa,aAAaR,EAAeM,GAGnCX,KAAKc,cAAcT,EAAeM,GAClCX,KAAKQ,oBAAsBH,EAAcX,QAC3C,CAUUqB,cAAAA,CACRC,EACAZ,GAEA,MAAMa,OAAEA,GAAWb,EACnB,MACE,CACEc,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,GAEFC,IAAKC,GACLZ,EAAOa,GAAGD,EAAME,GACd9B,KAAKG,cACHyB,IAAQV,EACJ,CACEa,KAAMC,EACNC,QAASL,EACTE,IACAb,UAEF,CACEc,KAAMG,EACND,QAASL,EACTE,IACAb,YAKd,CAQUkB,SAAAA,CACRnB,EACAZ,GAEAJ,KAAKoC,YAAYpB,EAAQZ,GACzB,MAAMiC,EAAYrC,KAAKe,eAAeC,EAAQZ,GAC9CJ,KAAKC,eAAeqC,IAAItB,EAAQqB,EAClC,CAKUD,WAAAA,CACRpB,EACAuB,IAECvC,KAAKC,eAAeuC,IAAIxB,IAAW,IAAIyB,QAASC,GAAMA,KACvD1C,KAAKC,eAAe0C,OAAO3B,EAC7B,CAEA4B,kBAAAA,CACExC,GAEAA,EAAQyC,QAAQJ,QAASzB,GAAWhB,KAAKoC,YAAYpB,EAAQZ,GAC/D,CAEA0C,gBAAAA,CACE1C,GAEAA,EAAQyC,QAAQJ,QAASzB,GAAWhB,KAAKmC,UAAUnB,EAAQZ,GAC7D,CAEUM,cAAAA,CAAeN,GACvB,MAAMa,OAAEA,EAAMc,KAAEA,GAAS3B,GACnB2C,OAAEA,GAAW9B,EAkBnB,GAfIc,IAASiB,GAA8BjB,IAASkB,EAClDjD,KAAK8C,iBAAiB1C,GACb2B,IAASmB,GAClBlD,KAAK4C,mBAAmBxC,GAG1Ba,EAAOkC,KAAK,gBAAiB,CAC3B/C,YAEF2C,GACEA,EAAOI,KAAK,uBAAwB,CAClClC,SACAb,YAGA2B,IAASqB,GAA0BhD,EAAQiD,KAAM,CACnD,MAAQ3D,SAAU4D,KAAMC,GAAqBnD,EAE7Ca,EAAOuC,cACJxC,GACEA,EAAiByC,eACjBzC,EAAiByC,cAActD,cAAc,IACzCoD,EACHjD,SAAS,EACTW,OAAQD,IAGhB,CACF,CAEUJ,eAAAA,CACRR,GAEA,MAAMa,OAAEA,EAAMvB,SAAEA,EAAQqC,KAAEA,GAAS3B,EAE7BsD,EAAShE,EAASiE,iBAAiBvD,EAASa,EAAO2C,cAEzD,IAAKF,EACH,OAGF,MAAMG,EACJ9B,IAASiB,EACL,IAAIc,EACJ7C,EAAO8C,0BAGXC,OAAQC,EAAUC,WAClBA,EAAa,IAAIJ,EAAOK,mBACxBA,EAAqB,IAAIL,GACvBJ,EACEU,EAASP,EACZQ,SAASJ,GACTK,IAAIJ,GACJK,UAECxC,IAASiB,EACLwB,EACAC,EAAgBxD,EAAOyD,kBAC3B,GAEDJ,IAAIH,GAEP,MAAO,CACLT,SACAG,aACAI,aACAG,SAEJ,CAEUvD,YAAAA,CACRT,EACAO,GAEA,MAAMM,OAAEA,GAAWb,GAEjBsD,QAAQiB,KAAEA,GAAMV,WAChBA,GACEtD,EAO6C,IAAAiE,EAAAC,GALjD5D,EAAOqB,IAAI,CAAEwC,MAAOH,EAAKI,EAAGC,OAAQL,EAAKM,IAEzCjF,KAAKkF,cAAc9E,EAASO,GAGxBP,EAAQ2B,OAASiB,GAEnB/B,EAAOqB,IAAI,CACT6C,KACW,QADPP,EACFxE,EAAQ2E,SAAC,IAAAH,EAAAA,EAAIX,EAAWc,EAAIJ,EAAKI,EAAIK,EAAcnE,EAAOoE,SAC5DC,IAAc,QAAXT,EAAEzE,EAAQ6E,SAAC,IAAAJ,EAAAA,EAAIZ,EAAWgB,EAAIN,EAAKM,EAAIG,EAAcnE,EAAOsE,YAGjEtE,EAAOuE,oBAAoBvB,EAAYwB,EAAQA,GAE/CxE,EAAOyE,YACPzE,EAAOqB,IAAI,SAAS,GAExB,CAEU4C,aAAAA,CACR9E,EACAO,GAEA,MAAMM,OAAEA,GAAWb,EAEnBa,EAAOuC,cAAexC,IACpBA,EAAO2E,QAAU1E,GACfjB,KAAK4F,aAAaxF,EAASO,EAAcK,KAG7CZ,EAAQV,SAASmG,qBAAqBzF,IACpCJ,KAAK4F,aAAaxF,EAASO,EAAcM,EAAO6E,SACpD,CAMUF,YAAAA,CACRxF,EAA4B2F,EAE5B/E,GACA,IAFAoD,OAAEA,GAAgC2B,EAMlC/E,EAAOsB,IAAI,CACT6C,KAAMnE,EAAOmE,KAAOf,EAAOW,EAC3BO,IAAKtE,EAAOsE,IAAMlB,EAAOa,GAE7B,CAEUnE,aAAAA,CACRV,EACAO,GAEA,MAAMM,OACJA,EAAMvB,SACNA,EAAQY,QACRA,EACAC,aAAc+C,KACX0C,GACD5F,GACE2C,OAAEA,GAAW9B,EAGnBA,EAAOkC,KAAK,eAAgB,CAC1B/C,UACAsD,OAAQ/C,IAEVoC,GACEA,EAAOI,KAAK,sBAAuB,CACjC/C,UACAsD,OAAQ/C,EACRM,WAIJ,MAAMgF,EAAShF,EAAOgF,OAClB3F,SAAW2F,GAAAA,EAAQxC,iBAEpBuC,EAAgBE,OAASF,EAAgBE,KAAO,KAAKC,KAAKlF,GAE3DgF,EAAOxC,cAActD,cAAc,IAC9B6F,EACH/E,OAAQgF,KAGZhF,EAAOqB,IAAI,SAAS,EACtB,CAEA8D,OAAAA,GACE,MAAMnG,eAAEA,GAAmBD,KAC3BC,EAAewC,QAASJ,GAAcA,EAAUI,QAASC,GAAMA,MAC/DzC,EAAeoG,OACjB,CAEAC,QAAAA,GACE,MAAO,CACLvE,KAAMxC,EACNG,SAAWM,KAAKN,SAASD,YAAsCsC,KAEnE,CAEAwE,MAAAA,GACE,OAAOvG,KAAKsG,UACd,EAGFE,EAAcC,SAASjH,EAAeD"}