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

package/dist/Treble/Treble.d.ts

@@ -1,7 +1,7 @@
 import threekitAPI from '../api';
 import { IThreekitPlayer, IThreekitPrivatePlayer, IThreekitPrivateConfigurator } from '../types';
 import { IWishlist } from './wishlist';
-import snapshots from './snapshots';
+import snapshot from './snapshot';
 import { ISaveConfiguration } from '../api/configurations';
 import { ICreateOrder } from '../api/orders';
 import { ICartItem } from '../http/orders';
@@ -22,7 +22,7 @@ declare class Treble {
     _player: IThreekitPrivatePlayer;
     wishlist: IWishlist;
     private _snapshots;
-    takeSnapshots: typeof snapshots['takeSnapshots'];
+    takeSnapshots: typeof snapshot['takeSnapshots'];
     _debugMode: boolean;
     constructor({ player, orgId }: ITreble);
     createOrder: (order?: IOrder) => Promise<import("../http/orders").IOrderResponse>;

package/dist/Treble/Treble.js

@@ -45,7 +45,7 @@ var types_1 = require("../types");
 var constants_1 = require("../constants");
 var utils_1 = require("../utils");
 var wishlist_1 = __importDefault(require("./wishlist"));
-var snapshots_1 = __importDefault(require("./snapshots"));
+var snapshot_1 = __importDefault(require("./snapshot"));
 var Treble = (function () {
     function Treble(_a) {
         var player = _a.player, orgId = _a.orgId;
@@ -147,7 +147,7 @@ var Treble = (function () {
         };
         this._api = api_1.default;
         this.wishlist = (0, wishlist_1.default)(orgId);
-        this._snapshots = snapshots_1.default;
+        this._snapshots = snapshot_1.default;
         this.takeSnapshots = this._snapshots.takeSnapshots;
         this._player = player.enableApi(types_1.PRIVATE_APIS.PLAYER);
         this._debugMode = constants_1.TREBLE_DEBUG;

package/dist/Treble/index.d.ts

@@ -1,5 +1,5 @@
 import Treble from './Treble';
 export * from './Treble';
-export * from './snapshots';
+export * from './snapshot';
 export * from './wishlist';
 export default Treble;

package/dist/Treble/index.js

@@ -19,6 +19,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var Treble_1 = __importDefault(require("./Treble"));
 __exportStar(require("./Treble"), exports);
-__exportStar(require("./snapshots"), exports);
+__exportStar(require("./snapshot"), exports);
 __exportStar(require("./wishlist"), exports);
 exports.default = Treble_1.default;

package/dist/components/BreatheAnimation/index.js

@@ -40,10 +40,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var react_1 = require("react");
-var useAnimationStart_1 = __importDefault(require("../../hooks/useAnimationStart"));
+var usePlayerReady_1 = __importDefault(require("../../hooks/usePlayerReady"));
 var types_1 = require("../../types");
 var BreatheAnimation = function (props) {
-    var readyToAnimate = (0, useAnimationStart_1.default)();
+    var readyToAnimate = (0, usePlayerReady_1.default)();
     var initialTranslation = (0, react_1.useRef)(null);
     var initialRotation = (0, react_1.useRef)(null);
     var animationInProgress = (0, react_1.useRef)(false);

package/dist/components/TurntableAnimation/index.js

@@ -40,7 +40,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var react_1 = require("react");
-var useAnimationStart_1 = __importDefault(require("../../hooks/useAnimationStart"));
+var usePlayerReady_1 = __importDefault(require("../../hooks/usePlayerReady"));
 var types_1 = require("../../types");
 var RotationDirections;
 (function (RotationDirections) {
@@ -48,7 +48,7 @@ var RotationDirections;
     RotationDirections["COUNTER_CLOCKWISE"] = "counter-clockwise";
 })(RotationDirections || (RotationDirections = {}));
 var TurntableAnimation = function (props) {
-    var readyToAnimate = (0, useAnimationStart_1.default)();
+    var readyToAnimate = (0, usePlayerReady_1.default)();
     var initialRotation = (0, react_1.useRef)(null);
     var animationInProgress = (0, react_1.useRef)(false);
     var rotationNodeId = (0, react_1.useRef)(undefined);

package/dist/components/containers/formInputContainer.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hydrateAttributeForComponent = void 0;
 var react_1 = __importDefault(require("react"));
 var useAttribute_1 = __importDefault(require("../../hooks/useAttribute"));
-var usePlayerLoadingStatus_1 = __importDefault(require("../../hooks/usePlayerLoadingStatus"));
+var useConfigurationChangeStatus_1 = __importDefault(require("../../hooks/useConfigurationChangeStatus"));
 var utils_1 = require("../../utils");
 var constants_1 = require("../../constants");
 var hydrateAttributeForComponent = function (attribute, config) {
@@ -80,7 +80,7 @@ exports.hydrateAttributeForComponent = hydrateAttributeForComponent;
 function formComponentContainer(FormComponent) {
     return function (props) {
         var attribute = props.attribute, metadataKeyThumbnail = props.metadataKeyThumbnail, metadataKeyDescription = props.metadataKeyDescription, metadataKeyPrice = props.metadataKeyPrice, hideAttributeTitle = props.hideAttributeTitle, sort = props.sort;
-        var isLoading = (0, usePlayerLoadingStatus_1.default)();
+        var isConfigurationChanging = (0, useConfigurationChangeStatus_1.default)();
         var _a = (0, useAttribute_1.default)(attribute), attributeData = _a[0], setAttribute = _a[1];
         if (!attribute)
             return react_1.default.createElement(FormComponent, __assign({}, props));
@@ -104,7 +104,7 @@ function formComponentContainer(FormComponent) {
         var preppedProps = __assign({}, props);
         if (!hideAttributeTitle && !preppedProps.title)
             preppedProps.title = attributeData.label;
-        return (react_1.default.createElement(FormComponent, __assign({}, preppedProps, { value: selected, onClick: handleSetAttribute, onChange: handleSetAttribute, options: options, isPlayerLoading: isLoading })));
+        return (react_1.default.createElement(FormComponent, __assign({}, preppedProps, { value: selected, onClick: handleSetAttribute, onChange: handleSetAttribute, options: options, isPlayerLoading: isConfigurationChanging })));
     };
 }
 exports.default = formComponentContainer;

package/dist/hooks/useAttribute/index.js

@@ -35,14 +35,10 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 var store_1 = require("../../store");
 var attributes_1 = require("../../store/attributes");
 var utils_1 = require("../../utils");
-var api_1 = __importDefault(require("../../api"));
 var utils_2 = require("../../utils");
 var useAttribute = function (attributeName) {
     var _a;
@@ -66,7 +62,7 @@ var useAttribute = function (attributeName) {
                     if (!!value) return [3, 1];
                     preppedValue = (0, utils_1.selectionToConfiguration)('', attribute.type);
                     return [3, 3];
-                case 1: return [4, api_1.default.catalog.uploadAsset(value)];
+                case 1: return [4, window.threekit.player.uploadImage(value)];
                 case 2:
                     assetId = _b.sent();
                     if (assetId)

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

@@ -0,0 +1,2 @@
+declare const useConfigurationChangeStatus: () => boolean;
+export default useConfigurationChangeStatus;

package/dist/hooks/{usePlayerLoadingStatus → useConfigurationChangeStatus}/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var store_1 = require("../../store");
 var treble_1 = require("../../store/treble");
-var usePlayerLoadingStatus = function () {
+var useConfigurationChangeStatus = function () {
     return (0, store_1.useThreekitSelector)(treble_1.isPlayerLoading);
 };
-exports.default = usePlayerLoadingStatus;
+exports.default = useConfigurationChangeStatus;

package/dist/hooks/useNestedConfigurator/index.js

@@ -57,8 +57,7 @@ var useNestedConfigurator = function (address) {
                 return;
             if (playerLoading)
                 return;
-            configurator.current =
-                window.threekit.treble.getNestedConfigurator(address);
+            configurator.current = window.threekit.configurator.getNestedConfigurator([address].flat());
             if (!configurator.current)
                 return;
             var updatedAttrs = configurator.current.getDisplayAttributes();

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

@@ -0,0 +1,2 @@
+declare const usePlayerReady: () => boolean;
+export default usePlayerReady;

package/dist/hooks/{useAnimationStart → usePlayerReady}/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var store_1 = require("../../store");
 var treble_1 = require("../../store/treble");
-var useAnimationStart = function () {
+var usePlayerReady = function () {
     return (0, store_1.useThreekitSelector)(treble_1.isFirstRenderComplete);
 };
-exports.default = useAnimationStart;
+exports.default = usePlayerReady;

package/dist/hooks/useSpaces/Canvas.d.ts

@@ -0,0 +1,37 @@
+import { ICoordinate2D, ICoordinatesLine, IGridToDraw, IUnits } from './types';
+declare class Canvas {
+    private _scale;
+    private _dimensions;
+    private _zoom;
+    private _zoomLimits;
+    private _translate;
+    private _translateLimits;
+    private _unit;
+    constructor(scale: number, dimensions: ICoordinate2D, zoom: number, translate: ICoordinate2D, unit: IUnits);
+    get dimensions(): ICoordinate2D;
+    set dimensions(dimensions: ICoordinate2D);
+    get width(): number;
+    get height(): number;
+    get zoom(): number;
+    set zoom(delta: number);
+    get zoomFactor(): number;
+    set zoomFactor(val: number);
+    get zoomMin(): number;
+    get zoomMax(): number;
+    get translate(): ICoordinate2D;
+    get translateMin(): ICoordinate2D;
+    get translateMax(): ICoordinate2D;
+    set translate(position: ICoordinate2D);
+    get unit(): IUnits;
+    set unit(unit: IUnits);
+    get gridUnitLength(): number;
+    get gridUnitLengthToDraw(): number;
+    get gridOffset(): ICoordinate2D;
+    get gridToDraw(): IGridToDraw;
+    transformLengthFromCanvas(length: number): number;
+    transformLengthToCanvas(length: number): number;
+    transformPointToCanvas(point: ICoordinate2D): ICoordinate2D;
+    transformPointFromCanvas(point: ICoordinate2D): ICoordinate2D;
+    transformLineToCanvas(line: ICoordinatesLine): ICoordinatesLine;
+}
+export default Canvas;

package/dist/hooks/useSpaces/Canvas.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var constants_1 = require("./constants");
+var dataHandlers_1 = require("./dataHandlers");
+var types_1 = require("./types");
+var Canvas = (function () {
+    function Canvas(scale, dimensions, zoom, translate, unit) {
+        this._scale = scale;
+        this._dimensions = dimensions;
+        this._zoom = zoom;
+        this._zoomLimits = [constants_1.ZOOM_MIN, constants_1.ZOOM_MAX];
+        this._translate = translate;
+        this._translateLimits = [constants_1.TRANSLATE_MIN, constants_1.TRANSLATE_MAX];
+        this._unit = unit;
+    }
+    Object.defineProperty(Canvas.prototype, "dimensions", {
+        get: function () {
+            return this._dimensions;
+        },
+        set: function (dimensions) {
+            this._dimensions = dimensions;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.prototype, "width", {
+        get: function () {
+            return this._dimensions[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.prototype, "height", {
+        get: function () {
+            return this._dimensions[1];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.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(Canvas.prototype, "zoomFactor", {
+        get: function () {
+            return this._zoom / this.zoomMin;
+        },
+        set: function (val) {
+            var updatedZoom = val * this.zoomMin;
+            if (updatedZoom < this.zoomMin)
+                this._zoom = this.zoomMin;
+            else if (updatedZoom > this.zoomMax)
+                this._zoom = this.zoomMax;
+            else
+                this._zoom = updatedZoom;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.prototype, "zoomMin", {
+        get: function () {
+            return this._zoomLimits[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.prototype, "zoomMax", {
+        get: function () {
+            return this._zoomLimits[1];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.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(Canvas.prototype, "translateMin", {
+        get: function () {
+            return this._translateLimits[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.prototype, "translateMax", {
+        get: function () {
+            return this._translateLimits[1];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.prototype, "unit", {
+        get: function () {
+            return this._unit;
+        },
+        set: function (unit) {
+            this._unit = unit;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.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(Canvas.prototype, "gridUnitLengthToDraw", {
+        get: function () {
+            return this.transformLengthToCanvas(this.gridUnitLength);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Canvas.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(Canvas.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
+    });
+    Canvas.prototype.transformLengthFromCanvas = function (length) {
+        return length / this.zoomFactor;
+    };
+    Canvas.prototype.transformLengthToCanvas = function (length) {
+        return length * this.zoomFactor;
+    };
+    Canvas.prototype.transformPointToCanvas = function (point) {
+        var widthOffset = this.width / 2;
+        var heightOffset = this.height / 2;
+        return [
+            this.transformLengthToCanvas(point[0] + this.translate[0]) -
+                widthOffset * (this.zoomFactor - 1),
+            this.transformLengthToCanvas(point[1] + this.translate[1]) -
+                heightOffset * (this.zoomFactor - 1),
+        ];
+    };
+    Canvas.prototype.transformPointFromCanvas = function (point) {
+        var widthOffset = this.width / 2;
+        var heightOffset = this.height / 2;
+        return [
+            this.transformLengthFromCanvas(point[0] + widthOffset * (this.zoomFactor - 1)) - this.translate[0],
+            this.transformLengthFromCanvas(point[1] + heightOffset * (this.zoomFactor - 1)) - this.translate[1],
+        ];
+    };
+    Canvas.prototype.transformLineToCanvas = function (line) {
+        return [
+            this.transformPointToCanvas(line[0]),
+            this.transformPointToCanvas(line[1]),
+        ];
+    };
+    return Canvas;
+}());
+exports.default = Canvas;

package/dist/hooks/useSpaces/SpacesLayout.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { ICoordinate2D } from './types';
+interface ISpacesLayout {
+    loops?: Array<ICoordinate2D[]>;
+    size?: number;
+    color?: string;
+    padding?: number;
+    strokeWidth?: number;
+}
+export default function SpacesLayout(props: ISpacesLayout): JSX.Element;
+export {};

package/dist/hooks/useSpaces/SpacesLayout.js

@@ -0,0 +1,74 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importDefault(require("react"));
+function SpacesLayout(props) {
+    var loops = props.loops;
+    var size = props.size || 20;
+    var padding = props.padding || 2;
+    var strokeWidth = props.strokeWidth || 2;
+    if (!(loops === null || loops === void 0 ? void 0 : loops.length))
+        return react_1.default.createElement(react_1.default.Fragment, null);
+    var _a = loops.reduce(function (output, loop, i) {
+        loop.forEach(function (_a, j) {
+            var x = _a[0], y = _a[1];
+            if (!i && !j) {
+                output = {
+                    xMin: x,
+                    yMin: y,
+                    xMax: x,
+                    yMax: y,
+                };
+            }
+            else {
+                if (x < output.xMin)
+                    output.xMin = x;
+                else if (x > output.xMax)
+                    output.xMax = x;
+                if (y < output.yMin)
+                    output.yMin = y;
+                else if (y > output.yMax)
+                    output.yMax = y;
+            }
+        });
+        return output;
+    }, {
+        xMin: 0,
+        yMin: 0,
+        xMax: 0,
+        yMax: 0,
+    }), xMin = _a.xMin, yMin = _a.yMin, xMax = _a.xMax, yMax = _a.yMax;
+    var xSpan = xMax - xMin;
+    var ySpan = yMax - yMin;
+    var xCenter = xMin + xSpan / 2;
+    var yCenter = yMin + ySpan / 2;
+    var scaleFactor = (size - 2 * padding) / Math.max(xSpan, ySpan);
+    var translate = [
+        xCenter * scaleFactor - size / 2,
+        yCenter * scaleFactor - size / 2,
+    ];
+    return (react_1.default.createElement("svg", __assign({ width: size, height: size, fill: "none", xmlns: "http://www.w3.org/2000/svg" }, props), loops.map(function (loop, i) {
+        var path = loop
+            .map(function (point, i) {
+            var x = point[0] * scaleFactor - translate[0];
+            var y = point[1] * scaleFactor - translate[1];
+            return (!i ? 'M ' : 'L ') + x + ' ' + y;
+        })
+            .join(' ') + ' Z';
+        return (react_1.default.createElement("path", { key: "path-".concat(i), d: path, stroke: props.color, strokeWidth: strokeWidth }));
+    })));
+}
+exports.default = SpacesLayout;

package/dist/hooks/useSpaces/SpacesState.d.ts

@@ -0,0 +1,162 @@
+import type { IWalls, IVerticesState, ICoordinate2D, IFeature, IFeatures, ICoordinatesLine, ISpacesStateProps, IElementAddress, IFeatureName, IVertex, IFeaturesHydrated, IElementUi, IElementName, IActiveElement, IEnclosedSpace, IFeatureDoor, IWallsValidationConfig, IGuides, IAttributeDefaults, IGridToDraw } from './types';
+import { IUnits } from './types';
+import type { IHydratedAttribute } from '../../types';
+export declare class SpacesState {
+    private _config;
+    private _attributesState;
+    private _attributeDefaults;
+    private _newWall;
+    private _activeElement;
+    private _selectedElement;
+    private _highlightedElement;
+    private _errorElement;
+    private _showDimensions;
+    private _angleSnappingEnabled;
+    private _guideSnappingEnabled;
+    private _guides;
+    private _gridSnappingEnabled;
+    private _zoom;
+    private _zoomLimits;
+    private _canvasDimensions;
+    private _translate;
+    private _translateLimits;
+    private _unit;
+    private _validationConfig;
+    private _state;
+    constructor(config: ISpacesStateProps);
+    get styles(): import("./types").ISpacesStyles;
+    get attributeDefaults(): IAttributeDefaults;
+    set attributeDefaults(val: IAttributeDefaults);
+    get scale(): number;
+    get snapProximity(): number;
+    get gridUnitLength(): number;
+    get gridUnitLengthToDraw(): number;
+    get gridOffset(): ICoordinate2D;
+    get gridToDraw(): IGridToDraw;
+    get walls(): IWalls;
+    get wallsToDraw(): {
+        line: ICoordinatesLine;
+        path: undefined;
+        assetId: string;
+        connections: [elementType: IFeatureName, index: number][];
+        restConfiguration: string;
+    }[];
+    set walls(walls: IWalls);
+    get wallCount(): number;
+    get wallLines(): ICoordinatesLine[];
+    get vertices(): IVerticesState;
+    get verticesToDraw(): IVerticesState;
+    set vertices(vertices: IVerticesState);
+    get verticesList(): Array<IVertex>;
+    get verticesListToDraw(): Array<IVertex>;
+    get features(): IFeatures;
+    get featuresToDraw(): Record<string, IFeature[] | IFeatureDoor[]>;
+    set features(features: IFeatures);
+    get getHydratedFeatures(): undefined | IFeaturesHydrated;
+    get featureCount(): number;
+    get activeElement(): IActiveElement | null;
+    get selectedElement(): null | IElementAddress;
+    set selectedElement(element: null | IElementAddress);
+    get showDimensions(): boolean;
+    set showDimensions(val: boolean);
+    get angleSnappingEnabled(): boolean;
+    set angleSnappingEnabled(val: boolean);
+    get guideSnappingEnabled(): boolean;
+    set guideSnappingEnabled(val: boolean);
+    get gridSnappingEnabled(): boolean;
+    set gridSnappingEnabled(val: boolean);
+    get guides(): IGuides | null;
+    set guides(val: IGuides | null);
+    get enclosedSpacesToDraw(): Array<IEnclosedSpace>;
+    get canvasDimensions(): ICoordinate2D;
+    get canvasWidth(): number;
+    get canvasHeight(): number;
+    set canvasDimensions(dimensions: ICoordinate2D);
+    get zoom(): number;
+    get zoomFactor(): number;
+    set zoomFactor(val: number);
+    get zoomMin(): number;
+    get zoomMax(): number;
+    set zoom(delta: number);
+    get unit(): IUnits;
+    set unit(unit: IUnits);
+    get translate(): ICoordinate2D;
+    get translateMin(): ICoordinate2D;
+    get translateMax(): ICoordinate2D;
+    set translate(position: ICoordinate2D);
+    get isDrawWallActive(): boolean;
+    get validationConfig(): IWallsValidationConfig;
+    set validationConfig(config: IWallsValidationConfig);
+    private transformLengthFromCanvas;
+    private transformLengthToCanvas;
+    private transformPointToCanvas;
+    private transformPointFromCanvas;
+    private transformLineToCanvas;
+    private getWall;
+    private addWall;
+    private addWalls;
+    private updateWall;
+    private getWallConnectionCount;
+    private getWallConnectionsHydrated;
+    private getWallDimensions;
+    private getWallDimensionsByIndex;
+    private getWallDetailedDimensionsByIndex;
+    private getAllWallDimensionsToDraw;
+    private shiftAllFeaturesOnWall;
+    private addFeatureToWall;
+    private removeFeatureFromWall;
+    splitWallAtOffset(wallIndex: number, offset?: number): void;
+    private splitWallAtPoint;
+    deleteWall(index: number): void;
+    private getFirstVacantLocationOnWallIndex;
+    private getFirstVacantLocation;
+    getWallUiAnchorPoint(index: number): undefined | ICoordinate2D;
+    private getVertex;
+    private getWallsConnectedToVertex;
+    private repositionVertex;
+    private getFeatureType;
+    private setFeatureType;
+    private getFeature;
+    private updateFeature;
+    private repositionFeature;
+    addFeature(type: IFeatureName, addToWallIndex?: number, feature?: Partial<Pick<IFeature, 'assetId' | 'offset' | 'length' | 'height' | 'altitude'>>): void;
+    deleteFeature(type: IFeatureName, index: number): void;
+    private getHydratedFeature;
+    getFeatureUiAnchorPoint(type: IFeatureName, index: number): undefined | ICoordinate2D;
+    deleteElement(type: IElementName, index: number): void;
+    private getVertexIndexInProximity;
+    private getWallIndexInProximity;
+    private getSnapPointToVertexInProximity;
+    private getSnapPointToWallInProximity;
+    private getSnapPointToAngleInProximity;
+    private getSnapVertexToGuideInProximity;
+    private getSnapActiveVertexToGuideInProximity;
+    private getSnapPointToGridInProximity;
+    private getFeatureAtPoint;
+    private getElementAddressAtPoint;
+    getElementUiAtPoint(cursorPoint: ICoordinate2D): undefined | IElementUi;
+    private getSnapPointToElementInProximity;
+    private runValidators;
+    private reevaluateFeatureConnections;
+    private pushStateToConfigurator;
+    setAttributesToState(attributes?: Record<string, IHydratedAttribute>): void;
+    deleteAll(): void;
+    private resetInternalState;
+    highlightElementIfInProximity(canvas: HTMLCanvasElement, cursorPoint: ICoordinate2D): void;
+    centerSpace(canvas: HTMLCanvasElement | null, zoomToFit?: boolean): void;
+    showNewWallAnchor(canvas: HTMLCanvasElement, cursorPoint: ICoordinate2D): void;
+    startDrawNewWall(startPoint: ICoordinate2D): void;
+    drawNewWall(canvas: HTMLCanvasElement, endPoint: ICoordinate2D): void;
+    cancelDrawNewWall(canvas: HTMLCanvasElement): void;
+    finishDrawNewWall(canvas: HTMLCanvasElement, assetId?: string): Promise<void>;
+    private moveActiveVertex;
+    private finishMoveActiveVertex;
+    private moveActiveFeature;
+    private finishMoveActiveFeature;
+    selectElementIfInProximity(canvas: HTMLCanvasElement, cursorPoint: ICoordinate2D): void;
+    moveActiveElement(canvas: HTMLCanvasElement, moveToPoint: ICoordinate2D): void;
+    finishMoveActiveElement(canvas: HTMLCanvasElement): void;
+    cancelMoveActiveElement(canvas: HTMLCanvasElement): void;
+    drawSpaces(canvas: HTMLCanvasElement | null): void;
+}
+export default SpacesState;