@zag-js/rect-utils 1.34.0 → 1.35.0

package/dist/affine-transform.d.mts

@@ -0,0 +1,39 @@
+import { Point } from './types.mjs';
+
+declare class AffineTransform {
+    m00: number;
+    m01: number;
+    m02: number;
+    m10: number;
+    m11: number;
+    m12: number;
+    constructor([m00, m01, m02, m10, m11, m12]?: Iterable<number>);
+    applyTo(point: Point): Point;
+    prepend(other: AffineTransform): AffineTransform;
+    append(other: AffineTransform): AffineTransform;
+    get determinant(): number;
+    get isInvertible(): boolean;
+    invert(): AffineTransform;
+    get array(): number[];
+    get float32Array(): Float32Array;
+    static get identity(): AffineTransform;
+    static rotate(theta: number, origin?: Point): AffineTransform;
+    rotate: (typeof AffineTransform)["rotate"];
+    static scale(sx: number, sy?: number, origin?: Point): AffineTransform;
+    scale: (typeof AffineTransform)["scale"];
+    static translate(tx: number, ty: number): AffineTransform;
+    translate: (typeof AffineTransform)["translate"];
+    static multiply(...[first, ...rest]: AffineTransform[]): AffineTransform;
+    get a(): number;
+    get b(): number;
+    get c(): number;
+    get d(): number;
+    get tx(): number;
+    get ty(): number;
+    get scaleComponents(): Point;
+    get translationComponents(): Point;
+    get skewComponents(): Point;
+    toString(): string;
+}
+
+export { AffineTransform };

package/dist/affine-transform.d.ts

@@ -0,0 +1,39 @@
+import { Point } from './types.js';
+
+declare class AffineTransform {
+    m00: number;
+    m01: number;
+    m02: number;
+    m10: number;
+    m11: number;
+    m12: number;
+    constructor([m00, m01, m02, m10, m11, m12]?: Iterable<number>);
+    applyTo(point: Point): Point;
+    prepend(other: AffineTransform): AffineTransform;
+    append(other: AffineTransform): AffineTransform;
+    get determinant(): number;
+    get isInvertible(): boolean;
+    invert(): AffineTransform;
+    get array(): number[];
+    get float32Array(): Float32Array;
+    static get identity(): AffineTransform;
+    static rotate(theta: number, origin?: Point): AffineTransform;
+    rotate: (typeof AffineTransform)["rotate"];
+    static scale(sx: number, sy?: number, origin?: Point): AffineTransform;
+    scale: (typeof AffineTransform)["scale"];
+    static translate(tx: number, ty: number): AffineTransform;
+    translate: (typeof AffineTransform)["translate"];
+    static multiply(...[first, ...rest]: AffineTransform[]): AffineTransform;
+    get a(): number;
+    get b(): number;
+    get c(): number;
+    get d(): number;
+    get tx(): number;
+    get ty(): number;
+    get scaleComponents(): Point;
+    get translationComponents(): Point;
+    get skewComponents(): Point;
+    toString(): string;
+}
+
+export { AffineTransform };

package/dist/affine-transform.js

@@ -0,0 +1,189 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/affine-transform.ts
+var affine_transform_exports = {};
+__export(affine_transform_exports, {
+  AffineTransform: () => AffineTransform
+});
+module.exports = __toCommonJS(affine_transform_exports);
+var AffineTransform = class _AffineTransform {
+  constructor([m00, m01, m02, m10, m11, m12] = [0, 0, 0, 0, 0, 0]) {
+    __publicField(this, "m00");
+    __publicField(this, "m01");
+    __publicField(this, "m02");
+    __publicField(this, "m10");
+    __publicField(this, "m11");
+    __publicField(this, "m12");
+    __publicField(this, "rotate", (...args) => {
+      return this.prepend(_AffineTransform.rotate(...args));
+    });
+    __publicField(this, "scale", (...args) => {
+      return this.prepend(_AffineTransform.scale(...args));
+    });
+    __publicField(this, "translate", (...args) => {
+      return this.prepend(_AffineTransform.translate(...args));
+    });
+    this.m00 = m00;
+    this.m01 = m01;
+    this.m02 = m02;
+    this.m10 = m10;
+    this.m11 = m11;
+    this.m12 = m12;
+  }
+  applyTo(point) {
+    const { x, y } = point;
+    const { m00, m01, m02, m10, m11, m12 } = this;
+    return {
+      x: m00 * x + m01 * y + m02,
+      y: m10 * x + m11 * y + m12
+    };
+  }
+  prepend(other) {
+    return new _AffineTransform([
+      this.m00 * other.m00 + this.m01 * other.m10,
+      // m00
+      this.m00 * other.m01 + this.m01 * other.m11,
+      // m01
+      this.m00 * other.m02 + this.m01 * other.m12 + this.m02,
+      // m02
+      this.m10 * other.m00 + this.m11 * other.m10,
+      // m10
+      this.m10 * other.m01 + this.m11 * other.m11,
+      // m11
+      this.m10 * other.m02 + this.m11 * other.m12 + this.m12
+      // m12
+    ]);
+  }
+  append(other) {
+    return new _AffineTransform([
+      other.m00 * this.m00 + other.m01 * this.m10,
+      // m00
+      other.m00 * this.m01 + other.m01 * this.m11,
+      // m01
+      other.m00 * this.m02 + other.m01 * this.m12 + other.m02,
+      // m02
+      other.m10 * this.m00 + other.m11 * this.m10,
+      // m10
+      other.m10 * this.m01 + other.m11 * this.m11,
+      // m11
+      other.m10 * this.m02 + other.m11 * this.m12 + other.m12
+      // m12
+    ]);
+  }
+  get determinant() {
+    return this.m00 * this.m11 - this.m01 * this.m10;
+  }
+  get isInvertible() {
+    const det = this.determinant;
+    return isFinite(det) && isFinite(this.m02) && isFinite(this.m12) && det !== 0;
+  }
+  invert() {
+    const det = this.determinant;
+    return new _AffineTransform([
+      this.m11 / det,
+      // m00
+      -this.m01 / det,
+      // m01
+      (this.m01 * this.m12 - this.m11 * this.m02) / det,
+      // m02
+      -this.m10 / det,
+      // m10
+      this.m00 / det,
+      // m11
+      (this.m10 * this.m02 - this.m00 * this.m12) / det
+      // m12
+    ]);
+  }
+  get array() {
+    return [this.m00, this.m01, this.m02, this.m10, this.m11, this.m12, 0, 0, 1];
+  }
+  get float32Array() {
+    return new Float32Array(this.array);
+  }
+  // Static
+  static get identity() {
+    return new _AffineTransform([1, 0, 0, 0, 1, 0]);
+  }
+  static rotate(theta, origin) {
+    const rotation = new _AffineTransform([Math.cos(theta), -Math.sin(theta), 0, Math.sin(theta), Math.cos(theta), 0]);
+    if (origin && (origin.x !== 0 || origin.y !== 0)) {
+      return _AffineTransform.multiply(
+        _AffineTransform.translate(origin.x, origin.y),
+        rotation,
+        _AffineTransform.translate(-origin.x, -origin.y)
+      );
+    }
+    return rotation;
+  }
+  static scale(sx, sy = sx, origin = { x: 0, y: 0 }) {
+    const scale = new _AffineTransform([sx, 0, 0, 0, sy, 0]);
+    if (origin.x !== 0 || origin.y !== 0) {
+      return _AffineTransform.multiply(
+        _AffineTransform.translate(origin.x, origin.y),
+        scale,
+        _AffineTransform.translate(-origin.x, -origin.y)
+      );
+    }
+    return scale;
+  }
+  static translate(tx, ty) {
+    return new _AffineTransform([1, 0, tx, 0, 1, ty]);
+  }
+  static multiply(...[first, ...rest]) {
+    if (!first) return _AffineTransform.identity;
+    return rest.reduce((result, item) => result.prepend(item), first);
+  }
+  get a() {
+    return this.m00;
+  }
+  get b() {
+    return this.m10;
+  }
+  get c() {
+    return this.m01;
+  }
+  get d() {
+    return this.m11;
+  }
+  get tx() {
+    return this.m02;
+  }
+  get ty() {
+    return this.m12;
+  }
+  get scaleComponents() {
+    return { x: this.a, y: this.d };
+  }
+  get translationComponents() {
+    return { x: this.tx, y: this.ty };
+  }
+  get skewComponents() {
+    return { x: this.c, y: this.b };
+  }
+  toString() {
+    return `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.tx}, ${this.ty})`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AffineTransform
+});

package/dist/affine-transform.mjs

@@ -0,0 +1,166 @@
+import {
+  __publicField
+} from "./chunk-QZ7TP4HQ.mjs";
+
+// src/affine-transform.ts
+var AffineTransform = class _AffineTransform {
+  constructor([m00, m01, m02, m10, m11, m12] = [0, 0, 0, 0, 0, 0]) {
+    __publicField(this, "m00");
+    __publicField(this, "m01");
+    __publicField(this, "m02");
+    __publicField(this, "m10");
+    __publicField(this, "m11");
+    __publicField(this, "m12");
+    __publicField(this, "rotate", (...args) => {
+      return this.prepend(_AffineTransform.rotate(...args));
+    });
+    __publicField(this, "scale", (...args) => {
+      return this.prepend(_AffineTransform.scale(...args));
+    });
+    __publicField(this, "translate", (...args) => {
+      return this.prepend(_AffineTransform.translate(...args));
+    });
+    this.m00 = m00;
+    this.m01 = m01;
+    this.m02 = m02;
+    this.m10 = m10;
+    this.m11 = m11;
+    this.m12 = m12;
+  }
+  applyTo(point) {
+    const { x, y } = point;
+    const { m00, m01, m02, m10, m11, m12 } = this;
+    return {
+      x: m00 * x + m01 * y + m02,
+      y: m10 * x + m11 * y + m12
+    };
+  }
+  prepend(other) {
+    return new _AffineTransform([
+      this.m00 * other.m00 + this.m01 * other.m10,
+      // m00
+      this.m00 * other.m01 + this.m01 * other.m11,
+      // m01
+      this.m00 * other.m02 + this.m01 * other.m12 + this.m02,
+      // m02
+      this.m10 * other.m00 + this.m11 * other.m10,
+      // m10
+      this.m10 * other.m01 + this.m11 * other.m11,
+      // m11
+      this.m10 * other.m02 + this.m11 * other.m12 + this.m12
+      // m12
+    ]);
+  }
+  append(other) {
+    return new _AffineTransform([
+      other.m00 * this.m00 + other.m01 * this.m10,
+      // m00
+      other.m00 * this.m01 + other.m01 * this.m11,
+      // m01
+      other.m00 * this.m02 + other.m01 * this.m12 + other.m02,
+      // m02
+      other.m10 * this.m00 + other.m11 * this.m10,
+      // m10
+      other.m10 * this.m01 + other.m11 * this.m11,
+      // m11
+      other.m10 * this.m02 + other.m11 * this.m12 + other.m12
+      // m12
+    ]);
+  }
+  get determinant() {
+    return this.m00 * this.m11 - this.m01 * this.m10;
+  }
+  get isInvertible() {
+    const det = this.determinant;
+    return isFinite(det) && isFinite(this.m02) && isFinite(this.m12) && det !== 0;
+  }
+  invert() {
+    const det = this.determinant;
+    return new _AffineTransform([
+      this.m11 / det,
+      // m00
+      -this.m01 / det,
+      // m01
+      (this.m01 * this.m12 - this.m11 * this.m02) / det,
+      // m02
+      -this.m10 / det,
+      // m10
+      this.m00 / det,
+      // m11
+      (this.m10 * this.m02 - this.m00 * this.m12) / det
+      // m12
+    ]);
+  }
+  get array() {
+    return [this.m00, this.m01, this.m02, this.m10, this.m11, this.m12, 0, 0, 1];
+  }
+  get float32Array() {
+    return new Float32Array(this.array);
+  }
+  // Static
+  static get identity() {
+    return new _AffineTransform([1, 0, 0, 0, 1, 0]);
+  }
+  static rotate(theta, origin) {
+    const rotation = new _AffineTransform([Math.cos(theta), -Math.sin(theta), 0, Math.sin(theta), Math.cos(theta), 0]);
+    if (origin && (origin.x !== 0 || origin.y !== 0)) {
+      return _AffineTransform.multiply(
+        _AffineTransform.translate(origin.x, origin.y),
+        rotation,
+        _AffineTransform.translate(-origin.x, -origin.y)
+      );
+    }
+    return rotation;
+  }
+  static scale(sx, sy = sx, origin = { x: 0, y: 0 }) {
+    const scale = new _AffineTransform([sx, 0, 0, 0, sy, 0]);
+    if (origin.x !== 0 || origin.y !== 0) {
+      return _AffineTransform.multiply(
+        _AffineTransform.translate(origin.x, origin.y),
+        scale,
+        _AffineTransform.translate(-origin.x, -origin.y)
+      );
+    }
+    return scale;
+  }
+  static translate(tx, ty) {
+    return new _AffineTransform([1, 0, tx, 0, 1, ty]);
+  }
+  static multiply(...[first, ...rest]) {
+    if (!first) return _AffineTransform.identity;
+    return rest.reduce((result, item) => result.prepend(item), first);
+  }
+  get a() {
+    return this.m00;
+  }
+  get b() {
+    return this.m10;
+  }
+  get c() {
+    return this.m01;
+  }
+  get d() {
+    return this.m11;
+  }
+  get tx() {
+    return this.m02;
+  }
+  get ty() {
+    return this.m12;
+  }
+  get scaleComponents() {
+    return { x: this.a, y: this.d };
+  }
+  get translationComponents() {
+    return { x: this.tx, y: this.ty };
+  }
+  get skewComponents() {
+    return { x: this.c, y: this.b };
+  }
+  toString() {
+    return `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.tx}, ${this.ty})`;
+  }
+};
+export {
+  AffineTransform
+};

package/dist/align.d.mts

@@ -0,0 +1,5 @@
+import { Rect, AlignOptions } from './types.mjs';
+
+declare function alignRect(a: Rect, ref: Rect, options: AlignOptions): Rect;
+
+export { alignRect };

package/dist/align.d.ts

@@ -0,0 +1,5 @@
+import { Rect, AlignOptions } from './types.js';
+
+declare function alignRect(a: Rect, ref: Rect, options: AlignOptions): Rect;
+
+export { alignRect };

package/dist/align.js

@@ -0,0 +1,51 @@
+"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/align.ts
+var align_exports = {};
+__export(align_exports, {
+  alignRect: () => alignRect
+});
+module.exports = __toCommonJS(align_exports);
+function hAlign(a, ref, h) {
+  let x = ref.minX;
+  if (h === "left-inside") x = ref.minX;
+  if (h === "left-outside") x = ref.minX - ref.width;
+  if (h === "right-inside") x = ref.maxX - ref.width;
+  if (h === "right-outside") x = ref.maxX;
+  if (h === "center") x = ref.midX - ref.width / 2;
+  return { ...a, x };
+}
+function vAlign(a, ref, v) {
+  let y = ref.minY;
+  if (v === "top-inside") y = ref.minY;
+  if (v === "top-outside") y = ref.minY - a.height;
+  if (v === "bottom-inside") y = ref.maxY - a.height;
+  if (v === "bottom-outside") y = ref.maxY;
+  if (v === "center") y = ref.midY - a.height / 2;
+  return { ...a, y };
+}
+function alignRect(a, ref, options) {
+  const { h, v } = options;
+  return vAlign(hAlign(a, ref, h), ref, v);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alignRect
+});

package/dist/align.mjs

@@ -0,0 +1,28 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/align.ts
+function hAlign(a, ref, h) {
+  let x = ref.minX;
+  if (h === "left-inside") x = ref.minX;
+  if (h === "left-outside") x = ref.minX - ref.width;
+  if (h === "right-inside") x = ref.maxX - ref.width;
+  if (h === "right-outside") x = ref.maxX;
+  if (h === "center") x = ref.midX - ref.width / 2;
+  return { ...a, x };
+}
+function vAlign(a, ref, v) {
+  let y = ref.minY;
+  if (v === "top-inside") y = ref.minY;
+  if (v === "top-outside") y = ref.minY - a.height;
+  if (v === "bottom-inside") y = ref.maxY - a.height;
+  if (v === "bottom-outside") y = ref.maxY;
+  if (v === "center") y = ref.midY - a.height / 2;
+  return { ...a, y };
+}
+function alignRect(a, ref, options) {
+  const { h, v } = options;
+  return vAlign(hAlign(a, ref, h), ref, v);
+}
+export {
+  alignRect
+};

package/dist/angle.d.mts

@@ -0,0 +1,5 @@
+import { Rect, Point } from './types.mjs';
+
+declare function getPointAngle(rect: Rect, point: Point, reference?: Point): number;
+
+export { getPointAngle };

package/dist/angle.d.ts

@@ -0,0 +1,5 @@
+import { Rect, Point } from './types.js';
+
+declare function getPointAngle(rect: Rect, point: Point, reference?: Point): number;
+
+export { getPointAngle };

package/dist/angle.js

@@ -0,0 +1,35 @@
+"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/angle.ts
+var angle_exports = {};
+__export(angle_exports, {
+  getPointAngle: () => getPointAngle
+});
+module.exports = __toCommonJS(angle_exports);
+function getPointAngle(rect, point, reference = rect.center) {
+  const x = point.x - reference.x;
+  const y = point.y - reference.y;
+  const deg = Math.atan2(x, y) * (180 / Math.PI) + 180;
+  return 360 - deg;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPointAngle
+});

package/dist/angle.mjs

@@ -0,0 +1,12 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/angle.ts
+function getPointAngle(rect, point, reference = rect.center) {
+  const x = point.x - reference.x;
+  const y = point.y - reference.y;
+  const deg = Math.atan2(x, y) * (180 / Math.PI) + 180;
+  return 360 - deg;
+}
+export {
+  getPointAngle
+};

package/dist/chunk-QZ7TP4HQ.mjs

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __publicField
+};

package/dist/clamp.d.mts

@@ -0,0 +1,12 @@
+import { Point, Size, RectInit } from './types.mjs';
+
+declare const clampPoint: (position: Point, size: Size, boundaryRect: RectInit) => {
+    x: number;
+    y: number;
+};
+declare const clampSize: (size: Size, minSize?: Size, maxSize?: Size) => {
+    width: number;
+    height: number;
+};
+
+export { clampPoint, clampSize };

package/dist/clamp.d.ts

@@ -0,0 +1,12 @@
+import { Point, Size, RectInit } from './types.js';
+
+declare const clampPoint: (position: Point, size: Size, boundaryRect: RectInit) => {
+    x: number;
+    y: number;
+};
+declare const clampSize: (size: Size, minSize?: Size, maxSize?: Size) => {
+    width: number;
+    height: number;
+};
+
+export { clampPoint, clampSize };

package/dist/clamp.js

@@ -0,0 +1,51 @@
+"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/clamp.ts
+var clamp_exports = {};
+__export(clamp_exports, {
+  clampPoint: () => clampPoint,
+  clampSize: () => clampSize
+});
+module.exports = __toCommonJS(clamp_exports);
+var clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+var clampPoint = (position, size, boundaryRect) => {
+  const x = clamp(position.x, boundaryRect.x, boundaryRect.x + boundaryRect.width - size.width);
+  const y = clamp(position.y, boundaryRect.y, boundaryRect.y + boundaryRect.height - size.height);
+  return { x, y };
+};
+var defaultMinSize = {
+  width: 0,
+  height: 0
+};
+var defaultMaxSize = {
+  width: Infinity,
+  height: Infinity
+};
+var clampSize = (size, minSize = defaultMinSize, maxSize = defaultMaxSize) => {
+  return {
+    width: Math.min(Math.max(size.width, minSize.width), maxSize.width),
+    height: Math.min(Math.max(size.height, minSize.height), maxSize.height)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clampPoint,
+  clampSize
+});