@zag-js/rect-utils 1.34.1 → 1.35.0

package/dist/rect.mjs

@@ -0,0 +1,66 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/rect.ts
+var createPoint = (x, y) => ({ x, y });
+var subtractPoints = (a, b) => {
+  if (!b) return a;
+  return createPoint(a.x - b.x, a.y - b.y);
+};
+var addPoints = (a, b) => createPoint(a.x + b.x, a.y + b.y);
+function isPoint(v) {
+  return Reflect.has(v, "x") && Reflect.has(v, "y");
+}
+function createRect(r) {
+  const { x, y, width, height } = r;
+  const midX = x + width / 2;
+  const midY = y + height / 2;
+  return {
+    x,
+    y,
+    width,
+    height,
+    minX: x,
+    minY: y,
+    maxX: x + width,
+    maxY: y + height,
+    midX,
+    midY,
+    center: createPoint(midX, midY)
+  };
+}
+function isRect(v) {
+  return Reflect.has(v, "x") && Reflect.has(v, "y") && Reflect.has(v, "width") && Reflect.has(v, "height");
+}
+function getRectCenters(v) {
+  const top = createPoint(v.midX, v.minY);
+  const right = createPoint(v.maxX, v.midY);
+  const bottom = createPoint(v.midX, v.maxY);
+  const left = createPoint(v.minX, v.midY);
+  return { top, right, bottom, left };
+}
+function getRectCorners(v) {
+  const top = createPoint(v.minX, v.minY);
+  const right = createPoint(v.maxX, v.minY);
+  const bottom = createPoint(v.maxX, v.maxY);
+  const left = createPoint(v.minX, v.maxY);
+  return { top, right, bottom, left };
+}
+function getRectEdges(v) {
+  const c = getRectCorners(v);
+  const top = [c.top, c.right];
+  const right = [c.right, c.bottom];
+  const bottom = [c.left, c.bottom];
+  const left = [c.top, c.left];
+  return { top, right, bottom, left };
+}
+export {
+  addPoints,
+  createPoint,
+  createRect,
+  getRectCenters,
+  getRectCorners,
+  getRectEdges,
+  isPoint,
+  isRect,
+  subtractPoints
+};

package/dist/resize.d.mts

@@ -0,0 +1,6 @@
+import { CompassDirection } from './compass.mjs';
+import { Rect, Point, ScalingOptions, RectInit } from './types.mjs';
+
+declare function resizeRect(rect: Rect, offset: Point, direction: CompassDirection, opts: ScalingOptions): RectInit;
+
+export { resizeRect };

package/dist/resize.d.ts

@@ -0,0 +1,6 @@
+import { CompassDirection } from './compass.js';
+import { Rect, Point, ScalingOptions, RectInit } from './types.js';
+
+declare function resizeRect(rect: Rect, offset: Point, direction: CompassDirection, opts: ScalingOptions): RectInit;
+
+export { resizeRect };

package/dist/resize.js

@@ -0,0 +1,113 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/resize.ts
+var resize_exports = {};
+__export(resize_exports, {
+  resizeRect: () => resizeRect
+});
+module.exports = __toCommonJS(resize_exports);
+var import_affine_transform = require("./affine-transform.cjs");
+var import_compass = require("./compass.cjs");
+var { sign, abs, min } = Math;
+function getRectExtentPoint(rect, direction) {
+  const { minX, minY, maxX, maxY, midX, midY } = rect;
+  const x = direction.includes("w") ? minX : direction.includes("e") ? maxX : midX;
+  const y = direction.includes("n") ? minY : direction.includes("s") ? maxY : midY;
+  return { x, y };
+}
+function getOppositeDirection(direction) {
+  return import_compass.oppositeDirectionMap[direction];
+}
+function resizeRect(rect, offset, direction, opts) {
+  const { scalingOriginMode, lockAspectRatio } = opts;
+  const extent = getRectExtentPoint(rect, direction);
+  const oppositeDirection = getOppositeDirection(direction);
+  const oppositeExtent = getRectExtentPoint(rect, oppositeDirection);
+  if (scalingOriginMode === "center") {
+    offset = { x: offset.x * 2, y: offset.y * 2 };
+  }
+  const newExtent = {
+    x: extent.x + offset.x,
+    y: extent.y + offset.y
+  };
+  const multiplier = {
+    x: import_compass.compassDirectionMap[direction].x * 2 - 1,
+    y: import_compass.compassDirectionMap[direction].y * 2 - 1
+  };
+  const newSize = {
+    width: newExtent.x - oppositeExtent.x,
+    height: newExtent.y - oppositeExtent.y
+  };
+  const scaleX = multiplier.x * newSize.width / rect.width;
+  const scaleY = multiplier.y * newSize.height / rect.height;
+  const largestMagnitude = abs(scaleX) > abs(scaleY) ? scaleX : scaleY;
+  const scale = lockAspectRatio ? { x: largestMagnitude, y: largestMagnitude } : {
+    x: extent.x === oppositeExtent.x ? 1 : scaleX,
+    y: extent.y === oppositeExtent.y ? 1 : scaleY
+  };
+  if (extent.y === oppositeExtent.y) {
+    scale.y = abs(scale.y);
+  } else if (sign(scale.y) !== sign(scaleY)) {
+    scale.y *= -1;
+  }
+  if (extent.x === oppositeExtent.x) {
+    scale.x = abs(scale.x);
+  } else if (sign(scale.x) !== sign(scaleX)) {
+    scale.x *= -1;
+  }
+  switch (scalingOriginMode) {
+    case "extent":
+      return transformRect(rect, import_affine_transform.AffineTransform.scale(scale.x, scale.y, oppositeExtent), false);
+    case "center":
+      return transformRect(
+        rect,
+        import_affine_transform.AffineTransform.scale(scale.x, scale.y, {
+          x: rect.midX,
+          y: rect.midY
+        }),
+        false
+      );
+  }
+}
+function createRectFromPoints(initialPoint, finalPoint, normalized = true) {
+  if (normalized) {
+    return {
+      x: min(finalPoint.x, initialPoint.x),
+      y: min(finalPoint.y, initialPoint.y),
+      width: abs(finalPoint.x - initialPoint.x),
+      height: abs(finalPoint.y - initialPoint.y)
+    };
+  }
+  return {
+    x: initialPoint.x,
+    y: initialPoint.y,
+    width: finalPoint.x - initialPoint.x,
+    height: finalPoint.y - initialPoint.y
+  };
+}
+function transformRect(rect, transform, normalized = true) {
+  const p1 = transform.applyTo({ x: rect.minX, y: rect.minY });
+  const p2 = transform.applyTo({ x: rect.maxX, y: rect.maxY });
+  return createRectFromPoints(p1, p2, normalized);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resizeRect
+});

package/dist/resize.mjs

@@ -0,0 +1,90 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/resize.ts
+import { AffineTransform } from "./affine-transform.mjs";
+import { compassDirectionMap, oppositeDirectionMap } from "./compass.mjs";
+var { sign, abs, min } = Math;
+function getRectExtentPoint(rect, direction) {
+  const { minX, minY, maxX, maxY, midX, midY } = rect;
+  const x = direction.includes("w") ? minX : direction.includes("e") ? maxX : midX;
+  const y = direction.includes("n") ? minY : direction.includes("s") ? maxY : midY;
+  return { x, y };
+}
+function getOppositeDirection(direction) {
+  return oppositeDirectionMap[direction];
+}
+function resizeRect(rect, offset, direction, opts) {
+  const { scalingOriginMode, lockAspectRatio } = opts;
+  const extent = getRectExtentPoint(rect, direction);
+  const oppositeDirection = getOppositeDirection(direction);
+  const oppositeExtent = getRectExtentPoint(rect, oppositeDirection);
+  if (scalingOriginMode === "center") {
+    offset = { x: offset.x * 2, y: offset.y * 2 };
+  }
+  const newExtent = {
+    x: extent.x + offset.x,
+    y: extent.y + offset.y
+  };
+  const multiplier = {
+    x: compassDirectionMap[direction].x * 2 - 1,
+    y: compassDirectionMap[direction].y * 2 - 1
+  };
+  const newSize = {
+    width: newExtent.x - oppositeExtent.x,
+    height: newExtent.y - oppositeExtent.y
+  };
+  const scaleX = multiplier.x * newSize.width / rect.width;
+  const scaleY = multiplier.y * newSize.height / rect.height;
+  const largestMagnitude = abs(scaleX) > abs(scaleY) ? scaleX : scaleY;
+  const scale = lockAspectRatio ? { x: largestMagnitude, y: largestMagnitude } : {
+    x: extent.x === oppositeExtent.x ? 1 : scaleX,
+    y: extent.y === oppositeExtent.y ? 1 : scaleY
+  };
+  if (extent.y === oppositeExtent.y) {
+    scale.y = abs(scale.y);
+  } else if (sign(scale.y) !== sign(scaleY)) {
+    scale.y *= -1;
+  }
+  if (extent.x === oppositeExtent.x) {
+    scale.x = abs(scale.x);
+  } else if (sign(scale.x) !== sign(scaleX)) {
+    scale.x *= -1;
+  }
+  switch (scalingOriginMode) {
+    case "extent":
+      return transformRect(rect, AffineTransform.scale(scale.x, scale.y, oppositeExtent), false);
+    case "center":
+      return transformRect(
+        rect,
+        AffineTransform.scale(scale.x, scale.y, {
+          x: rect.midX,
+          y: rect.midY
+        }),
+        false
+      );
+  }
+}
+function createRectFromPoints(initialPoint, finalPoint, normalized = true) {
+  if (normalized) {
+    return {
+      x: min(finalPoint.x, initialPoint.x),
+      y: min(finalPoint.y, initialPoint.y),
+      width: abs(finalPoint.x - initialPoint.x),
+      height: abs(finalPoint.y - initialPoint.y)
+    };
+  }
+  return {
+    x: initialPoint.x,
+    y: initialPoint.y,
+    width: finalPoint.x - initialPoint.x,
+    height: finalPoint.y - initialPoint.y
+  };
+}
+function transformRect(rect, transform, normalized = true) {
+  const p1 = transform.applyTo({ x: rect.minX, y: rect.minY });
+  const p2 = transform.applyTo({ x: rect.maxX, y: rect.maxY });
+  return createRectFromPoints(p1, p2, normalized);
+}
+export {
+  resizeRect
+};

package/dist/types.d.mts

@@ -0,0 +1,55 @@
+interface Point {
+    x: number;
+    y: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+interface Bounds {
+    minX: number;
+    midX: number;
+    maxX: number;
+    minY: number;
+    midY: number;
+    maxY: number;
+}
+interface CenterPoint {
+    center: Point;
+}
+interface RectInit extends Point, Size {
+}
+interface Rect extends Point, Size, Bounds, CenterPoint {
+}
+type RectSide = "top" | "right" | "bottom" | "left";
+type RectPoint = "top-left" | "top-center" | "top-right" | "right-center" | "left-center" | "bottom-left" | "bottom-right" | "bottom-center" | "center";
+type RectEdge = [Point, Point];
+type RectPoints = [Point, Point, Point, Point];
+type RectEdges = Record<RectSide, RectEdge> & {
+    value: RectEdge[];
+};
+type RectCorner = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+type RectCorners = Record<RectCorner, Point> & {
+    value: RectPoints;
+};
+type RectCenter = "topCenter" | "rightCenter" | "leftCenter" | "bottomCenter";
+type RectCenters = Record<RectCenter, Point> & {
+    value: RectPoints;
+};
+type RectInset = Partial<Record<RectSide, number>>;
+interface SymmetricRectInset {
+    dx?: number | undefined;
+    dy?: number | undefined;
+}
+interface ScalingOptions {
+    scalingOriginMode: "center" | "extent";
+    lockAspectRatio: boolean;
+}
+interface AlignOptions {
+    h: HAlign;
+    v: VAlign;
+}
+type HAlign = "left-inside" | "left-outside" | "center" | "right-inside" | "right-outside";
+type VAlign = "top-inside" | "top-outside" | "center" | "bottom-inside" | "bottom-outside";
+
+export type { AlignOptions, Bounds, CenterPoint, HAlign, Point, Rect, RectCenter, RectCenters, RectCorner, RectCorners, RectEdge, RectEdges, RectInit, RectInset, RectPoint, RectPoints, RectSide, ScalingOptions, Size, SymmetricRectInset, VAlign };

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+interface Point {
+    x: number;
+    y: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+interface Bounds {
+    minX: number;
+    midX: number;
+    maxX: number;
+    minY: number;
+    midY: number;
+    maxY: number;
+}
+interface CenterPoint {
+    center: Point;
+}
+interface RectInit extends Point, Size {
+}
+interface Rect extends Point, Size, Bounds, CenterPoint {
+}
+type RectSide = "top" | "right" | "bottom" | "left";
+type RectPoint = "top-left" | "top-center" | "top-right" | "right-center" | "left-center" | "bottom-left" | "bottom-right" | "bottom-center" | "center";
+type RectEdge = [Point, Point];
+type RectPoints = [Point, Point, Point, Point];
+type RectEdges = Record<RectSide, RectEdge> & {
+    value: RectEdge[];
+};
+type RectCorner = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+type RectCorners = Record<RectCorner, Point> & {
+    value: RectPoints;
+};
+type RectCenter = "topCenter" | "rightCenter" | "leftCenter" | "bottomCenter";
+type RectCenters = Record<RectCenter, Point> & {
+    value: RectPoints;
+};
+type RectInset = Partial<Record<RectSide, number>>;
+interface SymmetricRectInset {
+    dx?: number | undefined;
+    dy?: number | undefined;
+}
+interface ScalingOptions {
+    scalingOriginMode: "center" | "extent";
+    lockAspectRatio: boolean;
+}
+interface AlignOptions {
+    h: HAlign;
+    v: VAlign;
+}
+type HAlign = "left-inside" | "left-outside" | "center" | "right-inside" | "right-outside";
+type VAlign = "top-inside" | "top-outside" | "center" | "bottom-inside" | "bottom-outside";
+
+export type { AlignOptions, Bounds, CenterPoint, HAlign, Point, Rect, RectCenter, RectCenters, RectCorner, RectCorners, RectEdge, RectEdges, RectInit, RectInset, RectPoint, RectPoints, RectSide, ScalingOptions, Size, SymmetricRectInset, VAlign };

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/union.d.mts

@@ -0,0 +1,5 @@
+import { Rect } from './types.mjs';
+
+declare function union(...rs: Rect[]): Rect;
+
+export { union };

package/dist/union.d.ts

@@ -0,0 +1,5 @@
+import { Rect } from './types.js';
+
+declare function union(...rs: Rect[]): Rect;
+
+export { union };

package/dist/union.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/union.ts
+var union_exports = {};
+__export(union_exports, {
+  union: () => union
+});
+module.exports = __toCommonJS(union_exports);
+var import_from_points = require("./from-points.cjs");
+var { min, max } = Math;
+function union(...rs) {
+  const pMin = {
+    x: min(...rs.map((r) => r.minX)),
+    y: min(...rs.map((r) => r.minY))
+  };
+  const pMax = {
+    x: max(...rs.map((r) => r.maxX)),
+    y: max(...rs.map((r) => r.maxY))
+  };
+  return (0, import_from_points.getRectFromPoints)(pMin, pMax);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  union
+});

package/dist/union.mjs

@@ -0,0 +1,19 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/union.ts
+import { getRectFromPoints } from "./from-points.mjs";
+var { min, max } = Math;
+function union(...rs) {
+  const pMin = {
+    x: min(...rs.map((r) => r.minX)),
+    y: min(...rs.map((r) => r.minY))
+  };
+  const pMax = {
+    x: max(...rs.map((r) => r.maxX)),
+    y: max(...rs.map((r) => r.maxY))
+  };
+  return getRectFromPoints(pMin, pMax);
+}
+export {
+  union
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zag-js/rect-utils",
-  "version": "1.34.1",
+  "version": "1.35.0",
   "description": "",
   "keywords": [
     "js",