@threekit-tools/treble 0.0.87 → 0.0.89-next-001

package/dist/hooks/useRoomBuilder/geometry.js

@@ -0,0 +1,462 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findClosedPaths = exports.getClosestPointOnCircumference = exports.getDistanceFromCircumference = exports.doLinesOverlap = exports.getAllLineIntersections = exports.doeslineSegmentIntersectQuadrilateral = exports.getTangetIntersectionAndOffset = exports.getTangentIntersection = exports.findAllIntersectionPoints = exports.orderCoordinatesOnLineSegment = exports.splitLineAtOffset = exports.splitLineAtPoints = exports.splitLineAtPoint = exports.getLineSegmentsIntersection = exports.getLineIntersection = exports.isPointInPolygon = exports.isPointInQuadrilateral = exports.arePointsWithinProximity = exports.addThicknessToLine = exports.getParallelLineSegmentAtDistance = exports.getTriangleArea = exports.getQuadrilateralArea = exports.getAngleBetweenLines = exports.closestPointOnLine = exports.getDistanceToLine = exports.getLineMidpoint = exports.getLineAtOffsetOnLineSegment = exports.getPointAtOffsetOnLineSegment = exports.getAngleOfLineSegment = exports.getMidpointOfLineSegment = exports.getLengthOfLineSegment = exports.areLinesEqual = exports.arePointsEqual = void 0;
+function arePointsEqual(point1, point2) {
+    if (!point1 || !point2)
+        return false;
+    return point1[0] === point2[0] && point1[1] === point2[1];
+}
+exports.arePointsEqual = arePointsEqual;
+function areLinesEqual(line1, line2) {
+    if (!line1 || !line2)
+        return false;
+    if ((arePointsEqual(line1[0], line2[0]) &&
+        arePointsEqual(line1[1], line2[1])) ||
+        (arePointsEqual(line1[0], line2[1]) && arePointsEqual(line1[1], line2[0]))) {
+        return true;
+    }
+    return false;
+}
+exports.areLinesEqual = areLinesEqual;
+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.getLengthOfLineSegment = getLengthOfLineSegment;
+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 [Math.round(xMidpoint), Math.round(yMidpoint)];
+}
+exports.getMidpointOfLineSegment = getMidpointOfLineSegment;
+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.getAngleOfLineSegment = getAngleOfLineSegment;
+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.getPointAtOffsetOnLineSegment = getPointAtOffsetOnLineSegment;
+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.getLineAtOffsetOnLineSegment = getLineAtOffsetOnLineSegment;
+function getLineMidpoint(line) {
+    var x = (line[0][0] + line[1][0]) / 2;
+    var y = (line[0][1] + line[1][1]) / 2;
+    return [x, y];
+}
+exports.getLineMidpoint = getLineMidpoint;
+function getDistanceToLine(pointOnLine, lineSlope, point) {
+    var x1 = point[0], y1 = point[1];
+    var x2 = pointOnLine[0], y2 = pointOnLine[1];
+    var lineYIntercept = y2 - lineSlope * x2;
+    return Math.abs((lineSlope * x1 - y1 + lineYIntercept) /
+        Math.sqrt(lineSlope * lineSlope + 1));
+}
+exports.getDistanceToLine = getDistanceToLine;
+function closestPointOnLine(pointOnLine, lineSlope, point) {
+    var x1 = point[0], y1 = point[1];
+    var x2 = pointOnLine[0], y2 = pointOnLine[1];
+    var lineYIntercept = y2 - lineSlope * x2;
+    var perpendicularSlope = -1 / lineSlope;
+    var perpendicularYIntercept = y1 - perpendicularSlope * x1;
+    var intersectionX = (lineYIntercept - perpendicularYIntercept) /
+        (perpendicularSlope - lineSlope);
+    var intersectionY = lineSlope * intersectionX + lineYIntercept;
+    return [intersectionX, intersectionY];
+}
+exports.closestPointOnLine = closestPointOnLine;
+function getAngleBetweenLines(line1, line2) {
+    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 line1Slope = (y2 - y1) / (x2 - x1);
+    var line2Slope = (y4 - y3) / (x4 - x3);
+    return Math.atan2(line1Slope - line2Slope, 1 + line1Slope * line2Slope);
+}
+exports.getAngleBetweenLines = getAngleBetweenLines;
+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.getQuadrilateralArea = getQuadrilateralArea;
+function getTriangleArea(point1, point2, point3) {
+    var x1 = point1[0], y1 = point1[1];
+    var x2 = point2[0], y2 = point2[1];
+    var x3 = point3[0], y3 = point3[1];
+    var a = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+    var b = Math.sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
+    var c = Math.sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3));
+    var s = (a + b + c) / 2;
+    var area = Math.sqrt(s * (s - a) * (s - b) * (s - c));
+    return area;
+}
+exports.getTriangleArea = getTriangleArea;
+function getParallelLineSegmentAtDistance(line, distance) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var angle = Math.atan2(y2 - y1, x2 - x1);
+    var xOffset = (distance / 2) * Math.sin(angle);
+    var yOffset = (distance / 2) * Math.cos(angle);
+    var point1 = [x1 + xOffset, y1 - yOffset];
+    var point2 = [x2 + xOffset, y2 - yOffset];
+    return [point1, point2];
+}
+exports.getParallelLineSegmentAtDistance = getParallelLineSegmentAtDistance;
+function addThicknessToLine(line, thickness) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var angle = Math.atan2(y2 - y1, x2 - x1);
+    var xOffset = (thickness / 2) * Math.sin(angle);
+    var yOffset = (thickness / 2) * Math.cos(angle);
+    var point1 = [x1 + xOffset, y1 - yOffset];
+    var point2 = [x1 - xOffset, y1 + yOffset];
+    var point3 = [x2 - xOffset, y2 + yOffset];
+    var point4 = [x2 + xOffset, y2 - yOffset];
+    return [point1, point2, point3, point4];
+}
+exports.addThicknessToLine = addThicknessToLine;
+function arePointsWithinProximity(point1, point2, proximity) {
+    var length = getLengthOfLineSegment([point1, point2]);
+    return length <= proximity;
+}
+exports.arePointsWithinProximity = arePointsWithinProximity;
+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 = getQuadrilateralArea(quadrilateral);
+    var area1 = getTriangleArea(point, quadrilateral[0], quadrilateral[1]);
+    var area2 = getTriangleArea(point, quadrilateral[1], quadrilateral[2]);
+    var area3 = getTriangleArea(point, quadrilateral[2], quadrilateral[3]);
+    var area4 = getTriangleArea(point, quadrilateral[3], quadrilateral[0]);
+    return (Math.abs(Math.round(area) - Math.round(area1 + area2 + area3 + area4)) < 2);
+}
+exports.isPointInQuadrilateral = isPointInQuadrilateral;
+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 (getLineSegmentsIntersection(ray, [polygonStart, polygonEnd]))
+            intersectCount++;
+    }
+    return intersectCount % 2 === 1;
+}
+exports.isPointInPolygon = isPointInPolygon;
+function getLineIntersection(line1, line2) {
+    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;
+    return [x, y];
+}
+exports.getLineIntersection = getLineIntersection;
+function getLineSegmentsIntersection(line1, line2) {
+    if (arePointsEqual.apply(void 0, line1) || arePointsEqual.apply(void 0, line2))
+        return null;
+    if (arePointsEqual(line1[0], line2[0]))
+        return null;
+    if (arePointsEqual(line1[0], line2[1]))
+        return null;
+    if (arePointsEqual(line1[1], line2[0]))
+        return null;
+    if (arePointsEqual(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];
+    if ((x1 === x2 && x3 === x4) || (y1 === y2 && y3 === y4))
+        return null;
+    if (x1 === x2 || x3 === x4) {
+        var _c = x1 === x2 ? line1.flat() : line2.flat(), xVert = _c[0], y1Vert = _c[1], _1 = _c[2], y2Vert = _c[3];
+        var _d = x1 === x2 ? line2.flat() : line1.flat(), x1Line = _d[0], y1Line = _d[1], x2Line = _d[2], y2Line = _d[3];
+        if (Math.min(x1Line, x2Line) <= xVert &&
+            xVert <= Math.max(x1Line, x2Line)) {
+            var m = (y2Line - y1Line) / (x2Line - x1Line);
+            var yValue = m * xVert + y1Line - m * x1Line;
+            if (Math.min(y1Vert, y2Vert) <= yValue &&
+                yValue <= Math.max(y1Vert, y2Vert))
+                return [xVert, yValue];
+        }
+        return null;
+    }
+    var m1 = (y2 - y1) / (x2 - x1);
+    var b1 = y1 - m1 * x1;
+    var m2 = (y4 - y3) / (x4 - x3);
+    var b2 = y3 - m2 * x3;
+    if (m1 === m2)
+        return null;
+    var x = (b2 - b1) / (m1 - m2);
+    var y = m1 * x + b1;
+    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.getLineSegmentsIntersection = getLineSegmentsIntersection;
+function splitLineAtPoint(line, point) {
+    return [
+        [line[0], point],
+        [point, line[1]],
+    ];
+}
+exports.splitLineAtPoint = splitLineAtPoint;
+function splitLineAtPoints(line, points) {
+    if (!points.length)
+        return [line];
+    var orderedPoints = orderCoordinatesOnLineSegment(__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.splitLineAtPoints = splitLineAtPoints;
+function splitLineAtOffset(line, offset) {
+    var splitPoint = getPointAtOffsetOnLineSegment(line, offset);
+    return splitLineAtPoint(line, splitPoint);
+}
+exports.splitLineAtOffset = splitLineAtOffset;
+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.orderCoordinatesOnLineSegment = orderCoordinatesOnLineSegment;
+function findAllIntersectionPoints(lines) {
+    var intersectionPoints = [];
+    for (var i = 0; i < lines.length - 1; i++) {
+        var _a = lines[i].flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+        for (var j = i + 1; j < lines.length; j++) {
+            var _b = lines[j].flat(), x3 = _b[0], y3 = _b[1], x4 = _b[2], y4 = _b[3];
+            var den = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+            if (den === 0) {
+                continue;
+            }
+            var t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / den;
+            var u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / den;
+            if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
+                var x = x1 + t * (x2 - x1);
+                var y = y1 + t * (y2 - y1);
+                intersectionPoints.push({ lines: [i, j], point: [x, y] });
+            }
+        }
+    }
+    return intersectionPoints;
+}
+exports.findAllIntersectionPoints = findAllIntersectionPoints;
+function getTangentIntersection(line, point) {
+    var _a = line.flat(), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];
+    var xTest = point[0], yTest = point[1];
+    if (x1 === x2) {
+        if (Math.min(y1, y2) <= yTest && yTest <= Math.max(y1, y2))
+            return [x1, yTest];
+        return undefined;
+    }
+    if (y1 === y2) {
+        if (Math.min(x1, x2) <= xTest && xTest <= Math.max(x1, x2))
+            return [xTest, y1];
+        return undefined;
+    }
+    var slope = (y2 - y1) / (x2 - x1);
+    var yIntercept = y1 - slope * x1;
+    var tangentSlope = -1 / slope;
+    var tangentYIntercept = yTest - tangentSlope * xTest;
+    var intersectionX = (tangentYIntercept - yIntercept) / (slope - tangentSlope);
+    var intersectionY = slope * intersectionX + yIntercept;
+    if (intersectionX >= Math.min(x1, x2) &&
+        intersectionX <= Math.max(x1, x2) &&
+        intersectionY >= Math.min(y1, y2) &&
+        intersectionY <= Math.max(y1, y2)) {
+        return [intersectionX, intersectionY];
+    }
+    else {
+        return undefined;
+    }
+}
+exports.getTangentIntersection = getTangentIntersection;
+function getTangetIntersectionAndOffset(line, point) {
+    var interceptPoint = getTangentIntersection(line, point);
+    if (!interceptPoint)
+        return undefined;
+    return {
+        point: interceptPoint,
+        offset: getLengthOfLineSegment([line[0], point]),
+    };
+}
+exports.getTangetIntersectionAndOffset = getTangetIntersectionAndOffset;
+function doeslineSegmentIntersectQuadrilateral(line, quadrilateral) {
+    for (var i = 0; i < quadrilateral.length; i++) {
+        var quadStart = quadrilateral[i];
+        var quadEnd = quadrilateral[(i + 1) % quadrilateral.length];
+        if (getLineSegmentsIntersection(line, [quadStart, quadEnd]))
+            return true;
+    }
+    return false;
+}
+exports.doeslineSegmentIntersectQuadrilateral = doeslineSegmentIntersectQuadrilateral;
+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 = getLineSegmentsIntersection(line, existingLine);
+        if (!intersectionPoint)
+            return output;
+        output.push({ index: i, point: intersectionPoint });
+        return output;
+    }, []);
+}
+exports.getAllLineIntersections = getAllLineIntersections;
+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.doLinesOverlap = doLinesOverlap;
+function getDistanceFromCircumference(point, circleCenter, radius) {
+    var x = point[0], y = point[1];
+    var xCircle = circleCenter[0], yCircle = circleCenter[1];
+    var dx = x - xCircle;
+    var dy = y - yCircle;
+    var distanceFromCenter = Math.sqrt(dx * dx + dy * dy);
+    return Math.abs(distanceFromCenter - radius);
+}
+exports.getDistanceFromCircumference = getDistanceFromCircumference;
+function getClosestPointOnCircumference(point, circleCenter, radius) {
+    var x = point[0], y = point[1];
+    var xCircle = circleCenter[0], yCircle = circleCenter[1];
+    var dx = x - xCircle;
+    var dy = y - yCircle;
+    var angle = Math.atan2(dy, dx);
+    var x2 = xCircle + radius * Math.cos(angle);
+    var y2 = yCircle + radius * Math.sin(angle);
+    return [x2, y2];
+}
+exports.getClosestPointOnCircumference = getClosestPointOnCircumference;
+function findClosedPaths(lines) {
+    if (!(lines === null || lines === void 0 ? void 0 : lines.length))
+        return [];
+    var vertices = lines.reduce(function (output, line, i) {
+        line.forEach(function (point) {
+            var pointStr = JSON.stringify(point);
+            if (output[pointStr])
+                output[pointStr].push(i);
+            else
+                output[pointStr] = [i];
+        });
+        return output;
+    }, {});
+    var closedLoops = [];
+    var linesVisted = new Set([]);
+    for (var i = 0; i < lines.length; i++) {
+        if (!linesVisted.has(i))
+            depthFirstSearch(i);
+    }
+    return closedLoops;
+    function depthFirstSearch(index, vertexPath, linesPath) {
+        if (vertexPath === void 0) { vertexPath = []; }
+        if (linesPath === void 0) { linesPath = []; }
+        var pointsToSearch = vertexPath.length
+            ? lines[index].filter(function (point) { return !arePointsEqual(vertexPath[vertexPath.length - 1], point); })
+            : lines[index];
+        pointsToSearch.forEach(function (pointToSearch) {
+            var vertexVisted = vertexPath.findIndex(function (point) {
+                return arePointsEqual(pointToSearch, point);
+            });
+            if (vertexVisted !== -1) {
+                var loop = linesPath.slice(vertexVisted, linesPath.length - 1);
+                closedLoops.push(__spreadArray([index], loop, true));
+                return;
+            }
+            if (linesVisted.has(index))
+                return;
+            var linesToSearch = vertices[JSON.stringify(pointToSearch)];
+            if (!(linesToSearch === null || linesToSearch === void 0 ? void 0 : linesToSearch.length))
+                return;
+            linesToSearch.forEach(function (lineIndex) {
+                if (index === lineIndex)
+                    return;
+                depthFirstSearch(lineIndex, __spreadArray(__spreadArray([], vertexPath, true), [pointToSearch], false), __spreadArray(__spreadArray([], linesPath, true), [lineIndex], false));
+            });
+        });
+        linesVisted.add(index);
+    }
+}
+exports.findClosedPaths = findClosedPaths;

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

@@ -0,0 +1,40 @@
+import React from 'react';
+import type { IHydratedAttributeArray } from '../../types';
+import type { IElementName, IElementPublic, IRoomBuilderHookProps } from './types';
+import { IModes, IUnits, IElements } from './types';
+import { IThemes } from './themes';
+interface IUseRoomBuilder {
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    [IElements.WALL]?: IHydratedAttributeArray;
+    [IElements.WINDOW]?: IHydratedAttributeArray;
+    [IElements.DOOR]?: IHydratedAttributeArray;
+    [IElements.OPENING]?: IHydratedAttributeArray;
+    selectedElement: IElementPublic | null;
+    deleteAll: () => void;
+    deleteElement: (type: IElementName, index: number) => void;
+    dimensions: {
+        show: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    snapping: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    mode: {
+        value: IModes;
+        options: Array<{
+            label: IModes;
+            value: IModes;
+            selected: boolean;
+            handleSelect: () => void;
+        }>;
+        handleChange: (mode: IModes) => void;
+    };
+}
+declare const useRoomBuilder: {
+    (props: IRoomBuilderHookProps): IUseRoomBuilder;
+    themes: typeof IThemes;
+    units: typeof IUnits;
+    modes: typeof IModes;
+};
+export default useRoomBuilder;