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

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,76 @@
+import React from 'react';
+import type { IHydratedAttributeArray } from '../../types';
+import type { ICoordinate2D, 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: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => 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;