@threekit-tools/treble 0.0.91 → 0.0.92

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,82 @@
+import React from 'react';
+import type { IHydratedAttributeArray } from '../../types';
+import { ICoordinate2D, IDimensionOptions, IElementName, IElementPublic, ISpacesHookProps } from './types';
+import { IModes, IUnits, IElements } from './types';
+import { IThemes } from './themes';
+import SpacesLayout from './SpacesLayout';
+interface IUseSpaces {
+    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;
+    };
+    layouts: Array<{
+        label: string;
+        loops: Array<ICoordinate2D[]>;
+        handleSelect: () => void;
+    }>;
+}
+declare const useSpaces: {
+    (props: ISpacesHookProps): IUseSpaces;
+    themes: typeof IThemes;
+    units: typeof IUnits;
+    modes: typeof IModes;
+    LayoutIcon: typeof SpacesLayout;
+};
+export default useSpaces;