@react-arch/geometry 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 React Arch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+import { EPSILON, Vec2, Vec2 as Vec2$1, Vec3 } from "@react-arch/shared";
+
+//#region src/vec2.d.ts
+declare const add: (a: Vec2$1, b: Vec2$1) => Vec2$1;
+declare const sub: (a: Vec2$1, b: Vec2$1) => Vec2$1;
+declare const scale: (a: Vec2$1, s: number) => Vec2$1;
+declare const dot: (a: Vec2$1, b: Vec2$1) => number;
+declare const cross: (a: Vec2$1, b: Vec2$1) => number;
+declare const length: (a: Vec2$1) => number;
+declare const distance: (a: Vec2$1, b: Vec2$1) => number;
+declare function normalize(a: Vec2$1): Vec2$1;
+/** Left-hand normal of a vector (rotate +90°). */
+declare function normal(a: Vec2$1): Vec2$1;
+declare function lerp(a: Vec2$1, b: Vec2$1, t: number): Vec2$1;
+declare function angle(a: Vec2$1, b: Vec2$1): number;
+declare function equals(a: Vec2$1, b: Vec2$1, eps?: number): boolean;
+/** Project point p onto the segment [a,b], returning the closest point + t. */
+declare function projectPointOnSegment(p: Vec2$1, a: Vec2$1, b: Vec2$1): {
+  point: Vec2$1;
+  t: number;
+  distance: number;
+};
+//#endregion
+//#region src/line.d.ts
+interface Segment {
+  a: Vec2$1;
+  b: Vec2$1;
+}
+/**
+ * Intersection of two infinite lines defined by segments. Returns null when
+ * the lines are parallel (within EPSILON).
+ */
+declare function lineIntersection(s1: Segment, s2: Segment): Vec2$1 | null;
+/**
+ * Intersection point of two finite segments, or null if they don't cross.
+ */
+declare function segmentIntersection(s1: Segment, s2: Segment): Vec2$1 | null;
+//#endregion
+//#region src/polygon.d.ts
+/** Signed area (positive = counter-clockwise winding). */
+declare function signedArea(polygon: Vec2$1[]): number;
+declare function polygonArea(polygon: Vec2$1[]): number;
+declare function polygonCentroid(polygon: Vec2$1[]): Vec2$1;
+declare function isClockwise(polygon: Vec2$1[]): boolean;
+declare function ensureCounterClockwise(polygon: Vec2$1[]): Vec2$1[];
+/** Axis-aligned bounding box of a set of points. */
+declare function bounds(points: Vec2$1[]): {
+  min: Vec2$1;
+  max: Vec2$1;
+  width: number;
+  height: number;
+};
+declare function pointInPolygon(point: Vec2$1, polygon: Vec2$1[]): boolean;
+//#endregion
+//#region src/wall.d.ts
+interface WallLike {
+  start: Vec2$1;
+  end: Vec2$1;
+  thickness: number;
+}
+declare function wallLength(wall: WallLike): number;
+declare function wallDirection(wall: WallLike): Vec2$1;
+/**
+ * Generate the visible quad polygon of a wall from its centerline and
+ * thickness. Vertices are ordered counter-clockwise.
+ */
+declare function wallPolygon(wall: WallLike, extendEnds?: number): Vec2$1[];
+/** World position of a point at distance `offset` along the wall centerline. */
+declare function pointAlongWall(wall: WallLike, offset: number): Vec2$1;
+interface OpeningLike {
+  offset: number;
+  width: number;
+}
+/**
+ * The two centerline endpoints of an opening cut, clamped to the wall length.
+ */
+declare function openingSpan(wall: WallLike, opening: OpeningLike): {
+  start: Vec2$1;
+  end: Vec2$1;
+  center: Vec2$1;
+};
+/** Whether an opening fits entirely within the wall it is attached to. */
+declare function openingFits(wall: WallLike, opening: OpeningLike): boolean;
+interface WallOpeningInput extends OpeningLike {
+  /** Bottom of the opening above the floor. */
+  sillHeight: number;
+  /** Opening height. */
+  height: number;
+}
+/**
+ * A solid box of the wall expressed in wall-local coordinates: `along` runs
+ * from the wall start, `z` is vertical. The 3D renderer extrudes each box by
+ * the wall thickness. This is how openings are "cut" without CSG — the wall is
+ * decomposed into the solid pieces that remain around its openings.
+ */
+interface WallBox {
+  along0: number;
+  along1: number;
+  z0: number;
+  z1: number;
+}
+declare function wallBoxes(wall: WallLike, openings: WallOpeningInput[], wallHeight: number,
+/**
+ * Extend the solid wall by this much past each end. Pass `thickness / 2` so
+ * walls meeting at a corner overlap and fill the corner square — otherwise
+ * each centerline box stops short and leaves a notch.
+ */
+
+extendEnds?: number): WallBox[];
+//#endregion
+//#region src/snap.d.ts
+type SnapKind = "endpoint" | "midpoint" | "grid" | "perpendicular";
+interface SnapResult {
+  point: Vec2$1;
+  kind: SnapKind;
+  distance: number;
+}
+interface SnapSegment {
+  a: Vec2$1;
+  b: Vec2$1;
+}
+declare function snapToGrid(point: Vec2$1, gridSize: number): Vec2$1;
+/**
+ * Find the best snap candidate near `point`. Endpoint and midpoint snaps take
+ * priority over grid snaps within the given pixel/world tolerance.
+ */
+declare function findSnap(point: Vec2$1, segments: SnapSegment[], options?: {
+  tolerance: number;
+  gridSize?: number;
+}): SnapResult | null;
+//#endregion
+export { EPSILON, OpeningLike, Segment, SnapKind, SnapResult, SnapSegment, type Vec2, type Vec3, WallBox, WallLike, WallOpeningInput, add, angle, bounds, cross, distance, dot, ensureCounterClockwise, equals, findSnap, isClockwise, length, lerp, lineIntersection, normal, normalize, openingFits, openingSpan, pointAlongWall, pointInPolygon, polygonArea, polygonCentroid, projectPointOnSegment, scale, segmentIntersection, signedArea, snapToGrid, sub, wallBoxes, wallDirection, wallLength, wallPolygon };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/vec2.ts","../src/line.ts","../src/polygon.ts","../src/wall.ts","../src/snap.ts"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,308 @@
+import { EPSILON, EPSILON as EPSILON$1 } from "@react-arch/shared";
+//#region src/vec2.ts
+const add = (a, b) => [a[0] + b[0], a[1] + b[1]];
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1]];
+const scale = (a, s) => [a[0] * s, a[1] * s];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+const cross = (a, b) => a[0] * b[1] - a[1] * b[0];
+const length = (a) => Math.hypot(a[0], a[1]);
+const distance = (a, b) => length(sub(a, b));
+function normalize(a) {
+	const len = length(a);
+	if (len < EPSILON$1) return [0, 0];
+	return [a[0] / len, a[1] / len];
+}
+/** Left-hand normal of a vector (rotate +90°). */
+function normal(a) {
+	return [-a[1], a[0]];
+}
+function lerp(a, b, t) {
+	return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+function angle(a, b) {
+	return Math.atan2(b[1] - a[1], b[0] - a[0]);
+}
+function equals(a, b, eps = EPSILON$1) {
+	return Math.abs(a[0] - b[0]) <= eps && Math.abs(a[1] - b[1]) <= eps;
+}
+/** Project point p onto the segment [a,b], returning the closest point + t. */
+function projectPointOnSegment(p, a, b) {
+	const ab = sub(b, a);
+	const len2 = dot(ab, ab);
+	if (len2 < EPSILON$1) return {
+		point: a,
+		t: 0,
+		distance: distance(p, a)
+	};
+	let t = dot(sub(p, a), ab) / len2;
+	t = Math.max(0, Math.min(1, t));
+	const point = add(a, scale(ab, t));
+	return {
+		point,
+		t,
+		distance: distance(p, point)
+	};
+}
+//#endregion
+//#region src/line.ts
+/**
+* Intersection of two infinite lines defined by segments. Returns null when
+* the lines are parallel (within EPSILON).
+*/
+function lineIntersection(s1, s2) {
+	const r = sub(s1.b, s1.a);
+	const s = sub(s2.b, s2.a);
+	const denom = cross(r, s);
+	if (Math.abs(denom) < EPSILON$1) return null;
+	const t = cross(sub(s2.a, s1.a), s) / denom;
+	return [s1.a[0] + t * r[0], s1.a[1] + t * r[1]];
+}
+/**
+* Intersection point of two finite segments, or null if they don't cross.
+*/
+function segmentIntersection(s1, s2) {
+	const r = sub(s1.b, s1.a);
+	const s = sub(s2.b, s2.a);
+	const denom = cross(r, s);
+	if (Math.abs(denom) < EPSILON$1) return null;
+	const qp = sub(s2.a, s1.a);
+	const t = cross(qp, s) / denom;
+	const u = cross(qp, r) / denom;
+	if (t < -EPSILON$1 || t > 1 + EPSILON$1 || u < -EPSILON$1 || u > 1 + EPSILON$1) return null;
+	return [s1.a[0] + t * r[0], s1.a[1] + t * r[1]];
+}
+//#endregion
+//#region src/polygon.ts
+/** Signed area (positive = counter-clockwise winding). */
+function signedArea(polygon) {
+	let sum = 0;
+	for (let i = 0; i < polygon.length; i++) {
+		const a = polygon[i];
+		const b = polygon[(i + 1) % polygon.length];
+		sum += a[0] * b[1] - b[0] * a[1];
+	}
+	return sum / 2;
+}
+function polygonArea(polygon) {
+	return Math.abs(signedArea(polygon));
+}
+function polygonCentroid(polygon) {
+	let cx = 0;
+	let cy = 0;
+	let a = 0;
+	for (let i = 0; i < polygon.length; i++) {
+		const p0 = polygon[i];
+		const p1 = polygon[(i + 1) % polygon.length];
+		const f = p0[0] * p1[1] - p1[0] * p0[1];
+		cx += (p0[0] + p1[0]) * f;
+		cy += (p0[1] + p1[1]) * f;
+		a += f;
+	}
+	if (Math.abs(a) < 1e-9) {
+		const n = polygon.length || 1;
+		return [polygon.reduce((s, p) => s + p[0], 0) / n, polygon.reduce((s, p) => s + p[1], 0) / n];
+	}
+	a *= 3;
+	return [cx / a, cy / a];
+}
+function isClockwise(polygon) {
+	return signedArea(polygon) < 0;
+}
+function ensureCounterClockwise(polygon) {
+	return isClockwise(polygon) ? [...polygon].reverse() : polygon;
+}
+/** Axis-aligned bounding box of a set of points. */
+function bounds(points) {
+	if (points.length === 0) return {
+		min: [0, 0],
+		max: [0, 0],
+		width: 0,
+		height: 0
+	};
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let 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 {
+		min: [minX, minY],
+		max: [maxX, maxY],
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+function pointInPolygon(point, polygon) {
+	let inside = false;
+	const [px, py] = point;
+	for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+		const a = polygon[i];
+		const b = polygon[j];
+		if (a[1] > py !== b[1] > py && px < (b[0] - a[0]) * (py - a[1]) / (b[1] - a[1]) + a[0]) inside = !inside;
+	}
+	return inside;
+}
+//#endregion
+//#region src/wall.ts
+function wallLength(wall) {
+	return distance(wall.start, wall.end);
+}
+function wallDirection(wall) {
+	return normalize(sub(wall.end, wall.start));
+}
+/**
+* Generate the visible quad polygon of a wall from its centerline and
+* thickness. Vertices are ordered counter-clockwise.
+*/
+function wallPolygon(wall, extendEnds = 0) {
+	const dir = wallDirection(wall);
+	const n = normal(dir);
+	const half = wall.thickness / 2;
+	const offset = scale(n, half);
+	const negOffset = scale(n, -half);
+	const start = add(wall.start, scale(dir, -extendEnds));
+	const end = add(wall.end, scale(dir, extendEnds));
+	return [
+		add(start, negOffset),
+		add(end, negOffset),
+		add(end, offset),
+		add(start, offset)
+	];
+}
+/** World position of a point at distance `offset` along the wall centerline. */
+function pointAlongWall(wall, offset) {
+	const dir = wallDirection(wall);
+	return add(wall.start, scale(dir, offset));
+}
+/**
+* The two centerline endpoints of an opening cut, clamped to the wall length.
+*/
+function openingSpan(wall, opening) {
+	const len = wallLength(wall);
+	const half = opening.width / 2;
+	const start = Math.max(0, opening.offset - half);
+	const end = Math.min(len, opening.offset + half);
+	return {
+		start: pointAlongWall(wall, start),
+		end: pointAlongWall(wall, end),
+		center: pointAlongWall(wall, opening.offset)
+	};
+}
+/** Whether an opening fits entirely within the wall it is attached to. */
+function openingFits(wall, opening) {
+	const len = wallLength(wall);
+	return opening.offset - opening.width / 2 >= -1e-6 && opening.offset + opening.width / 2 <= len + 1e-6;
+}
+function wallBoxes(wall, openings, wallHeight, extendEnds = 0) {
+	const len = wallLength(wall);
+	const lo = -extendEnds;
+	const hi = len + extendEnds;
+	if (openings.length === 0) return [{
+		along0: lo,
+		along1: hi,
+		z0: 0,
+		z1: wallHeight
+	}];
+	const sorted = [...openings].map((o) => ({
+		a0: Math.max(0, o.offset - o.width / 2),
+		a1: Math.min(len, o.offset + o.width / 2),
+		sill: Math.max(0, o.sillHeight),
+		top: Math.min(wallHeight, o.sillHeight + o.height)
+	})).sort((a, b) => a.a0 - b.a0);
+	const boxes = [];
+	let cursor = lo;
+	for (const o of sorted) {
+		if (o.a0 > cursor) boxes.push({
+			along0: cursor,
+			along1: o.a0,
+			z0: 0,
+			z1: wallHeight
+		});
+		if (o.top < wallHeight) boxes.push({
+			along0: o.a0,
+			along1: o.a1,
+			z0: o.top,
+			z1: wallHeight
+		});
+		if (o.sill > 0) boxes.push({
+			along0: o.a0,
+			along1: o.a1,
+			z0: 0,
+			z1: o.sill
+		});
+		cursor = Math.max(cursor, o.a1);
+	}
+	if (cursor < hi) boxes.push({
+		along0: cursor,
+		along1: hi,
+		z0: 0,
+		z1: wallHeight
+	});
+	return boxes;
+}
+//#endregion
+//#region src/snap.ts
+function snapToGrid(point, gridSize) {
+	if (gridSize <= 0) return point;
+	return [Math.round(point[0] / gridSize) * gridSize, Math.round(point[1] / gridSize) * gridSize];
+}
+/**
+* Find the best snap candidate near `point`. Endpoint and midpoint snaps take
+* priority over grid snaps within the given pixel/world tolerance.
+*/
+function findSnap(point, segments, options = { tolerance: .2 }) {
+	const candidates = [];
+	for (const seg of segments) {
+		for (const ep of [seg.a, seg.b]) {
+			const d = distance(point, ep);
+			if (d <= options.tolerance) candidates.push({
+				point: ep,
+				kind: "endpoint",
+				distance: d
+			});
+		}
+		const mid = lerp(seg.a, seg.b, .5);
+		const dm = distance(point, mid);
+		if (dm <= options.tolerance) candidates.push({
+			point: mid,
+			kind: "midpoint",
+			distance: dm
+		});
+		const proj = projectPointOnSegment(point, seg.a, seg.b);
+		if (proj.distance <= options.tolerance) candidates.push({
+			point: proj.point,
+			kind: "perpendicular",
+			distance: proj.distance
+		});
+	}
+	if (candidates.length > 0) {
+		candidates.sort((a, b) => {
+			const rank = {
+				endpoint: 0,
+				midpoint: 1,
+				perpendicular: 2,
+				grid: 3
+			};
+			if (rank[a.kind] !== rank[b.kind]) return rank[a.kind] - rank[b.kind];
+			return a.distance - b.distance;
+		});
+		return candidates[0];
+	}
+	if (options.gridSize) {
+		const gp = snapToGrid(point, options.gridSize);
+		return {
+			point: gp,
+			kind: "grid",
+			distance: distance(point, gp)
+		};
+	}
+	return null;
+}
+//#endregion
+export { EPSILON, add, angle, bounds, cross, distance, dot, ensureCounterClockwise, equals, findSnap, isClockwise, length, lerp, lineIntersection, normal, normalize, openingFits, openingSpan, pointAlongWall, pointInPolygon, polygonArea, polygonCentroid, projectPointOnSegment, scale, segmentIntersection, signedArea, snapToGrid, sub, wallBoxes, wallDirection, wallLength, wallPolygon };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["EPSILON","EPSILON"],"sources":["../src/vec2.ts","../src/line.ts","../src/polygon.ts","../src/wall.ts","../src/snap.ts"],"sourcesContent":["import { EPSILON, type Vec2 } from \"@react-arch/shared\";\n\nexport const add = (a: Vec2, b: Vec2): Vec2 => [a[0] + b[0], a[1] + b[1]];\nexport const sub = (a: Vec2, b: Vec2): Vec2 => [a[0] - b[0], a[1] - b[1]];\nexport const scale = (a: Vec2, s: number): Vec2 => [a[0] * s, a[1] * s];\nexport const dot = (a: Vec2, b: Vec2): number => a[0] * b[0] + a[1] * b[1];\nexport const cross = (a: Vec2, b: Vec2): number => a[0] * b[1] - a[1] * b[0];\nexport const length = (a: Vec2): number => Math.hypot(a[0], a[1]);\nexport const distance = (a: Vec2, b: Vec2): number => length(sub(a, b));\n\nexport function normalize(a: Vec2): Vec2 {\n  const len = length(a);\n  if (len < EPSILON) return [0, 0];\n  return [a[0] / len, a[1] / len];\n}\n\n/** Left-hand normal of a vector (rotate +90°). */\nexport function normal(a: Vec2): Vec2 {\n  return [-a[1], a[0]];\n}\n\nexport function lerp(a: Vec2, b: Vec2, t: number): Vec2 {\n  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];\n}\n\nexport function angle(a: Vec2, b: Vec2): number {\n  return Math.atan2(b[1] - a[1], b[0] - a[0]);\n}\n\nexport function equals(a: Vec2, b: Vec2, eps = EPSILON): boolean {\n  return Math.abs(a[0] - b[0]) <= eps && Math.abs(a[1] - b[1]) <= eps;\n}\n\n/** Project point p onto the segment [a,b], returning the closest point + t. */\nexport function projectPointOnSegment(\n  p: Vec2,\n  a: Vec2,\n  b: Vec2,\n): { point: Vec2; t: number; distance: number } {\n  const ab = sub(b, a);\n  const len2 = dot(ab, ab);\n  if (len2 < EPSILON) return { point: a, t: 0, distance: distance(p, a) };\n  let t = dot(sub(p, a), ab) / len2;\n  t = Math.max(0, Math.min(1, t));\n  const point = add(a, scale(ab, t));\n  return { point, t, distance: distance(p, point) };\n}\n","import { EPSILON, type Vec2 } from \"@react-arch/shared\";\nimport { cross, sub } from \"./vec2.js\";\n\nexport interface Segment {\n  a: Vec2;\n  b: Vec2;\n}\n\n/**\n * Intersection of two infinite lines defined by segments. Returns null when\n * the lines are parallel (within EPSILON).\n */\nexport function lineIntersection(s1: Segment, s2: Segment): Vec2 | null {\n  const r = sub(s1.b, s1.a);\n  const s = sub(s2.b, s2.a);\n  const denom = cross(r, s);\n  if (Math.abs(denom) < EPSILON) return null; // parallel\n  const qp = sub(s2.a, s1.a);\n  const t = cross(qp, s) / denom;\n  return [s1.a[0] + t * r[0], s1.a[1] + t * r[1]];\n}\n\n/**\n * Intersection point of two finite segments, or null if they don't cross.\n */\nexport function segmentIntersection(s1: Segment, s2: Segment): Vec2 | null {\n  const r = sub(s1.b, s1.a);\n  const s = sub(s2.b, s2.a);\n  const denom = cross(r, s);\n  if (Math.abs(denom) < EPSILON) return null;\n  const qp = sub(s2.a, s1.a);\n  const t = cross(qp, s) / denom;\n  const u = cross(qp, r) / denom;\n  if (t < -EPSILON || t > 1 + EPSILON || u < -EPSILON || u > 1 + EPSILON) {\n    return null;\n  }\n  return [s1.a[0] + t * r[0], s1.a[1] + t * r[1]];\n}\n","import { type Vec2 } from \"@react-arch/shared\";\n\n/** Signed area (positive = counter-clockwise winding). */\nexport function signedArea(polygon: Vec2[]): number {\n  let sum = 0;\n  for (let i = 0; i < polygon.length; i++) {\n    const a = polygon[i]!;\n    const b = polygon[(i + 1) % polygon.length]!;\n    sum += a[0] * b[1] - b[0] * a[1];\n  }\n  return sum / 2;\n}\n\nexport function polygonArea(polygon: Vec2[]): number {\n  return Math.abs(signedArea(polygon));\n}\n\nexport function polygonCentroid(polygon: Vec2[]): Vec2 {\n  let cx = 0;\n  let cy = 0;\n  let a = 0;\n  for (let i = 0; i < polygon.length; i++) {\n    const p0 = polygon[i]!;\n    const p1 = polygon[(i + 1) % polygon.length]!;\n    const f = p0[0] * p1[1] - p1[0] * p0[1];\n    cx += (p0[0] + p1[0]) * f;\n    cy += (p0[1] + p1[1]) * f;\n    a += f;\n  }\n  if (Math.abs(a) < 1e-9) {\n    // Degenerate polygon: fall back to vertex average.\n    const n = polygon.length || 1;\n    return [\n      polygon.reduce((s, p) => s + p[0], 0) / n,\n      polygon.reduce((s, p) => s + p[1], 0) / n,\n    ];\n  }\n  a *= 3;\n  return [cx / a, cy / a];\n}\n\nexport function isClockwise(polygon: Vec2[]): boolean {\n  return signedArea(polygon) < 0;\n}\n\nexport function ensureCounterClockwise(polygon: Vec2[]): Vec2[] {\n  return isClockwise(polygon) ? [...polygon].reverse() : polygon;\n}\n\n/** Axis-aligned bounding box of a set of points. */\nexport function bounds(points: Vec2[]): {\n  min: Vec2;\n  max: Vec2;\n  width: number;\n  height: number;\n} {\n  if (points.length === 0) {\n    return { min: [0, 0], max: [0, 0], width: 0, height: 0 };\n  }\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (const [x, y] of points) {\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  return {\n    min: [minX, minY],\n    max: [maxX, maxY],\n    width: maxX - minX,\n    height: maxY - minY,\n  };\n}\n\nexport function pointInPolygon(point: Vec2, polygon: Vec2[]): boolean {\n  let inside = false;\n  const [px, py] = point;\n  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {\n    const a = polygon[i]!;\n    const b = polygon[j]!;\n    const intersect =\n      a[1] > py !== b[1] > py &&\n      px < ((b[0] - a[0]) * (py - a[1])) / (b[1] - a[1]) + a[0];\n    if (intersect) inside = !inside;\n  }\n  return inside;\n}\n","import { type Vec2 } from \"@react-arch/shared\";\nimport { add, distance, normal, normalize, scale, sub } from \"./vec2.js\";\n\nexport interface WallLike {\n  start: Vec2;\n  end: Vec2;\n  thickness: number;\n}\n\nexport function wallLength(wall: WallLike): number {\n  return distance(wall.start, wall.end);\n}\n\nexport function wallDirection(wall: WallLike): Vec2 {\n  return normalize(sub(wall.end, wall.start));\n}\n\n/**\n * Generate the visible quad polygon of a wall from its centerline and\n * thickness. Vertices are ordered counter-clockwise.\n */\nexport function wallPolygon(wall: WallLike, extendEnds = 0): Vec2[] {\n  const dir = wallDirection(wall);\n  const n = normal(dir);\n  const half = wall.thickness / 2;\n  const offset = scale(n, half);\n  const negOffset = scale(n, -half);\n  // Push the ends out along the wall direction so corners overlap (no notch).\n  const start = add(wall.start, scale(dir, -extendEnds));\n  const end = add(wall.end, scale(dir, extendEnds));\n  return [\n    add(start, negOffset),\n    add(end, negOffset),\n    add(end, offset),\n    add(start, offset),\n  ];\n}\n\n/** World position of a point at distance `offset` along the wall centerline. */\nexport function pointAlongWall(wall: WallLike, offset: number): Vec2 {\n  const dir = wallDirection(wall);\n  return add(wall.start, scale(dir, offset));\n}\n\nexport interface OpeningLike {\n  offset: number;\n  width: number;\n}\n\n/**\n * The two centerline endpoints of an opening cut, clamped to the wall length.\n */\nexport function openingSpan(\n  wall: WallLike,\n  opening: OpeningLike,\n): { start: Vec2; end: Vec2; center: Vec2 } {\n  const len = wallLength(wall);\n  const half = opening.width / 2;\n  const start = Math.max(0, opening.offset - half);\n  const end = Math.min(len, opening.offset + half);\n  return {\n    start: pointAlongWall(wall, start),\n    end: pointAlongWall(wall, end),\n    center: pointAlongWall(wall, opening.offset),\n  };\n}\n\n/** Whether an opening fits entirely within the wall it is attached to. */\nexport function openingFits(wall: WallLike, opening: OpeningLike): boolean {\n  const len = wallLength(wall);\n  return (\n    opening.offset - opening.width / 2 >= -1e-6 &&\n    opening.offset + opening.width / 2 <= len + 1e-6\n  );\n}\n\nexport interface WallOpeningInput extends OpeningLike {\n  /** Bottom of the opening above the floor. */\n  sillHeight: number;\n  /** Opening height. */\n  height: number;\n}\n\n/**\n * A solid box of the wall expressed in wall-local coordinates: `along` runs\n * from the wall start, `z` is vertical. The 3D renderer extrudes each box by\n * the wall thickness. This is how openings are \"cut\" without CSG — the wall is\n * decomposed into the solid pieces that remain around its openings.\n */\nexport interface WallBox {\n  along0: number;\n  along1: number;\n  z0: number;\n  z1: number;\n}\n\nexport function wallBoxes(\n  wall: WallLike,\n  openings: WallOpeningInput[],\n  wallHeight: number,\n  /**\n   * Extend the solid wall by this much past each end. Pass `thickness / 2` so\n   * walls meeting at a corner overlap and fill the corner square — otherwise\n   * each centerline box stops short and leaves a notch.\n   */\n  extendEnds = 0,\n): WallBox[] {\n  const len = wallLength(wall);\n  const lo = -extendEnds;\n  const hi = len + extendEnds;\n  if (openings.length === 0) {\n    return [{ along0: lo, along1: hi, z0: 0, z1: wallHeight }];\n  }\n  const sorted = [...openings]\n    .map((o) => ({\n      a0: Math.max(0, o.offset - o.width / 2),\n      a1: Math.min(len, o.offset + o.width / 2),\n      sill: Math.max(0, o.sillHeight),\n      top: Math.min(wallHeight, o.sillHeight + o.height),\n    }))\n    .sort((a, b) => a.a0 - b.a0);\n\n  const boxes: WallBox[] = [];\n  let cursor = lo;\n  for (const o of sorted) {\n    if (o.a0 > cursor) {\n      boxes.push({ along0: cursor, along1: o.a0, z0: 0, z1: wallHeight });\n    }\n    // Lintel above the opening.\n    if (o.top < wallHeight) {\n      boxes.push({ along0: o.a0, along1: o.a1, z0: o.top, z1: wallHeight });\n    }\n    // Sill below the opening (windows).\n    if (o.sill > 0) {\n      boxes.push({ along0: o.a0, along1: o.a1, z0: 0, z1: o.sill });\n    }\n    cursor = Math.max(cursor, o.a1);\n  }\n  if (cursor < hi) {\n    boxes.push({ along0: cursor, along1: hi, z0: 0, z1: wallHeight });\n  }\n  return boxes;\n}\n","import { type Vec2 } from \"@react-arch/shared\";\nimport { distance, lerp } from \"./vec2.js\";\nimport { projectPointOnSegment } from \"./vec2.js\";\n\nexport type SnapKind = \"endpoint\" | \"midpoint\" | \"grid\" | \"perpendicular\";\n\nexport interface SnapResult {\n  point: Vec2;\n  kind: SnapKind;\n  distance: number;\n}\n\nexport interface SnapSegment {\n  a: Vec2;\n  b: Vec2;\n}\n\nexport function snapToGrid(point: Vec2, gridSize: number): Vec2 {\n  if (gridSize <= 0) return point;\n  return [\n    Math.round(point[0] / gridSize) * gridSize,\n    Math.round(point[1] / gridSize) * gridSize,\n  ];\n}\n\n/**\n * Find the best snap candidate near `point`. Endpoint and midpoint snaps take\n * priority over grid snaps within the given pixel/world tolerance.\n */\nexport function findSnap(\n  point: Vec2,\n  segments: SnapSegment[],\n  options: { tolerance: number; gridSize?: number } = { tolerance: 0.2 },\n): SnapResult | null {\n  const candidates: SnapResult[] = [];\n  for (const seg of segments) {\n    for (const ep of [seg.a, seg.b]) {\n      const d = distance(point, ep);\n      if (d <= options.tolerance) {\n        candidates.push({ point: ep, kind: \"endpoint\", distance: d });\n      }\n    }\n    const mid = lerp(seg.a, seg.b, 0.5);\n    const dm = distance(point, mid);\n    if (dm <= options.tolerance) {\n      candidates.push({ point: mid, kind: \"midpoint\", distance: dm });\n    }\n    const proj = projectPointOnSegment(point, seg.a, seg.b);\n    if (proj.distance <= options.tolerance) {\n      candidates.push({\n        point: proj.point,\n        kind: \"perpendicular\",\n        distance: proj.distance,\n      });\n    }\n  }\n\n  if (candidates.length > 0) {\n    candidates.sort((a, b) => {\n      const rank: Record<SnapKind, number> = {\n        endpoint: 0,\n        midpoint: 1,\n        perpendicular: 2,\n        grid: 3,\n      };\n      if (rank[a.kind] !== rank[b.kind]) return rank[a.kind] - rank[b.kind];\n      return a.distance - b.distance;\n    });\n    return candidates[0]!;\n  }\n\n  if (options.gridSize) {\n    const gp = snapToGrid(point, options.gridSize);\n    return { point: gp, kind: \"grid\", distance: distance(point, gp) };\n  }\n  return null;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@react-arch/geometry",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@react-arch/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/react-arch/react-arch.git",
+    "directory": "packages/geometry"
+  },
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "lint": "oxlint src",
+    "build": "tsdown"
+  }
+}