@blocksuite/global - npm Package Compare versions

Comparing version 0.0.0-canary-20241022001415 to 0.0.0-canary-20241023001414

CHANGELOG.md

 # @blocksuite/global
 
-## 0.0.0-canary-20241022001415
+## 0.0.0-canary-20241023001414
 
@@ -5,0 +5,0 @@ ### Patch Changes

dist/utils/bound.d.ts

 import { Bound, type IBound, type IVec } from './model/index.js';
+export declare function getPointsFromBoundWithRotation(bounds: IBound, getPoints?: (bounds: IBound) => IVec[], resPadding?: [number, number]): IVec[];
+export declare function getQuadBoundWithRotation(bounds: IBound): DOMRect;
+export declare function getBoundWithRotation(bound: IBound): IBound;
+/**
+ * Returns the common bound of the given bounds.
+ * The rotation of the bounds is not considered.
+ * @param bounds
+ * @returns
+ */
 export declare function getCommonBound(bounds: IBound[]): Bound | null;
-export declare function getElementsBound(bounds: IBound[]): Bound;
+/**
+ * Like `getCommonBound`, but considers the rotation of the bounds.
+ * @returns
+ */
+export declare function getCommonBoundWithRotation(bounds: IBound[]): Bound;
+export declare function getIBoundFromPoints(points: IVec[], rotation?: number): IBound & {
+    maxX: number;
+    maxY: number;
+    minX: number;
+    minY: number;
+};
 export declare function getBoundFromPoints(points: IVec[]): Bound;
@@ -5,0 +24,0 @@ export declare function inflateBound(bound: IBound, delta: number): Bound;

dist/utils/bound.js

@@ -1,3 +0,2 @@
-import { getBoundsFromPoints, getBoundsWithRotation } from './math.js';
-import { Bound } from './model/index.js';
+import { Bound, Vec } from './model/index.js';
 function getExpandedBound(a, b) {
@@ -17,2 +16,51 @@ const minX = Math.min(a.x, b.x);
 }
+export function getPointsFromBoundWithRotation(bounds, getPoints = ({ x, y, w, h }) => [
+    // left-top
+    [x, y],
+    // right-top
+    [x + w, y],
+    // right-bottom
+    [x + w, y + h],
+    // left-bottom
+    [x, y + h],
+], resPadding = [0, 0]) {
+    const { rotate } = bounds;
+    let points = getPoints({
+        x: bounds.x - resPadding[1],
+        y: bounds.y - resPadding[0],
+        w: bounds.w + resPadding[1] * 2,
+        h: bounds.h + resPadding[0] * 2,
+    });
+    if (rotate) {
+        const { x, y, w, h } = bounds;
+        const cx = x + w / 2;
+        const cy = y + h / 2;
+        const m = new DOMMatrix()
+            .translateSelf(cx, cy)
+            .rotateSelf(rotate)
+            .translateSelf(-cx, -cy);
+        points = points.map(point => {
+            const { x, y } = new DOMPoint(...point).matrixTransform(m);
+            return [x, y];
+        });
+    }
+    return points;
+}
+export function getQuadBoundWithRotation(bounds) {
+    const { x, y, w, h, rotate } = bounds;
+    const rect = new DOMRect(x, y, w, h);
+    if (!rotate)
+        return rect;
+    return new DOMQuad(...getPointsFromBoundWithRotation(bounds).map(point => new DOMPoint(...point))).getBounds();
+}
+export function getBoundWithRotation(bound) {
+    const { x, y, width: w, height: h } = getQuadBoundWithRotation(bound);
+    return { x, y, w, h };
+}
+/**
+ * Returns the common bound of the given bounds.
+ * The rotation of the bounds is not considered.
+ * @param bounds
+ * @returns
+ */
 export function getCommonBound(bounds) {
@@ -32,19 +80,49 @@ if (!bounds.length) {
 }
-export function getElementsBound(bounds) {
-    let minX = Number.POSITIVE_INFINITY;
-    let minY = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let maxY = Number.NEGATIVE_INFINITY;
-    bounds.forEach(ele => {
-        const b = getBoundsWithRotation(ele);
-        minX = Math.min(minX, b.x);
-        minY = Math.min(minY, b.y);
-        maxX = Math.max(maxX, b.x + b.w);
-        maxY = Math.max(maxY, b.y + b.h);
-    });
-    return new Bound(minX, minY, maxX - minX, maxY - minY);
+/**
+ * Like `getCommonBound`, but considers the rotation of the bounds.
+ * @returns
+ */
+export function getCommonBoundWithRotation(bounds) {
+    if (bounds.length === 0) {
+        return new Bound(0, 0, 0, 0);
+    }
+    return bounds.reduce((pre, bound) => {
+        return pre.unite(bound instanceof Bound ? bound : Bound.from(getBoundWithRotation(bound)));
+    }, Bound.from(getBoundWithRotation(bounds[0])));
 }
+export function getIBoundFromPoints(points, rotation = 0) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    if (points.length < 1) {
+        minX = 0;
+        minY = 0;
+        maxX = 1;
+        maxY = 1;
+    }
+    else {
+        for (const [x, y] of points) {
+            minX = Math.min(x, minX);
+            minY = Math.min(y, minY);
+            maxX = Math.max(x, maxX);
+            maxY = Math.max(y, maxY);
+        }
+    }
+    if (rotation !== 0) {
+        return getIBoundFromPoints(points.map(pt => Vec.rotWith(pt, [(minX + maxX) / 2, (minY + maxY) / 2], rotation)));
+    }
+    return {
+        minX,
+        minY,
+        maxX,
+        maxY,
+        x: minX,
+        y: minY,
+        w: maxX - minX,
+        h: maxY - minY,
+    };
+}
 export function getBoundFromPoints(points) {
-    const { minX, minY, width, height } = getBoundsFromPoints(points);
-    return new Bound(minX, minY, width, height);
+    return Bound.from(getIBoundFromPoints(points));
 }
@@ -51,0 +129,0 @@ export function inflateBound(bound, delta) {

dist/utils/math.d.ts

@@ -8,16 +8,3 @@ import type { Bound, IBound } from './model/bound.js';
 export declare const CURVETIME_EPSILON = 1e-8;
-interface TLBounds {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-    width: number;
-    height: number;
-    rotation?: number;
-}
 export declare function randomSeed(): number;
-export declare function getBoundsFromPoints(points: IVec[], rotation?: number): TLBounds;
-export declare function getPointsFromBoundsWithRotation(bounds: IBound, getPoints?: (bounds: IBound) => IVec[], resPadding?: [number, number]): IVec[];
-export declare function getQuadBoundsWithRotation(bounds: IBound): DOMRect;
-export declare function getBoundsWithRotation(bounds: IBound): IBound;
 export declare function lineIntersects(sp: IVec, ep: IVec, sp2: IVec, ep2: IVec, infinite?: boolean): IVec | null;
@@ -62,3 +49,2 @@ export declare function polygonNearestPoint(points: IVec[], point: IVec): IVec;
 };
-export {};
 //# sourceMappingURL=math.d.ts.map

dist/utils/math.js

@@ -10,76 +10,2 @@ import { PointLocation } from './model/point-location.js';
 }
-export function getBoundsFromPoints(points, rotation = 0) {
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    if (points.length < 1) {
-        minX = 0;
-        minY = 0;
-        maxX = 1;
-        maxY = 1;
-    }
-    else {
-        for (const [x, y] of points) {
-            minX = Math.min(x, minX);
-            minY = Math.min(y, minY);
-            maxX = Math.max(x, maxX);
-            maxY = Math.max(y, maxY);
-        }
-    }
-    if (rotation !== 0) {
-        return getBoundsFromPoints(points.map(pt => Vec.rotWith(pt, [(minX + maxX) / 2, (minY + maxY) / 2], rotation)));
-    }
-    return {
-        minX,
-        minY,
-        maxX,
-        maxY,
-        width: Math.max(1, maxX - minX),
-        height: Math.max(1, maxY - minY),
-    };
-}
-export function getPointsFromBoundsWithRotation(bounds, getPoints = ({ x, y, w, h }) => [
-    // left-top
-    [x, y],
-    // right-top
-    [x + w, y],
-    // right-bottom
-    [x + w, y + h],
-    // left-bottom
-    [x, y + h],
-], resPadding = [0, 0]) {
-    const { rotate } = bounds;
-    let points = getPoints({
-        x: bounds.x - resPadding[1],
-        y: bounds.y - resPadding[0],
-        w: bounds.w + resPadding[1] * 2,
-        h: bounds.h + resPadding[0] * 2,
-    });
-    if (rotate) {
-        const { x, y, w, h } = bounds;
-        const cx = x + w / 2;
-        const cy = y + h / 2;
-        const m = new DOMMatrix()
-            .translateSelf(cx, cy)
-            .rotateSelf(rotate)
-            .translateSelf(-cx, -cy);
-        points = points.map(point => {
-            const { x, y } = new DOMPoint(...point).matrixTransform(m);
-            return [x, y];
-        });
-    }
-    return points;
-}
-export function getQuadBoundsWithRotation(bounds) {
-    const { x, y, w, h, rotate } = bounds;
-    const rect = new DOMRect(x, y, w, h);
-    if (!rotate)
-        return rect;
-    return new DOMQuad(...getPointsFromBoundsWithRotation(bounds).map(point => new DOMPoint(...point))).getBounds();
-}
-export function getBoundsWithRotation(bounds) {
-    const { x, y, width: w, height: h } = getQuadBoundsWithRotation(bounds);
-    return { x, y, w, h };
-}
 export function lineIntersects(sp, ep, sp2, ep2, infinite = false) {
@@ -86,0 +12,0 @@ const v1 = Vec.sub(ep, sp);

dist/utils/model/bound.js

@@ -1,2 +0,3 @@
-import { EPSILON, getBoundsFromPoints, lineIntersects, polygonPointDistance, } from '../math.js';
+import { getIBoundFromPoints } from '../bound.js';
+import { EPSILON, lineIntersects, polygonPointDistance } from '../math.js';
 import { deserializeXYWH, serializeXYWH } from '../xywh.js';
@@ -109,4 +110,3 @@ export class Bound {
     static fromPoints(points) {
-        const { minX, minY, maxX, maxY } = getBoundsFromPoints(points);
-        return new Bound(minX, minY, maxX - minX, maxY - minY);
+        return Bound.from(getIBoundFromPoints(points));
     }
@@ -113,0 +113,0 @@ static fromXYWH(xywh) {

package.json

 {
   "name": "@blocksuite/global",
-  "version": "0.0.0-canary-20241022001415",
+  "version": "0.0.0-canary-20241023001414",
   "types": "./index.d.ts",
@@ -5,0 +5,0 @@ "type": "module",

src/utils/bound.ts

@@ -1,3 +0,2 @@
-import { getBoundsFromPoints, getBoundsWithRotation } from './math.js';
-import { Bound, type IBound, type IVec } from './model/index.js';
+import { Bound, type IBound, type IVec, Vec } from './model/index.js';
 
@@ -20,2 +19,67 @@ function getExpandedBound(a: IBound, b: IBound): IBound {
 
+export function getPointsFromBoundWithRotation(
+  bounds: IBound,
+  getPoints: (bounds: IBound) => IVec[] = ({ x, y, w, h }: IBound) => [
+    // left-top
+    [x, y],
+    // right-top
+    [x + w, y],
+    // right-bottom
+    [x + w, y + h],
+    // left-bottom
+    [x, y + h],
+  ],
+  resPadding: [number, number] = [0, 0]
+): IVec[] {
+  const { rotate } = bounds;
+  let points = getPoints({
+    x: bounds.x - resPadding[1],
+    y: bounds.y - resPadding[0],
+    w: bounds.w + resPadding[1] * 2,
+    h: bounds.h + resPadding[0] * 2,
+  });
+
+  if (rotate) {
+    const { x, y, w, h } = bounds;
+    const cx = x + w / 2;
+    const cy = y + h / 2;
+
+    const m = new DOMMatrix()
+      .translateSelf(cx, cy)
+      .rotateSelf(rotate)
+      .translateSelf(-cx, -cy);
+
+    points = points.map(point => {
+      const { x, y } = new DOMPoint(...point).matrixTransform(m);
+      return [x, y];
+    });
+  }
+
+  return points;
+}
+
+export function getQuadBoundWithRotation(bounds: IBound): DOMRect {
+  const { x, y, w, h, rotate } = bounds;
+  const rect = new DOMRect(x, y, w, h);
+
+  if (!rotate) return rect;
+
+  return new DOMQuad(
+    ...getPointsFromBoundWithRotation(bounds).map(
+      point => new DOMPoint(...point)
+    )
+  ).getBounds();
+}
+
+export function getBoundWithRotation(bound: IBound): IBound {
+  const { x, y, width: w, height: h } = getQuadBoundWithRotation(bound);
+  return { x, y, w, h };
+}
+
+/**
+ * Returns the common bound of the given bounds.
+ * The rotation of the bounds is not considered.
+ * @param bounds
+ * @returns
+ */
 export function getCommonBound(bounds: IBound[]): Bound | null {
@@ -25,2 +89,3 @@ if (!bounds.length) {
   }
+
   if (bounds.length === 1) {
@@ -40,23 +105,71 @@ const { x, y, w, h } = bounds[0];
 
-export function getElementsBound(bounds: IBound[]): Bound {
-  let minX = Number.POSITIVE_INFINITY;
-  let minY = Number.POSITIVE_INFINITY;
-  let maxX = Number.NEGATIVE_INFINITY;
-  let maxY = Number.NEGATIVE_INFINITY;
+/**
+ * Like `getCommonBound`, but considers the rotation of the bounds.
+ * @returns
+ */
+export function getCommonBoundWithRotation(bounds: IBound[]): Bound {
+  if (bounds.length === 0) {
+    return new Bound(0, 0, 0, 0);
+  }
 
-  bounds.forEach(ele => {
-    const b = getBoundsWithRotation(ele);
+  return bounds.reduce(
+    (pre, bound) => {
+      return pre.unite(
+        bound instanceof Bound ? bound : Bound.from(getBoundWithRotation(bound))
+      );
+    },
+    Bound.from(getBoundWithRotation(bounds[0]))
+  );
+}
 
-    minX = Math.min(minX, b.x);
-    minY = Math.min(minY, b.y);
-    maxX = Math.max(maxX, b.x + b.w);
-    maxY = Math.max(maxY, b.y + b.h);
-  });
+export function getIBoundFromPoints(
+  points: IVec[],
+  rotation = 0
+): IBound & {
+  maxX: number;
+  maxY: number;
+  minX: number;
+  minY: number;
+} {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
 
-  return new Bound(minX, minY, maxX - minX, maxY - minY);
+  if (points.length < 1) {
+    minX = 0;
+    minY = 0;
+    maxX = 1;
+    maxY = 1;
+  } else {
+    for (const [x, y] of points) {
+      minX = Math.min(x, minX);
+      minY = Math.min(y, minY);
+      maxX = Math.max(x, maxX);
+      maxY = Math.max(y, maxY);
+    }
+  }
+
+  if (rotation !== 0) {
+    return getIBoundFromPoints(
+      points.map(pt =>
+        Vec.rotWith(pt, [(minX + maxX) / 2, (minY + maxY) / 2], rotation)
+      )
+    );
+  }
+
+  return {
+    minX,
+    minY,
+    maxX,
+    maxY,
+    x: minX,
+    y: minY,
+    w: maxX - minX,
+    h: maxY - minY,
+  };
 }
 
 export function getBoundFromPoints(points: IVec[]) {
-  const { minX, minY, width, height } = getBoundsFromPoints(points);
-  return new Bound(minX, minY, width, height);
+  return Bound.from(getIBoundFromPoints(points));
 }
@@ -63,0 +176,0 @@

src/utils/math.ts

@@ -11,12 +11,2 @@ import type { Bound, IBound } from './model/bound.js';
 
-interface TLBounds {
-  minX: number;
-  minY: number;
-  maxX: number;
-  maxY: number;
-  width: number;
-  height: number;
-  rotation?: number;
-}
-
 export function randomSeed(): number {
@@ -26,99 +16,2 @@ return Math.floor(Math.random() * 2 ** 31);
 
-export function getBoundsFromPoints(points: IVec[], rotation = 0): TLBounds {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-
-  if (points.length < 1) {
-    minX = 0;
-    minY = 0;
-    maxX = 1;
-    maxY = 1;
-  } else {
-    for (const [x, y] of points) {
-      minX = Math.min(x, minX);
-      minY = Math.min(y, minY);
-      maxX = Math.max(x, maxX);
-      maxY = Math.max(y, maxY);
-    }
-  }
-
-  if (rotation !== 0) {
-    return getBoundsFromPoints(
-      points.map(pt =>
-        Vec.rotWith(pt, [(minX + maxX) / 2, (minY + maxY) / 2], rotation)
-      )
-    );
-  }
-
-  return {
-    minX,
-    minY,
-    maxX,
-    maxY,
-    width: Math.max(1, maxX - minX),
-    height: Math.max(1, maxY - minY),
-  };
-}
-
-export function getPointsFromBoundsWithRotation(
-  bounds: IBound,
-  getPoints: (bounds: IBound) => IVec[] = ({ x, y, w, h }: IBound) => [
-    // left-top
-    [x, y],
-    // right-top
-    [x + w, y],
-    // right-bottom
-    [x + w, y + h],
-    // left-bottom
-    [x, y + h],
-  ],
-  resPadding: [number, number] = [0, 0]
-): IVec[] {
-  const { rotate } = bounds;
-  let points = getPoints({
-    x: bounds.x - resPadding[1],
-    y: bounds.y - resPadding[0],
-    w: bounds.w + resPadding[1] * 2,
-    h: bounds.h + resPadding[0] * 2,
-  });
-
-  if (rotate) {
-    const { x, y, w, h } = bounds;
-    const cx = x + w / 2;
-    const cy = y + h / 2;
-
-    const m = new DOMMatrix()
-      .translateSelf(cx, cy)
-      .rotateSelf(rotate)
-      .translateSelf(-cx, -cy);
-
-    points = points.map(point => {
-      const { x, y } = new DOMPoint(...point).matrixTransform(m);
-      return [x, y];
-    });
-  }
-
-  return points;
-}
-
-export function getQuadBoundsWithRotation(bounds: IBound): DOMRect {
-  const { x, y, w, h, rotate } = bounds;
-  const rect = new DOMRect(x, y, w, h);
-
-  if (!rotate) return rect;
-
-  return new DOMQuad(
-    ...getPointsFromBoundsWithRotation(bounds).map(
-      point => new DOMPoint(...point)
-    )
-  ).getBounds();
-}
-
-export function getBoundsWithRotation(bounds: IBound): IBound {
-  const { x, y, width: w, height: h } = getQuadBoundsWithRotation(bounds);
-  return { x, y, w, h };
-}
-
 export function lineIntersects(
@@ -125,0 +18,0 @@ sp: IVec,

src/utils/model/bound.ts

 import type { SerializedXYWH, XYWH } from '../xywh.js';
 import type { IVec } from './vec.js';
 
-import {
-  EPSILON,
-  getBoundsFromPoints,
-  lineIntersects,
-  polygonPointDistance,
-} from '../math.js';
+import { getIBoundFromPoints } from '../bound.js';
+import { EPSILON, lineIntersects, polygonPointDistance } from '../math.js';
 import { deserializeXYWH, serializeXYWH } from '../xywh.js';
@@ -160,4 +156,3 @@
   static fromPoints(points: IVec[]) {
-    const { minX, minY, maxX, maxY } = getBoundsFromPoints(points);
-    return new Bound(minX, minY, maxX - minX, maxY - minY);
+    return Bound.from(getIBoundFromPoints(points));
   }
@@ -164,0 +159,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Lines of code

10925

increased by0.11%

Worsened metrics

Total package byte prevSize

700447

decreased by-0.14%

No dependency changes