@threekit-tools/treble 0.0.93 → 0.0.94-next-01

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

@@ -0,0 +1,11 @@
+import { IElementAddress, IEnclosedSpace, IFeatures, IGridToDraw, IGuides, ILineDimensions, ISpacesConfigInternal, IVertex } from '../types';
+import { drawDimensions } from './drawDimensions';
+import { drawVertex } from './drawVertices';
+import { IWallToDraw, drawNewWall } from './drawWalls';
+export { drawNewWall, drawVertex, drawDimensions };
+export declare function drawSpaces(canvas: HTMLCanvasElement, grid: IGridToDraw, enclosedSpaces: Array<IEnclosedSpace>, walls: Array<IWallToDraw>, vertices: Array<IVertex>, features: IFeatures, dimensions: Array<ILineDimensions> | undefined, guides: null | IGuides, selections: {
+    active?: Array<IElementAddress> | IElementAddress;
+    highlighted?: Array<IElementAddress> | IElementAddress;
+    hidden?: Array<IElementAddress> | IElementAddress;
+    error?: Array<IElementAddress> | IElementAddress;
+}, config: ISpacesConfigInternal): void;

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

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawSpaces = exports.drawDimensions = exports.drawVertex = exports.drawNewWall = void 0;
+var types_1 = require("../types");
+var clearCanvas_1 = __importDefault(require("./clearCanvas"));
+var drawBackground_1 = __importDefault(require("./drawBackground"));
+var drawDimensions_1 = require("./drawDimensions");
+Object.defineProperty(exports, "drawDimensions", { enumerable: true, get: function () { return drawDimensions_1.drawDimensions; } });
+var drawDoors_1 = __importDefault(require("./drawDoors"));
+var drawFloor_1 = require("./drawFloor");
+var drawGrid_1 = __importDefault(require("./drawGrid"));
+var drawGuides_1 = __importDefault(require("./drawGuides"));
+var drawOpenings_1 = __importDefault(require("./drawOpenings"));
+var drawVertices_1 = require("./drawVertices");
+Object.defineProperty(exports, "drawVertex", { enumerable: true, get: function () { return drawVertices_1.drawVertex; } });
+var drawWalls_1 = require("./drawWalls");
+Object.defineProperty(exports, "drawNewWall", { enumerable: true, get: function () { return drawWalls_1.drawNewWall; } });
+var drawWindows_1 = __importDefault(require("./drawWindows"));
+function drawElements(canvas, walls, vertices, features, selections, styles) {
+    var wallSelections = {
+        active: [],
+        highlighted: [],
+        hidden: [],
+        error: [],
+    };
+    var verticesSelections = {
+        active: [],
+        highlighted: [],
+        hidden: [],
+        error: [],
+    };
+    var windowSelections = {
+        active: [],
+        highlighted: [],
+        hidden: [],
+        error: [],
+    };
+    var doorSelections = {
+        active: [],
+        highlighted: [],
+        hidden: [],
+        error: [],
+    };
+    var openingSelections = {
+        active: [],
+        highlighted: [],
+        hidden: [],
+        error: [],
+    };
+    selections.active.forEach(function (address) {
+        if (address.type === types_1.IElements.WALL)
+            wallSelections.active.push(address.index);
+        else if (address.type === types_1.IElements.VERTEX)
+            verticesSelections.active.push(address.index);
+        else if (address.type === types_1.IElements.WINDOW)
+            windowSelections.active.push(address.index);
+        else if (address.type === types_1.IElements.DOOR)
+            doorSelections.active.push(address.index);
+        else if (address.type === types_1.IElements.OPENING)
+            openingSelections.active.push(address.index);
+    });
+    selections.highlighted.forEach(function (address) {
+        if (address.type === types_1.IElements.WALL)
+            wallSelections.highlighted.push(address.index);
+        else if (address.type === types_1.IElements.VERTEX)
+            verticesSelections.highlighted.push(address.index);
+        else if (address.type === types_1.IElements.WINDOW)
+            windowSelections.highlighted.push(address.index);
+        else if (address.type === types_1.IElements.DOOR)
+            doorSelections.highlighted.push(address.index);
+        else if (address.type === types_1.IElements.OPENING)
+            openingSelections.highlighted.push(address.index);
+    });
+    selections.hidden.forEach(function (address) {
+        if (address.type === types_1.IElements.WALL)
+            wallSelections.hidden.push(address.index);
+        else if (address.type === types_1.IElements.VERTEX)
+            verticesSelections.hidden.push(address.index);
+        else if (address.type === types_1.IElements.WINDOW)
+            windowSelections.hidden.push(address.index);
+        else if (address.type === types_1.IElements.DOOR)
+            doorSelections.hidden.push(address.index);
+        else if (address.type === types_1.IElements.OPENING)
+            openingSelections.hidden.push(address.index);
+    });
+    selections.error.forEach(function (address) {
+        if (address.type === types_1.IElements.WALL)
+            wallSelections.error.push(address.index);
+        else if (address.type === types_1.IElements.VERTEX)
+            verticesSelections.error.push(address.index);
+        else if (address.type === types_1.IElements.WINDOW)
+            windowSelections.error.push(address.index);
+        else if (address.type === types_1.IElements.DOOR)
+            doorSelections.error.push(address.index);
+        else if (address.type === types_1.IElements.OPENING)
+            openingSelections.error.push(address.index);
+    });
+    (0, drawWalls_1.drawWalls)(canvas, walls, wallSelections, styles.wall);
+    (0, drawVertices_1.drawVertices)(canvas, vertices, verticesSelections, styles.vertex);
+    if (features[types_1.IElements.WINDOW])
+        (0, drawWindows_1.default)(canvas, walls, features[types_1.IElements.WINDOW] || [], windowSelections, styles);
+    if (features[types_1.IElements.DOOR])
+        (0, drawDoors_1.default)(canvas, walls, features[types_1.IElements.DOOR] || [], doorSelections, styles);
+    if (features[types_1.IElements.OPENING])
+        (0, drawOpenings_1.default)(canvas, walls, features[types_1.IElements.OPENING] || [], openingSelections, styles);
+}
+function drawSpaces(canvas, grid, enclosedSpaces, walls, vertices, features, dimensions, guides, selections, config) {
+    var preppedSelections = {
+        active: [(selections === null || selections === void 0 ? void 0 : selections.active) || []].flat(),
+        highlighted: [(selections === null || selections === void 0 ? void 0 : selections.highlighted) || []].flat(),
+        error: [(selections === null || selections === void 0 ? void 0 : selections.error) || []].flat(),
+        hidden: [(selections === null || selections === void 0 ? void 0 : selections.hidden) || []].flat(),
+    };
+    (0, clearCanvas_1.default)(canvas);
+    (0, drawBackground_1.default)(canvas, config.styles.grid.backgroundColor);
+    (0, drawGrid_1.default)(canvas, grid, config.styles.grid);
+    (0, drawFloor_1.drawFloor)(canvas, enclosedSpaces, config.styles.floor);
+    drawElements(canvas, walls, vertices, features, preppedSelections, config.styles);
+    if (dimensions) {
+        (0, drawDimensions_1.drawDimensions)(canvas, dimensions, config);
+        (0, drawFloor_1.drawFloorArea)(canvas, enclosedSpaces, config.styles.floor);
+    }
+    if (guides)
+        (0, drawGuides_1.default)(canvas, guides.point, guides.orientations, config.styles.guides);
+}
+exports.drawSpaces = drawSpaces;

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getParallelLineSegmentAtDistance_1 = __importDefault(require("./getParallelLineSegmentAtDistance"));
+function addThicknessToLine(line, thickness) {
+    var offset = thickness / 2;
+    var _a = (0, getParallelLineSegmentAtDistance_1.default)(line, offset), point1 = _a[0], point2 = _a[1];
+    var _b = (0, getParallelLineSegmentAtDistance_1.default)(line, -offset), point4 = _b[0], point3 = _b[1];
+    return [point1, point2, point3, point4];
+}
+exports.default = addThicknessToLine;

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

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

package/dist/hooks/useSpaces/geometry/areLinesEqual.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 arePointsEqual_1 = __importDefault(require("./arePointsEqual"));
+function areLinesEqual(line1, line2) {
+    if (!line1 || !line2)
+        return false;
+    if (((0, arePointsEqual_1.default)(line1[0], line2[0]) &&
+        (0, arePointsEqual_1.default)(line1[1], line2[1])) ||
+        ((0, arePointsEqual_1.default)(line1[0], line2[1]) && (0, arePointsEqual_1.default)(line1[1], line2[0]))) {
+        return true;
+    }
+    return false;
+}
+exports.default = areLinesEqual;

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function arePointsEqual(point1, point2) {
+    if (!point1 || !point2)
+        return false;
+    return point1[0] === point2[0] && point1[1] === point2[1];
+}
+exports.default = arePointsEqual;

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

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

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

@@ -0,0 +1,11 @@
+"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 arePointsWithinProximity(point1, point2, proximity) {
+    var length = (0, getLengthOfLineSegment_1.default)([point1, point2]);
+    return length <= proximity;
+}
+exports.default = arePointsWithinProximity;

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function closestPointOnLine(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);
+    var t = ((x1 - x2) * dx + (y1 - y2) * dy) / (dx * dx + dy * dy);
+    var x = x2 + t * dx;
+    var y = y2 + t * dy;
+    return [x, y];
+}
+exports.default = closestPointOnLine;

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

@@ -0,0 +1,2 @@
+declare function doLinesOverlap(line1: [offset: number, length: number], line2: [offset: number, length: number]): boolean;
+export default doLinesOverlap;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function doLinesOverlap(line1, line2) {
+    var start1 = line1[0];
+    var end1 = line1[0] + line1[1];
+    var start2 = line2[0];
+    var end2 = line2[0] + line2[1];
+    if (start2 < start1 && start1 < end2)
+        return true;
+    if (start2 < end1 && end1 < end2)
+        return true;
+    if (start1 < start2 && start2 < end1 && start1 < end2 && end2 < end1)
+        return true;
+    return false;
+}
+exports.default = doLinesOverlap;

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

@@ -0,0 +1,2 @@
+declare function euclideanMod(number: number, mod: number): number;
+export default euclideanMod;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function euclideanMod(number, mod) {
+    return ((number % mod) + mod) % mod;
+}
+exports.default = euclideanMod;

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;
@@ -77,7 +82,11 @@ function findLoops(lines) {
         var curr = start;
         do {
             path.push(curr[1]);
-            unvisitedSides.delete(composeSideKey(curr));
+            var currSideKey = composeSideKey(curr);
+            if (!unvisitedSides.has(currSideKey)) {
+                throw new Error('Unexpected case when computing floor area (are there parallel overlapping walls?)');
+            }
+            unvisitedSides.delete(currSideKey);
             curr = nextAdjacentWallSide(curr);
         } while (!areSidesEqual(start, curr));
         return path;
@@ -87,13 +96,22 @@ function findLoops(lines) {
     while (unvisitedSides.size > 0) {
         sumCurvature = 0;
         var start = decomposeSideKey(unvisitedSides.values().next().value);
-        var path = traverseLoop(start);
-        var isClockwise = sumCurvature < 0;
-        (isClockwise ? innerLoops : outerLoops).push(path);
+        try {
+            var path = traverseLoop(start);
+            var isClockwise = sumCurvature < 0;
+            (isClockwise ? innerLoops : outerLoops).push(path);
+        }
+        catch (e) {
+            console.log(e);
+            return {
+                inner: innerLoops,
+                outer: outerLoops,
+            };
+        }
     }
     return {
         inner: innerLoops,
         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;