@threekit-tools/treble 0.0.90 → 0.0.91-next-01

package/dist/hooks/useSpaces/geometry/findLoops.d.ts

@@ -0,0 +1,6 @@
+import type { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function findLoops(lines: Array<ICoordinatesLine>): {
+    inner: Array<ICoordinate2D[]>;
+    outer: Array<ICoordinate2D[]>;
+};
+export default findLoops;

package/dist/hooks/{useRoomBuilder → useSpaces/geometry}/findLoops.js

@@ -8,13 +8,18 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findLoops = void 0;
-var geometry_1 = require("./geometry");
+var arePointsEqual_1 = __importDefault(require("./arePointsEqual"));
+var euclideanMod_1 = __importDefault(require("./euclideanMod"));
+var getAngleOfLineSegment_1 = __importDefault(require("./getAngleOfLineSegment"));
+var getLineOtherPoint_1 = __importDefault(require("./getLineOtherPoint"));
 var areSidesEqual = function (_a, _b) {
     var lineIndex0 = _a[0], fromPoint0 = _a[1];
     var lineIndex1 = _b[0], fromPoint1 = _b[1];
-    return lineIndex0 === lineIndex1 && (0, geometry_1.arePointsEqual)(fromPoint0, fromPoint1);
+    return lineIndex0 === lineIndex1 && (0, arePointsEqual_1.default)(fromPoint0, fromPoint1);
 };
 var composeSideKey = function (_a) {
     var lineIndex = _a[0], point = _a[1];
@@ -43,8 +48,8 @@ function findLoops(lines) {
     function nextAdjacentWallSide(side) {
         var lineIndex = side[0], fromPoint = side[1];
         var line = lines[lineIndex];
-        var toPoint = (0, geometry_1.getLineOtherPoint)(line, fromPoint);
-        var lineAng = (0, geometry_1.getAngleOfLineSegment)([fromPoint, toPoint]);
+        var toPoint = (0, getLineOtherPoint_1.default)(line, fromPoint);
+        var lineAng = (0, getAngleOfLineSegment_1.default)([fromPoint, toPoint]);
         var adjacentLineIndices = pointToLinesIndices[JSON.stringify(toPoint)];
         var nextLineIndex;
         if (adjacentLineIndices.length === 0)
@@ -60,9 +65,9 @@ function findLoops(lines) {
                 if (adjacentLineIndex === lineIndex)
                     continue;
                 var adjacentLine = lines[adjacentLineIndex];
-                var adjacentPoint = (0, geometry_1.getLineOtherPoint)(adjacentLine, toPoint);
-                var adjacentLineAng = (0, geometry_1.getAngleOfLineSegment)([toPoint, adjacentPoint]);
-                var angDiff = (0, geometry_1.euclideanMod)(lineAng - adjacentLineAng + Math.PI, Math.PI * 2);
+                var adjacentPoint = (0, getLineOtherPoint_1.default)(adjacentLine, toPoint);
+                var adjacentLineAng = (0, getAngleOfLineSegment_1.default)([toPoint, adjacentPoint]);
+                var angDiff = (0, euclideanMod_1.default)(lineAng - adjacentLineAng + Math.PI, Math.PI * 2);
                 if (angDiff < smallestAngDiff) {
                     smallestAngDiff = angDiff;
                     nextLineIndex = adjacentLineIndex;
@@ -96,4 +101,4 @@ function findLoops(lines) {
         outer: outerLoops,
     };
 }
-exports.findLoops = findLoops;
+exports.default = findLoops;

package/dist/hooks/useSpaces/geometry/getAllLineIntersections.d.ts

@@ -0,0 +1,6 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getAllLineIntersections(line: ICoordinatesLine, lines: Array<ICoordinatesLine | null>): {
+    index: number;
+    point: ICoordinate2D;
+}[];
+export default getAllLineIntersections;

package/dist/hooks/useSpaces/geometry/getAllLineIntersections.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getLineSegmentsIntersection_1 = __importDefault(require("./getLineSegmentsIntersection"));
+function getAllLineIntersections(line, lines) {
+    var lineStr = [JSON.stringify(line[0]), JSON.stringify(line[1])];
+    return lines.reduce(function (output, existingLine, i) {
+        if (existingLine === null)
+            return output;
+        var startStr = JSON.stringify(existingLine[0]);
+        var endStr = JSON.stringify(existingLine[1]);
+        if (lineStr.includes(startStr) || lineStr.includes(endStr))
+            return output;
+        var intersectionPoint = (0, getLineSegmentsIntersection_1.default)(line, existingLine);
+        if (!intersectionPoint)
+            return output;
+        output.push({ index: i, point: intersectionPoint });
+        return output;
+    }, []);
+}
+exports.default = getAllLineIntersections;

package/dist/hooks/useSpaces/geometry/getAngleOfLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinatesLine } from '../types';
+declare function getAngleOfLineSegment(line: ICoordinatesLine): number;
+export default getAngleOfLineSegment;

package/dist/hooks/useSpaces/geometry/getAngleOfLineSegment.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getAngleOfLineSegment(line) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    return Math.atan2(y2 - y1, x2 - x1);
+}
+exports.default = getAngleOfLineSegment;

package/dist/hooks/useSpaces/geometry/getClosestPointOnLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getClosestPointOnLineSegment(line: ICoordinatesLine, point: ICoordinate2D): undefined | ICoordinate2D;
+export default getClosestPointOnLineSegment;

package/dist/hooks/useSpaces/geometry/getClosestPointOnLineSegment.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getClosestPointOnLineSegment(line, point) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var lineVector = [x2 - x1, y2 - y1];
+    var pointVector = [point[0] - x1, point[1] - y1];
+    var lineLength = Math.pow(lineVector[0], 2) + Math.pow(lineVector[1], 2);
+    var dotProduct = (pointVector[0] * lineVector[0] + pointVector[1] * lineVector[1]) /
+        lineLength;
+    if (dotProduct < 0)
+        return [x1, y1];
+    if (dotProduct > 1)
+        return [x2, y2];
+    else
+        return [x1 + dotProduct * lineVector[0], y1 + dotProduct * lineVector[1]];
+}
+exports.default = getClosestPointOnLineSegment;

package/dist/hooks/useSpaces/geometry/getDistanceToLine.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D } from '../types';
+declare function getDistanceToLine(pointOnLine: ICoordinate2D, angle: number, point: ICoordinate2D): number;
+export default getDistanceToLine;

package/dist/hooks/useSpaces/geometry/getDistanceToLine.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getDistanceToLine(pointOnLine, angle, point) {
+    var x1 = point[0], y1 = point[1];
+    var x2 = pointOnLine[0], y2 = pointOnLine[1];
+    var dx = Math.cos(angle);
+    var dy = Math.sin(angle);
+    return (Math.abs((y1 - y2) * dx - (x1 - x2) * dy) / Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2)));
+}
+exports.default = getDistanceToLine;

package/dist/hooks/useSpaces/geometry/getLengthOfLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinatesLine } from '../types';
+declare function getLengthOfLineSegment(line: ICoordinatesLine): number;
+export default getLengthOfLineSegment;

package/dist/hooks/useSpaces/geometry/getLengthOfLineSegment.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getLengthOfLineSegment(line) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    return Math.sqrt(Math.pow((x2 - x1), 2) + Math.pow((y2 - y1), 2));
+}
+exports.default = getLengthOfLineSegment;

package/dist/hooks/useSpaces/geometry/getLineAtOffsetOnLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinatesLine } from '../types';
+declare function getLineAtOffsetOnLineSegment(line: ICoordinatesLine, offset: number, length: number): ICoordinatesLine;
+export default getLineAtOffsetOnLineSegment;

package/dist/hooks/useSpaces/geometry/getLineAtOffsetOnLineSegment.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getLineAtOffsetOnLineSegment(line, offset, length) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var d = Math.sqrt(Math.pow((x2 - x1), 2) + Math.pow((y2 - y1), 2));
+    var startRatio = offset / d;
+    var endRatio = (offset + length) / d;
+    var startX = x1 + startRatio * (x2 - x1);
+    var startY = y1 + startRatio * (y2 - y1);
+    var endX = x1 + endRatio * (x2 - x1);
+    var endY = y1 + endRatio * (y2 - y1);
+    return [
+        [startX, startY],
+        [endX, endY],
+    ];
+}
+exports.default = getLineAtOffsetOnLineSegment;

package/dist/hooks/useSpaces/geometry/getLineOtherPoint.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getLineOtherPoint(line: ICoordinatesLine, point: ICoordinate2D): ICoordinate2D;
+export default getLineOtherPoint;

package/dist/hooks/useSpaces/geometry/getLineOtherPoint.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+function getLineOtherPoint(line, point) {
+    var eq0 = (0, geometry_1.arePointsEqual)(line[0], point);
+    var eq1 = (0, geometry_1.arePointsEqual)(line[1], point);
+    if (eq0 === eq1)
+        console.warn('Unexpected. Is your wall of 0 length?', JSON.parse(JSON.stringify({ line: line, point: point })));
+    return eq0 ? line[1] : line[0];
+}
+exports.default = getLineOtherPoint;

package/dist/hooks/useSpaces/geometry/getLineSegmentsIntersection.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getLineSegmentsIntersection(line1: ICoordinatesLine, line2: ICoordinatesLine): null | ICoordinate2D;
+export default getLineSegmentsIntersection;

package/dist/hooks/useSpaces/geometry/getLineSegmentsIntersection.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var arePointsEqual_1 = __importDefault(require("./arePointsEqual"));
+function getLineSegmentsIntersection(line1, line2) {
+    if (arePointsEqual_1.default.apply(void 0, line1) || arePointsEqual_1.default.apply(void 0, line2))
+        return null;
+    if ((0, arePointsEqual_1.default)(line1[0], line2[0]))
+        return null;
+    if ((0, arePointsEqual_1.default)(line1[0], line2[1]))
+        return null;
+    if ((0, arePointsEqual_1.default)(line1[1], line2[0]))
+        return null;
+    if ((0, arePointsEqual_1.default)(line1[1], line2[1]))
+        return null;
+    var _a = line1.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var _b = line2.flat(), x3 = _b[0], y3 = _b[1], x4 = _b[2], y4 = _b[3];
+    var a1 = y2 - y1;
+    var b1 = x1 - x2;
+    var c1 = a1 * x1 + b1 * y1;
+    var a2 = y4 - y3;
+    var b2 = x3 - x4;
+    var c2 = a2 * x3 + b2 * y3;
+    var determinant = a1 * b2 - a2 * b1;
+    if (determinant === 0)
+        return null;
+    var x = (b2 * c1 - b1 * c2) / determinant;
+    var y = (a1 * c2 - a2 * c1) / determinant;
+    if (x < Math.min(x1, x2) ||
+        x > Math.max(x1, x2) ||
+        x < Math.min(x3, x4) ||
+        x > Math.max(x3, x4))
+        return null;
+    if (y < Math.min(y1, y2) ||
+        y > Math.max(y1, y2) ||
+        y < Math.min(y3, y4) ||
+        y > Math.max(y3, y4))
+        return null;
+    return [x, y];
+}
+exports.default = getLineSegmentsIntersection;

package/dist/hooks/useSpaces/geometry/getMidpointOfLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getMidpointOfLineSegment(line: ICoordinatesLine): ICoordinate2D;
+export default getMidpointOfLineSegment;

package/dist/hooks/useSpaces/geometry/getMidpointOfLineSegment.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getMidpointOfLineSegment(line) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var xMidpoint = (x1 + x2) / 2;
+    var yMidpoint = (y1 + y2) / 2;
+    return [xMidpoint, yMidpoint];
+}
+exports.default = getMidpointOfLineSegment;

package/dist/hooks/useSpaces/geometry/getParallelLineSegmentAtDistance.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinatesLine } from '../types';
+declare function getParallelLineSegmentAtDistance(line: ICoordinatesLine, distance: number): ICoordinatesLine;
+export default getParallelLineSegmentAtDistance;

package/dist/hooks/useSpaces/geometry/getParallelLineSegmentAtDistance.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getUnitVectorOfLineSegment_1 = __importDefault(require("./getUnitVectorOfLineSegment"));
+function getParallelLineSegmentAtDistance(line, distance) {
+    if (!distance)
+        return line;
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var unitVector = (0, getUnitVectorOfLineSegment_1.default)(line);
+    var _b = distance > 0
+        ? [unitVector[1], -unitVector[0]]
+        : [-unitVector[1], unitVector[0]], xNormal = _b[0], yNormal = _b[1];
+    var length = Math.abs(distance);
+    var point1 = [x1 + xNormal * length, y1 + yNormal * length];
+    var point2 = [x2 + xNormal * length, y2 + yNormal * length];
+    return [point1, point2];
+}
+exports.default = getParallelLineSegmentAtDistance;

package/dist/hooks/useSpaces/geometry/getPointAtOffsetOnLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getPointAtOffsetOnLineSegment(line: ICoordinatesLine, offset: number): ICoordinate2D;
+export default getPointAtOffsetOnLineSegment;

package/dist/hooks/useSpaces/geometry/getPointAtOffsetOnLineSegment.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getPointAtOffsetOnLineSegment(line, offset) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var d = Math.sqrt(Math.pow((x2 - x1), 2) + Math.pow((y2 - y1), 2));
+    var r = offset / d;
+    var x = x1 + r * (x2 - x1);
+    var y = y1 + r * (y2 - y1);
+    return [x, y];
+}
+exports.default = getPointAtOffsetOnLineSegment;

package/dist/hooks/useSpaces/geometry/getPolygonArea.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D } from '../types';
+declare function getPolygonArea(polygon: Array<ICoordinate2D>): number;
+export default getPolygonArea;

package/dist/hooks/useSpaces/geometry/getPolygonArea.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getTriangleArea_1 = __importDefault(require("./getTriangleArea"));
+function getPolygonArea(polygon) {
+    var origin = [0, 0];
+    return polygon.reduce(function (sum, point1, i) {
+        var point2 = polygon[(i + 1) % polygon.length];
+        sum += (0, getTriangleArea_1.default)(origin, point1, point2);
+        return sum;
+    }, 0);
+}
+exports.default = getPolygonArea;

package/dist/hooks/useSpaces/geometry/getQuadrilateralArea.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinatesQuadrilateral } from '../types';
+declare function getQuadrilateralArea(quadrilateral: ICoordinatesQuadrilateral): number;
+export default getQuadrilateralArea;

package/dist/hooks/useSpaces/geometry/getQuadrilateralArea.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getQuadrilateralArea(quadrilateral) {
+    var _a = quadrilateral.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3], x3 = _a[4], y3 = _a[5], x4 = _a[6], y4 = _a[7];
+    var area = Math.abs((x1 * y2 +
+        x2 * y3 +
+        x3 * y4 +
+        x4 * y1 -
+        x2 * y1 -
+        x3 * y2 -
+        x4 * y3 -
+        x1 * y4) /
+        2);
+    return area;
+}
+exports.default = getQuadrilateralArea;

package/dist/hooks/useSpaces/geometry/getTangetIntersectionAndOffset.d.ts

@@ -0,0 +1,6 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getTangetIntersectionAndOffset(line: ICoordinatesLine, point: ICoordinate2D): undefined | {
+    point: ICoordinate2D;
+    offset: number;
+};
+export default getTangetIntersectionAndOffset;

package/dist/hooks/useSpaces/geometry/getTangetIntersectionAndOffset.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getClosestPointOnLineSegment_1 = __importDefault(require("./getClosestPointOnLineSegment"));
+var getLengthOfLineSegment_1 = __importDefault(require("./getLengthOfLineSegment"));
+function getTangetIntersectionAndOffset(line, point) {
+    var interceptPoint = (0, getClosestPointOnLineSegment_1.default)(line, point);
+    if (!interceptPoint)
+        return undefined;
+    return {
+        point: interceptPoint,
+        offset: (0, getLengthOfLineSegment_1.default)([line[0], interceptPoint]),
+    };
+}
+exports.default = getTangetIntersectionAndOffset;

package/dist/hooks/useSpaces/geometry/getTriangleArea.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D } from '../types';
+declare function getTriangleArea(point1: ICoordinate2D, point2: ICoordinate2D, point3: ICoordinate2D): number;
+export default getTriangleArea;

package/dist/hooks/useSpaces/geometry/getTriangleArea.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getTriangleArea(point1, point2, point3) {
+    return ((point1[0] * (point2[1] - point3[1]) +
+        point2[0] * (point3[1] - point1[1]) +
+        point3[0] * (point1[1] - point2[1])) /
+        2);
+}
+exports.default = getTriangleArea;

package/dist/hooks/useSpaces/geometry/getUnitVectorOfLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function getUnitVectorOfLineSegment(line: ICoordinatesLine): ICoordinate2D;
+export default getUnitVectorOfLineSegment;

package/dist/hooks/useSpaces/geometry/getUnitVectorOfLineSegment.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getLengthOfLineSegment_1 = __importDefault(require("./getLengthOfLineSegment"));
+function getUnitVectorOfLineSegment(line) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var magnitude = (0, getLengthOfLineSegment_1.default)(line);
+    return [(x2 - x1) / magnitude, (y2 - y1) / magnitude];
+}
+exports.default = getUnitVectorOfLineSegment;

package/dist/hooks/useSpaces/geometry/index.d.ts

@@ -0,0 +1,30 @@
+import euclideanMod from './euclideanMod';
+import arePointsEqual from './arePointsEqual';
+import areLinesEqual from './areLinesEqual';
+import getLineOtherPoint from './getLineOtherPoint';
+import getLengthOfLineSegment from './getLengthOfLineSegment';
+import getUnitVectorOfLineSegment from './getUnitVectorOfLineSegment';
+import getMidpointOfLineSegment from './getMidpointOfLineSegment';
+import getAngleOfLineSegment from './getAngleOfLineSegment';
+import getPointAtOffsetOnLineSegment from './getPointAtOffsetOnLineSegment';
+import getLineAtOffsetOnLineSegment from './getLineAtOffsetOnLineSegment';
+import getDistanceToLine from './getDistanceToLine';
+import closestPointOnLine from './closestPointOnLine';
+import getQuadrilateralArea from './getQuadrilateralArea';
+import getTriangleArea from './getTriangleArea';
+import getPolygonArea from './getPolygonArea';
+import getParallelLineSegmentAtDistance from './getParallelLineSegmentAtDistance';
+import addThicknessToLine from './addThicknessToLine';
+import arePointsWithinProximity from './arePointsWithinProximity';
+import isPointInQuadrilateral from './isPointInQuadrilateral';
+import isPointInPolygon from './isPointInPolygon';
+import getLineSegmentsIntersection from './getLineSegmentsIntersection';
+import splitLineAtPoint from './splitLineAtPoint';
+import splitLineAtPoints from './splitLineAtPoints';
+import splitLineAtOffset from './splitLineAtOffset';
+import orderCoordinatesOnLineSegment from './orderCoordinatesOnLineSegment';
+import getTangetIntersectionAndOffset from './getTangetIntersectionAndOffset';
+import getAllLineIntersections from './getAllLineIntersections';
+import doLinesOverlap from './doLinesOverlap';
+import findLoops from './findLoops';
+export { euclideanMod, arePointsEqual, areLinesEqual, getLineOtherPoint, getLengthOfLineSegment, getUnitVectorOfLineSegment, getMidpointOfLineSegment, getAngleOfLineSegment, getPointAtOffsetOnLineSegment, getLineAtOffsetOnLineSegment, getDistanceToLine, closestPointOnLine, getQuadrilateralArea, getTriangleArea, getPolygonArea, getParallelLineSegmentAtDistance, addThicknessToLine, arePointsWithinProximity, isPointInQuadrilateral, isPointInPolygon, getLineSegmentsIntersection, splitLineAtPoint, splitLineAtPoints, splitLineAtOffset, orderCoordinatesOnLineSegment, getTangetIntersectionAndOffset, getAllLineIntersections, doLinesOverlap, findLoops, };

package/dist/hooks/useSpaces/geometry/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLoops = exports.doLinesOverlap = exports.getAllLineIntersections = exports.getTangetIntersectionAndOffset = exports.orderCoordinatesOnLineSegment = exports.splitLineAtOffset = exports.splitLineAtPoints = exports.splitLineAtPoint = exports.getLineSegmentsIntersection = exports.isPointInPolygon = exports.isPointInQuadrilateral = exports.arePointsWithinProximity = exports.addThicknessToLine = exports.getParallelLineSegmentAtDistance = exports.getPolygonArea = exports.getTriangleArea = exports.getQuadrilateralArea = exports.closestPointOnLine = exports.getDistanceToLine = exports.getLineAtOffsetOnLineSegment = exports.getPointAtOffsetOnLineSegment = exports.getAngleOfLineSegment = exports.getMidpointOfLineSegment = exports.getUnitVectorOfLineSegment = exports.getLengthOfLineSegment = exports.getLineOtherPoint = exports.areLinesEqual = exports.arePointsEqual = exports.euclideanMod = void 0;
+var euclideanMod_1 = __importDefault(require("./euclideanMod"));
+exports.euclideanMod = euclideanMod_1.default;
+var arePointsEqual_1 = __importDefault(require("./arePointsEqual"));
+exports.arePointsEqual = arePointsEqual_1.default;
+var areLinesEqual_1 = __importDefault(require("./areLinesEqual"));
+exports.areLinesEqual = areLinesEqual_1.default;
+var getLineOtherPoint_1 = __importDefault(require("./getLineOtherPoint"));
+exports.getLineOtherPoint = getLineOtherPoint_1.default;
+var getLengthOfLineSegment_1 = __importDefault(require("./getLengthOfLineSegment"));
+exports.getLengthOfLineSegment = getLengthOfLineSegment_1.default;
+var getUnitVectorOfLineSegment_1 = __importDefault(require("./getUnitVectorOfLineSegment"));
+exports.getUnitVectorOfLineSegment = getUnitVectorOfLineSegment_1.default;
+var getMidpointOfLineSegment_1 = __importDefault(require("./getMidpointOfLineSegment"));
+exports.getMidpointOfLineSegment = getMidpointOfLineSegment_1.default;
+var getAngleOfLineSegment_1 = __importDefault(require("./getAngleOfLineSegment"));
+exports.getAngleOfLineSegment = getAngleOfLineSegment_1.default;
+var getPointAtOffsetOnLineSegment_1 = __importDefault(require("./getPointAtOffsetOnLineSegment"));
+exports.getPointAtOffsetOnLineSegment = getPointAtOffsetOnLineSegment_1.default;
+var getLineAtOffsetOnLineSegment_1 = __importDefault(require("./getLineAtOffsetOnLineSegment"));
+exports.getLineAtOffsetOnLineSegment = getLineAtOffsetOnLineSegment_1.default;
+var getDistanceToLine_1 = __importDefault(require("./getDistanceToLine"));
+exports.getDistanceToLine = getDistanceToLine_1.default;
+var closestPointOnLine_1 = __importDefault(require("./closestPointOnLine"));
+exports.closestPointOnLine = closestPointOnLine_1.default;
+var getQuadrilateralArea_1 = __importDefault(require("./getQuadrilateralArea"));
+exports.getQuadrilateralArea = getQuadrilateralArea_1.default;
+var getTriangleArea_1 = __importDefault(require("./getTriangleArea"));
+exports.getTriangleArea = getTriangleArea_1.default;
+var getPolygonArea_1 = __importDefault(require("./getPolygonArea"));
+exports.getPolygonArea = getPolygonArea_1.default;
+var getParallelLineSegmentAtDistance_1 = __importDefault(require("./getParallelLineSegmentAtDistance"));
+exports.getParallelLineSegmentAtDistance = getParallelLineSegmentAtDistance_1.default;
+var addThicknessToLine_1 = __importDefault(require("./addThicknessToLine"));
+exports.addThicknessToLine = addThicknessToLine_1.default;
+var arePointsWithinProximity_1 = __importDefault(require("./arePointsWithinProximity"));
+exports.arePointsWithinProximity = arePointsWithinProximity_1.default;
+var isPointInQuadrilateral_1 = __importDefault(require("./isPointInQuadrilateral"));
+exports.isPointInQuadrilateral = isPointInQuadrilateral_1.default;
+var isPointInPolygon_1 = __importDefault(require("./isPointInPolygon"));
+exports.isPointInPolygon = isPointInPolygon_1.default;
+var getLineSegmentsIntersection_1 = __importDefault(require("./getLineSegmentsIntersection"));
+exports.getLineSegmentsIntersection = getLineSegmentsIntersection_1.default;
+var splitLineAtPoint_1 = __importDefault(require("./splitLineAtPoint"));
+exports.splitLineAtPoint = splitLineAtPoint_1.default;
+var splitLineAtPoints_1 = __importDefault(require("./splitLineAtPoints"));
+exports.splitLineAtPoints = splitLineAtPoints_1.default;
+var splitLineAtOffset_1 = __importDefault(require("./splitLineAtOffset"));
+exports.splitLineAtOffset = splitLineAtOffset_1.default;
+var orderCoordinatesOnLineSegment_1 = __importDefault(require("./orderCoordinatesOnLineSegment"));
+exports.orderCoordinatesOnLineSegment = orderCoordinatesOnLineSegment_1.default;
+var getTangetIntersectionAndOffset_1 = __importDefault(require("./getTangetIntersectionAndOffset"));
+exports.getTangetIntersectionAndOffset = getTangetIntersectionAndOffset_1.default;
+var getAllLineIntersections_1 = __importDefault(require("./getAllLineIntersections"));
+exports.getAllLineIntersections = getAllLineIntersections_1.default;
+var doLinesOverlap_1 = __importDefault(require("./doLinesOverlap"));
+exports.doLinesOverlap = doLinesOverlap_1.default;
+var findLoops_1 = __importDefault(require("./findLoops"));
+exports.findLoops = findLoops_1.default;

package/dist/hooks/useSpaces/geometry/isPointInPolygon.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D } from '../types';
+declare function isPointInPolygon(point: ICoordinate2D, polygon: Array<ICoordinate2D>): boolean;
+export default isPointInPolygon;

package/dist/hooks/useSpaces/geometry/isPointInPolygon.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getLineSegmentsIntersection_1 = __importDefault(require("./getLineSegmentsIntersection"));
+function isPointInPolygon(point, polygon) {
+    var ray = [
+        point,
+        [point[0] + Number.MAX_SAFE_INTEGER, point[1]],
+    ];
+    var intersectCount = 0;
+    for (var i = 0; i < polygon.length; i++) {
+        var polygonStart = polygon[i];
+        var polygonEnd = polygon[(i + 1) % polygon.length];
+        if ((0, getLineSegmentsIntersection_1.default)(ray, [polygonStart, polygonEnd]))
+            intersectCount++;
+    }
+    return intersectCount % 2 === 1;
+}
+exports.default = isPointInPolygon;

package/dist/hooks/useSpaces/geometry/isPointInQuadrilateral.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesQuadrilateral } from '../types';
+declare function isPointInQuadrilateral(quadrilateral: ICoordinatesQuadrilateral, point: ICoordinate2D): boolean;
+export default isPointInQuadrilateral;

package/dist/hooks/useSpaces/geometry/isPointInQuadrilateral.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getQuadrilateralArea_1 = __importDefault(require("./getQuadrilateralArea"));
+var getTriangleArea_1 = __importDefault(require("./getTriangleArea"));
+function isPointInQuadrilateral(quadrilateral, point) {
+    var _a = quadrilateral.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3], x3 = _a[4], y3 = _a[5], x4 = _a[6], y4 = _a[7];
+    var pointX = point[0], pointY = point[1];
+    if (pointX < Math.min(x1, x2, x3, x4) ||
+        pointX > Math.max(x1, x2, x3, x4) ||
+        pointY < Math.min(y1, y2, y3, y4) ||
+        pointY > Math.max(y1, y2, y3, y4)) {
+        return false;
+    }
+    var area = (0, getQuadrilateralArea_1.default)(quadrilateral);
+    var area1 = (0, getTriangleArea_1.default)(point, quadrilateral[0], quadrilateral[1]);
+    var area2 = (0, getTriangleArea_1.default)(point, quadrilateral[1], quadrilateral[2]);
+    var area3 = (0, getTriangleArea_1.default)(point, quadrilateral[2], quadrilateral[3]);
+    var area4 = (0, getTriangleArea_1.default)(point, quadrilateral[3], quadrilateral[0]);
+    var compareArea = Math.abs(area1) + Math.abs(area2) + Math.abs(area3) + Math.abs(area4);
+    return Math.abs(Math.round(area) - Math.round(compareArea)) < 2;
+}
+exports.default = isPointInQuadrilateral;

package/dist/hooks/useSpaces/geometry/orderCoordinatesOnLineSegment.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D } from '../types';
+declare function orderCoordinatesOnLineSegment(points?: Array<ICoordinate2D>): Array<ICoordinate2D>;
+export default orderCoordinatesOnLineSegment;

package/dist/hooks/useSpaces/geometry/orderCoordinatesOnLineSegment.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function orderCoordinatesOnLineSegment(points) {
+    if (!points)
+        return [];
+    if (points[0][0] === points[1][0])
+        return points.sort(function (a, b) { return a[1] - b[1]; });
+    else
+        return points.sort(function (a, b) { return a[0] - b[0]; });
+}
+exports.default = orderCoordinatesOnLineSegment;

package/dist/hooks/useSpaces/geometry/splitLineAtOffset.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinatesLine } from '../types';
+declare function splitLineAtOffset(line: ICoordinatesLine, offset: number): [ICoordinatesLine, ICoordinatesLine];
+export default splitLineAtOffset;

package/dist/hooks/useSpaces/geometry/splitLineAtOffset.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getPointAtOffsetOnLineSegment_1 = __importDefault(require("./getPointAtOffsetOnLineSegment"));
+var splitLineAtPoint_1 = __importDefault(require("./splitLineAtPoint"));
+function splitLineAtOffset(line, offset) {
+    var splitPoint = (0, getPointAtOffsetOnLineSegment_1.default)(line, offset);
+    return (0, splitLineAtPoint_1.default)(line, splitPoint);
+}
+exports.default = splitLineAtOffset;

package/dist/hooks/useSpaces/geometry/splitLineAtPoint.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function splitLineAtPoint(line: ICoordinatesLine, point: ICoordinate2D): [ICoordinatesLine, ICoordinatesLine];
+export default splitLineAtPoint;

package/dist/hooks/useSpaces/geometry/splitLineAtPoint.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function splitLineAtPoint(line, point) {
+    return [
+        [line[0], point],
+        [point, line[1]],
+    ];
+}
+exports.default = splitLineAtPoint;