@fulate/share 1.0.0

package/README.md

@@ -0,0 +1,27 @@
+# `@fulate/share`
+
+> 文档角色：`GUIDE`。权威来源：share 源码导出与测试；本包只提供低层纯工具，不拥有场景、领域或 Editor 状态。
+
+`@fulate/share` 是 Fulate 最底层的无场景工具包，提供点、矩形、矩阵、颜色、渐变和相交计算。
+
+- 点：`PointView`、`MutablePointView`、`createPointView()`、`transformPoint()`、距离判断；
+- 矩形：`Rect`、`BoundingBox`、可变 `Bound` 及 points/rects 边界计算；
+- 矩阵和数学：`qrDecompose()`、角度/弧度换算、矩形边缘位置；
+- 几何：`Intersection`、`clipPolygonToRect()`；
+- 颜色和渐变：颜色解析/格式化、alpha 合成、混色和 Canvas gradient 创建。
+
+```ts
+import {
+  Bound,
+  createPointView,
+  transformPoint,
+  colorWithAlpha
+} from "@fulate/share";
+
+const point = transformPoint(createPointView(10, 20), matrix);
+const bounds = Bound.fromPoints([point]);
+const overlay = colorWithAlpha("#6750a4", 0.12);
+```
+
+函数直接消费声明类型，不为 Core/UI 建立 DTO、registry 或缓存。返回可变 `Bound` 的方法按普通对象
+语义工作；调用方需要独立结果时使用明确的 `copy()` 或在自身 owner 内创建新值。

package/dist/Intersection.d.ts

@@ -0,0 +1,32 @@
+import type { PointView } from "./point";
+import type { BoundingBox, Rect } from "./rect";
+/** 将凸多边形裁剪到轴对齐矩形，并返回交集轮廓。 */
+export declare function clipPolygonToRect(subject: readonly PointView[], rect: Readonly<Rect>): PointView[];
+type IntersectionStatus = "Intersection" | "Coincident" | "Parallel";
+export declare class Intersection {
+    private points;
+    status?: IntersectionStatus;
+    private constructor();
+    private includes;
+    private append;
+    private static isPointOnSegment;
+    /** Return whether a point lies inside or on the boundary of an AABB. */
+    static isPointInRect(point: PointView, rect: Readonly<Rect> | Readonly<BoundingBox>): boolean;
+    /** 判断两个 AABB 是否相交；边界接触也算相交。 */
+    static isAABBIntersect(first: Readonly<Rect> | Readonly<BoundingBox>, second: Readonly<Rect> | Readonly<BoundingBox>): boolean;
+    static isPointInPolygon(point: PointView, points: readonly PointView[]): boolean;
+    private static intersectSegments;
+    private static intersectSegmentPolygon;
+    static isContainedInRect(rect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }, topLeft: PointView, bottomRight: PointView): boolean;
+    private static intersectPolygonPolygon;
+    static intersectPolygonRectangle(points: readonly PointView[], r1: PointView, r2: PointView): Intersection;
+    static pointToLineSegmentDistance(point: PointView, start: PointView, end: PointView): number;
+    static isPointInCircle(point: PointView, center: PointView, radius: number): boolean;
+    static isPointInRoundRect(point: PointView, width: number, height: number, radius: number): boolean;
+}
+export {};

package/dist/color.d.ts

@@ -0,0 +1,13 @@
+export declare function parseColor(val: string): import("colord").RgbaColor;
+export declare function formatColor(rgba: {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}): string;
+type RgbaColor = ReturnType<typeof parseColor>;
+export declare function parsePremultipliedColor(val: string): RgbaColor;
+export declare function formatPremultipliedColor({ r, g, b, a }: RgbaColor): string;
+export declare function blendColor(base: string, overlay: string, ratio: number): string;
+export declare function colorWithAlpha(color: string, alpha: number): string;
+export {};

package/dist/gradient.d.ts

@@ -0,0 +1,18 @@
+import type { MutablePointView } from "./point";
+export type GradientType = "linear" | "radial";
+export interface GradientStop {
+    color: string;
+    position: number;
+}
+export interface GradientOption {
+    type: GradientType;
+    stops: GradientStop[];
+    from?: MutablePointView;
+    to?: MutablePointView;
+    angle?: number;
+    center?: MutablePointView;
+    radius?: number;
+}
+export type BackgroundColor = string | GradientOption;
+export declare function isGradient(bg: BackgroundColor): bg is GradientOption;
+export declare function createCanvasGradient(ctx: CanvasRenderingContext2D, gradient: GradientOption, width: number, height: number): CanvasGradient;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { transformPoint, createPointView, isPointWithinDistance } from "./point";
+export type { MutablePointView, PointView } from "./point";
+export { Bound, makeBoundingBoxFromPoints, makeBoundsFromPoints, makeBoundingBoxFromRects } from "./rect";
+export type { Rect, RectWithCenter, BoundingBox } from "./rect";
+export { qrDecompose } from "./matrix";
+export { degreesToRadians, radiansToDegrees, rectEdgePosition } from "./math";
+export type { Edge } from "./math";
+export { Intersection, clipPolygonToRect } from "./Intersection";
+export { parseColor, formatColor, parsePremultipliedColor, formatPremultipliedColor, blendColor, colorWithAlpha } from "./color";
+export { isGradient, createCanvasGradient } from "./gradient";
+export type { GradientType, GradientStop, GradientOption, BackgroundColor } from "./gradient";

package/dist/index.js

@@ -0,0 +1,465 @@
+import { colord } from "colord";
+import { isString, isUndefined } from "lodash-es";
+//#region packages/share/src/point.ts
+function createPointView(x, y) {
+	return {
+		x,
+		y
+	};
+}
+function isPointWithinDistance(point, target, threshold) {
+	const dx = point.x - target.x;
+	const dy = point.y - target.y;
+	return dx * dx + dy * dy <= threshold ** 2;
+}
+function transformPoint(m, point, out) {
+	const x = m.a * point.x + m.c * point.y + m.e;
+	const y = m.b * point.x + m.d * point.y + m.f;
+	if (out) {
+		out.x = x;
+		out.y = y;
+		return out;
+	}
+	return createPointView(x, y);
+}
+//#endregion
+//#region packages/share/src/rect.ts
+function pointBounds(points) {
+	let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+	for (const { x, y } of points) {
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
+	}
+	return {
+		minX,
+		minY,
+		maxX,
+		maxY
+	};
+}
+function makeBoundingBoxFromPoints(points) {
+	const { minX, minY, maxX, maxY } = pointBounds(points);
+	return {
+		left: minX,
+		top: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+var Bound = class Bound {
+	minX;
+	minY;
+	maxX;
+	maxY;
+	constructor(minX = 0, minY = 0, maxX = 0, maxY = 0) {
+		this.minX = minX;
+		this.minY = minY;
+		this.maxX = maxX;
+		this.maxY = maxY;
+	}
+	get left() {
+		return this.minX;
+	}
+	get top() {
+		return this.minY;
+	}
+	get width() {
+		return this.maxX - this.minX;
+	}
+	get height() {
+		return this.maxY - this.minY;
+	}
+	get centerX() {
+		return (this.minX + this.maxX) / 2;
+	}
+	get centerY() {
+		return (this.minY + this.maxY) / 2;
+	}
+	merge(other) {
+		this.minX = Math.min(this.minX, other.minX);
+		this.minY = Math.min(this.minY, other.minY);
+		this.maxX = Math.max(this.maxX, other.maxX);
+		this.maxY = Math.max(this.maxY, other.maxY);
+		return this;
+	}
+	copy() {
+		return new Bound(this.minX, this.minY, this.maxX, this.maxY);
+	}
+	expand(padding, minSize = 0) {
+		this.minX -= padding;
+		this.minY -= padding;
+		this.maxX += padding;
+		this.maxY += padding;
+		if (minSize > 0) {
+			if (this.maxX - this.minX < minSize) {
+				const cx = (this.minX + this.maxX) / 2;
+				this.minX = cx - minSize / 2;
+				this.maxX = cx + minSize / 2;
+			}
+			if (this.maxY - this.minY < minSize) {
+				const cy = (this.minY + this.maxY) / 2;
+				this.minY = cy - minSize / 2;
+				this.maxY = cy + minSize / 2;
+			}
+		}
+		return this;
+	}
+	includePoint(x, y, padding = 0) {
+		this.minX = Math.min(this.minX, x - padding);
+		this.minY = Math.min(this.minY, y - padding);
+		this.maxX = Math.max(this.maxX, x + padding);
+		this.maxY = Math.max(this.maxY, y + padding);
+		return this;
+	}
+	static fromPoints(points) {
+		const { minX, minY, maxX, maxY } = pointBounds(points);
+		return new Bound(minX, minY, maxX, maxY);
+	}
+};
+function makeBoundsFromPoints(points) {
+	return pointBounds(points);
+}
+function makeBoundingBoxFromRects(rects) {
+	let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+	for (let i = 0; i < rects.length; i++) {
+		const r = rects[i];
+		if (r.left < minX) minX = r.left;
+		if (r.top < minY) minY = r.top;
+		if (r.left + r.width > maxX) maxX = r.left + r.width;
+		if (r.top + r.height > maxY) maxY = r.top + r.height;
+	}
+	return {
+		left: minX,
+		top: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+//#endregion
+//#region packages/share/src/math.ts
+var PiBy180 = Math.PI / 180;
+var degreesToRadians = (degrees) => degrees * PiBy180;
+var radiansToDegrees = (radians) => radians / PiBy180;
+/**
+* 矩形边上按 ratio 取点，同时返回朝外法线。
+* ratio ∈ [0, 1]，沿边的起点到终点方向插值。
+*/
+function rectEdgePosition(w, h, edge, ratio) {
+	switch (edge) {
+		case "top": return {
+			x: w * ratio,
+			y: 0,
+			nx: 0,
+			ny: -1
+		};
+		case "right": return {
+			x: w,
+			y: h * ratio,
+			nx: 1,
+			ny: 0
+		};
+		case "bottom": return {
+			x: w * ratio,
+			y: h,
+			nx: 0,
+			ny: 1
+		};
+		case "left": return {
+			x: 0,
+			y: h * ratio,
+			nx: -1,
+			ny: 0
+		};
+	}
+}
+//#endregion
+//#region packages/share/src/matrix.ts
+function qrDecompose(matrix) {
+	const { a, b, c, d } = matrix;
+	const angleRad = Math.atan2(b, a);
+	const cos = Math.cos(-angleRad);
+	const sin = Math.sin(-angleRad);
+	const a1 = a * cos - b * sin;
+	const c1 = c * cos - d * sin;
+	const d1 = c * sin + d * cos;
+	return {
+		angle: radiansToDegrees(angleRad),
+		scaleX: a1,
+		scaleY: d1,
+		skewX: radiansToDegrees(Math.atan2(c1, d1))
+	};
+}
+//#endregion
+//#region packages/share/src/Intersection.ts
+/** 将凸多边形裁剪到轴对齐矩形，并返回交集轮廓。 */
+function clipPolygonToRect(subject, rect) {
+	const boundaries = [
+		[
+			"x",
+			rect.left,
+			1
+		],
+		[
+			"x",
+			rect.left + rect.width,
+			-1
+		],
+		[
+			"y",
+			rect.top,
+			1
+		],
+		[
+			"y",
+			rect.top + rect.height,
+			-1
+		]
+	];
+	let output = [...subject];
+	for (const [axis, edge, direction] of boundaries) {
+		const input = output;
+		output = [];
+		if (input.length === 0) break;
+		let previous = input[input.length - 1];
+		let previousDistance = direction * (previous[axis] - edge);
+		let previousInside = previousDistance >= 0;
+		for (const current of input) {
+			const currentDistance = direction * (current[axis] - edge);
+			const currentInside = currentDistance >= 0;
+			if (currentInside !== previousInside) {
+				const ratio = previousDistance / (previousDistance - currentDistance);
+				output.push({
+					x: previous.x + (current.x - previous.x) * ratio,
+					y: previous.y + (current.y - previous.y) * ratio
+				});
+			}
+			if (currentInside) output.push(current);
+			previous = current;
+			previousDistance = currentDistance;
+			previousInside = currentInside;
+		}
+	}
+	return output;
+}
+var Intersection = class Intersection {
+	points = [];
+	status;
+	constructor(status) {
+		this.status = status;
+	}
+	includes(point) {
+		return this.points.some((item) => item.x === point.x && item.y === point.y);
+	}
+	append(...points) {
+		this.points.push(...points.filter((point) => !this.includes(point)));
+		return this;
+	}
+	static isPointOnSegment(point, start, end, tolerance = 0) {
+		const dx = end.x - start.x;
+		const dy = end.y - start.y;
+		const cross = (point.x - start.x) * dy - (point.y - start.y) * dx;
+		if (Math.abs(cross) > tolerance) return false;
+		return point.x >= Math.min(start.x, end.x) - tolerance && point.x <= Math.max(start.x, end.x) + tolerance && point.y >= Math.min(start.y, end.y) - tolerance && point.y <= Math.max(start.y, end.y) + tolerance;
+	}
+	/** Return whether a point lies inside or on the boundary of an AABB. */
+	static isPointInRect(point, rect) {
+		const minX = "minX" in rect ? rect.minX : rect.left;
+		const minY = "minY" in rect ? rect.minY : rect.top;
+		const maxX = "maxX" in rect ? rect.maxX : rect.left + rect.width;
+		const maxY = "maxY" in rect ? rect.maxY : rect.top + rect.height;
+		return point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY;
+	}
+	/** 判断两个 AABB 是否相交；边界接触也算相交。 */
+	static isAABBIntersect(first, second) {
+		const firstMinX = "minX" in first ? first.minX : first.left;
+		const firstMinY = "minY" in first ? first.minY : first.top;
+		const firstMaxX = "maxX" in first ? first.maxX : first.left + first.width;
+		const firstMaxY = "maxY" in first ? first.maxY : first.top + first.height;
+		const secondMinX = "minX" in second ? second.minX : second.left;
+		const secondMinY = "minY" in second ? second.minY : second.top;
+		const secondMaxX = "maxX" in second ? second.maxX : second.left + second.width;
+		const secondMaxY = "maxY" in second ? second.maxY : second.top + second.height;
+		return firstMinX <= secondMaxX && firstMaxX >= secondMinX && firstMinY <= secondMaxY && firstMaxY >= secondMinY;
+	}
+	static isPointInPolygon(point, points) {
+		if (points.length < 3) return false;
+		let inside = false;
+		for (let index = 0, previous = points.length - 1; index < points.length; previous = index++) {
+			const current = points[index];
+			const prior = points[previous];
+			if (this.isPointOnSegment(point, prior, current, 1e-9)) return true;
+			if (current.y > point.y !== prior.y > point.y && point.x < (prior.x - current.x) * (point.y - current.y) / (prior.y - current.y) + current.x) inside = !inside;
+		}
+		return inside;
+	}
+	static intersectSegments(a1, a2, b1, b2) {
+		const a2xa1x = a2.x - a1.x;
+		const a2ya1y = a2.y - a1.y;
+		const b2xb1x = b2.x - b1.x;
+		const b2yb1y = b2.y - b1.y;
+		const a1xb1x = a1.x - b1.x;
+		const a1yb1y = a1.y - b1.y;
+		const uaT = b2xb1x * a1yb1y - b2yb1y * a1xb1x;
+		const ubT = a2xa1x * a1yb1y - a2ya1y * a1xb1x;
+		const uB = b2yb1y * a2xa1x - b2xb1x * a2ya1y;
+		if (uB !== 0) {
+			const ua = uaT / uB;
+			const ub = ubT / uB;
+			if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) return new Intersection("Intersection").append({
+				x: a1.x + ua * a2xa1x,
+				y: a1.y + ua * a2ya1y
+			});
+			return new Intersection();
+		}
+		if (uaT === 0 || ubT === 0) return new Intersection(this.isPointOnSegment(a1, b1, b2) || this.isPointOnSegment(a2, b1, b2) || this.isPointOnSegment(b1, a1, a2) || this.isPointOnSegment(b2, a1, a2) ? "Coincident" : void 0);
+		return new Intersection("Parallel");
+	}
+	static intersectSegmentPolygon(start, end, points) {
+		const result = new Intersection();
+		for (let index = 0; index < points.length; index++) {
+			const intersection = this.intersectSegments(start, end, points[index], points[(index + 1) % points.length]);
+			if (intersection.status === "Coincident") return intersection;
+			result.append(...intersection.points);
+		}
+		if (result.points.length) result.status = "Intersection";
+		return result;
+	}
+	static isContainedInRect(rect, topLeft, bottomRight) {
+		return rect.left >= topLeft.x && rect.left + rect.width <= bottomRight.x && rect.top >= topLeft.y && rect.top + rect.height <= bottomRight.y;
+	}
+	static intersectPolygonPolygon(points1, points2) {
+		const result = new Intersection();
+		let coincidentEdges = 0;
+		for (let index = 0; index < points1.length; index++) {
+			const start = points1[index];
+			const end = points1[(index + 1) % points1.length];
+			const intersection = this.intersectSegmentPolygon(start, end, points2);
+			if (intersection.status === "Coincident") {
+				coincidentEdges++;
+				result.append(start, end);
+			} else result.append(...intersection.points);
+		}
+		if (coincidentEdges && coincidentEdges === points1.length) return new Intersection("Coincident");
+		if (result.points.length) result.status = "Intersection";
+		return result;
+	}
+	static intersectPolygonRectangle(points, r1, r2) {
+		const minX = Math.min(r1.x, r2.x);
+		const minY = Math.min(r1.y, r2.y);
+		const maxX = Math.max(r1.x, r2.x);
+		const maxY = Math.max(r1.y, r2.y);
+		return this.intersectPolygonPolygon(points, [
+			{
+				x: minX,
+				y: minY
+			},
+			{
+				x: maxX,
+				y: minY
+			},
+			{
+				x: maxX,
+				y: maxY
+			},
+			{
+				x: minX,
+				y: maxY
+			}
+		]);
+	}
+	static pointToLineSegmentDistance(point, start, end) {
+		const segmentX = end.x - start.x;
+		const segmentY = end.y - start.y;
+		const lengthSquared = segmentX * segmentX + segmentY * segmentY;
+		const ratio = lengthSquared ? ((point.x - start.x) * segmentX + (point.y - start.y) * segmentY) / lengthSquared : 0;
+		const nearestX = ratio <= 0 ? start.x : ratio >= 1 ? end.x : start.x + ratio * segmentX;
+		const nearestY = ratio <= 0 ? start.y : ratio >= 1 ? end.y : start.y + ratio * segmentY;
+		return Math.hypot(point.x - nearestX, point.y - nearestY);
+	}
+	static isPointInCircle(point, center, radius) {
+		const dx = point.x - center.x;
+		const dy = point.y - center.y;
+		return dx * dx + dy * dy <= radius * radius;
+	}
+	static isPointInRoundRect(point, width, height, radius) {
+		const x = Math.abs(point.x - width / 2);
+		const y = Math.abs(point.y - height / 2);
+		if (x > width / 2 || y > height / 2) return false;
+		if (x <= width / 2 - radius || y <= height / 2 - radius) return true;
+		const dx = x - (width / 2 - radius);
+		const dy = y - (height / 2 - radius);
+		return dx * dx + dy * dy <= radius * radius;
+	}
+};
+//#endregion
+//#region packages/share/src/color.ts
+function resolve(val) {
+	return !val || val === "transparent" ? "rgba(0,0,0,0)" : val;
+}
+function parseColor(val) {
+	return colord(resolve(val)).toRgb();
+}
+function formatColor(rgba) {
+	return colord(rgba).toRgbString();
+}
+function parsePremultipliedColor(val) {
+	const { r, g, b, a } = parseColor(val);
+	return {
+		r: r * a,
+		g: g * a,
+		b: b * a,
+		a
+	};
+}
+function formatPremultipliedColor({ r, g, b, a }) {
+	if (a === 0) return formatColor({
+		r: 0,
+		g: 0,
+		b: 0,
+		a
+	});
+	return formatColor({
+		r: r / a,
+		g: g / a,
+		b: b / a,
+		a
+	});
+}
+function blendColor(base, overlay, ratio) {
+	const b = colord(resolve(base)).toRgb();
+	const o = colord(resolve(overlay)).toRgb();
+	return colord({
+		r: b.r * (1 - ratio) + o.r * ratio,
+		g: b.g * (1 - ratio) + o.g * ratio,
+		b: b.b * (1 - ratio) + o.b * ratio,
+		a: b.a * (1 - ratio) + o.a * ratio
+	}).toRgbString();
+}
+function colorWithAlpha(color, alpha) {
+	return colord(resolve(color)).alpha(alpha).toRgbString();
+}
+//#endregion
+//#region packages/share/src/gradient.ts
+function isGradient(bg) {
+	return !isString(bg);
+}
+function createCanvasGradient(ctx, gradient, width, height) {
+	let result;
+	if (gradient.type === "radial") {
+		const x = (gradient.center?.x ?? .5) * width;
+		const y = (gradient.center?.y ?? .5) * height;
+		const radius = (gradient.radius ?? .5) * Math.max(width, height);
+		result = ctx.createRadialGradient(x, y, 0, x, y, radius);
+	} else if (!isUndefined(gradient.angle)) {
+		const angle = (gradient.angle - 90) * Math.PI / 180;
+		const x = Math.cos(angle) * .5;
+		const y = Math.sin(angle) * .5;
+		result = ctx.createLinearGradient(width * (.5 - x), height * (.5 - y), width * (.5 + x), height * (.5 + y));
+	} else result = ctx.createLinearGradient((gradient.from?.x ?? 0) * width, (gradient.from?.y ?? 0) * height, (gradient.to?.x ?? 1) * width, (gradient.to?.y ?? 0) * height);
+	for (const stop of gradient.stops) result.addColorStop(stop.position, stop.color);
+	return result;
+}
+//#endregion
+export { Bound, Intersection, blendColor, clipPolygonToRect, colorWithAlpha, createCanvasGradient, createPointView, degreesToRadians, formatColor, formatPremultipliedColor, isGradient, isPointWithinDistance, makeBoundingBoxFromPoints, makeBoundingBoxFromRects, makeBoundsFromPoints, parseColor, parsePremultipliedColor, qrDecompose, radiansToDegrees, rectEdgePosition, transformPoint };

package/dist/math.d.ts

@@ -0,0 +1,13 @@
+export declare const degreesToRadians: (degrees: number) => number;
+export declare const radiansToDegrees: (radians: number) => number;
+export type Edge = "top" | "right" | "bottom" | "left";
+/**
+ * 矩形边上按 ratio 取点，同时返回朝外法线。
+ * ratio ∈ [0, 1]，沿边的起点到终点方向插值。
+ */
+export declare function rectEdgePosition(w: number, h: number, edge: Edge, ratio: number): {
+    x: number;
+    y: number;
+    nx: number;
+    ny: number;
+};

package/dist/matrix.d.ts

@@ -0,0 +1,6 @@
+export declare function qrDecompose(matrix: DOMMatrixReadOnly): {
+    angle: number;
+    scaleX: number;
+    scaleY: number;
+    skewX: number;
+};

package/dist/point.d.ts

@@ -0,0 +1,11 @@
+export type PointView = {
+    readonly x: number;
+    readonly y: number;
+};
+export type MutablePointView = {
+    -readonly [Key in keyof PointView]: PointView[Key];
+};
+export declare function createPointView(x: number, y: number): PointView;
+export declare function isPointWithinDistance(point: PointView, target: PointView, threshold: number): boolean;
+export declare function transformPoint(m: DOMMatrixReadOnly, point: PointView): PointView;
+export declare function transformPoint<T extends MutablePointView>(m: DOMMatrixReadOnly, point: PointView, out: T): T;

package/dist/rect.d.ts

@@ -0,0 +1,38 @@
+import type { PointView } from "./point";
+export interface Rect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface RectWithCenter extends Rect {
+    centerX?: number;
+    centerY?: number;
+}
+export interface BoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export declare function makeBoundingBoxFromPoints(points: readonly PointView[]): Rect;
+export declare class Bound implements RectWithCenter {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    constructor(minX?: number, minY?: number, maxX?: number, maxY?: number);
+    get left(): number;
+    get top(): number;
+    get width(): number;
+    get height(): number;
+    get centerX(): number;
+    get centerY(): number;
+    merge(other: Bound): this;
+    copy(): Bound;
+    expand(padding: number, minSize?: number): this;
+    includePoint(x: number, y: number, padding?: number): this;
+    static fromPoints(points: readonly PointView[]): Bound;
+}
+export declare function makeBoundsFromPoints(points: readonly PointView[]): BoundingBox;
+export declare function makeBoundingBoxFromRects(rects: readonly Rect[]): Rect;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@fulate/share",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "test": "vitest run --config vitest.config.ts"
+  },
+  "dependencies": {
+    "colord": "^2.9.3",
+    "lodash-es": "^4.17.22"
+  }
+}