@zag-js/rect-utils 0.2.0 → 0.2.2

package/dist/from-rotation.js

@@ -0,0 +1,92 @@
+"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/from-rotation.ts
+var from_rotation_exports = {};
+__export(from_rotation_exports, {
+  getRotationRect: () => getRotationRect,
+  rotate: () => rotate,
+  toRad: () => toRad
+});
+module.exports = __toCommonJS(from_rotation_exports);
+
+// src/rect.ts
+var point = (x, y) => ({ x, 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: point(midX, midY)
+  };
+}
+function getRectCorners(v) {
+  const top = point(v.minX, v.minY);
+  const right = point(v.maxX, v.minY);
+  const bottom = point(v.maxX, v.maxY);
+  const left = point(v.minX, v.maxY);
+  return { top, right, bottom, left };
+}
+
+// src/from-rotation.ts
+function toRad(d) {
+  return d % 360 * Math.PI / 180;
+}
+function rotate(a, d, c) {
+  const r = toRad(d);
+  const sin = Math.sin(r);
+  const cos = Math.cos(r);
+  const x = a.x - c.x;
+  const y = a.y - c.y;
+  return {
+    x: c.x + x * cos - y * sin,
+    y: c.y + x * sin + y * cos
+  };
+}
+function getRotationRect(r, deg) {
+  const rr = Object.values(getRectCorners(r)).map((p) => rotate(p, deg, r.center));
+  const xs = rr.map((p) => p.x);
+  const ys = rr.map((p) => p.y);
+  const minX = Math.min(...xs);
+  const minY = Math.min(...ys);
+  const maxX = Math.max(...xs);
+  const maxY = Math.max(...ys);
+  return createRect({
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRotationRect,
+  rotate,
+  toRad
+});

package/dist/from-rotation.mjs

@@ -0,0 +1,11 @@
+import {
+  getRotationRect,
+  rotate,
+  toRad
+} from "./chunk-BGAHRJ6S.mjs";
+import "./chunk-YDYJCJQZ.mjs";
+export {
+  getRotationRect,
+  rotate,
+  toRad
+};

package/dist/from-window.d.ts

@@ -0,0 +1,24 @@
+import { Rect } from './rect.js';
+import './types.js';
+
+type WindowRectOptions = {
+    /**
+     * Whether to exclude the element's scrollbar size from the calculation.
+     */
+    excludeScrollbar?: boolean;
+};
+/**
+ * Creates a rectange from window object
+ */
+declare function getWindowRect(win: Window, opts?: WindowRectOptions): Rect;
+/**
+ * Get the rect of the window with the option to exclude the scrollbar
+ */
+declare function getViewportRect(win: Window, opts: WindowRectOptions): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+export { WindowRectOptions, getViewportRect, getWindowRect };

package/dist/from-window.js

@@ -0,0 +1,71 @@
+"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/from-window.ts
+var from_window_exports = {};
+__export(from_window_exports, {
+  getViewportRect: () => getViewportRect,
+  getWindowRect: () => getWindowRect
+});
+module.exports = __toCommonJS(from_window_exports);
+
+// src/rect.ts
+var point = (x, y) => ({ x, 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: point(midX, midY)
+  };
+}
+
+// src/from-window.ts
+function getWindowRect(win, opts = {}) {
+  return createRect(getViewportRect(win, opts));
+}
+function getViewportRect(win, opts) {
+  const { excludeScrollbar = false } = opts;
+  const { innerWidth, innerHeight, document: doc, visualViewport } = win;
+  const width = visualViewport?.width || innerWidth;
+  const height = visualViewport?.height || innerHeight;
+  const rect = { x: 0, y: 0, width, height };
+  if (excludeScrollbar) {
+    const scrollbarWidth = innerWidth - doc.documentElement.clientWidth;
+    const scrollbarHeight = innerHeight - doc.documentElement.clientHeight;
+    rect.width -= scrollbarWidth;
+    rect.height -= scrollbarHeight;
+  }
+  return rect;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getViewportRect,
+  getWindowRect
+});

package/dist/from-window.mjs

@@ -0,0 +1,9 @@
+import {
+  getViewportRect,
+  getWindowRect
+} from "./chunk-LBA674LT.mjs";
+import "./chunk-YDYJCJQZ.mjs";
+export {
+  getViewportRect,
+  getWindowRect
+};

package/dist/get-polygon.d.ts

@@ -0,0 +1,8 @@
+import { RectValue } from './types.js';
+
+declare function getElementPolygon(rectValue: RectValue, placement: string): {
+    x: number;
+    y: number;
+}[] | undefined;
+
+export { getElementPolygon };

package/dist/get-polygon.js

@@ -0,0 +1,70 @@
+"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/get-polygon.ts
+var get_polygon_exports = {};
+__export(get_polygon_exports, {
+  getElementPolygon: () => getElementPolygon
+});
+module.exports = __toCommonJS(get_polygon_exports);
+
+// src/rect.ts
+var point = (x, y) => ({ x, 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: point(midX, midY)
+  };
+}
+function getRectCorners(v) {
+  const top = point(v.minX, v.minY);
+  const right = point(v.maxX, v.minY);
+  const bottom = point(v.maxX, v.maxY);
+  const left = point(v.minX, v.maxY);
+  return { top, right, bottom, left };
+}
+
+// src/get-polygon.ts
+function getElementPolygon(rectValue, placement) {
+  const rect = createRect(rectValue);
+  const { top, right, left, bottom } = getRectCorners(rect);
+  const [base] = placement.split("-");
+  return {
+    top: [left, top, right, bottom],
+    right: [top, right, bottom, left],
+    bottom: [top, left, bottom, right],
+    left: [right, top, left, bottom]
+  }[base];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getElementPolygon
+});

package/dist/get-polygon.mjs

@@ -0,0 +1,7 @@
+import {
+  getElementPolygon
+} from "./chunk-S3HXSPS7.mjs";
+import "./chunk-YDYJCJQZ.mjs";
+export {
+  getElementPolygon
+};

package/dist/index.d.ts

@@ -1,186 +1,16 @@
-declare type Point = {
-    x: number;
-    y: number;
-};
-declare type RectValue = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-declare type RectSide = "top" | "right" | "bottom" | "left";
-declare type RectPoint = "top-left" | "top-center" | "top-right" | "right-center" | "left-center" | "bottom-left" | "bottom-right" | "bottom-center" | "center";
-declare type RectEdge = [Point, Point];
-declare type RectPoints = [Point, Point, Point, Point];
-declare type RectEdges = Record<RectSide, RectEdge> & {
-    value: RectEdge[];
-};
-declare type RectCorner = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
-declare type RectCorners = Record<RectCorner, Point> & {
-    value: RectPoints;
-};
-declare type RectCenter = "topCenter" | "rightCenter" | "leftCenter" | "bottomCenter";
-declare type RectCenters = Record<RectCenter, Point> & {
-    value: RectPoints;
-};
-declare type RectInset = Partial<Record<RectSide, number>>;
-declare type SymmetricRectInset = {
-    dx?: number;
-    dy?: number;
-};
-
-declare function createRect(r: RectValue): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-    midX: number;
-    midY: number;
-    center: {
-        x: number;
-        y: number;
-    };
-};
-declare type Rect = ReturnType<typeof createRect>;
-declare function isRect(v: any): v is Rect;
-declare function getRectCenters(v: Rect): {
-    top: {
-        x: number;
-        y: number;
-    };
-    right: {
-        x: number;
-        y: number;
-    };
-    bottom: {
-        x: number;
-        y: number;
-    };
-    left: {
-        x: number;
-        y: number;
-    };
-};
-declare function getRectCorners(v: Rect): {
-    top: {
-        x: number;
-        y: number;
-    };
-    right: {
-        x: number;
-        y: number;
-    };
-    bottom: {
-        x: number;
-        y: number;
-    };
-    left: {
-        x: number;
-        y: number;
-    };
-};
-declare function getRectEdges(v: Rect): {
-    top: RectEdge;
-    right: RectEdge;
-    bottom: RectEdge;
-    left: RectEdge;
-};
-
-declare function alignRect(a: Rect, ref: Rect, options: AlignOptions): Rect;
-declare type AlignOptions = {
-    h: HAlign;
-    v: VAlign;
-};
-declare type HAlign = "left-inside" | "left-outside" | "center" | "right-inside" | "right-outside";
-declare type VAlign = "top-inside" | "top-outside" | "center" | "bottom-inside" | "bottom-outside";
-
-declare function closest(...pts: Point[]): (a: Point) => Point;
-declare function closestSideToRect(ref: Rect, r: Rect): RectSide;
-declare function closestSideToPoint(ref: Rect, p: Point): RectSide;
-
-declare function containsPoint(r: Rect, p: Point): boolean;
-declare function containsRect(a: Rect, b: Rect): boolean;
-declare function contains(r: Rect, v: Rect | Point): boolean;
-
-declare type DistanceValue = Point & {
-    value: number;
-};
-declare function distance(a: Point, b?: Point): number;
-declare function distanceFromPoint(r: Rect, p: Point): DistanceValue;
-declare function distanceFromRect(a: Rect, b: Rect): DistanceValue;
-declare function distanceBtwEdges(a: Rect, b: Rect): Record<RectSide, number>;
-
-declare function getElementRect(el: HTMLElement, opts?: ElementRectOptions): Rect;
-declare type ElementRectOptions = {
-    /**
-     * Whether to exclude the element's scrollbar size from the calculation.
-     */
-    excludeScrollbar?: boolean;
-    /**
-     * Whether to exclude the element's borders from the calculation.
-     */
-    excludeBorders?: boolean;
-};
-
-declare function getRectFromPoints(...pts: Point[]): Rect;
-
-declare function fromRange(range: Range): Rect;
-
-declare function toRad(d: number): number;
-declare function rotate(a: Point, d: number, c: Point): Point;
-declare function getRotationRect(r: Rect, deg: number): Rect;
-
-declare type WindowRectOptions = {
-    /**
-     * Whether to exclude the element's scrollbar size from the calculation.
-     */
-    excludeScrollbar?: boolean;
-};
-/**
- * Creates a rectange from window object
- */
-declare function getWindowRect(win: Window, opts?: WindowRectOptions): Rect;
-/**
- * Get the rect of the window with the option to exclude the scrollbar
- */
-declare function getViewportRect(win: Window, opts: WindowRectOptions): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-
-declare function getElementPolygon(rectValue: RectValue, placement: string): {
-    x: number;
-    y: number;
-}[] | undefined;
-
-/**
- * Checks if a Rect intersects another Rect
- */
-declare function intersects(a: Rect, b: Rect): boolean;
-/**
- * Returns a new Rect that represents the intersection between two Rects
- */
-declare function intersection(a: Rect, b: Rect): Rect;
-/**
- * Returns whether two rects collide along each edge
- */
-declare function collisions(a: Rect, b: Rect): Record<RectSide, boolean>;
-
-declare const isSymmetric: (v: any) => v is SymmetricRectInset;
-declare function inset(r: Rect, i: RectInset | SymmetricRectInset): Rect;
-declare function expand(r: Rect, v: number | SymmetricRectInset): Rect;
-declare function shrink(r: Rect, v: number | SymmetricRectInset): Rect;
-declare function shift(r: Rect, o: Partial<Point>): Rect;
-
-declare function isPointInPolygon(polygon: Point[], point: Point): boolean;
-declare function debugPolygon(polygon: Point[]): () => void;
-
-declare function union(...rs: Rect[]): Rect;
-
-export { AlignOptions, DistanceValue, ElementRectOptions, HAlign, Point, Rect, RectCenter, RectCenters, RectCorner, RectCorners, RectEdge, RectEdges, RectInset, RectPoint, RectPoints, RectSide, RectValue, SymmetricRectInset, VAlign, WindowRectOptions, alignRect, closest, closestSideToPoint, closestSideToRect, collisions, contains, containsPoint, containsRect, createRect, debugPolygon, distance, distanceBtwEdges, distanceFromPoint, distanceFromRect, expand, fromRange, getElementPolygon, getElementRect, getRectCenters, getRectCorners, getRectEdges, getRectFromPoints, getRotationRect, getViewportRect, getWindowRect, inset, intersection, intersects, isPointInPolygon, isRect, isSymmetric, rotate, shift, shrink, toRad, union };
+export { AlignOptions, HAlign, VAlign, alignRect } from './align.js';
+export { closest, closestSideToPoint, closestSideToRect } from './closest.js';
+export { contains, containsPoint, containsRect } from './contains.js';
+export { DistanceValue, distance, distanceBtwEdges, distanceFromPoint, distanceFromRect } from './distance.js';
+export { ElementRectOptions, getElementRect } from './from-element.js';
+export { getRectFromPoints } from './from-points.js';
+export { fromRange } from './from-range.js';
+export { getRotationRect, rotate, toRad } from './from-rotation.js';
+export { WindowRectOptions, getViewportRect, getWindowRect } from './from-window.js';
+export { getElementPolygon } from './get-polygon.js';
+export { collisions, intersection, intersects } from './intersection.js';
+export { expand, inset, isSymmetric, shift, shrink } from './operations.js';
+export { debugPolygon, isPointInPolygon } from './polygon.js';
+export { Rect, createRect, getRectCenters, getRectCorners, getRectEdges, isRect } from './rect.js';
+export { Point, RectCenter, RectCenters, RectCorner, RectCorners, RectEdge, RectEdges, RectInset, RectPoint, RectPoints, RectSide, RectValue, SymmetricRectInset } from './types.js';
+export { union } from './union.js';

package/dist/index.js

@@ -103,7 +103,7 @@ function alignRect(a, ref, options) {
   return vAlign(hAlign(a, ref, h), ref, v);
 }
 
-// ../core/dist/index.mjs
+// ../core/src/guard.ts
 var hasProp = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
 
 // src/rect.ts
@@ -267,20 +267,19 @@ function contains(r, v) {
   return isRect(v) ? containsRect(r, v) : containsPoint(r, v);
 }
 
-// ../dom/dist/index.mjs
+// ../dom/src/get-computed-style.ts
 function getCache() {
   const g = globalThis;
   g.__styleCache = g.__styleCache || /* @__PURE__ */ new WeakMap();
   return g.__styleCache;
 }
 function getComputedStyle(el) {
-  var _a;
   if (!el)
     return {};
   const cache = getCache();
   let style = cache.get(el);
   if (!style) {
-    const win = (_a = el == null ? void 0 : el.ownerDocument.defaultView) != null ? _a : window;
+    const win = el?.ownerDocument.defaultView ?? window;
     style = win.getComputedStyle(el);
     cache.set(el, style);
   }
@@ -409,13 +408,13 @@ function getWindowRect(win, opts = {}) {
 }
 function getViewportRect(win, opts) {
   const { excludeScrollbar = false } = opts;
-  const { innerWidth: innerWidth2, innerHeight: innerHeight2, document: doc, visualViewport } = win;
-  const width = (visualViewport == null ? void 0 : visualViewport.width) || innerWidth2;
-  const height = (visualViewport == null ? void 0 : visualViewport.height) || innerHeight2;
+  const { innerWidth, innerHeight, document: doc, visualViewport } = win;
+  const width = visualViewport?.width || innerWidth;
+  const height = visualViewport?.height || innerHeight;
   const rect = { x: 0, y: 0, width, height };
   if (excludeScrollbar) {
-    const scrollbarWidth = innerWidth2 - doc.documentElement.clientWidth;
-    const scrollbarHeight = innerHeight2 - doc.documentElement.clientHeight;
+    const scrollbarWidth = innerWidth - doc.documentElement.clientWidth;
+    const scrollbarHeight = innerHeight - doc.documentElement.clientHeight;
     rect.width -= scrollbarWidth;
     rect.height -= scrollbarHeight;
   }