@wirekyt/dom 0.0.1 → 0.0.2

package/dist/rect-utils-DiT4k3jS.cjs

@@ -0,0 +1,548 @@
+//#region src/common/rect-utils/affine-transform.ts
+var AffineTransform = class AffineTransform {
+	m00;
+	m01;
+	m02;
+	m10;
+	m11;
+	m12;
+	constructor([m00, m01, m02, m10, m11, m12] = [
+		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) {
+		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,
+			this.m00 * other.m01 + this.m01 * other.m11,
+			this.m00 * other.m02 + this.m01 * other.m12 + this.m02,
+			this.m10 * other.m00 + this.m11 * other.m10,
+			this.m10 * other.m01 + this.m11 * other.m11,
+			this.m10 * other.m02 + this.m11 * other.m12 + this.m12
+		]);
+	}
+	append(other) {
+		return new AffineTransform([
+			other.m00 * this.m00 + other.m01 * this.m10,
+			other.m00 * this.m01 + other.m01 * this.m11,
+			other.m00 * this.m02 + other.m01 * this.m12 + other.m02,
+			other.m10 * this.m00 + other.m11 * this.m10,
+			other.m10 * this.m01 + other.m11 * this.m11,
+			other.m10 * this.m02 + other.m11 * this.m12 + other.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,
+			-this.m01 / det,
+			(this.m01 * this.m12 - this.m11 * this.m02) / det,
+			-this.m10 / det,
+			this.m00 / det,
+			(this.m10 * this.m02 - this.m00 * this.m12) / det
+		]);
+	}
+	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 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;
+	}
+	rotate = (...args) => {
+		return this.prepend(AffineTransform.rotate(...args));
+	};
+	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;
+	}
+	scale = (...args) => {
+		return this.prepend(AffineTransform.scale(...args));
+	};
+	static translate(tx, ty) {
+		return new AffineTransform([
+			1,
+			0,
+			tx,
+			0,
+			1,
+			ty
+		]);
+	}
+	translate = (...args) => {
+		return this.prepend(AffineTransform.translate(...args));
+	};
+	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})`;
+	}
+};
+//#endregion
+//#region src/common/rect-utils/rect.ts
+const createPoint = (x, y) => ({
+	x,
+	y
+});
+const subtractPoints = (a, b) => {
+	if (!b) return a;
+	return createPoint(a.x - b.x, a.y - b.y);
+};
+const 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) {
+	return {
+		top: createPoint(v.midX, v.minY),
+		right: createPoint(v.maxX, v.midY),
+		bottom: createPoint(v.midX, v.maxY),
+		left: createPoint(v.minX, v.midY)
+	};
+}
+function getRectCorners(v) {
+	return {
+		top: createPoint(v.minX, v.minY),
+		right: createPoint(v.maxX, v.minY),
+		bottom: createPoint(v.maxX, v.maxY),
+		left: createPoint(v.minX, v.maxY)
+	};
+}
+function getRectEdges(v) {
+	const c = getRectCorners(v);
+	return {
+		top: [c.top, c.right],
+		right: [c.right, c.bottom],
+		bottom: [c.left, c.bottom],
+		left: [c.top, c.left]
+	};
+}
+//#endregion
+//#region src/common/rect-utils/from-element.ts
+const styleCache = /* @__PURE__ */ new WeakMap();
+function getCacheComputedStyle(el) {
+	if (!styleCache.has(el)) {
+		const win = el.ownerDocument.defaultView || window;
+		styleCache.set(el, win.getComputedStyle(el));
+	}
+	return styleCache.get(el);
+}
+function getElementRect(el, opts = {}) {
+	return createRect(getClientRect(el, opts));
+}
+function getClientRect(el, opts = {}) {
+	const { excludeScrollbar = false, excludeBorders = false } = opts;
+	const { x, y, width, height } = el.getBoundingClientRect();
+	const r = {
+		x,
+		y,
+		width,
+		height
+	};
+	const { borderLeftWidth, borderTopWidth, borderRightWidth, borderBottomWidth } = getCacheComputedStyle(el);
+	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) => parseFloat(v.replace("px", ""));
+const sum = (...vals) => vals.reduce((sum, v) => sum + (v ? px(v) : 0), 0);
+//#endregion
+//#region src/common/rect-utils/from-points.ts
+function getRectFromPoints(...pts) {
+	const xs = pts.map((p) => p.x);
+	const ys = pts.map((p) => p.y);
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return createRect({
+		x,
+		y,
+		width: Math.max(...xs) - x,
+		height: Math.max(...ys) - y
+	});
+}
+//#endregion
+//#region src/common/rect-utils/union.ts
+const { min: min$1, max } = Math;
+function union(...rs) {
+	return getRectFromPoints({
+		x: min$1(...rs.map((r) => r.minX)),
+		y: min$1(...rs.map((r) => r.minY))
+	}, {
+		x: max(...rs.map((r) => r.maxX)),
+		y: max(...rs.map((r) => r.maxY))
+	});
+}
+//#endregion
+//#region src/common/rect-utils/from-range.ts
+function fromRange(range) {
+	let rs = [];
+	const rects = Array.from(range.getClientRects());
+	if (rects.length) {
+		rs = rs.concat(rects.map(createRect));
+		return union.apply(void 0, rs);
+	}
+	let start = 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(void 0, rs);
+}
+//#endregion
+//#region src/common/rect-utils/compass.ts
+const compassDirectionMap = {
+	n: {
+		x: .5,
+		y: 0
+	},
+	ne: {
+		x: 1,
+		y: 0
+	},
+	e: {
+		x: 1,
+		y: .5
+	},
+	se: {
+		x: 1,
+		y: 1
+	},
+	s: {
+		x: .5,
+		y: 1
+	},
+	sw: {
+		x: 0,
+		y: 1
+	},
+	w: {
+		x: 0,
+		y: .5
+	},
+	nw: {
+		x: 0,
+		y: 0
+	}
+};
+const oppositeDirectionMap = {
+	n: "s",
+	ne: "sw",
+	e: "w",
+	se: "nw",
+	s: "n",
+	sw: "ne",
+	w: "e",
+	nw: "se"
+};
+//#endregion
+//#region src/common/rect-utils/resize.ts
+const { sign, abs, min } = Math;
+function getRectExtentPoint(rect, direction) {
+	const { minX, minY, maxX, maxY, midX, midY } = rect;
+	return {
+		x: direction.includes("w") ? minX : direction.includes("e") ? maxX : midX,
+		y: direction.includes("n") ? minY : direction.includes("s") ? maxY : midY
+	};
+}
+function getOppositeDirection(direction) {
+	return oppositeDirectionMap[direction];
+}
+function resizeRect(rect, offset, direction, opts) {
+	const { scalingOriginMode, lockAspectRatio } = opts;
+	const extent = getRectExtentPoint(rect, direction);
+	const oppositeExtent = getRectExtentPoint(rect, getOppositeDirection(direction));
+	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) {
+	return createRectFromPoints(transform.applyTo({
+		x: rect.minX,
+		y: rect.minY
+	}), transform.applyTo({
+		x: rect.maxX,
+		y: rect.maxY
+	}), normalized);
+}
+//#endregion
+Object.defineProperty(exports, "AffineTransform", {
+	enumerable: true,
+	get: function() {
+		return AffineTransform;
+	}
+});
+Object.defineProperty(exports, "addPoints", {
+	enumerable: true,
+	get: function() {
+		return addPoints;
+	}
+});
+Object.defineProperty(exports, "createPoint", {
+	enumerable: true,
+	get: function() {
+		return createPoint;
+	}
+});
+Object.defineProperty(exports, "createRect", {
+	enumerable: true,
+	get: function() {
+		return createRect;
+	}
+});
+Object.defineProperty(exports, "fromRange", {
+	enumerable: true,
+	get: function() {
+		return fromRange;
+	}
+});
+Object.defineProperty(exports, "getElementRect", {
+	enumerable: true,
+	get: function() {
+		return getElementRect;
+	}
+});
+Object.defineProperty(exports, "getRectCenters", {
+	enumerable: true,
+	get: function() {
+		return getRectCenters;
+	}
+});
+Object.defineProperty(exports, "getRectCorners", {
+	enumerable: true,
+	get: function() {
+		return getRectCorners;
+	}
+});
+Object.defineProperty(exports, "getRectEdges", {
+	enumerable: true,
+	get: function() {
+		return getRectEdges;
+	}
+});
+Object.defineProperty(exports, "getRectFromPoints", {
+	enumerable: true,
+	get: function() {
+		return getRectFromPoints;
+	}
+});
+Object.defineProperty(exports, "isPoint", {
+	enumerable: true,
+	get: function() {
+		return isPoint;
+	}
+});
+Object.defineProperty(exports, "isRect", {
+	enumerable: true,
+	get: function() {
+		return isRect;
+	}
+});
+Object.defineProperty(exports, "resizeRect", {
+	enumerable: true,
+	get: function() {
+		return resizeRect;
+	}
+});
+Object.defineProperty(exports, "subtractPoints", {
+	enumerable: true,
+	get: function() {
+		return subtractPoints;
+	}
+});
+Object.defineProperty(exports, "union", {
+	enumerable: true,
+	get: function() {
+		return union;
+	}
+});