@zag-js/rect-utils 0.70.0 → 0.71.0

package/src/affine-transform.ts

@@ -1,177 +0,0 @@
-import type { Point } from "./types"
-
-export class AffineTransform {
-  m00: number
-  m01: number
-  m02: number
-  m10: number
-  m11: number
-  m12: number
-
-  constructor([m00, m01, m02, m10, m11, m12]: Iterable<number> = [0, 0, 0, 0, 0, 0]) {
-    this.m00 = m00
-    this.m01 = m01
-    this.m02 = m02
-    this.m10 = m10
-    this.m11 = m11
-    this.m12 = m12
-  }
-
-  applyTo(point: Point): 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: AffineTransform): AffineTransform {
-    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: AffineTransform): AffineTransform {
-    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(): number[] {
-    return [this.m00, this.m01, this.m02, this.m10, this.m11, this.m12, 0, 0, 1]
-  }
-
-  get float32Array(): Float32Array {
-    return new Float32Array(this.array)
-  }
-
-  // Static
-
-  static get identity(): AffineTransform {
-    return new AffineTransform([1, 0, 0, 0, 1, 0])
-  }
-
-  static rotate(theta: number, origin?: Point): AffineTransform {
-    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
-  }
-
-  rotate: (typeof AffineTransform)["rotate"] = (...args) => {
-    return this.prepend(AffineTransform.rotate(...args))
-  }
-
-  static scale(sx: number, sy: number = sx, origin: Point = { x: 0, y: 0 }): AffineTransform {
-    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
-  }
-
-  scale: (typeof AffineTransform)["scale"] = (...args) => {
-    return this.prepend(AffineTransform.scale(...args))
-  }
-
-  static translate(tx: number, ty: number): AffineTransform {
-    return new AffineTransform([1, 0, tx, 0, 1, ty])
-  }
-
-  translate: (typeof AffineTransform)["translate"] = (...args) => {
-    return this.prepend(AffineTransform.translate(...args))
-  }
-
-  static multiply(...[first, ...rest]: AffineTransform[]): AffineTransform {
-    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(): Point {
-    return { x: this.a, y: this.d }
-  }
-
-  get translationComponents(): Point {
-    return { x: this.tx, y: this.ty }
-  }
-
-  get skewComponents(): Point {
-    return { x: this.c, y: this.b }
-  }
-
-  toString() {
-    return `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.tx}, ${this.ty})`
-  }
-}

package/src/align.ts

@@ -1,26 +0,0 @@
-import type { AlignOptions, HAlign, Rect, VAlign } from "./types"
-
-function hAlign(a: Rect, ref: Rect, h: HAlign): Rect {
-  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: Rect, ref: Rect, v: VAlign): Rect {
-  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 }
-}
-
-export function alignRect(a: Rect, ref: Rect, options: AlignOptions): Rect {
-  const { h, v } = options
-  return vAlign(hAlign(a, ref, h), ref, v)
-}

package/src/clamp.ts

@@ -1,26 +0,0 @@
-import type { Point, RectInit, Size } from "./types"
-
-const clamp = (value: number, min: number, max: number) => Math.min(Math.max(value, min), max)
-
-export const clampPoint = (position: Point, size: Size, boundaryRect: RectInit) => {
-  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 }
-}
-
-const defaultMinSize: Size = {
-  width: 0,
-  height: 0,
-}
-
-const defaultMaxSize: Size = {
-  width: Infinity,
-  height: Infinity,
-}
-
-export const clampSize = (size: 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),
-  }
-}

package/src/closest.ts

@@ -1,44 +0,0 @@
-import { distance } from "./distance"
-import type { Point, Rect, RectSide } from "./types"
-
-export function closest(...pts: Point[]) {
-  return (a: Point): Point => {
-    const ds = pts.map((b) => distance(b, a))
-    const c = Math.min.apply(Math, ds)
-    return pts[ds.indexOf(c)]
-  }
-}
-
-export function closestSideToRect(ref: Rect, r: Rect): RectSide {
-  if (r.maxX <= ref.minX) return "left"
-  if (r.minX >= ref.maxX) return "right"
-  if (r.maxY <= ref.minY) return "top"
-  if (r.minY >= ref.maxY) return "bottom"
-  return "left"
-}
-
-export function closestSideToPoint(ref: Rect, p: Point): RectSide {
-  const { x, y } = p
-
-  const dl = x - ref.minX
-  const dr = ref.maxX - x
-  const dt = y - ref.minY
-  const db = ref.maxY - y
-
-  let closest = dl
-  let side: RectSide = "left"
-
-  if (dr < closest) {
-    closest = dr
-    side = "right"
-  }
-  if (dt < closest) {
-    closest = dt
-    side = "top"
-  }
-  if (db < closest) {
-    side = "bottom"
-  }
-
-  return side
-}

package/src/compass.ts

@@ -1,25 +0,0 @@
-import type { Point } from "./types"
-
-export type CompassDirection = "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw"
-
-export const compassDirectionMap: Record<CompassDirection, Point> = {
-  n: { x: 0.5, y: 0 },
-  ne: { x: 1, y: 0 },
-  e: { x: 1, y: 0.5 },
-  se: { x: 1, y: 1 },
-  s: { x: 0.5, y: 1 },
-  sw: { x: 0, y: 1 },
-  w: { x: 0, y: 0.5 },
-  nw: { x: 0, y: 0 },
-}
-
-export const oppositeDirectionMap: Record<CompassDirection, CompassDirection> = {
-  n: "s",
-  ne: "sw",
-  e: "w",
-  se: "nw",
-  s: "n",
-  sw: "ne",
-  w: "e",
-  nw: "se",
-}

package/src/constrain.ts

@@ -1,15 +0,0 @@
-import type { RectInit } from "./types"
-
-// given a rect and a boundary, return a new rect that is constrained within the boundary
-// resize or reposition the rect so that it fits within the boundary
-export const constrainRect = (rect: RectInit, boundary: RectInit): RectInit => {
-  const left = Math.max(boundary.x, Math.min(rect.x, boundary.x + boundary.width - rect.width))
-  const top = Math.max(boundary.y, Math.min(rect.y, boundary.y + boundary.height - rect.height))
-
-  return {
-    x: left,
-    y: top,
-    width: Math.min(rect.width, boundary.width),
-    height: Math.min(rect.height, boundary.height),
-  }
-}

package/src/contains.ts

@@ -1,14 +0,0 @@
-import { getRectCorners, isRect } from "./rect"
-import type { Point, Rect } from "./types"
-
-export function containsPoint(r: Rect, p: Point): boolean {
-  return r.minX <= p.x && p.x <= r.maxX && r.minY <= p.y && p.y <= r.maxY
-}
-
-export function containsRect(a: Rect, b: Rect): boolean {
-  return Object.values(getRectCorners(b)).every((c) => containsPoint(a, c))
-}
-
-export function contains(r: Rect, v: Rect | Point): boolean {
-  return isRect(v) ? containsRect(r, v) : containsPoint(r, v)
-}

package/src/distance.ts

@@ -1,44 +0,0 @@
-import { intersects } from "./intersection"
-import type { Point, Rect, RectSide } from "./types"
-
-export interface DistanceValue extends Point {
-  value: number
-}
-
-export function distance(a: Point, b: Point = { x: 0, y: 0 }): number {
-  return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2))
-}
-
-export function distanceFromPoint(r: Rect, p: Point): DistanceValue {
-  let x = 0
-  let y = 0
-
-  if (p.x < r.x) x = r.x - p.x
-  else if (p.x > r.maxX) x = p.x - r.maxX
-
-  if (p.y < r.y) y = r.y - p.y
-  else if (p.y > r.maxY) y = p.y - r.maxY
-  return { x, y, value: distance({ x, y }) }
-}
-
-export function distanceFromRect(a: Rect, b: Rect): DistanceValue {
-  if (intersects(a, b)) return { x: 0, y: 0, value: 0 }
-  const left = a.x < b.x ? a : b
-  const right = b.x < a.x ? a : b
-  const upper = a.y < b.y ? a : b
-  const lower = b.y < a.y ? a : b
-  let x = left.x === right.x ? 0 : right.x - left.maxX
-  x = Math.max(0, x)
-  let y = upper.y === lower.y ? 0 : lower.y - upper.maxY
-  y = Math.max(0, y)
-  return { x, y, value: distance({ x, y }) }
-}
-
-export function distanceBtwEdges(a: Rect, b: Rect): Record<RectSide, number> {
-  return {
-    left: b.x - a.x,
-    top: b.y - a.y,
-    right: a.maxX - b.maxX,
-    bottom: a.maxY - b.maxY,
-  }
-}

package/src/equality.ts

@@ -1,13 +0,0 @@
-import type { Point, RectInit, Size } from "./types"
-
-export const isSizeEqual = (a: Size, b: Size) => {
-  return a.width === b.width && a.height === b.height
-}
-
-export const isPointEqual = (a: Point, b: Point) => {
-  return a.x === b.x && a.y === b.y
-}
-
-export const isRectEqual = (a: RectInit, b: RectInit) => {
-  return isPointEqual(a, b) && isSizeEqual(a, b)
-}

package/src/from-element.ts

@@ -1,61 +0,0 @@
-import { createRect } from "./rect"
-import type { Rect } from "./types"
-
-const styleCache = new WeakMap<HTMLElement, any>()
-
-function getCacheComputedStyle(el: HTMLElement) {
-  if (!styleCache.has(el)) {
-    const win = el.ownerDocument.defaultView || window
-    styleCache.set(el, win.getComputedStyle(el))
-  }
-  return styleCache.get(el)
-}
-
-export function getElementRect(el: HTMLElement, opts: ElementRectOptions = {}): Rect {
-  return createRect(getClientRect(el, opts))
-}
-
-export 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
-}
-
-function getClientRect(el: HTMLElement, opts: ElementRectOptions = {}) {
-  const { excludeScrollbar = false, excludeBorders = false } = opts
-
-  const { x, y, width, height } = el.getBoundingClientRect()
-  const r = { x, y, width, height }
-
-  const style = getCacheComputedStyle(el)
-
-  const { borderLeftWidth, borderTopWidth, borderRightWidth, borderBottomWidth } = style
-
-  const borderXWidth = sum(borderLeftWidth, borderRightWidth)
-  const borderYWidth = sum(borderTopWidth, borderBottomWidth)
-
-  if (excludeBorders) {
-    r.width -= borderXWidth
-    r.height -= borderYWidth
-    r.x += px(borderLeftWidth)
-    r.y += px(borderTopWidth)
-  }
-
-  if (excludeScrollbar) {
-    const scrollbarWidth = el.offsetWidth - el.clientWidth - borderXWidth
-    const scrollbarHeight = el.offsetHeight - el.clientHeight - borderYWidth
-    r.width -= scrollbarWidth
-    r.height -= scrollbarHeight
-  }
-
-  return r
-}
-
-const px = (v: string) => parseFloat(v.replace("px", ""))
-
-const sum = (...vals: string[]) => vals.reduce((sum, v) => sum + (v ? px(v) : 0), 0)

package/src/from-points.ts

@@ -1,15 +0,0 @@
-import { createRect } from "./rect"
-import type { Point, Rect } from "./types"
-
-export function getRectFromPoints(...pts: Point[]): Rect {
-  const xs = pts.map((p) => p.x)
-  const ys = pts.map((p) => p.y)
-
-  const x = Math.min(...xs)
-  const y = Math.min(...ys)
-
-  const width = Math.max(...xs) - x
-  const height = Math.max(...ys) - y
-
-  return createRect({ x, y, width, height })
-}

package/src/from-range.ts

@@ -1,27 +0,0 @@
-import { createRect } from "./rect"
-import { getElementRect } from "./from-element"
-import { union } from "./union"
-import type { Rect } from "./types"
-
-export function fromRange(range: Range): Rect {
-  let rs: Rect[] = []
-  const rects = Array.from(range.getClientRects())
-
-  if (rects.length) {
-    rs = rs.concat(rects.map(createRect))
-    return union.apply(undefined, rs)
-  }
-
-  let start: Node | ParentNode | null = range.startContainer
-
-  if (start.nodeType === Node.TEXT_NODE) {
-    start = start.parentNode
-  }
-
-  if (start instanceof HTMLElement) {
-    const r = getElementRect(start)
-    rs.push({ ...r, x: r.maxX, width: 0 })
-  }
-
-  return union.apply(undefined, rs)
-}

package/src/from-rotation.ts

@@ -1,41 +0,0 @@
-import { createRect, getRectCorners } from "./rect"
-import type { Point, Rect } from "./types"
-
-export function toRad(d: number) {
-  return ((d % 360) * Math.PI) / 180
-}
-
-export function rotate(a: Point, d: number, c: Point): Point {
-  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,
-  }
-}
-
-export function getRotationRect(r: Rect, deg: number): Rect {
-  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,
-  })
-}

package/src/from-window.ts

@@ -1,34 +0,0 @@
-import { createRect } from "./rect"
-import type { Rect } from "./types"
-
-export type WindowRectOptions = {
-  /**
-   * Whether to exclude the element's scrollbar size from the calculation.
-   */
-  excludeScrollbar?: boolean
-}
-
-/**
- * Creates a rectange from window object
- */
-export function getWindowRect(win: Window, opts: WindowRectOptions = {}): Rect {
-  return createRect(getViewportRect(win, opts))
-}
-
-/**
- * Get the rect of the window with the option to exclude the scrollbar
- */
-export function getViewportRect(win: Window, opts: WindowRectOptions) {
-  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
-}

package/src/index.ts

@@ -1,20 +0,0 @@
-export * from "./affine-transform"
-export * from "./align"
-export * from "./clamp"
-export * from "./closest"
-export * from "./constrain"
-export * from "./contains"
-export * from "./distance"
-export * from "./equality"
-export * from "./from-element"
-export * from "./from-points"
-export * from "./from-range"
-export * from "./from-rotation"
-export * from "./from-window"
-export * from "./intersection"
-export * from "./operations"
-export * from "./polygon"
-export * from "./rect"
-export * from "./resize"
-export * from "./types"
-export * from "./union"

package/src/intersection.ts

@@ -1,32 +0,0 @@
-import { createRect } from "./rect"
-import type { Rect, RectSide } from "./types"
-
-/**
- * Checks if a Rect intersects another Rect
- */
-export function intersects(a: Rect, b: Rect): boolean {
-  return a.x < b.maxX && a.y < b.maxY && a.maxX > b.x && a.maxY > b.y
-}
-
-/**
- * Returns a new Rect that represents the intersection between two Rects
- */
-export function intersection(a: Rect, b: Rect): Rect {
-  const x = Math.max(a.x, b.x)
-  const y = Math.max(a.y, b.y)
-  const x2 = Math.min(a.x + a.width, b.x + b.width)
-  const y2 = Math.min(a.y + a.height, b.y + b.height)
-  return createRect({ x, y, width: x2 - x, height: y2 - y })
-}
-
-/**
- * Returns whether two rects collide along each edge
- */
-export function collisions(a: Rect, b: Rect): Record<RectSide, boolean> {
-  return {
-    top: a.minY <= b.minY,
-    right: a.maxX >= b.maxX,
-    bottom: a.maxY >= b.maxY,
-    left: a.minX <= b.minX,
-  }
-}

package/src/operations.ts

@@ -1,35 +0,0 @@
-import { createRect } from "./rect"
-import type { Point, Rect, RectInset, SymmetricRectInset } from "./types"
-
-export const isSymmetric = (v: any): v is SymmetricRectInset => "dx" in v || "dy" in v
-
-export function inset(r: Rect, i: RectInset | SymmetricRectInset): Rect {
-  const v = isSymmetric(i) ? { left: i.dx, right: i.dx, top: i.dy, bottom: i.dy } : i
-  const { top = 0, right = 0, bottom = 0, left = 0 } = v
-  return createRect({
-    x: r.x + left,
-    y: r.y + top,
-    width: r.width - left - right,
-    height: r.height - top - bottom,
-  })
-}
-
-export function expand(r: Rect, v: number | SymmetricRectInset): Rect {
-  const value = typeof v === "number" ? { dx: -v, dy: -v } : v
-  return inset(r, value)
-}
-
-export function shrink(r: Rect, v: number | SymmetricRectInset): Rect {
-  const value = typeof v === "number" ? { dx: -v, dy: -v } : v
-  return inset(r, value)
-}
-
-export function shift(r: Rect, o: Partial<Point>): Rect {
-  const { x = 0, y = 0 } = o
-  return createRect({
-    x: r.x + x,
-    y: r.y + y,
-    width: r.width,
-    height: r.height,
-  })
-}