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

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;

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    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 });
+var orderCoordinatesOnLineSegment_1 = __importDefault(require("./orderCoordinatesOnLineSegment"));
+function splitLineAtPoints(line, points) {
+    if (!points.length)
+        return [line];
+    var orderedPoints = (0, orderCoordinatesOnLineSegment_1.default)(__spreadArray(__spreadArray([], line, true), points, true));
+    return (orderedPoints[0][0] === line[0][0] ? orderedPoints : orderedPoints.reverse()).reduce(function (output, point, i) {
+        if (!i)
+            return output;
+        else
+            output.push([orderedPoints[i - 1], point]);
+        return output;
+    }, []);
+}
+exports.default = splitLineAtPoints;

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

@@ -0,0 +1,95 @@
+import React from 'react';
+import type { IHydratedAttributeArray } from '../../types';
+import { ICoordinate2D, IDimensionOptions, IElementName, IElementPublic, ISpacesHookProps } from './types';
+import { IModes, IUnits, IElements } from './types';
+import { WallModes } from './constants';
+import { IThemes } from './themes';
+import SpacesLayout from './SpacesLayout';
+interface IUseSpaces {
+    hasLoaded: boolean;
+    draw: () => void;
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    [IElements.WALL]?: IHydratedAttributeArray;
+    [IElements.WINDOW]?: IHydratedAttributeArray;
+    [IElements.DOOR]?: IHydratedAttributeArray;
+    [IElements.OPENING]?: IHydratedAttributeArray;
+    selectedElement: IElementPublic | null;
+    reset: () => void;
+    recenter: (zoomToFit?: boolean) => void;
+    deleteElement: (type: IElementName, index: number) => void;
+    dimensions: {
+        value: IDimensionOptions;
+        options: Array<{
+            label: string;
+            value: IDimensionOptions;
+            selected: boolean;
+            handleSelect: () => void;
+        }>;
+        handleChange: (opt: IDimensionOptions) => void;
+    };
+    angleSnapping: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    guideSnapping: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    gridSnapping: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    zoom: {
+        min: number;
+        max: number;
+        value: number;
+        handleChange: (value: number) => void;
+    };
+    unit: {
+        value: IUnits;
+        options: Array<{
+            label: string;
+            value: IUnits;
+            selected: boolean;
+            handleSelect: () => void;
+        }>;
+        handleChange: (unit: IUnits) => void;
+    };
+    translate: {
+        handleChange: (delta: ICoordinate2D) => void;
+    };
+    mode: {
+        value: IModes;
+        options: Array<{
+            label: IModes;
+            value: IModes;
+            selected: boolean;
+            handleSelect: () => void;
+        }>;
+        handleChange: (mode: IModes) => void;
+    };
+    wallMode: {
+        value: WallModes;
+        options: Array<{
+            label: string;
+            value: WallModes;
+            selected: boolean;
+            handleSelect: () => void;
+        }>;
+        handleChange: (wallMode: WallModes) => void;
+    };
+    layouts: Array<{
+        label: string;
+        loops: Array<ICoordinate2D[]>;
+        handleSelect: () => void;
+    }>;
+}
+declare const useSpaces: {
+    (props: ISpacesHookProps): IUseSpaces;
+    themes: typeof IThemes;
+    units: typeof IUnits;
+    modes: typeof IModes;
+    wallModes: typeof WallModes;
+    LayoutIcon: typeof SpacesLayout;
+};
+export default useSpaces;