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

package/dist/hooks/useSpaces/SpacesState.js

@@ -0,0 +1,1791 @@
+"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 padding = _this.validationConfig.padding;
+            var minOffset = padding;
+            var maxOffset = (0, geometry_1.getLengthOfLineSegment)(wall.line) - (padding + feature.length);
+            var newOffset = intersection.offset - feature.length / 2;
+            if (newOffset < minOffset)
+                newOffset = minOffset;
+            else if (newOffset > maxOffset)
+                newOffset = maxOffset;
+            var validationData = {
+                wall: wall,
+                updatedFeature: {
+                    length: feature.length,
+                    offset: newOffset,
+                    address: { type: type, index: index },
+                },
+            };
+            _this._errorElement = _this.runValidators([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 () {
+            var unitLength = this.gridUnitLengthToDraw;
+            var subdivisions = [types_1.IUnits.FEET, types_1.IUnits.INCH].includes(this.unit) ? 4 : 5;
+            return {
+                unitLength: unitLength,
+                offset: this.gridOffset,
+                subdivisions: subdivisions,
+                showSubdivisions: this.styles.grid.showSubdivisions &&
+                    unitLength / subdivisions > this.styles.grid.subdivisionThreshold,
+            };
+        },
+        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) {
+            var newZoom = val * this.zoomMin;
+            var validatedZoom = newZoom < this.zoomMin
+                ? this.zoomMin
+                : newZoom > this.zoomMax
+                    ? this.zoomMax
+                    : newZoom;
+            this._zoom = validatedZoom;
+        },
+        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 _a = this.gridToDraw, showSubdivisions = _a.showSubdivisions, subdivisions = _a.subdivisions;
+        var gridUnitLength = showSubdivisions
+            ? this.gridUnitLength / subdivisions
+            : this.gridUnitLength;
+        var floor = function (val) {
+            return Math.floor(val / gridUnitLength) * gridUnitLength;
+        };
+        var ceil = function (val) {
+            return Math.ceil(val / gridUnitLength) * 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;
+        if (!this.verticesList.length)
+            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.showNewWallAnchor = 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();
+            if (elementAtPoint.type === types_1.IElements.WALL ||
+                elementAtPoint.type === types_1.IElements.VERTEX) {
+                this._highlightedElement = elementAtPoint;
+                this.drawSpaces(canvas);
+            }
+            return;
+        }
+        else if (this._highlightedElement) {
+            this._highlightedElement = null;
+            this.drawSpaces(canvas);
+        }
+        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;