@threekit-tools/treble 0.0.91-next-03 → 0.0.92

package/dist/hooks/useRoomBuilder/RoomBuilderState.js

@@ -0,0 +1,1237 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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.RoomBuilderState = void 0;
+var types_1 = require("./types");
+var types_2 = require("./types");
+var validators_1 = require("./validators");
+var geometry_1 = require("./geometry");
+var draw_1 = require("./draw");
+var dataHandlers_1 = require("./dataHandlers");
+var __1 = require("../..");
+var constants_1 = require("./constants");
+var findLoops_1 = require("./findLoops");
+var RoomBuilderState = (function () {
+    function RoomBuilderState(config) {
+        var _a;
+        var _this = this;
+        this.moveActiveVertex = function (canvas, point) {
+            var _a, _b, _c, _d;
+            if (!canvas)
+                return;
+            if (((_a = _this._activeElement) === null || _a === void 0 ? void 0 : _a.type) !== types_2.IElements.VERTEX)
+                return;
+            var snapPoint = _this.getPointProximity(point);
+            if (!snapPoint && _this._angleSnappingEnabled)
+                snapPoint = _this.snapVertexToAbsoluteAngle(_this._activeElement.index, point);
+            var vertex = _this.getVertex(_this._activeElement.index);
+            if (!vertex)
+                return;
+            var validationData = {
+                vertex: vertex,
+                walls: _this.walls,
+                updatedPosition: {
+                    point: point,
+                    snapTo: snapPoint,
+                },
+                features: _this.features,
+            };
+            _this._errorElement = (0, validators_1.runValidators)([
+                validators_1.isVertexLandingOnFeature,
+                validators_1.areWallsTooShort,
+                validators_1.areWallsIntersecting,
+                validators_1.areWallsOrphaningFeatures,
+                validators_1.areWallsDuplicated,
+            ], validationData);
+            var errorType = ((_b = _this._errorElement) === null || _b === void 0 ? void 0 : _b[0].type) || null;
+            switch (errorType) {
+                case types_1.IErrorTypes.HARD:
+                    return;
+                case types_1.IErrorTypes.SOFT:
+                case types_1.IErrorTypes.WARN:
+                case null:
+                default:
+                    _this._activeElement.snapPoint = snapPoint;
+                    _this.repositionVertex(_this._activeElement.index, (_c = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.point) !== null && _c !== void 0 ? _c : point);
+                    _this.drawRoom(canvas);
+                    (0, draw_1.drawVertex)(canvas, (_d = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.point) !== null && _d !== void 0 ? _d : point, _this._config.config.styles.vertex, types_1.IElementStyleModes.HIGHLIGHT);
+                    break;
+            }
+        };
+        this.finishMoveActiveVertex = function () {
+            var _a, _b;
+            if (((_a = _this._activeElement) === null || _a === void 0 ? void 0 : _a.type) !== types_2.IElements.VERTEX)
+                return;
+            if (((_b = _this._activeElement.snapPoint) === null || _b === void 0 ? void 0 : _b.type) === types_2.IElements.WALL)
+                _this.splitWall(_this._activeElement.snapPoint.index, _this._activeElement.snapPoint.point);
+            _this.pushStateToConfigurator();
+        };
+        this.moveActiveFeature = function (canvas, moveToPoint) {
+            var _a, _b;
+            if (_this._activeElement === null)
+                return;
+            var _c = _this._activeElement, type = _c.type, index = _c.index;
+            if (type !== types_2.IElements.WINDOW &&
+                type !== types_2.IElements.DOOR &&
+                type !== types_2.IElements.OPENING)
+                return;
+            var feature = _this.getFeature(type, index);
+            if (!feature)
+                return;
+            var wallIndex = (_a = _this.getWallInProximity(moveToPoint)) !== null && _a !== void 0 ? _a : feature.connectedTo[1];
+            var wall = _this.getWall(wallIndex);
+            if (!wall)
+                return;
+            var intersection = (0, geometry_1.getTangetIntersectionAndOffset)(wall.line, moveToPoint);
+            if (!intersection)
+                return;
+            var newOffset = intersection.offset - feature.length / 2;
+            var featureUpdatesToValidate = {
+                length: feature.length,
+                offset: newOffset,
+                address: { type: type, index: index },
+            };
+            _this._errorElement = (0, validators_1.runValidators)([validators_1.isFeatureOutsideWallBounds, validators_1.isFeatureCollidingWithExistingFeature], {
+                wall: wall,
+                features: _this.features,
+                updatedFeature: featureUpdatesToValidate,
+            });
+            var errorType = ((_b = _this._errorElement) === null || _b === void 0 ? void 0 : _b[0].type) || null;
+            switch (errorType) {
+                case types_1.IErrorTypes.HARD:
+                    return;
+                case types_1.IErrorTypes.SOFT:
+                    _this.drawRoom(canvas);
+                    break;
+                case types_1.IErrorTypes.WARN:
+                case null:
+                default:
+                    _this.repositionFeature([type, index], newOffset, wallIndex);
+                    _this.drawRoom(canvas);
+                    break;
+            }
+        };
+        this.finishMoveActiveFeature = function () {
+            var _a;
+            var type = (_a = _this._activeElement) === null || _a === void 0 ? void 0 : _a.type;
+            if (!type)
+                return;
+            if (type !== types_2.IElements.WINDOW &&
+                type !== types_2.IElements.DOOR &&
+                type !== types_2.IElements.OPENING)
+                return;
+            _this.pushStateToConfigurator();
+        };
+        this._config = config;
+        this._newWall = null;
+        this._activeElement = null;
+        this._selectedElement = null;
+        this._highlightedElement = null;
+        this._errorElement = null;
+        this._state = (_a = {},
+            _a[types_2.IElements.WALL] = [],
+            _a[types_2.IElements.VERTEX] = {},
+            _a[types_2.IElements.FEATURE] = {},
+            _a);
+        this._showDimensions = true;
+        this._angleSnappingEnabled = true;
+        this._attributesState = null;
+    }
+    Object.defineProperty(RoomBuilderState.prototype, "walls", {
+        get: function () {
+            return this._state[types_2.IElements.WALL];
+        },
+        set: function (walls) {
+            this._state[types_2.IElements.WALL] = walls;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "wallCount", {
+        get: function () {
+            return this.walls.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "wallLines", {
+        get: function () {
+            return this.walls.map(function (_a) {
+                var line = _a.line;
+                return line;
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "vertices", {
+        get: function () {
+            return this._state[types_2.IElements.VERTEX];
+        },
+        set: function (vertices) {
+            this._state[types_2.IElements.VERTEX] = vertices;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "verticesList", {
+        get: function () {
+            return Object.entries(this.vertices).map(function (_a) {
+                var pointStr = _a[0], connections = _a[1];
+                return ({
+                    point: JSON.parse(pointStr),
+                    connections: connections,
+                });
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "features", {
+        get: function () {
+            return this._state[types_2.IElements.FEATURE];
+        },
+        set: function (features) {
+            this._state[types_2.IElements.FEATURE] = features;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "getHydratedFeatures", {
+        get: function () {
+            var _this = this;
+            return Object.entries(this.features).reduce(function (output, _a) {
+                var _b;
+                var type = _a[0], featureArr = _a[1];
+                return Object.assign(output, (_b = {},
+                    _b[type] = featureArr.map(function (feature) {
+                        var wall = _this.getWall(feature.connectedTo[1]);
+                        if (!wall)
+                            return;
+                        var line = (0, geometry_1.getLineAtOffsetOnLineSegment)(wall.line, feature.offset, feature.length);
+                        return __assign(__assign({}, feature), { line: line });
+                    }),
+                    _b));
+            }, {});
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "featureCount", {
+        get: function () {
+            return Object.values(this.features).flat().length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "activeElement", {
+        get: function () {
+            return this._activeElement;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "selectedElement", {
+        get: function () {
+            return this._selectedElement;
+        },
+        set: function (element) {
+            this._selectedElement = element;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "showDimensions", {
+        get: function () {
+            return this._showDimensions;
+        },
+        set: function (val) {
+            this._showDimensions = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "angleSnappingEnabled", {
+        get: function () {
+            return this._angleSnappingEnabled;
+        },
+        set: function (val) {
+            this._angleSnappingEnabled = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RoomBuilderState.prototype, "enclosedSpaces", {
+        get: function () {
+            var _this = this;
+            var loops = (0, findLoops_1.findLoops)(this.wallLines).inner;
+            return loops.reduce(function (output, loop) {
+                var screenSpaceArea = Math.round((0, geometry_1.getPolygonArea)(loop));
+                var area = screenSpaceArea * Math.pow(_this._config.config.scale, 2);
+                var convertedArea = (0, dataHandlers_1.convertAreaUnit)(area, types_1.IUnits.METER, _this._config.config.unit);
+                var enclosedSpace = {
+                    loop: loop,
+                    area: (0, dataHandlers_1.prepAreaForUser)(convertedArea, _this._config.config.unit),
+                    center: loop.reduce(function (centerPoint, point) {
+                        centerPoint[0] += point[0] / loop.length;
+                        centerPoint[1] += point[1] / loop.length;
+                        return centerPoint;
+                    }, [0, 0]),
+                };
+                output.push(enclosedSpace);
+                return output;
+            }, []);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RoomBuilderState.prototype.getWall = function (index) {
+        return this.walls[index];
+    };
+    RoomBuilderState.prototype.addWall = function (wall) {
+        if (!wall)
+            return;
+        var updatedWalls = this.walls;
+        updatedWalls.push(wall);
+        this.walls = updatedWalls;
+    };
+    RoomBuilderState.prototype.addWalls = function (walls) {
+        var _this = this;
+        if (!(walls === null || walls === void 0 ? void 0 : walls.length))
+            return;
+        walls.forEach(function (wall) { return _this.addWall(wall); });
+    };
+    RoomBuilderState.prototype.updateWall = function (index, wall) {
+        var currentWall = this.walls[index];
+        if (!currentWall)
+            return;
+        this._state[types_2.IElements.WALL][index] = Object.assign({}, currentWall, wall);
+    };
+    RoomBuilderState.prototype.getWallConnectionCount = function (index) {
+        var wall = this.getWall(index);
+        return (wall === null || wall === void 0 ? void 0 : wall.connections.length) || 0;
+    };
+    RoomBuilderState.prototype.getWallConnectionsHydrated = function (index) {
+        var _this = this;
+        var _a;
+        var connections = (_a = this.getWall(index)) === null || _a === void 0 ? void 0 : _a.connections;
+        if (!connections)
+            return undefined;
+        return connections.reduce(function (output, connection) {
+            var feature = _this.getFeature.apply(_this, connection);
+            if (feature)
+                output.push(feature);
+            return output;
+        }, []);
+    };
+    RoomBuilderState.prototype.getWallDimensions = function (index) {
+        var _a;
+        var line = (_a = this.getWall(index)) === null || _a === void 0 ? void 0 : _a.line;
+        if (!line)
+            return undefined;
+        var lineLength = (0, geometry_1.getLengthOfLineSegment)(line) * this._config.config.scale;
+        var convertedVal = (0, dataHandlers_1.convertLengthUnit)(lineLength, types_1.IUnits.METER, this._config.config.unit);
+        return {
+            line: line,
+            label: (0, dataHandlers_1.prepLengthForUser)(convertedVal, this._config.config.unit),
+        };
+    };
+    RoomBuilderState.prototype.getWallDetailedDimensions = function (index) {
+        var _this = this;
+        var _a;
+        var line = (_a = this.getWall(index)) === null || _a === void 0 ? void 0 : _a.line;
+        var features = this.getWallConnectionsHydrated(index);
+        if (!line || !features)
+            return undefined;
+        var prepLength = function (val) { return val.toFixed(2); };
+        var lines = features
+            .sort(function (a, b) { return a.offset - b.offset; })
+            .reduce(function (output, _a, i) {
+            var offset = _a.offset, length = _a.length;
+            var featureLine = (0, geometry_1.getLineAtOffsetOnLineSegment)(line, offset, length);
+            var featureLength = (0, geometry_1.getLengthOfLineSegment)(featureLine);
+            var unit = constants_1.UNIT_LABELS[_this._config.config.unit];
+            var scale = _this._config.config.scale;
+            if (!i) {
+                var startLine = [line[0], featureLine[0]];
+                var startLineLength = (0, geometry_1.getLengthOfLineSegment)(startLine);
+                output.push({
+                    line: startLine,
+                    label: "".concat(prepLength(startLineLength * scale), " ").concat(unit),
+                });
+            }
+            else {
+                var previousLine = [
+                    output[output.length - 1].line[1],
+                    featureLine[0],
+                ];
+                var previousLineLength = (0, geometry_1.getLengthOfLineSegment)(previousLine);
+                output.push({
+                    line: previousLine,
+                    label: "".concat(prepLength(previousLineLength * scale), " ").concat(unit),
+                });
+            }
+            output.push({
+                line: featureLine,
+                label: "".concat(prepLength(featureLength * scale), " ").concat(unit),
+            });
+            if (i === features.length - 1) {
+                var endLine = [featureLine[1], line[1]];
+                var endLineLength = (0, geometry_1.getLengthOfLineSegment)(endLine);
+                output.push({
+                    line: endLine,
+                    label: "".concat(prepLength(endLineLength * scale), " ").concat(unit),
+                });
+            }
+            return output;
+        }, []);
+        return lines;
+    };
+    RoomBuilderState.prototype.getAllWallDimensions = function (detailedWallsIndexes) {
+        var _this = this;
+        if (detailedWallsIndexes === void 0) { detailedWallsIndexes = []; }
+        var indexes = new Set([detailedWallsIndexes].flat());
+        return this.walls.reduce(function (output, _, i) {
+            var dimensions = indexes.has(i)
+                ? _this.getWallDetailedDimensions(i)
+                : _this.getWallDimensions(i);
+            if (!dimensions)
+                return output;
+            if (Array.isArray(dimensions))
+                output.push.apply(output, dimensions);
+            else
+                output.push(dimensions);
+            return output;
+        }, []);
+    };
+    RoomBuilderState.prototype.shiftAllFeaturesOnWall = function (index, shift) {
+        var _this = this;
+        var _a;
+        var connections = (_a = this.getWall(index)) === null || _a === void 0 ? void 0 : _a.connections;
+        if (!connections)
+            return;
+        connections.forEach(function (_a) {
+            var type = _a[0], featureIndex = _a[1];
+            var feature = _this.getFeature(type, featureIndex);
+            if (!feature)
+                return;
+            _this.updateFeature(type, featureIndex, {
+                offset: feature.offset + shift,
+            });
+        });
+    };
+    RoomBuilderState.prototype.addFeatureToWall = function (index, featurePath) {
+        var _a;
+        var updatedWalls = this.walls;
+        (_a = updatedWalls[index]) === null || _a === void 0 ? void 0 : _a.connections.push(featurePath);
+        this.walls = updatedWalls;
+    };
+    RoomBuilderState.prototype.removeFeatureFromWall = function (index, featurePath) {
+        var updatedWalls = this.walls;
+        if (!updatedWalls[index])
+            return;
+        updatedWalls[index].connections = updatedWalls[index].connections.filter(function (connection) {
+            return connection[0] !== featurePath[0] || connection[1] !== featurePath[1];
+        });
+        this.walls = updatedWalls;
+    };
+    RoomBuilderState.prototype.splitWall = function (wallIndex, point) {
+        var _this = this;
+        var singleWall = this.getWall(wallIndex);
+        if (!singleWall)
+            return;
+        var offset = (0, geometry_1.getLengthOfLineSegment)([singleWall.line[0], point]);
+        var _a = (0, geometry_1.splitLineAtPoint)(singleWall.line, point), line1 = _a[0], line2 = _a[1];
+        var newWallIndex = this.wallCount;
+        var wall1 = {
+            assetId: singleWall.assetId,
+            line: line1,
+            height: singleWall.height,
+            thickness: singleWall.thickness,
+            connections: singleWall.connections,
+        };
+        var wall2 = {
+            assetId: singleWall.assetId,
+            line: line2,
+            height: singleWall.height,
+            thickness: singleWall.thickness,
+            connections: [],
+        };
+        this.updateWall(wallIndex, wall1);
+        this.addWall(wall2);
+        singleWall.connections.forEach(function (connection) {
+            var feature = _this.getFeature.apply(_this, connection);
+            if (!feature)
+                return;
+            var updatedOffset = feature.offset - offset;
+            if (updatedOffset > 0)
+                _this.repositionFeature(connection, updatedOffset, newWallIndex);
+        });
+    };
+    RoomBuilderState.prototype.deleteWall = function (index) {
+        var wall = this.getWall(index);
+        if (!wall)
+            return;
+        if (wall.connections.length) {
+            var currentFeatures_1 = this.features;
+            var deleteMap = wall.connections.reduce(function (output, _a) {
+                var type = _a[0], index = _a[1];
+                if (output[type])
+                    output[type].push(index);
+                else
+                    output[type] = [index];
+                return output;
+            }, {});
+            var updatedFeatures = Object.entries(deleteMap).reduce(function (output, _a) {
+                var _b;
+                var type = _a[0], deletionIndexes = _a[1];
+                output[type] = (_b = currentFeatures_1[type]) === null || _b === void 0 ? void 0 : _b.filter(function (_, i) { return !deletionIndexes.includes(i); });
+                return output;
+            }, __assign({}, currentFeatures_1));
+            this.features = updatedFeatures;
+        }
+        var updatedWalls = this.walls;
+        updatedWalls.splice(index, 1);
+        this.walls = updatedWalls;
+        var reevaluatedFeatures = Object.entries(this.features).reduce(function (output, _a) {
+            var type = _a[0], featuresArr = _a[1];
+            output[type] = featuresArr.map(function (feature) {
+                return feature.connectedTo[1] > index
+                    ? Object.assign({}, feature, {
+                        connectedTo: [
+                            feature.connectedTo[0],
+                            feature.connectedTo[1] - 1,
+                        ],
+                    })
+                    : feature;
+            });
+            return output;
+        }, {});
+        this.features = reevaluatedFeatures;
+        this.reevaluateFeatureConnections();
+        this.pushStateToConfigurator();
+    };
+    RoomBuilderState.prototype.getFirstVacantLocation = function (length) {
+        var _a;
+        var walls = this.walls;
+        var offset = undefined;
+        for (var i = 0; i < walls.length; i++) {
+            var wallLength = (0, geometry_1.getLengthOfLineSegment)(walls[i].line);
+            var features = (_a = this.getWallConnectionsHydrated(i)) === null || _a === void 0 ? void 0 : _a.sort(function (a, b) { return a.offset - b.offset; });
+            if (!(features === null || features === void 0 ? void 0 : features.length)) {
+                if (length < wallLength - 2 * constants_1.WALL_PADDING_FOR_FEATURE)
+                    offset = (wallLength - 2 * constants_1.WALL_PADDING_FOR_FEATURE) / 2 - length / 2;
+            }
+            else {
+                for (var j = 0; j < features.length && offset === undefined; j++) {
+                    var _b = features[j], currentOffset = _b.offset, currentLength = _b.length;
+                    if (!j) {
+                        if (constants_1.WALL_PADDING_FOR_FEATURE + length < currentOffset) {
+                            var slotStart = constants_1.WALL_PADDING_FOR_FEATURE;
+                            var slotEnd = currentOffset;
+                            offset = slotStart + (slotEnd - slotStart) / 2 - length / 2;
+                            continue;
+                        }
+                    }
+                    else {
+                        var _c = features[j - 1], previousOffset = _c.offset, previousLength = _c.length;
+                        if (length < currentOffset - (previousOffset + previousLength)) {
+                            var slotStart = previousOffset + previousLength;
+                            var slotEnd = currentOffset;
+                            offset = slotStart + (slotEnd - slotStart) / 2 - length / 2;
+                            continue;
+                        }
+                    }
+                    if (j === features.length - 1) {
+                        if (length <
+                            wallLength -
+                                constants_1.WALL_PADDING_FOR_FEATURE -
+                                (currentOffset + currentLength)) {
+                            var slotStart = currentOffset + currentLength;
+                            var slotEnd = wallLength - constants_1.WALL_PADDING_FOR_FEATURE;
+                            offset = slotStart + (slotEnd - slotStart) / 2 - length / 2;
+                        }
+                    }
+                }
+            }
+            if (offset !== undefined)
+                return {
+                    wallIndex: i,
+                    offset: offset,
+                };
+        }
+        return false;
+    };
+    RoomBuilderState.prototype.getWallUiAnchorPoint = function (index) {
+        var wall = this.getWall(index);
+        if (!wall)
+            return undefined;
+        var line = (0, geometry_1.getParallelLineSegmentAtDistance)(wall.line, constants_1.UI_ANCHOR_DISTANCE);
+        return (0, geometry_1.getMidpointOfLineSegment)(line);
+    };
+    RoomBuilderState.prototype.getVertex = function (index) {
+        return this.verticesList[index];
+    };
+    RoomBuilderState.prototype.getWallsConnectedToVertex = function (index) {
+        if (index === undefined)
+            return [];
+        var vertex = this.getVertex(index);
+        if (!vertex)
+            return [];
+        return vertex.connections.map(function (_a) {
+            var index = _a[0];
+            return index;
+        });
+    };
+    RoomBuilderState.prototype.repositionVertex = function (index, newCoordinates) {
+        var _this = this;
+        var _a;
+        var connections = (_a = this.getVertex(index)) === null || _a === void 0 ? void 0 : _a.connections;
+        if (!connections)
+            return;
+        connections.forEach(function (_a) {
+            var wallIdx = _a[0], vertexIdx = _a[1];
+            var updatedLine = JSON.parse(JSON.stringify(_this.walls[wallIdx].line));
+            var currentLine = JSON.parse(JSON.stringify(_this.walls[wallIdx].line));
+            updatedLine[vertexIdx] = newCoordinates;
+            if (_this.getWallConnectionCount(wallIdx) && vertexIdx === 0) {
+                var delta = (0, geometry_1.getLengthOfLineSegment)(updatedLine) -
+                    (0, geometry_1.getLengthOfLineSegment)(currentLine);
+                _this.shiftAllFeaturesOnWall(wallIdx, delta);
+            }
+            _this.updateWall(wallIdx, {
+                line: updatedLine,
+                path: undefined,
+            });
+        });
+    };
+    RoomBuilderState.prototype.getFeatureType = function (type) {
+        return this.features[type];
+    };
+    RoomBuilderState.prototype.setFeatureType = function (type, features) {
+        var updatedFeatures = this.features;
+        updatedFeatures[type] = features;
+        this.features = updatedFeatures;
+        this.reevaluateFeatureConnections();
+    };
+    RoomBuilderState.prototype.getFeature = function (type, index) {
+        var _a;
+        return (_a = this.features[type]) === null || _a === void 0 ? void 0 : _a[index];
+    };
+    RoomBuilderState.prototype.updateFeature = function (type, index, feature) {
+        var currentFeature = this._state[types_2.IElements.FEATURE][type][index];
+        if (!currentFeature)
+            return;
+        this._state[types_2.IElements.FEATURE][type][index] = Object.assign({}, currentFeature, feature);
+    };
+    RoomBuilderState.prototype.repositionFeature = function (featurePath, offset, moveToWallIndex) {
+        var type = featurePath[0], index = featurePath[1];
+        var feature = this.getFeature(type, index);
+        if (!feature)
+            return;
+        this.updateFeature(type, index, { offset: offset, path: undefined });
+        if (moveToWallIndex === feature.connectedTo[1])
+            return;
+        this.removeFeatureFromWall(index, featurePath);
+        this.addFeatureToWall(moveToWallIndex, featurePath);
+        this.updateFeature(type, index, {
+            connectedTo: [types_2.IElements.WALL, moveToWallIndex],
+        });
+    };
+    RoomBuilderState.prototype.addFeature = function (type, feature, addToWallIndex) {
+        var offset = undefined;
+        var index = undefined;
+        if (addToWallIndex !== undefined && feature.offset !== undefined) {
+            var wall = this.getWall(addToWallIndex);
+            if (wall) {
+                var isColliding = (0, validators_1.isFeatureCollidingWithExistingFeature)({
+                    wall: wall,
+                    features: this.features,
+                    updatedFeature: __assign(__assign({}, feature), { offset: feature.offset, address: { type: types_2.IElements.WALL, index: addToWallIndex } }),
+                });
+                if (!isColliding) {
+                    offset = feature.offset;
+                    index = addToWallIndex;
+                }
+            }
+        }
+        if (offset === undefined) {
+            var availableSlot = this.getFirstVacantLocation(feature.length);
+            if (!availableSlot)
+                return;
+            offset = availableSlot.offset;
+            index = availableSlot.wallIndex;
+        }
+        if (index === undefined || offset === undefined)
+            return;
+        var newFeature = __assign(__assign({}, feature), { offset: offset, connectedTo: [types_2.IElements.WALL, index] });
+        var newFeatureIndex;
+        if (this._state[types_2.IElements.FEATURE][type]) {
+            this._state[types_2.IElements.FEATURE][type].push(newFeature);
+            newFeatureIndex = this._state[types_2.IElements.FEATURE][type].length;
+        }
+        else {
+            this._state[types_2.IElements.FEATURE][type] = [newFeature];
+            newFeatureIndex = 1;
+        }
+        this.addFeatureToWall(index, [type, newFeatureIndex]);
+        this.pushStateToConfigurator();
+    };
+    RoomBuilderState.prototype.deleteFeature = function (type, index) {
+        var features = this.getFeatureType(type);
+        if (!(features === null || features === void 0 ? void 0 : features[index]))
+            return;
+        var deletedFeature = features.splice(index, 1)[0];
+        this.setFeatureType(type, features);
+        var wallToUpdate = this.getWall(deletedFeature.connectedTo[1]);
+        if (!wallToUpdate)
+            return;
+        this.updateWall(deletedFeature.connectedTo[1], {
+            connections: wallToUpdate.connections.filter(function (connection) { return connection[0] === type && connection[1] !== index; }),
+        });
+        this.pushStateToConfigurator();
+    };
+    RoomBuilderState.prototype.getHydratedFeature = function (type, index) {
+        var feature = this.getFeature(type, index);
+        if (!feature)
+            return;
+        var wall = this.getWall(feature.connectedTo[1]);
+        if (!wall)
+            return;
+        var line = (0, geometry_1.getLineAtOffsetOnLineSegment)(wall.line, feature.offset, feature.length);
+        return __assign(__assign({}, feature), { line: line });
+    };
+    RoomBuilderState.prototype.getFeatureUiAnchorPoint = function (type, index) {
+        var feature = this.getHydratedFeature(type, index);
+        if (!feature)
+            return;
+        var line = (0, geometry_1.getParallelLineSegmentAtDistance)(feature.line, constants_1.UI_ANCHOR_DISTANCE);
+        return (0, geometry_1.getMidpointOfLineSegment)(line);
+    };
+    RoomBuilderState.prototype.deleteElement = function (type, index) {
+        if (type === types_2.IElements.VERTEX)
+            return;
+        if (type === types_2.IElements.WALL)
+            this.deleteWall(index);
+        else
+            this.deleteFeature(type, index);
+    };
+    RoomBuilderState.prototype.getVertexInProximity = function (point) {
+        var _this = this;
+        if (!point)
+            return undefined;
+        var index = this.verticesList.findIndex(function (vertex) {
+            return (0, geometry_1.arePointsWithinProximity)(vertex.point, point, _this._config.config.snapProximity);
+        });
+        if (index === -1)
+            return undefined;
+        return index;
+    };
+    RoomBuilderState.prototype.getWallInProximity = function (point) {
+        var _this = this;
+        var index = this.walls.findIndex(function (wall) {
+            var path = (0, geometry_1.addThicknessToLine)(wall.line, _this._config.config.styles.wall.thickness + constants_1.WALL_SNAP_DISTANCE);
+            return (0, geometry_1.isPointInQuadrilateral)(path, point);
+        });
+        if (index === -1)
+            return undefined;
+        return index;
+    };
+    RoomBuilderState.prototype.snapPointToVertex = function (point) {
+        var _a, _b;
+        if (!point)
+            return undefined;
+        var index = this.getVertexInProximity(point);
+        if (index === undefined)
+            return undefined;
+        if (((_a = this._activeElement) === null || _a === void 0 ? void 0 : _a.type) === types_2.IElements.VERTEX &&
+            ((_b = this._activeElement) === null || _b === void 0 ? void 0 : _b.index) === index)
+            return undefined;
+        var vertex = this.getVertex(index);
+        if (!vertex)
+            return undefined;
+        return {
+            type: types_2.IElements.VERTEX,
+            index: index,
+            point: vertex.point,
+        };
+    };
+    RoomBuilderState.prototype.snapPointToWall = function (point) {
+        var index = this.getWallInProximity(point);
+        if (index === undefined)
+            return undefined;
+        if (this._activeElement) {
+            if (this._activeElement.type === types_2.IElements.WALL &&
+                this._activeElement.index === index)
+                return undefined;
+            if (this._activeElement.type === types_2.IElements.VERTEX) {
+                var vertex = this.getVertex(this._activeElement.index);
+                if (vertex)
+                    for (var i = 0; i < vertex.connections.length; i++) {
+                        if (vertex.connections[i][0] === index)
+                            return undefined;
+                    }
+            }
+        }
+        var intersection = (0, geometry_1.getTangetIntersectionAndOffset)(this.getWall(index).line, point);
+        if (!intersection)
+            return undefined;
+        return __assign({ type: types_2.IElements.WALL, index: index }, intersection);
+    };
+    RoomBuilderState.prototype.snapPointToAbsoluteAngle = function (point, anchorPoint, angle) {
+        if (angle === void 0) { angle = 15; }
+        var snapProximity = this._config.config.snapProximity;
+        if (Math.abs(point[0] - anchorPoint[0]) < snapProximity) {
+            return {
+                type: 'Angle',
+                point: [anchorPoint[0], point[1]],
+            };
+        }
+        else if (Math.abs(point[1] - anchorPoint[1]) < snapProximity) {
+            return {
+                type: 'Angle',
+                point: [point[0], anchorPoint[1]],
+            };
+        }
+        for (var degrees = 0; degrees < 360; degrees += angle) {
+            if (degrees === 0 || degrees % 90 === 0)
+                continue;
+            var radians = degrees * (Math.PI / 180);
+            if ((0, geometry_1.getDistanceToLine)(anchorPoint, radians, point) < snapProximity)
+                return {
+                    type: 'Angle',
+                    point: (0, geometry_1.closestPointOnLine)(anchorPoint, radians, point),
+                };
+        }
+        return undefined;
+    };
+    RoomBuilderState.prototype.snapVertexToAbsoluteAngle = function (vertexIndex, updatedPoint) {
+        var _this = this;
+        var vertex = this.getVertex(vertexIndex);
+        if (!vertex)
+            return undefined;
+        var point = vertex.connections.reduce(function (output, connection) {
+            var _a;
+            var line = (_a = _this.getWall(connection[0])) === null || _a === void 0 ? void 0 : _a.line;
+            if (!line)
+                return output;
+            var _b = output || updatedPoint, x = _b[0], y = _b[1];
+            var _c = line[connection[1] === 0 ? 1 : 0], xAnchor = _c[0], yAnchor = _c[1];
+            if (Math.abs(x - xAnchor) < _this._config.config.snapProximity)
+                return [xAnchor, y];
+            else if (Math.abs(y - yAnchor) < _this._config.config.snapProximity)
+                return [x, yAnchor];
+            return output;
+        }, undefined);
+        if (!point)
+            return point;
+        return {
+            type: 'Angle',
+            point: point,
+        };
+    };
+    RoomBuilderState.prototype.getFeatureAtPoint = function (point) {
+        var _this = this;
+        if (!point)
+            return undefined;
+        if (!this.featureCount)
+            return undefined;
+        var featuresMap = Object.entries(this.features);
+        for (var i = 0; i < featuresMap.length; i++) {
+            var _a = featuresMap[i], name_1 = _a[0], feature = _a[1];
+            var index = feature.findIndex(function (feature) {
+                var path = feature.path;
+                if (!path) {
+                    var wallIndex = feature.connectedTo[1];
+                    var featureLine = (0, geometry_1.getLineAtOffsetOnLineSegment)(_this.getWall(wallIndex).line, feature.offset, feature.length);
+                    path = (0, geometry_1.addThicknessToLine)(featureLine, _this._config.config.styles.feature.thickness);
+                }
+                return (0, geometry_1.isPointInQuadrilateral)(path, point);
+            });
+            if (index !== -1)
+                return {
+                    type: name_1,
+                    index: index,
+                };
+        }
+        return undefined;
+    };
+    RoomBuilderState.prototype.getElementAtPoint = function (point) {
+        if (!point)
+            return undefined;
+        var snapToVertex = this.snapPointToVertex(point);
+        if (snapToVertex !== undefined)
+            return snapToVertex;
+        if (this.featureCount) {
+            var featureInProximity = this.getFeatureAtPoint(point);
+            if (featureInProximity)
+                return featureInProximity;
+        }
+        var wallInProximity = this.getWallInProximity(point);
+        if (wallInProximity !== undefined)
+            return { type: types_2.IElements.WALL, index: wallInProximity };
+        return undefined;
+    };
+    RoomBuilderState.prototype.getClickedElement = function (point) {
+        var element = this.getElementAtPoint(point);
+        if (!element)
+            return;
+        var uiAnchor;
+        if (element.type === types_2.IElements.VERTEX)
+            return;
+        if (element.type === types_2.IElements.WALL)
+            uiAnchor = this.getWallUiAnchorPoint(element.index);
+        else
+            uiAnchor = this.getFeatureUiAnchorPoint(element.type, element.index);
+        if (!uiAnchor)
+            return undefined;
+        return {
+            path: [element.type, element.index],
+            uiAnchor: uiAnchor,
+        };
+    };
+    RoomBuilderState.prototype.getPointProximity = function (point) {
+        var feature = this.getFeatureAtPoint(point);
+        if (feature)
+            return __assign(__assign({}, feature), { point: point });
+        var snapToVertex = this.snapPointToVertex(point);
+        if (snapToVertex)
+            return snapToVertex;
+        var snapToWall = this.snapPointToWall(point);
+        if (snapToWall)
+            return snapToWall;
+        return undefined;
+    };
+    RoomBuilderState.prototype.reevaluateFeatureConnections = function () {
+        var _this = this;
+        this.walls.forEach(function (_, i) { return _this.updateWall(i, { connections: [] }); });
+        Object.entries(this.features).forEach(function (_a) {
+            var type = _a[0], featuresArr = _a[1];
+            return featuresArr.forEach(function (feature, i) {
+                return _this.addFeatureToWall(feature.connectedTo[1], [type, i]);
+            });
+        });
+    };
+    RoomBuilderState.prototype.pushStateToConfigurator = function () {
+        var configuration = (0, dataHandlers_1.prepAttributesOutgoing)(this.walls, this.features, this._config);
+        window.threekit.configurator.setConfiguration(configuration);
+    };
+    RoomBuilderState.prototype.setAttributesToState = function (attributes) {
+        if (!attributes)
+            return;
+        if (!attributes[this._config.attributes[types_2.IElements.WALL]])
+            return;
+        this._attributesState = attributes;
+        var data = (0, dataHandlers_1.prepAttributesIncoming)(attributes, this._config);
+        this.walls = data[types_2.IElements.WALL];
+        this.vertices = data[types_2.IElements.VERTEX];
+        this.features = data[types_2.IElements.FEATURE];
+        this.reevaluateFeatureConnections();
+    };
+    RoomBuilderState.prototype.deleteAll = function () {
+        this.walls = [];
+        this.vertices = {};
+        this.features = Object.keys(this.features).reduce(function (output, type) {
+            var _a;
+            return Object.assign(output, (_a = {}, _a[type] = [], _a));
+        }, {});
+        this.pushStateToConfigurator();
+    };
+    RoomBuilderState.prototype.resetInternalState = function () {
+        if (this._attributesState)
+            this.setAttributesToState(this._attributesState);
+    };
+    RoomBuilderState.prototype.highlightElementIfInProximity = function (canvas, point) {
+        var _a, _b;
+        var elementAtPoint = this.getElementAtPoint(point);
+        if ((!elementAtPoint && !this._highlightedElement) ||
+            Array.isArray(this._highlightedElement))
+            return;
+        if (elementAtPoint) {
+            var type = elementAtPoint.type, index = elementAtPoint.index;
+            if (((_a = this._highlightedElement) === null || _a === void 0 ? void 0 : _a.type) === type &&
+                ((_b = this._highlightedElement) === null || _b === void 0 ? void 0 : _b.index) === index)
+                return;
+        }
+        this._highlightedElement = elementAtPoint !== null && elementAtPoint !== void 0 ? elementAtPoint : null;
+        this.drawRoom(canvas);
+    };
+    RoomBuilderState.prototype.startDrawNewWall = function (startPoint) {
+        var _a;
+        var snapPoint = this.getPointProximity(startPoint);
+        if ((snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.type) === types_2.IElements.WINDOW ||
+            (snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.type) === types_2.IElements.OPENING ||
+            (snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.type) === types_2.IElements.DOOR)
+            return;
+        this._newWall = {
+            start: (_a = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.point) !== null && _a !== void 0 ? _a : startPoint,
+            snapStartTo: snapPoint,
+        };
+    };
+    RoomBuilderState.prototype.drawNewWall = function (canvas, endPoint) {
+        var _a, _b, _c, _d, _e;
+        if (!this._newWall)
+            return;
+        var snapPoint = this.getPointProximity(endPoint);
+        if (!snapPoint && this._angleSnappingEnabled)
+            snapPoint = this.snapPointToAbsoluteAngle(endPoint, (_b = (_a = this._newWall.snapStartTo) === null || _a === void 0 ? void 0 : _a.point) !== null && _b !== void 0 ? _b : this._newWall.start);
+        var wallLine = [
+            this._newWall.start,
+            (_c = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.point) !== null && _c !== void 0 ? _c : endPoint,
+        ];
+        var validationData = {
+            walls: this.walls,
+            features: this.features,
+            newWall: {
+                line: wallLine,
+                snapStartTo: this._newWall.snapStartTo,
+                snapEndTo: snapPoint,
+            },
+        };
+        this._errorElement = (0, validators_1.runValidators)([
+            validators_1.isWallEndingOnFeature,
+            validators_1.isWallTooShort,
+            validators_1.isWallOverlappingExisitingWalls,
+            validators_1.isWallIntersectingFeature,
+        ], validationData);
+        var errorType = ((_d = this._errorElement) === null || _d === void 0 ? void 0 : _d[0].type) || null;
+        switch (errorType) {
+            case types_1.IErrorTypes.HARD:
+                return;
+            case types_1.IErrorTypes.SOFT:
+            case types_1.IErrorTypes.WARN:
+            case null:
+            default:
+                this._newWall.end = (_e = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.point) !== null && _e !== void 0 ? _e : endPoint;
+                this._newWall.snapEndTo = snapPoint;
+                this.drawRoom(canvas);
+                break;
+        }
+    };
+    RoomBuilderState.prototype.cancelDrawNewWall = function (canvas) {
+        this._newWall = null;
+        this._errorElement = null;
+        this._highlightedElement = null;
+        this.drawRoom(canvas);
+    };
+    RoomBuilderState.prototype.finishDrawNewWall = function (canvas, assetId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, start, end, snapStartTo, snapEndTo, wallsToExclude, filteredWalls, intersections, newWallLines;
+            var _this = this;
+            return __generator(this, function (_b) {
+                if (this._errorElement) {
+                    if ([this._errorElement].flat()[0].message)
+                        __1.message.info([this._errorElement].flat()[0].message);
+                    this._newWall = null;
+                    this._errorElement = null;
+                    this._highlightedElement = null;
+                    this.drawRoom(canvas);
+                    return [2];
+                }
+                _a = this._newWall || {}, start = _a.start, end = _a.end, snapStartTo = _a.snapStartTo, snapEndTo = _a.snapEndTo;
+                if (!start || !end) {
+                    this._newWall = null;
+                    this._errorElement = null;
+                    this._highlightedElement = null;
+                    return [2];
+                }
+                wallsToExclude = new Set([]);
+                if ((snapStartTo === null || snapStartTo === void 0 ? void 0 : snapStartTo.type) === types_2.IElements.WALL) {
+                    this.splitWall(snapStartTo.index, start);
+                    wallsToExclude.add(snapStartTo.index);
+                }
+                if ((snapEndTo === null || snapEndTo === void 0 ? void 0 : snapEndTo.type) === types_2.IElements.WALL) {
+                    this.splitWall(snapEndTo.index, end);
+                    wallsToExclude.add(snapEndTo.index);
+                }
+                if (wallsToExclude.size === 1)
+                    wallsToExclude.add(this.wallCount - 1);
+                else if (wallsToExclude.size === 2)
+                    wallsToExclude.add(this.wallCount - 1).add(this.wallCount - 2);
+                filteredWalls = this.walls.map(function (wall, i) {
+                    return wallsToExclude.has(i) ? null : wall.line;
+                });
+                intersections = (0, geometry_1.getAllLineIntersections)([start, end], filteredWalls);
+                intersections.forEach(function (_a) {
+                    var index = _a.index, point = _a.point;
+                    return _this.splitWall(index, point);
+                });
+                newWallLines = (0, geometry_1.splitLineAtPoints)([start, end], intersections.map(function (_a) {
+                    var point = _a.point;
+                    return point;
+                }));
+                this.addWalls(newWallLines.map(function (line) { return ({
+                    assetId: assetId,
+                    line: line,
+                    height: 1,
+                    thickness: 0.6,
+                    connections: [],
+                }); }));
+                this._newWall = null;
+                this._errorElement = null;
+                this._highlightedElement = null;
+                this.pushStateToConfigurator();
+                return [2];
+            });
+        });
+    };
+    RoomBuilderState.prototype.selectElementIfInProximity = function (canvas, point) {
+        var elementAtPoint = this.getElementAtPoint(point);
+        if (!elementAtPoint || elementAtPoint.type === types_2.IElements.WALL)
+            return;
+        this._activeElement = elementAtPoint;
+        if (elementAtPoint.type === types_2.IElements.VERTEX) {
+            var wallIndexes = this.getWallsConnectedToVertex(elementAtPoint.index);
+            this._highlightedElement = wallIndexes.map(function (index) { return ({
+                type: types_2.IElements.WALL,
+                index: index,
+            }); });
+        }
+        this.drawRoom(canvas);
+    };
+    RoomBuilderState.prototype.moveActiveElement = function (canvas, moveToPoint) {
+        if (!canvas)
+            return;
+        if (!this._activeElement)
+            return;
+        var type = this._activeElement.type;
+        if (type === types_2.IElements.VERTEX)
+            this.moveActiveVertex(canvas, moveToPoint);
+        else if (type === types_2.IElements.WINDOW ||
+            type === types_2.IElements.DOOR ||
+            type === types_2.IElements.OPENING)
+            this.moveActiveFeature(canvas, moveToPoint);
+    };
+    RoomBuilderState.prototype.finishMoveActiveElement = function (canvas) {
+        if (!this._activeElement)
+            return;
+        if (this._errorElement) {
+            if ([this._errorElement].flat()[0].message)
+                __1.message.info([this._errorElement].flat()[0].message);
+            this._activeElement = null;
+            this._errorElement = null;
+            this._highlightedElement = null;
+            this.resetInternalState();
+            this.drawRoom(canvas);
+            return;
+        }
+        var type = this._activeElement.type;
+        if (type === types_2.IElements.VERTEX)
+            this.finishMoveActiveVertex();
+        else if (type === types_2.IElements.WINDOW ||
+            type === types_2.IElements.DOOR ||
+            type === types_2.IElements.OPENING)
+            this.finishMoveActiveFeature();
+        this._activeElement = null;
+        this._errorElement = null;
+        this._highlightedElement = null;
+        this.drawRoom(canvas);
+    };
+    RoomBuilderState.prototype.cancelMoveActiveElement = function (canvas) {
+        this._activeElement = null;
+        this._errorElement = null;
+        this._highlightedElement = null;
+        this.resetInternalState();
+        this.drawRoom(canvas);
+    };
+    RoomBuilderState.prototype.drawRoom = function (canvas) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!canvas)
+            return;
+        var highlighted = this._highlightedElement
+            ? [this._highlightedElement].flat()
+            : [];
+        var active = this._activeElement && this._activeElement.type !== types_2.IElements.VERTEX
+            ? [this._activeElement]
+            : [];
+        var error = this._errorElement
+            ? [this._errorElement]
+                .flat()
+                .reduce(function (output, _a) {
+                var address = _a.address;
+                return (address ? __spreadArray(__spreadArray([], output, true), [address], false) : output);
+            }, [])
+            : [];
+        var hidden = ((_a = this._activeElement) === null || _a === void 0 ? void 0 : _a.type) === types_2.IElements.VERTEX
+            ? [this._activeElement]
+            : [];
+        if (this.selectedElement)
+            highlighted.push(this.selectedElement);
+        var selection = {
+            highlighted: highlighted,
+            active: active,
+            error: error,
+            hidden: hidden,
+        };
+        var activeWallIndex;
+        if (this._showDimensions &&
+            (((_b = this._activeElement) === null || _b === void 0 ? void 0 : _b.type) === types_2.IElements.WINDOW ||
+                ((_c = this._activeElement) === null || _c === void 0 ? void 0 : _c.type) === types_2.IElements.DOOR ||
+                ((_d = this._activeElement) === null || _d === void 0 ? void 0 : _d.type) === types_2.IElements.OPENING))
+            activeWallIndex = (_e = this.getFeature(this._activeElement.type, this._activeElement.index)) === null || _e === void 0 ? void 0 : _e.connectedTo[1];
+        (0, draw_1.drawRoom)(canvas, this.enclosedSpaces, this.walls, this.verticesList, this.features, this._showDimensions
+            ? this.getAllWallDimensions(activeWallIndex)
+            : undefined, selection, this._config.config);
+        if (((_f = this._newWall) === null || _f === void 0 ? void 0 : _f.start) && ((_g = this._newWall) === null || _g === void 0 ? void 0 : _g.end)) {
+            (0, draw_1.drawNewWall)(canvas, [this._newWall.start, this._newWall.end], this._config.config.styles, this._errorElement ? types_1.IElementStyleModes.ERROR : undefined);
+        }
+    };
+    return RoomBuilderState;
+}());
+exports.RoomBuilderState = RoomBuilderState;
+exports.default = RoomBuilderState;