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

package/dist/hooks/useRoomBuilder/RoomBuilderState.js

@@ -1,1237 +0,0 @@
-"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;