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

package/dist/hooks/useSpaces/SpacesState.js

@@ -1,1759 +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.SpacesState = void 0;
-var types_1 = 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 SpacesState = (function () {
-    function SpacesState(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_1.IElements.VERTEX)
-                return;
-            var snapPoint = _this.getSnapPointToElementInProximity(point);
-            snapPoint = _this.getSnapActiveVertexToGuideInProximity(snapPoint);
-            snapPoint = _this.getSnapPointToGridInProximity(snapPoint);
-            if (snapPoint.type === types_1.SNAPPING_TYPES.GUIDE ||
-                snapPoint.type === types_1.SNAPPING_TYPES.GRID)
-                _this.guides = snapPoint;
-            else if (_this.guides)
-                _this.guides = null;
-            var vertex = _this.getVertex(_this._activeElement.index);
-            if (!vertex)
-                return;
-            var validationData = {
-                vertex: vertex,
-                updatedPosition: snapPoint,
-            };
-            _this._errorElement = _this.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.drawSpaces(canvas);
-                    (0, draw_1.drawVertex)(canvas, _this.transformPointToCanvas((_d = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.point) !== null && _d !== void 0 ? _d : point), _this.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_1.IElements.VERTEX)
-                return;
-            if (((_b = _this._activeElement.snapPoint) === null || _b === void 0 ? void 0 : _b.type) === types_1.IElements.WALL)
-                _this.splitWallAtPoint(_this._activeElement.snapPoint.index, _this._activeElement.snapPoint.point);
-            _this.guides = null;
-            _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_1.IElements.WINDOW &&
-                type !== types_1.IElements.DOOR &&
-                type !== types_1.IElements.OPENING)
-                return;
-            var feature = _this.getFeature(type, index);
-            if (!feature)
-                return;
-            var wallIndex = (_a = _this.getWallIndexInProximity(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 validationData = {
-                wall: wall,
-                updatedFeature: {
-                    length: feature.length,
-                    offset: newOffset,
-                    address: { type: type, index: index },
-                },
-            };
-            _this._errorElement = _this.runValidators([validators_1.isFeatureOutsideWallBounds, validators_1.isFeatureCollidingWithExistingFeature], 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:
-                    _this.drawSpaces(canvas);
-                    break;
-                case types_1.IErrorTypes.WARN:
-                case null:
-                default:
-                    _this.repositionFeature([type, index], newOffset, wallIndex);
-                    _this.drawSpaces(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_1.IElements.WINDOW &&
-                type !== types_1.IElements.DOOR &&
-                type !== types_1.IElements.OPENING)
-                return;
-            _this.pushStateToConfigurator();
-        };
-        this._config = config;
-        this._newWall = null;
-        this._activeElement = null;
-        this._selectedElement = null;
-        this._highlightedElement = null;
-        this._errorElement = null;
-        this._attributeDefaults = {};
-        this._state = (_a = {},
-            _a[types_1.IElements.WALL] = [],
-            _a[types_1.IElements.VERTEX] = {},
-            _a[types_1.IElements.FEATURE] = {},
-            _a);
-        this._showDimensions = true;
-        this._angleSnappingEnabled = true;
-        this._guideSnappingEnabled = !config.config.disableGuides;
-        this._guides = null;
-        this._attributesState = null;
-        this._canvasDimensions = [0, 0];
-        this._zoom = config.config.zoomDefault;
-        this._zoomLimits = [constants_1.ZOOM_MIN, constants_1.ZOOM_MAX];
-        this._translate = config.config.translateDefault;
-        this._translateLimits = [constants_1.TRANSLATE_MIN, constants_1.TRANSLATE_MAX];
-    }
-    Object.defineProperty(SpacesState.prototype, "styles", {
-        get: function () {
-            return this._config.config.styles;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "attributeDefaults", {
-        get: function () {
-            return this._attributeDefaults;
-        },
-        set: function (val) {
-            this._attributeDefaults = val;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "scale", {
-        get: function () {
-            return this._config.config.scale;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "snapProximity", {
-        get: function () {
-            return this.transformLengthFromCanvas(this._config.config.snapProximity);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "gridUnitLength", {
-        get: function () {
-            var length = [types_1.IUnits.FEET, types_1.IUnits.INCH].includes(this.unit)
-                ? (0, dataHandlers_1.convertLengthUnit)(1, types_1.IUnits.FEET, types_1.IUnits.METER)
-                : 1;
-            return length / this.scale;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "gridUnitLengthToDraw", {
-        get: function () {
-            return this.transformLengthToCanvas(this.gridUnitLength);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "gridOffset", {
-        get: function () {
-            var gridLength = this.gridUnitLengthToDraw;
-            var translate = this.transformPointToCanvas([0, 0]);
-            return [translate[0] % gridLength, translate[1] % gridLength];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "gridToDraw", {
-        get: function () {
-            return {
-                unitLength: this.gridUnitLengthToDraw,
-                offset: this.gridOffset,
-                subdivisions: [types_1.IUnits.FEET, types_1.IUnits.INCH].includes(this.unit) ? 4 : 5,
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "walls", {
-        get: function () {
-            return this._state[types_1.IElements.WALL];
-        },
-        set: function (walls) {
-            this._state[types_1.IElements.WALL] = walls;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "wallsToDraw", {
-        get: function () {
-            var _this = this;
-            return this._state[types_1.IElements.WALL].map(function (wall) { return (__assign(__assign({}, wall), { line: _this.transformLineToCanvas(wall.line), path: undefined })); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "wallCount", {
-        get: function () {
-            return this.walls.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "wallLines", {
-        get: function () {
-            return this.walls.map(function (_a) {
-                var line = _a.line;
-                return line;
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "vertices", {
-        get: function () {
-            return this._state[types_1.IElements.VERTEX];
-        },
-        set: function (vertices) {
-            this._state[types_1.IElements.VERTEX] = vertices;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "verticesToDraw", {
-        get: function () {
-            return this._state[types_1.IElements.VERTEX];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.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(SpacesState.prototype, "verticesListToDraw", {
-        get: function () {
-            var _this = this;
-            return this.verticesList.map(function (vertex) { return (__assign(__assign({}, vertex), { point: _this.transformPointToCanvas(vertex.point) })); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "features", {
-        get: function () {
-            return this._state[types_1.IElements.FEATURE];
-        },
-        set: function (features) {
-            this._state[types_1.IElements.FEATURE] = features;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "featuresToDraw", {
-        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) { return (__assign(__assign({}, feature), { path: undefined, offset: _this.transformLengthToCanvas(feature.offset), length: _this.transformLengthToCanvas(feature.length) })); }),
-                    _b));
-            }, {});
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.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(SpacesState.prototype, "featureCount", {
-        get: function () {
-            return Object.values(this.features).flat().length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "activeElement", {
-        get: function () {
-            return this._activeElement;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "selectedElement", {
-        get: function () {
-            return this._selectedElement;
-        },
-        set: function (element) {
-            this._selectedElement = element;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "showDimensions", {
-        get: function () {
-            return this._showDimensions;
-        },
-        set: function (val) {
-            this._showDimensions = val;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "angleSnappingEnabled", {
-        get: function () {
-            return this._angleSnappingEnabled;
-        },
-        set: function (val) {
-            this._angleSnappingEnabled = val;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "guideSnappingEnabled", {
-        get: function () {
-            return this._guideSnappingEnabled;
-        },
-        set: function (val) {
-            this._guideSnappingEnabled = val;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "gridSnappingEnabled", {
-        get: function () {
-            return this._gridSnappingEnabled;
-        },
-        set: function (val) {
-            this._gridSnappingEnabled = val;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "guides", {
-        get: function () {
-            return this._guides;
-        },
-        set: function (val) {
-            this._guides = val;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "enclosedSpacesToDraw", {
-        get: function () {
-            var _this = this;
-            var loops = (0, geometry_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.scale, 2);
-                var convertedArea = (0, dataHandlers_1.convertAreaUnit)(area, types_1.IUnits.METER, _this.unit);
-                var enclosedSpace = {
-                    loop: loop.map(function (point) { return _this.transformPointToCanvas(point); }),
-                    area: (0, dataHandlers_1.prepAreaForUser)(convertedArea, _this.unit),
-                    center: loop.reduce(function (centerPoint, point) {
-                        centerPoint[0] += point[0] / loop.length;
-                        centerPoint[1] += point[1] / loop.length;
-                        return centerPoint;
-                    }, [0, 0]),
-                };
-                enclosedSpace.center = _this.transformPointToCanvas(enclosedSpace.center);
-                output.push(enclosedSpace);
-                return output;
-            }, []);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "canvasDimensions", {
-        get: function () {
-            return this._canvasDimensions;
-        },
-        set: function (dimensions) {
-            this._canvasDimensions = dimensions;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "canvasWidth", {
-        get: function () {
-            return this.canvasDimensions[0];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "canvasHeight", {
-        get: function () {
-            return this.canvasDimensions[1];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "zoom", {
-        get: function () {
-            return this._zoom;
-        },
-        set: function (delta) {
-            var newZoom = this.zoom + delta;
-            var preppedZoom = newZoom < this.zoomMin
-                ? this.zoomMin
-                : newZoom > this.zoomMax
-                    ? this.zoomMax
-                    : newZoom;
-            if (preppedZoom === this.zoom)
-                return;
-            this._zoom = preppedZoom;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "zoomFactor", {
-        get: function () {
-            return this._zoom / this.zoomMin;
-        },
-        set: function (val) {
-            this._zoom = val * this.zoomMin;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "zoomMin", {
-        get: function () {
-            return this._zoomLimits[0];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "zoomMax", {
-        get: function () {
-            return this._zoomLimits[1];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "unit", {
-        get: function () {
-            return this._unit;
-        },
-        set: function (unit) {
-            this._unit = unit;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "translate", {
-        get: function () {
-            return this._translate;
-        },
-        set: function (position) {
-            var zoomFactor = this._zoom / this.zoomMin;
-            var delta = [
-                (position[0] - this._translate[0]) / zoomFactor,
-                (position[1] - this._translate[1]) / zoomFactor,
-            ];
-            this._translate = [
-                this._translate[0] + delta[0],
-                this._translate[1] + delta[1],
-            ];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "translateMin", {
-        get: function () {
-            return this._translateLimits[0];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "translateMax", {
-        get: function () {
-            return this._translateLimits[1];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "isDrawWallActive", {
-        get: function () {
-            return !!this._newWall;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SpacesState.prototype, "validationConfig", {
-        get: function () {
-            return this._validationConfig;
-        },
-        set: function (config) {
-            this._validationConfig = config;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    SpacesState.prototype.transformLengthFromCanvas = function (length) {
-        return length / this.zoomFactor;
-    };
-    SpacesState.prototype.transformLengthToCanvas = function (length) {
-        return length * this.zoomFactor;
-    };
-    SpacesState.prototype.transformPointToCanvas = function (point) {
-        var widthOffset = this.canvasWidth / 2;
-        var heightOffset = this.canvasHeight / 2;
-        return [
-            this.transformLengthToCanvas(point[0] + this.translate[0]) -
-                widthOffset * (this.zoomFactor - 1),
-            this.transformLengthToCanvas(point[1] + this.translate[1]) -
-                heightOffset * (this.zoomFactor - 1),
-        ];
-    };
-    SpacesState.prototype.transformPointFromCanvas = function (point) {
-        var widthOffset = this.canvasWidth / 2;
-        var heightOffset = this.canvasHeight / 2;
-        return [
-            this.transformLengthFromCanvas(point[0] + widthOffset * (this.zoomFactor - 1)) - this.translate[0],
-            this.transformLengthFromCanvas(point[1] + heightOffset * (this.zoomFactor - 1)) - this.translate[1],
-        ];
-    };
-    SpacesState.prototype.transformLineToCanvas = function (line) {
-        return [
-            this.transformPointToCanvas(line[0]),
-            this.transformPointToCanvas(line[1]),
-        ];
-    };
-    SpacesState.prototype.getWall = function (index) {
-        return this.walls[index];
-    };
-    SpacesState.prototype.addWall = function (wall) {
-        if (!wall)
-            return;
-        var updatedWalls = this.walls;
-        updatedWalls.push(wall);
-        this.walls = updatedWalls;
-    };
-    SpacesState.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); });
-    };
-    SpacesState.prototype.updateWall = function (index, wall) {
-        var currentWall = this.walls[index];
-        if (!currentWall)
-            return;
-        this._state[types_1.IElements.WALL][index] = Object.assign({}, currentWall, wall);
-    };
-    SpacesState.prototype.getWallConnectionCount = function (index) {
-        var wall = this.getWall(index);
-        return (wall === null || wall === void 0 ? void 0 : wall.connections.length) || 0;
-    };
-    SpacesState.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;
-        }, []);
-    };
-    SpacesState.prototype.getWallDimensions = function (line) {
-        var lineLength = (0, geometry_1.getLengthOfLineSegment)(line) * this.scale;
-        var convertedVal = (0, dataHandlers_1.convertLengthUnit)(lineLength, types_1.IUnits.METER, this.unit);
-        return {
-            line: line,
-            label: (0, dataHandlers_1.prepLengthForUser)(convertedVal, this.unit),
-        };
-    };
-    SpacesState.prototype.getWallDimensionsByIndex = function (index) {
-        var _a;
-        var line = (_a = this.getWall(index)) === null || _a === void 0 ? void 0 : _a.line;
-        if (!line)
-            return undefined;
-        return this.getWallDimensions(line);
-    };
-    SpacesState.prototype.getWallDetailedDimensionsByIndex = 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.unit];
-            if (!i) {
-                var startLine = [line[0], featureLine[0]];
-                var startLineLength = (0, geometry_1.getLengthOfLineSegment)(startLine);
-                output.push({
-                    line: startLine,
-                    label: "".concat(prepLength(startLineLength * _this.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 * _this.scale), " ").concat(unit),
-                });
-            }
-            output.push({
-                line: featureLine,
-                label: "".concat(prepLength(featureLength * _this.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 * _this.scale), " ").concat(unit),
-                });
-            }
-            return output;
-        }, []);
-        return lines;
-    };
-    SpacesState.prototype.getAllWallDimensionsToDraw = function (detailedWallsIndexes) {
-        var _this = this;
-        if (detailedWallsIndexes === void 0) { detailedWallsIndexes = []; }
-        var indexes = new Set([detailedWallsIndexes].flat());
-        var dimensionsList = this.walls.reduce(function (output, _, i) {
-            var dimensions = indexes.has(i)
-                ? _this.getWallDetailedDimensionsByIndex(i)
-                : _this.getWallDimensionsByIndex(i);
-            if (!dimensions)
-                return output;
-            if (Array.isArray(dimensions))
-                output.push.apply(output, dimensions);
-            else
-                output.push(dimensions);
-            return output;
-        }, []);
-        return dimensionsList.map(function (dimension) { return (__assign(__assign({}, dimension), { line: _this.transformLineToCanvas(dimension.line) })); });
-    };
-    SpacesState.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,
-            });
-        });
-    };
-    SpacesState.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;
-    };
-    SpacesState.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;
-    };
-    SpacesState.prototype.splitWallAtOffset = function (wallIndex, offset) {
-        var wall = this.getWall(wallIndex);
-        if (!wall)
-            return;
-        var point = offset
-            ? (0, geometry_1.getPointAtOffsetOnLineSegment)(wall.line, offset)
-            : (0, geometry_1.getMidpointOfLineSegment)(wall.line);
-        this.splitWallAtPoint(wallIndex, point);
-        this.pushStateToConfigurator();
-    };
-    SpacesState.prototype.splitWallAtPoint = function (wallIndex, point) {
-        var _this = this;
-        var originalWall = this.getWall(wallIndex);
-        if (!originalWall)
-            return;
-        var offset = (0, geometry_1.getLengthOfLineSegment)([originalWall.line[0], point]);
-        var _a = (0, geometry_1.splitLineAtPoint)(originalWall.line, point), line1 = _a[0], line2 = _a[1];
-        var newWallIndex = this.wallCount;
-        var wall1 = {
-            assetId: originalWall.assetId,
-            line: line1,
-            connections: originalWall.connections,
-            restConfiguration: originalWall.restConfiguration,
-        };
-        var wall2 = {
-            assetId: originalWall.assetId,
-            line: line2,
-            connections: [],
-            restConfiguration: originalWall.restConfiguration,
-        };
-        this.updateWall(wallIndex, wall1);
-        this.addWall(wall2);
-        originalWall.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);
-        });
-    };
-    SpacesState.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();
-    };
-    SpacesState.prototype.getFirstVacantLocationOnWallIndex = function (length, wallIndex) {
-        var _a;
-        var walls = this.walls;
-        var padding = this.validationConfig.padding;
-        var offset = undefined;
-        var wallLength = (0, geometry_1.getLengthOfLineSegment)(walls[wallIndex].line);
-        var features = (_a = this.getWallConnectionsHydrated(wallIndex)) === 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 * padding)
-                offset = (wallLength - 2 * padding) / 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 (padding + length < currentOffset) {
-                        var slotStart = padding;
-                        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 - padding - (currentOffset + currentLength)) {
-                        var slotStart = currentOffset + currentLength;
-                        var slotEnd = wallLength - padding;
-                        offset = slotStart + (slotEnd - slotStart) / 2 - length / 2;
-                    }
-                }
-            }
-        }
-        if (offset !== undefined)
-            return offset;
-        return false;
-    };
-    SpacesState.prototype.getFirstVacantLocation = function (length, wallIndex) {
-        var offset = false;
-        if (wallIndex !== undefined) {
-            offset = this.getFirstVacantLocationOnWallIndex(length, wallIndex);
-            if (offset)
-                return {
-                    wallIndex: wallIndex,
-                    offset: offset,
-                };
-        }
-        for (var i = 0; i < this.walls.length; i++) {
-            var offset_1 = this.getFirstVacantLocationOnWallIndex(length, i);
-            if (offset_1)
-                return {
-                    wallIndex: i,
-                    offset: offset_1,
-                };
-        }
-        return false;
-    };
-    SpacesState.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);
-        var point = (0, geometry_1.getMidpointOfLineSegment)(line);
-        return this.transformPointToCanvas(point);
-    };
-    SpacesState.prototype.getVertex = function (index) {
-        return this.verticesList[index];
-    };
-    SpacesState.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;
-        });
-    };
-    SpacesState.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,
-            });
-        });
-    };
-    SpacesState.prototype.getFeatureType = function (type) {
-        return this.features[type];
-    };
-    SpacesState.prototype.setFeatureType = function (type, features) {
-        var updatedFeatures = this.features;
-        updatedFeatures[type] = features;
-        this.features = updatedFeatures;
-        this.reevaluateFeatureConnections();
-    };
-    SpacesState.prototype.getFeature = function (type, index) {
-        var _a;
-        return (_a = this.features[type]) === null || _a === void 0 ? void 0 : _a[index];
-    };
-    SpacesState.prototype.updateFeature = function (type, index, feature) {
-        var currentFeature = this._state[types_1.IElements.FEATURE][type][index];
-        if (!currentFeature)
-            return;
-        this._state[types_1.IElements.FEATURE][type][index] = Object.assign({}, currentFeature, feature);
-    };
-    SpacesState.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_1.IElements.WALL, moveToWallIndex],
-        });
-    };
-    SpacesState.prototype.addFeature = function (type, addToWallIndex, feature) {
-        var _a;
-        var assetId = (feature === null || feature === void 0 ? void 0 : feature.assetId) || this.attributeDefaults[type];
-        if (!assetId)
-            return;
-        var offset = undefined;
-        var index = undefined;
-        var length = (feature === null || feature === void 0 ? void 0 : feature.length) || constants_1.FEATURE_LENGTH;
-        if (addToWallIndex !== undefined && (feature === null || feature === void 0 ? void 0 : feature.offset) !== undefined) {
-            var wall = this.getWall(addToWallIndex);
-            if (wall) {
-                var isColliding = (0, validators_1.isFeatureCollidingWithExistingFeature)({
-                    wall: wall,
-                    updatedFeature: {
-                        length: length,
-                        offset: feature.offset,
-                        address: { type: types_1.IElements.WALL, index: addToWallIndex },
-                    },
-                }, {
-                    walls: this.walls,
-                    features: this.features,
-                });
-                if (!isColliding) {
-                    offset = feature.offset;
-                    index = addToWallIndex;
-                }
-            }
-        }
-        if (offset === undefined) {
-            var availableSlot = this.getFirstVacantLocation(length, addToWallIndex);
-            if (!availableSlot)
-                return;
-            offset = availableSlot.offset;
-            index = availableSlot.wallIndex;
-        }
-        if (index === undefined || offset === undefined)
-            return;
-        var newFeature = __assign(__assign({}, feature), { assetId: assetId, offset: offset, length: length, height: (feature === null || feature === void 0 ? void 0 : feature.height) || 0, altitude: (feature === null || feature === void 0 ? void 0 : feature.altitude) || 0, connectedTo: [types_1.IElements.WALL, index], restConfiguration: '{}' });
-        if (type === types_1.IElements.DOOR) {
-            newFeature.orientation = 'left';
-            newFeature.openingDirection = 'inside';
-        }
-        var newFeatureIndex;
-        if ((_a = this._state[types_1.IElements.FEATURE][type]) === null || _a === void 0 ? void 0 : _a.length)
-            newFeatureIndex = this._state[types_1.IElements.FEATURE][type].length;
-        else {
-            this._state[types_1.IElements.FEATURE][type] = [];
-            newFeatureIndex = 0;
-        }
-        this._state[types_1.IElements.FEATURE][type].push(newFeature);
-        this.addFeatureToWall(index, [type, newFeatureIndex]);
-        this.pushStateToConfigurator();
-    };
-    SpacesState.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();
-    };
-    SpacesState.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 });
-    };
-    SpacesState.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);
-        var point = (0, geometry_1.getMidpointOfLineSegment)(line);
-        return this.transformPointToCanvas(point);
-    };
-    SpacesState.prototype.deleteElement = function (type, index) {
-        if (type === types_1.IElements.VERTEX)
-            return;
-        if (type === types_1.IElements.WALL)
-            this.deleteWall(index);
-        else
-            this.deleteFeature(type, index);
-    };
-    SpacesState.prototype.getVertexIndexInProximity = function (point) {
-        if (!point)
-            return undefined;
-        var snapProximity = this.snapProximity;
-        var index = this.verticesList.findIndex(function (vertex) {
-            return (0, geometry_1.arePointsWithinProximity)(vertex.point, point, snapProximity);
-        });
-        if (index === -1)
-            return undefined;
-        return index;
-    };
-    SpacesState.prototype.getWallIndexInProximity = function (point) {
-        var _this = this;
-        var index = this.walls.findIndex(function (wall) {
-            var path = (0, geometry_1.addThicknessToLine)(wall.line, _this.styles.wall.thickness + constants_1.WALL_SNAP_DISTANCE);
-            return (0, geometry_1.isPointInQuadrilateral)(path, point);
-        });
-        if (index === -1)
-            return undefined;
-        return index;
-    };
-    SpacesState.prototype.getSnapPointToVertexInProximity = function (point) {
-        var _a, _b;
-        if (!point)
-            return undefined;
-        var index = this.getVertexIndexInProximity(point);
-        if (index === undefined)
-            return undefined;
-        if (((_a = this._activeElement) === null || _a === void 0 ? void 0 : _a.type) === types_1.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_1.IElements.VERTEX,
-            index: index,
-            point: vertex.point,
-            locked: [true, true],
-        };
-    };
-    SpacesState.prototype.getSnapPointToWallInProximity = function (point) {
-        var index = this.getWallIndexInProximity(point);
-        if (index === undefined)
-            return undefined;
-        if (this._activeElement) {
-            if (this._activeElement.type === types_1.IElements.WALL &&
-                this._activeElement.index === index)
-                return undefined;
-            if (this._activeElement.type === types_1.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(__assign({ type: types_1.IElements.WALL, index: index }, intersection), { locked: [true, true] });
-    };
-    SpacesState.prototype.getSnapPointToAngleInProximity = function (snapPoint, anchorPoint, angle) {
-        var _a;
-        if (anchorPoint === void 0) { anchorPoint = ((_a = this._newWall) === null || _a === void 0 ? void 0 : _a.start.point) ||
-            undefined; }
-        if (angle === void 0) { angle = 30; }
-        if (!this.angleSnappingEnabled)
-            return snapPoint;
-        var point = snapPoint.point, locked = snapPoint.locked;
-        if (locked[0] || locked[1])
-            return snapPoint;
-        if (!anchorPoint)
-            return snapPoint;
-        if (Math.abs(point[0] - anchorPoint[0]) < this.snapProximity) {
-            return {
-                type: types_1.SNAPPING_TYPES.ANGLE,
-                point: [anchorPoint[0], point[1]],
-                orientations: [types_1.GUIDE_ORIENTATIONS.VERTICAL],
-                locked: [true, true],
-            };
-        }
-        else if (Math.abs(point[1] - anchorPoint[1]) < this.snapProximity) {
-            return {
-                type: types_1.SNAPPING_TYPES.ANGLE,
-                point: [point[0], anchorPoint[1]],
-                orientations: [types_1.GUIDE_ORIENTATIONS.HORIZONTAL],
-                locked: [true, true],
-            };
-        }
-        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) < this.snapProximity)
-                return {
-                    type: types_1.SNAPPING_TYPES.ANGLE,
-                    point: (0, geometry_1.closestPointOnLine)(anchorPoint, radians, point),
-                    orientations: [],
-                    locked: [true, true],
-                };
-        }
-        return snapPoint;
-    };
-    SpacesState.prototype.getSnapVertexToGuideInProximity = function (snapPoint, vertexIndex) {
-        if (!this.guideSnappingEnabled)
-            return snapPoint;
-        var locked = snapPoint.locked, point = snapPoint.point;
-        if (locked[0] && locked[1])
-            return snapPoint;
-        var x = point[0], y = point[1];
-        var outputSnapPoint;
-        var anchorPoints = [];
-        var orientations = new Set();
-        var vertices = __spreadArray([], this.verticesList.map(function (_a) {
-            var point = _a.point;
-            return point;
-        }), true);
-        if (this._newWall)
-            vertices.push(this._newWall.start.point);
-        for (var i = 0; i < vertices.length &&
-            (!orientations.has(types_1.GUIDE_ORIENTATIONS.VERTICAL) ||
-                !orientations.has(types_1.GUIDE_ORIENTATIONS.HORIZONTAL)); i++) {
-            if (vertexIndex === i)
-                continue;
-            var _a = vertices[i], xAnchor = _a[0], yAnchor = _a[1];
-            if (!orientations.has(types_1.GUIDE_ORIENTATIONS.VERTICAL) &&
-                Math.abs(x - xAnchor) < this.snapProximity) {
-                outputSnapPoint = orientations.has(types_1.GUIDE_ORIENTATIONS.HORIZONTAL)
-                    ? [xAnchor, outputSnapPoint[1]]
-                    : [xAnchor, y];
-                anchorPoints.push(vertices[i]);
-                orientations.add(types_1.GUIDE_ORIENTATIONS.VERTICAL);
-                locked[0] = true;
-            }
-            else if (!orientations.has(types_1.GUIDE_ORIENTATIONS.HORIZONTAL) &&
-                Math.abs(y - yAnchor) < this.snapProximity) {
-                outputSnapPoint = orientations.has(types_1.GUIDE_ORIENTATIONS.VERTICAL)
-                    ? [outputSnapPoint[0], yAnchor]
-                    : [x, yAnchor];
-                anchorPoints.push(vertices[i]);
-                orientations.add(types_1.GUIDE_ORIENTATIONS.HORIZONTAL);
-                locked[1] = true;
-            }
-        }
-        if (!outputSnapPoint)
-            return snapPoint;
-        return {
-            type: types_1.SNAPPING_TYPES.GUIDE,
-            point: outputSnapPoint,
-            orientations: Array.from(orientations),
-            locked: locked,
-        };
-    };
-    SpacesState.prototype.getSnapActiveVertexToGuideInProximity = function (snapPoint) {
-        if (!this._activeElement)
-            return snapPoint;
-        return this.getSnapVertexToGuideInProximity(snapPoint, this._activeElement.index);
-    };
-    SpacesState.prototype.getSnapPointToGridInProximity = function (snapPoint) {
-        var _this = this;
-        if (!this.gridSnappingEnabled)
-            return snapPoint;
-        var locked = snapPoint.locked, point = snapPoint.point;
-        if (locked[0] && locked[1])
-            return snapPoint;
-        var x = point[0], y = point[1];
-        var floor = function (val) {
-            return Math.floor(val / _this.gridUnitLength) * _this.gridUnitLength;
-        };
-        var ceil = function (val) {
-            return Math.ceil(val / _this.gridUnitLength) * _this.gridUnitLength;
-        };
-        var gridProximityPoint = [
-            [floor(x), floor(y)],
-            [floor(x), ceil(y)],
-            [ceil(x), floor(y)],
-            [ceil(x), ceil(y)],
-        ].find(function (gridPoint) {
-            return (0, geometry_1.getLengthOfLineSegment)([point, gridPoint]) < _this.snapProximity;
-        });
-        if (!gridProximityPoint)
-            return snapPoint;
-        if ((!locked[0] && !locked[1]) ||
-            (locked[0] && gridProximityPoint[0] === point[0]) ||
-            (locked[1] && gridProximityPoint[1] === point[1]))
-            return {
-                type: types_1.SNAPPING_TYPES.GRID,
-                point: gridProximityPoint,
-                locked: [true, true],
-                orientations: types_1.SNAPPING_TYPES.ANGLE === snapPoint.type ||
-                    types_1.SNAPPING_TYPES.GUIDE === snapPoint.type
-                    ? snapPoint.orientations
-                    : [],
-            };
-        return snapPoint;
-    };
-    SpacesState.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.styles.feature.thickness);
-                }
-                return (0, geometry_1.isPointInQuadrilateral)(path, point);
-            });
-            if (index !== -1)
-                return {
-                    type: name_1,
-                    index: index,
-                };
-        }
-        return undefined;
-    };
-    SpacesState.prototype.getElementAddressAtPoint = function (point) {
-        if (!point)
-            return undefined;
-        var snapToVertex = this.getSnapPointToVertexInProximity(point);
-        if (snapToVertex !== undefined)
-            return snapToVertex;
-        if (this.featureCount) {
-            var featureInProximity = this.getFeatureAtPoint(point);
-            if (featureInProximity)
-                return featureInProximity;
-        }
-        var wallInProximity = this.getWallIndexInProximity(point);
-        if (wallInProximity !== undefined)
-            return { type: types_1.IElements.WALL, index: wallInProximity };
-        return undefined;
-    };
-    SpacesState.prototype.getElementUiAtPoint = function (cursorPoint) {
-        var point = this.transformPointFromCanvas(cursorPoint);
-        var element = this.getElementAddressAtPoint(point);
-        if (!element)
-            return;
-        var uiAnchor;
-        if (element.type === types_1.IElements.VERTEX)
-            return;
-        if (element.type === types_1.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,
-        };
-    };
-    SpacesState.prototype.getSnapPointToElementInProximity = function (point) {
-        var feature = this.getFeatureAtPoint(point);
-        if (feature)
-            return __assign(__assign({}, feature), { point: point, locked: [true, true] });
-        var snapToVertex = this.getSnapPointToVertexInProximity(point);
-        if (snapToVertex)
-            return snapToVertex;
-        var snapToWall = this.getSnapPointToWallInProximity(point);
-        if (snapToWall)
-            return snapToWall;
-        return {
-            type: types_1.SNAPPING_TYPES.NONE,
-            point: point,
-            locked: [false, false],
-        };
-    };
-    SpacesState.prototype.runValidators = function (validators, input) {
-        return (0, validators_1.runValidators)(validators, input, { walls: this.walls, features: this.features }, this.validationConfig);
-    };
-    SpacesState.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]);
-            });
-        });
-    };
-    SpacesState.prototype.pushStateToConfigurator = function () {
-        var configuration = (0, dataHandlers_1.prepAttributesOutgoing)(this.walls, this.features, this._config);
-        window.threekit.configurator.setConfiguration(configuration);
-    };
-    SpacesState.prototype.setAttributesToState = function (attributes) {
-        if (!attributes)
-            return;
-        this._attributesState = attributes;
-        var data = (0, dataHandlers_1.prepAttributesIncoming)(attributes, this._config);
-        if (!Object.keys(this.attributeDefaults).length)
-            this.attributeDefaults = (0, dataHandlers_1.getAttributeDefaults)(attributes, this._config);
-        this.validationConfig = data.validationConfig;
-        this.walls = data[types_1.IElements.WALL];
-        this.vertices = data[types_1.IElements.VERTEX];
-        this.features = data[types_1.IElements.FEATURE];
-        this.reevaluateFeatureConnections();
-    };
-    SpacesState.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();
-    };
-    SpacesState.prototype.resetInternalState = function () {
-        if (this._attributesState)
-            this.setAttributesToState(this._attributesState);
-    };
-    SpacesState.prototype.highlightElementIfInProximity = function (canvas, cursorPoint) {
-        var _a, _b;
-        var point = this.transformPointFromCanvas(cursorPoint);
-        var elementAtPoint = this.getElementAddressAtPoint(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.drawSpaces(canvas);
-    };
-    SpacesState.prototype.centerSpace = function (canvas, zoomToFit) {
-        if (zoomToFit === void 0) { zoomToFit = true; }
-        if (!canvas)
-            return;
-        var _a = this.verticesList.reduce(function (output, _a, i) {
-            var point = _a.point;
-            if (!i)
-                return {
-                    xMin: point[0],
-                    yMin: point[1],
-                    xMax: point[0],
-                    yMax: point[1],
-                };
-            if (point[0] < output.xMin)
-                output.xMin = point[0];
-            if (point[1] < output.yMin)
-                output.yMin = point[1];
-            if (point[0] > output.xMax)
-                output.xMax = point[0];
-            if (point[1] > output.yMax)
-                output.yMax = point[1];
-            return output;
-        }, { xMin: 0, yMin: 0, xMax: 0, yMax: 0 }), xMin = _a.xMin, yMin = _a.yMin, xMax = _a.xMax, yMax = _a.yMax;
-        var centerPoint = [(xMin + xMax) / 2, (yMin + yMax) / 2];
-        this._translate = [
-            canvas.width / 2 - centerPoint[0],
-            canvas.height / 2 - centerPoint[1],
-        ];
-        if (zoomToFit)
-            this.zoomFactor = Math.min((canvas.width - 80) / (xMax - xMin), (canvas.height - 80) / (yMax - yMin));
-        this.drawSpaces(canvas);
-    };
-    SpacesState.prototype.showGuideAtPoint = function (canvas, cursorPoint) {
-        var _this = this;
-        if (!this.guideSnappingEnabled)
-            return;
-        var clearGuides = function () {
-            if (!_this.guides)
-                return;
-            _this.guides = null;
-            _this.drawSpaces(canvas);
-        };
-        var point = this.transformPointFromCanvas(cursorPoint);
-        var elementAtPoint = this.getElementAddressAtPoint(point);
-        if (elementAtPoint) {
-            clearGuides();
-            return;
-        }
-        var snapPoint = this.getSnapVertexToGuideInProximity({
-            type: types_1.SNAPPING_TYPES.NONE,
-            point: point,
-            locked: [false, false],
-        }) || null;
-        if (snapPoint.type === types_1.SNAPPING_TYPES.NONE) {
-            clearGuides();
-            return;
-        }
-        else if (snapPoint.type === types_1.SNAPPING_TYPES.GUIDE) {
-            this.guides = snapPoint;
-            this.drawSpaces(canvas);
-        }
-    };
-    SpacesState.prototype.startDrawNewWall = function (startPoint) {
-        if (this.guides) {
-            this._newWall = {
-                start: __assign(__assign({ type: types_1.SNAPPING_TYPES.GUIDE }, this.guides), { locked: [true, true] }),
-            };
-            return;
-        }
-        var point = this.transformPointFromCanvas(startPoint);
-        var snapPoint = this.getSnapPointToElementInProximity(point);
-        snapPoint = this.getSnapPointToGridInProximity(snapPoint);
-        if (snapPoint.type === types_1.IElements.WINDOW ||
-            snapPoint.type === types_1.IElements.DOOR ||
-            snapPoint.type === types_1.IElements.OPENING)
-            return;
-        this._newWall = {
-            start: snapPoint,
-        };
-    };
-    SpacesState.prototype.drawNewWall = function (canvas, endPoint) {
-        var _a;
-        if (!this._newWall)
-            return;
-        var point = this.transformPointFromCanvas(endPoint);
-        var snapPoint = this.getSnapPointToElementInProximity(point);
-        snapPoint = this.getSnapVertexToGuideInProximity(snapPoint);
-        snapPoint = this.getSnapPointToAngleInProximity(snapPoint);
-        snapPoint = this.getSnapPointToGridInProximity(snapPoint);
-        if (this.guideSnappingEnabled) {
-            if (snapPoint.type === types_1.SNAPPING_TYPES.GUIDE ||
-                snapPoint.type === types_1.SNAPPING_TYPES.ANGLE ||
-                snapPoint.type === types_1.SNAPPING_TYPES.GRID)
-                this.guides = snapPoint;
-            else if (this.guides)
-                this.guides = null;
-        }
-        var wallLine = [
-            this._newWall.start.point,
-            snapPoint.point,
-        ];
-        var validationData = {
-            newWall: __assign({ line: wallLine }, this._newWall),
-        };
-        this._errorElement = this.runValidators([
-            validators_1.isWallEndingOnFeature,
-            validators_1.isWallTooShort,
-            validators_1.isWallOverlappingExisitingWalls,
-            validators_1.isWallIntersectingFeature,
-        ], validationData);
-        var errorType = ((_a = this._errorElement) === null || _a === void 0 ? void 0 : _a[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 = snapPoint || { type: types_1.SNAPPING_TYPES.NONE, point: point };
-                this.drawSpaces(canvas);
-                break;
-        }
-    };
-    SpacesState.prototype.cancelDrawNewWall = function (canvas) {
-        this._newWall = null;
-        this._errorElement = null;
-        this._highlightedElement = null;
-        this.guides = null;
-        this.drawSpaces(canvas);
-    };
-    SpacesState.prototype.finishDrawNewWall = function (canvas, assetId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var newWallAssetId, _a, start, end, 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.drawSpaces(canvas);
-                    return [2];
-                }
-                newWallAssetId = assetId || this.attributeDefaults[types_1.IElements.WALL];
-                if (!newWallAssetId)
-                    return [2];
-                _a = this._newWall || {}, start = _a.start, end = _a.end;
-                if (!start || !end) {
-                    this._newWall = null;
-                    this._errorElement = null;
-                    this._highlightedElement = null;
-                    return [2];
-                }
-                wallsToExclude = new Set([]);
-                if (start.type === types_1.IElements.WALL) {
-                    this.splitWallAtPoint(start.index, start.point);
-                    wallsToExclude.add(start.index);
-                }
-                if (end.type === types_1.IElements.WALL) {
-                    this.splitWallAtPoint(end.index, end.point);
-                    wallsToExclude.add(end.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.point, end.point], filteredWalls);
-                intersections.forEach(function (_a) {
-                    var index = _a.index, point = _a.point;
-                    return _this.splitWallAtPoint(index, point);
-                });
-                newWallLines = (0, geometry_1.splitLineAtPoints)([start.point, end.point], intersections.map(function (_a) {
-                    var point = _a.point;
-                    return point;
-                }));
-                this.addWalls(newWallLines.map(function (line) { return ({
-                    assetId: newWallAssetId,
-                    line: line,
-                    connections: [],
-                    restConfiguration: JSON.stringify({}),
-                }); }));
-                this._newWall = null;
-                this._errorElement = null;
-                this._highlightedElement = null;
-                this.guides = null;
-                this.pushStateToConfigurator();
-                return [2];
-            });
-        });
-    };
-    SpacesState.prototype.selectElementIfInProximity = function (canvas, cursorPoint) {
-        var point = this.transformPointFromCanvas(cursorPoint);
-        var elementAtPoint = this.getElementAddressAtPoint(point);
-        if (!elementAtPoint || elementAtPoint.type === types_1.IElements.WALL)
-            return;
-        this._activeElement = elementAtPoint;
-        if (elementAtPoint.type === types_1.IElements.VERTEX) {
-            var wallIndexes = this.getWallsConnectedToVertex(elementAtPoint.index);
-            this._highlightedElement = wallIndexes.map(function (index) { return ({
-                type: types_1.IElements.WALL,
-                index: index,
-            }); });
-        }
-        this.drawSpaces(canvas);
-    };
-    SpacesState.prototype.moveActiveElement = function (canvas, moveToPoint) {
-        if (!canvas)
-            return;
-        if (!this._activeElement)
-            return;
-        var point = this.transformPointFromCanvas(moveToPoint);
-        var type = this._activeElement.type;
-        if (type === types_1.IElements.VERTEX)
-            this.moveActiveVertex(canvas, point);
-        else if (type === types_1.IElements.WINDOW ||
-            type === types_1.IElements.DOOR ||
-            type === types_1.IElements.OPENING)
-            this.moveActiveFeature(canvas, point);
-    };
-    SpacesState.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.drawSpaces(canvas);
-            return;
-        }
-        var type = this._activeElement.type;
-        if (type === types_1.IElements.VERTEX)
-            this.finishMoveActiveVertex();
-        else if (type === types_1.IElements.WINDOW ||
-            type === types_1.IElements.DOOR ||
-            type === types_1.IElements.OPENING)
-            this.finishMoveActiveFeature();
-        this._activeElement = null;
-        this._errorElement = null;
-        this._highlightedElement = null;
-        this.drawSpaces(canvas);
-    };
-    SpacesState.prototype.cancelMoveActiveElement = function (canvas) {
-        this._activeElement = null;
-        this._errorElement = null;
-        this._highlightedElement = null;
-        this.resetInternalState();
-        this.drawSpaces(canvas);
-    };
-    SpacesState.prototype.drawSpaces = 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_1.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_1.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_1.IElements.WINDOW ||
-                ((_c = this._activeElement) === null || _c === void 0 ? void 0 : _c.type) === types_1.IElements.DOOR ||
-                ((_d = this._activeElement) === null || _d === void 0 ? void 0 : _d.type) === types_1.IElements.OPENING))
-            activeWallIndex = (_e = this.getFeature(this._activeElement.type, this._activeElement.index)) === null || _e === void 0 ? void 0 : _e.connectedTo[1];
-        var guides = this.guides
-            ? __assign(__assign({}, this.guides), { point: this.transformPointToCanvas(this.guides.point) }) : this.guides;
-        (0, draw_1.drawSpaces)(canvas, this.gridToDraw, this.enclosedSpacesToDraw, this.wallsToDraw, this.verticesListToDraw, this.featuresToDraw, this._showDimensions
-            ? this.getAllWallDimensionsToDraw(activeWallIndex)
-            : undefined, guides, 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)) {
-            var newWallLine = [
-                this._newWall.start.point,
-                this._newWall.end.point,
-            ];
-            (0, draw_1.drawNewWall)(canvas, this.transformLineToCanvas(newWallLine), this.styles, this._errorElement ? types_1.IElementStyleModes.ERROR : undefined);
-            if (this._showDimensions) {
-                (0, draw_1.drawDimensions)(canvas, [
-                    {
-                        label: this.getWallDimensions(newWallLine).label,
-                        line: this.transformLineToCanvas(newWallLine),
-                    },
-                ], this._config.config);
-            }
-        }
-    };
-    return SpacesState;
-}());
-exports.SpacesState = SpacesState;
-exports.default = SpacesState;