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

package/dist/hooks/useSpaces/geometry/splitLineAtPoints.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinate2D, ICoordinatesLine } from '../types';
+declare function splitLineAtPoints(line: ICoordinatesLine, points: Array<ICoordinate2D>): Array<ICoordinatesLine>;
+export default splitLineAtPoints;

package/dist/hooks/useSpaces/geometry/splitLineAtPoints.js

@@ -0,0 +1,28 @@
+"use strict";
+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));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var orderCoordinatesOnLineSegment_1 = __importDefault(require("./orderCoordinatesOnLineSegment"));
+function splitLineAtPoints(line, points) {
+    if (!points.length)
+        return [line];
+    var orderedPoints = (0, orderCoordinatesOnLineSegment_1.default)(__spreadArray(__spreadArray([], line, true), points, true));
+    return (orderedPoints[0][0] === line[0][0] ? orderedPoints : orderedPoints.reverse()).reduce(function (output, point, i) {
+        if (!i)
+            return output;
+        else
+            output.push([orderedPoints[i - 1], point]);
+        return output;
+    }, []);
+}
+exports.default = splitLineAtPoints;

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

@@ -0,0 +1,76 @@
+import React from 'react';
+import type { IHydratedAttributeArray } from '../../types';
+import type { ICoordinate2D, IElementName, IElementPublic, ISpacesHookProps } from './types';
+import { IModes, IUnits, IElements } from './types';
+import { IThemes } from './themes';
+import SpacesLayout from './SpacesLayout';
+interface IUseSpaces {
+    draw: () => void;
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    [IElements.WALL]?: IHydratedAttributeArray;
+    [IElements.WINDOW]?: IHydratedAttributeArray;
+    [IElements.DOOR]?: IHydratedAttributeArray;
+    [IElements.OPENING]?: IHydratedAttributeArray;
+    selectedElement: IElementPublic | null;
+    reset: () => void;
+    recenter: (zoomToFit?: boolean) => void;
+    deleteElement: (type: IElementName, index: number) => void;
+    dimensions: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    angleSnapping: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    guideSnapping: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    gridSnapping: {
+        enabled: boolean;
+        handleToggle: (val?: boolean) => void;
+    };
+    zoom: {
+        min: number;
+        max: number;
+        value: number;
+        handleChange: (value: number) => void;
+    };
+    unit: {
+        value: IUnits;
+        options: Array<{
+            label: string;
+            value: IUnits;
+            selected: boolean;
+            handleSelect: () => void;
+        }>;
+        handleChange: (unit: IUnits) => void;
+    };
+    translate: {
+        handleChange: (delta: ICoordinate2D) => void;
+    };
+    mode: {
+        value: IModes;
+        options: Array<{
+            label: IModes;
+            value: IModes;
+            selected: boolean;
+            handleSelect: () => void;
+        }>;
+        handleChange: (mode: IModes) => void;
+    };
+    layouts: Array<{
+        label: string;
+        loops: Array<ICoordinate2D[]>;
+        handleSelect: () => void;
+    }>;
+}
+declare const useSpaces: {
+    (props: ISpacesHookProps): IUseSpaces;
+    themes: typeof IThemes;
+    units: typeof IUnits;
+    modes: typeof IModes;
+    LayoutIcon: typeof SpacesLayout;
+};
+export default useSpaces;

package/dist/hooks/useSpaces/index.js

@@ -0,0 +1,475 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+var types_1 = require("./types");
+var useConfigurator_1 = __importDefault(require("../useConfigurator"));
+var SpacesState_1 = __importDefault(require("./SpacesState"));
+var constants_1 = require("./constants");
+var themes_1 = __importStar(require("./themes"));
+var SpacesLayout_1 = __importDefault(require("./SpacesLayout"));
+var store_1 = require("../../store");
+var spaces_1 = require("../../store/spaces");
+var useThreekitInitStatus_1 = __importDefault(require("../useThreekitInitStatus"));
+var useSpaces = function (props) {
+    var _a;
+    var attributesState = (0, useConfigurator_1.default)()[0];
+    var hasLoaded = (0, useThreekitInitStatus_1.default)();
+    var dispatch = (0, store_1.useThreekitDispatch)();
+    var layouts = (0, store_1.useThreekitSelector)(spaces_1.getLayouts);
+    var zoom = (0, store_1.useThreekitSelector)(spaces_1.getZoom);
+    var unit = (0, store_1.useThreekitSelector)(spaces_1.getUnit);
+    var translation = (0, store_1.useThreekitSelector)(spaces_1.getTranslation);
+    var modeValue = (0, store_1.useThreekitSelector)(spaces_1.getMode);
+    var showDimensions = (0, store_1.useThreekitSelector)(spaces_1.getShowDimensions);
+    var angleSnappingEnabled = (0, store_1.useThreekitSelector)(spaces_1.getAngleSnappingEnabled);
+    var guideSnappingEnabled = (0, store_1.useThreekitSelector)(spaces_1.getGuideSnappingEnabled);
+    var gridSnappingEnabled = (0, store_1.useThreekitSelector)(spaces_1.getGridSnappingEnabled);
+    var _b = (0, react_1.useState)(null), selectedElement = _b[0], setSelectedElement = _b[1];
+    var canvasRef = (0, react_1.useRef)(null);
+    var selectElementPending = (0, react_1.useRef)(null);
+    var translationAnchorRef = (0, react_1.useRef)(null);
+    var preppedConfig = Object.assign({
+        scale: constants_1.SCALE,
+        unit: types_1.IUnits.FEET,
+        snapProximity: constants_1.SNAP_PROXIMITY,
+        zoomDefault: zoom || constants_1.ZOOM_DEFAULT,
+        translateDefault: translation || constants_1.TRANSLATE_DEFAULT,
+        disableGuides: false,
+        styles: ((_a = props.config) === null || _a === void 0 ? void 0 : _a.theme) && themes_1.default[props.config.theme]
+            ? themes_1.default[props.config.theme]
+            : themes_1.default[themes_1.IThemes.DEFAULT],
+    }, props.config);
+    var attributeNames = Object.assign(constants_1.ATTRIBUTE_NAME_DEFAULTS, props.attributes);
+    var spacesRef = (0, react_1.useRef)(new SpacesState_1.default(__assign(__assign({}, props), { config: preppedConfig, attributes: attributeNames })));
+    var drawSpaces = function () { return spacesRef.current.drawSpaces(canvasRef.current); };
+    (0, react_1.useEffect)(function () {
+        var attributesDelinked = JSON.parse(JSON.stringify(attributesState));
+        spacesRef.current.setAttributesToState(attributesDelinked);
+        drawSpaces();
+    }, [attributesState]);
+    (0, react_1.useEffect)(function () {
+        var _a;
+        var guidesEnabled = !(((_a = props.config) === null || _a === void 0 ? void 0 : _a.disableGuides) || false);
+        dispatch((0, spaces_1.setGuideSnappingEnabled)(guidesEnabled));
+        spacesRef.current.guideSnappingEnabled = guidesEnabled;
+    }, []);
+    (0, react_1.useEffect)(function () {
+        var _a;
+        if (zoom &&
+            ((_a = props.config) === null || _a === void 0 ? void 0 : _a.zoomDefault) &&
+            props.config.zoomDefault >= spacesRef.current.zoomMin &&
+            spacesRef.current.zoomMax >= props.config.zoomDefault)
+            updateZoom(props.config.zoomDefault);
+        updateUnit(preppedConfig.unit);
+    }, []);
+    (0, react_1.useEffect)(function () {
+        var _a, _b;
+        if (canvasRef === null || canvasRef === void 0 ? void 0 : canvasRef.current) {
+            spacesRef.current.canvasDimensions = [
+                canvasRef.current.width,
+                canvasRef.current.height,
+            ];
+            canvasRef.current.addEventListener('mousedown', handleDrawWallStart);
+            canvasRef.current.addEventListener('mousemove', handleDrawWallMouseMove);
+            document.addEventListener('mouseup', handleDrawWallFinish);
+            canvasRef.current.addEventListener('mousemove', handleHover);
+            canvasRef.current.addEventListener('mousedown', handleSelectElement);
+            canvasRef.current.addEventListener('mousemove', handleMoveSelectedElement);
+            if (!((_a = props.config) === null || _a === void 0 ? void 0 : _a.translateDisabled))
+                canvasRef.current.addEventListener('mousemove', handleMoveCanvas);
+            document.addEventListener('mouseup', handleSetSelectedElement);
+            if (!((_b = props.config) === null || _b === void 0 ? void 0 : _b.zoomDisabled))
+                canvasRef.current.addEventListener('wheel', handleScrollToZoom);
+        }
+        return function () {
+            var _a, _b;
+            if (canvasRef === null || canvasRef === void 0 ? void 0 : canvasRef.current) {
+                canvasRef.current.removeEventListener('mousedown', handleDrawWallStart);
+                canvasRef.current.removeEventListener('mousemove', handleDrawWallMouseMove);
+                document.removeEventListener('mouseup', handleDrawWallFinish);
+                canvasRef.current.removeEventListener('mousemove', handleHover);
+                canvasRef.current.removeEventListener('mousedown', handleSelectElement);
+                canvasRef.current.removeEventListener('mousemove', handleMoveSelectedElement);
+                if (!((_a = props.config) === null || _a === void 0 ? void 0 : _a.translateDisabled))
+                    canvasRef.current.removeEventListener('mousemove', handleMoveCanvas);
+                document.removeEventListener('mouseup', handleSetSelectedElement);
+                if (!((_b = props.config) === null || _b === void 0 ? void 0 : _b.zoomDisabled))
+                    canvasRef.current.removeEventListener('wheel', handleScrollToZoom);
+            }
+        };
+    });
+    (0, react_1.useEffect)(function () {
+        spacesRef.current.showDimensions = showDimensions;
+        spacesRef.current.angleSnappingEnabled = angleSnappingEnabled;
+        spacesRef.current.guideSnappingEnabled = guideSnappingEnabled;
+        spacesRef.current.gridSnappingEnabled = gridSnappingEnabled;
+        spacesRef.current.selectedElement = selectedElement
+            ? {
+                type: selectedElement.path[0],
+                index: selectedElement.path[1],
+            }
+            : null;
+        drawSpaces();
+    }, [
+        selectedElement,
+        showDimensions,
+        angleSnappingEnabled,
+        guideSnappingEnabled,
+        gridSnappingEnabled,
+    ]);
+    (0, react_1.useEffect)(function () {
+        if (!hasLoaded)
+            return;
+        var layoutIds = props.layouts || [];
+        dispatch((0, spaces_1.hydrateLayouts)(layoutIds, {
+            walls: attributeNames[types_1.IElements.WALL],
+            startX: attributeNames.wallStartX,
+            startZ: attributeNames.wallStartZ,
+            endX: attributeNames.wallEndX,
+            endZ: attributeNames.wallEndZ,
+        }));
+    }, [hasLoaded, JSON.stringify(props.layouts)]);
+    var updateZoom = function (value) {
+        spacesRef.current.zoom = value;
+        if (!spacesRef.current.zoom)
+            return;
+        dispatch((0, spaces_1.setZoom)(spacesRef.current.zoom));
+    };
+    var updateUnit = function (unit) {
+        if (!spacesRef.current)
+            return;
+        spacesRef.current.unit = unit;
+        if (!spacesRef.current.unit)
+            return;
+        dispatch((0, spaces_1.setUnit)(spacesRef.current.unit));
+        spacesRef.current.drawSpaces(canvasRef.current);
+    };
+    var handleRecenter = function (zoomToFit) {
+        spacesRef.current.centerSpace(canvasRef.current, zoomToFit);
+        dispatch((0, spaces_1.setZoom)(spacesRef.current.zoom));
+    };
+    var handleSelectModeHover = function (canvas, cursorPoint) {
+        if (spacesRef.current.activeElement !== null)
+            return;
+        if (translationAnchorRef.current)
+            return;
+        spacesRef.current.highlightElementIfInProximity(canvas, cursorPoint);
+    };
+    var handleSelectElement = function (e) {
+        var _a;
+        if (!canvasRef.current)
+            return;
+        if (modeValue !== types_1.IModes.SELECT)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        spacesRef.current.selectElementIfInProximity(canvasRef.current, cursorPoint);
+        var element = spacesRef.current.getElementUiAtPoint(cursorPoint);
+        if (!element) {
+            if (selectedElement !== null)
+                setSelectedElement(null);
+            if (!((_a = props.config) === null || _a === void 0 ? void 0 : _a.translateDisabled) && !spacesRef.current.activeElement)
+                translationAnchorRef.current = cursorPoint;
+            return;
+        }
+        if (spacesRef.current.activeElement ||
+            (selectedElement &&
+                JSON.stringify(element.path) !== JSON.stringify(selectedElement.path)))
+            setSelectedElement(null);
+        selectElementPending.current = element;
+    };
+    var handleMoveSelectedElement = function (e) {
+        if (modeValue !== types_1.IModes.SELECT)
+            return;
+        if (!canvasRef.current)
+            return;
+        var point = [e.offsetX, e.offsetY];
+        spacesRef.current.moveActiveElement(canvasRef.current, point);
+        selectElementPending.current = null;
+    };
+    var handleMoveCanvas = function (e) {
+        if (modeValue !== types_1.IModes.SELECT)
+            return;
+        if (!canvasRef.current)
+            return;
+        if (spacesRef.current.selectedElement || !translationAnchorRef.current)
+            return;
+        var delta = [
+            e.offsetX - translationAnchorRef.current[0],
+            e.offsetY - translationAnchorRef.current[1],
+        ];
+        handleChangeTranslate(delta);
+        translationAnchorRef.current = [e.offsetX, e.offsetY];
+    };
+    var handleSetSelectedElement = function (e) {
+        var _a;
+        if (modeValue !== types_1.IModes.SELECT)
+            return;
+        if (!canvasRef.current)
+            return;
+        if (!((_a = canvasRef.current) === null || _a === void 0 ? void 0 : _a.contains(e.target))) {
+            spacesRef.current.cancelMoveActiveElement(canvasRef.current);
+            return;
+        }
+        spacesRef.current.finishMoveActiveElement(canvasRef.current);
+        if (selectElementPending.current) {
+            setSelectedElement(selectElementPending.current);
+            selectElementPending.current = null;
+            return;
+        }
+        if (translationAnchorRef.current)
+            translationAnchorRef.current = null;
+    };
+    var handleDrawModeHover = function (canvas, cursorPoint) {
+        if (spacesRef.current.isDrawWallActive)
+            return;
+        spacesRef.current.showNewWallAnchor(canvas, cursorPoint);
+    };
+    var handleDrawWallStart = function (e) {
+        if (modeValue !== types_1.IModes.DRAW)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        spacesRef.current.startDrawNewWall(cursorPoint);
+    };
+    var handleDrawWallMouseMove = function (e) {
+        if (modeValue !== types_1.IModes.DRAW)
+            return;
+        if (!canvasRef.current)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        if (spacesRef.current.isDrawWallActive)
+            spacesRef.current.drawNewWall(canvasRef.current, cursorPoint);
+    };
+    var handleDrawWallFinish = function (e) {
+        var _a;
+        if (modeValue !== types_1.IModes.DRAW)
+            return;
+        if (!canvasRef.current)
+            return;
+        if (!((_a = canvasRef.current) === null || _a === void 0 ? void 0 : _a.contains(e.target))) {
+            spacesRef.current.cancelDrawNewWall(canvasRef.current);
+            return;
+        }
+        spacesRef.current.finishDrawNewWall(canvasRef.current);
+    };
+    var handleScrollToZoom = function (e) {
+        var _a;
+        if (!canvasRef.current)
+            return;
+        var zoomSensitivity = ((_a = props.config) === null || _a === void 0 ? void 0 : _a.zoomSensitivity) || constants_1.ZOOM_SENSITIVITY;
+        updateZoom(-1 * e.deltaY * zoomSensitivity);
+        e.preventDefault();
+    };
+    var handleHover = function (e) {
+        if (!canvasRef.current)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        if (modeValue === types_1.IModes.DRAW)
+            handleDrawModeHover(canvasRef.current, cursorPoint);
+        else if (modeValue === types_1.IModes.SELECT)
+            handleSelectModeHover(canvasRef.current, cursorPoint);
+    };
+    var prepFeatureAttributeForOutput = function (type, attribute) {
+        if (!attribute)
+            return undefined;
+        var values = attribute.values.map(function (val) { return (__assign(__assign({}, val), { add: function (addToWallIndex, feature) {
+                return spacesRef.current.addFeature(type, addToWallIndex, __assign({ assetId: val.assetId }, (feature || {})));
+            } })); });
+        var value = attribute.value.map(function (val, i) { return (__assign(__assign({}, val), { delete: function () { return spacesRef.current.deleteFeature(type, i); } })); });
+        return __assign(__assign({}, attribute), { values: values, value: value });
+    };
+    var prepWallAttributeForOutput = function (attribute) {
+        if (!attribute)
+            return undefined;
+        var values = attribute.values.map(function (val) { return (__assign({}, val)); });
+        var value = attribute.value.map(function (val, i) { return (__assign(__assign({}, val), { delete: function () { var _a; return (_a = spacesRef.current) === null || _a === void 0 ? void 0 : _a.deleteWall(i); }, splitWall: function (offset) { var _a; return (_a = spacesRef.current) === null || _a === void 0 ? void 0 : _a.splitWallAtOffset(i, offset); } })); });
+        return __assign(__assign({}, attribute), { values: values, value: value });
+    };
+    var getElementFromAttributeName = function (attributeName) {
+        var elementAttr = Object.entries(attributeNames).find(function (_a) {
+            var _ = _a[0], attrName = _a[1];
+            return attrName === attributeName;
+        });
+        if (!elementAttr)
+            return;
+        return elementAttr[0];
+    };
+    var handleSetMode = function (mode) {
+        if (mode === modeValue)
+            return;
+        drawSpaces();
+        dispatch((0, spaces_1.setMode)(mode));
+        setSelectedElement(null);
+    };
+    var handleReset = function () {
+        var _a;
+        (_a = spacesRef.current) === null || _a === void 0 ? void 0 : _a.deleteAll();
+        setSelectedElement(null);
+    };
+    var handleDeleteElement = function (type, index) {
+        var _a;
+        var elementType = type;
+        if (Object.values(attributeNames).includes(type)) {
+            var updatedType = getElementFromAttributeName(type);
+            if (!updatedType)
+                return;
+            elementType = updatedType;
+        }
+        (_a = spacesRef.current) === null || _a === void 0 ? void 0 : _a.deleteElement(elementType, index);
+        setSelectedElement(null);
+    };
+    var handleToggleDimensions = function (val) {
+        if (val === undefined)
+            dispatch((0, spaces_1.setShowDimensions)(!showDimensions));
+        else
+            dispatch((0, spaces_1.setShowDimensions)(val));
+        setSelectedElement(null);
+    };
+    var handleToggleAngleSnapping = function (val) {
+        if (val === undefined)
+            dispatch((0, spaces_1.setAngleSnappingEnabled)(!angleSnappingEnabled));
+        else
+            dispatch((0, spaces_1.setAngleSnappingEnabled)(val));
+        setSelectedElement(null);
+    };
+    var handleToggleGuideSnapping = function (val) {
+        if (val === undefined)
+            dispatch((0, spaces_1.setGuideSnappingEnabled)(!guideSnappingEnabled));
+        else
+            dispatch((0, spaces_1.setGuideSnappingEnabled)(val));
+        setSelectedElement(null);
+    };
+    var handleToggleGridSnapping = function (val) {
+        if (val === undefined)
+            dispatch((0, spaces_1.setGridSnappingEnabled)(!gridSnappingEnabled));
+        else
+            dispatch((0, spaces_1.setGridSnappingEnabled)(val));
+        setSelectedElement(null);
+    };
+    var handleChangeTranslate = function (delta) {
+        spacesRef.current.translate = [
+            spacesRef.current.translate[0] + delta[0],
+            spacesRef.current.translate[1] + delta[1],
+        ];
+        dispatch((0, spaces_1.setTranslation)(spacesRef.current.translate));
+        drawSpaces();
+    };
+    return {
+        draw: drawSpaces,
+        canvasRef: canvasRef,
+        selectedElement: selectedElement === null
+            ? selectedElement
+            : __assign(__assign({}, selectedElement), { path: [
+                    attributeNames[selectedElement.path[0]],
+                    selectedElement.path[1],
+                ], type: selectedElement.path[0], deleteElement: function () { return handleDeleteElement.apply(void 0, selectedElement.path); }, splitWall: selectedElement.path[0] !== types_1.IElements.WALL
+                    ? undefined
+                    : function (offset) {
+                        return spacesRef.current.splitWallAtOffset(selectedElement.path[1], offset);
+                    }, addFeature: selectedElement.path[0] !== types_1.IElements.WALL
+                    ? undefined
+                    : function (type, feature) {
+                        return spacesRef.current.addFeature(type, selectedElement.path[1], feature);
+                    } }),
+        mode: {
+            value: modeValue,
+            options: [types_1.IModes.SELECT, types_1.IModes.DRAW].map(function (el) { return ({
+                value: el,
+                label: el,
+                selected: modeValue === el,
+                handleSelect: function () { return handleSetMode(el); },
+            }); }),
+            handleChange: handleSetMode,
+        },
+        dimensions: {
+            enabled: showDimensions,
+            handleToggle: handleToggleDimensions,
+        },
+        angleSnapping: {
+            enabled: angleSnappingEnabled,
+            handleToggle: handleToggleAngleSnapping,
+        },
+        guideSnapping: {
+            enabled: guideSnappingEnabled,
+            handleToggle: handleToggleGuideSnapping,
+        },
+        gridSnapping: {
+            enabled: gridSnappingEnabled,
+            handleToggle: handleToggleGridSnapping,
+        },
+        zoom: {
+            min: spacesRef.current.zoomMin,
+            max: spacesRef.current.zoomMax,
+            value: zoom || constants_1.ZOOM_DEFAULT,
+            handleChange: updateZoom,
+        },
+        unit: {
+            value: unit,
+            options: [types_1.IUnits.FEET, types_1.IUnits.METER, types_1.IUnits.INCH, types_1.IUnits.CM].map(function (el) { return ({
+                value: el,
+                label: el,
+                selected: unit === el,
+                handleSelect: function () { return updateUnit(el); },
+            }); }),
+            handleChange: updateUnit,
+        },
+        translate: {
+            handleChange: handleChangeTranslate,
+        },
+        reset: handleReset,
+        recenter: handleRecenter,
+        deleteElement: handleDeleteElement,
+        layouts: layouts.map(function (layout) { return ({
+            label: layout.label,
+            loops: layout.loop,
+            handleSelect: function () {
+                return window.threekit.configurator.setFullConfiguration(layout.configuration);
+            },
+        }); }),
+        walls: prepWallAttributeForOutput(attributesState === null || attributesState === void 0 ? void 0 : attributesState[attributeNames[types_1.IElements.WALL]]),
+        windows: prepFeatureAttributeForOutput(types_1.IElements.WINDOW, attributesState === null || attributesState === void 0 ? void 0 : attributesState[attributeNames[types_1.IElements.WINDOW]]),
+        doors: prepFeatureAttributeForOutput(types_1.IElements.DOOR, attributesState === null || attributesState === void 0 ? void 0 : attributesState[attributeNames[types_1.IElements.DOOR]]),
+        openings: prepFeatureAttributeForOutput(types_1.IElements.OPENING, attributesState === null || attributesState === void 0 ? void 0 : attributesState[attributeNames[types_1.IElements.OPENING]]),
+    };
+};
+useSpaces.themes = themes_1.IThemes;
+useSpaces.units = types_1.IUnits;
+useSpaces.modes = types_1.IModes;
+useSpaces.LayoutIcon = SpacesLayout_1.default;
+exports.default = useSpaces;

package/dist/hooks/useSpaces/themes/blueprint.d.ts

@@ -0,0 +1,3 @@
+import type { ISpacesStyles } from '../types';
+declare const theme: ISpacesStyles;
+export default theme;

package/dist/hooks/useSpaces/themes/blueprint.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var WALL_THICKNESS = 22;
+var VERTEX_RADIUS = (WALL_THICKNESS - 8) / 2;
+var FEATURE_THICKNESS = WALL_THICKNESS + 6;
+var HIGHLIGHT_COLOR = '#36738E';
+var ACTIVE_COLOR = 'green';
+var ERROR_COLOR = 'red';
+var theme = {
+    grid: {
+        lineThickness: 2,
+        lineColor: '#fff',
+        showSubdivisions: true,
+        subdivisionLineThickness: 1,
+        subdivisionLineColor: '#fff',
+        subdivisionThreshold: 20,
+        backgroundColor: '#37588B',
+    },
+    guides: {
+        color: 'red',
+        thickness: 1,
+    },
+    floor: {
+        color: '#eee',
+        textColor: '#666',
+    },
+    dimensions: {
+        padding: WALL_THICKNESS / 2 + 12,
+        lineThickness: 1,
+        lineColor: '#fff',
+        fontSize: 14,
+        font: 'Helvetica',
+        textColor: '#444',
+        textBackgroundColor: '#fff',
+    },
+    wall: {
+        fill: '#848484',
+        stroke: '#fff',
+        strokeWidth: 1,
+        thickness: WALL_THICKNESS,
+        highlight: {
+            fill: HIGHLIGHT_COLOR,
+            stroke: HIGHLIGHT_COLOR,
+        },
+        active: {
+            fill: ACTIVE_COLOR,
+            stroke: ACTIVE_COLOR,
+        },
+        error: {
+            fill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+    vertex: {
+        innerFill: '#fff',
+        outerFill: '#fff',
+        stroke: '#36738E',
+        strokeWidth: 0,
+        outerRadius: VERTEX_RADIUS,
+        innerRadius: VERTEX_RADIUS / 2,
+        highlight: {
+            innerFill: HIGHLIGHT_COLOR,
+            outerFill: HIGHLIGHT_COLOR,
+            stroke: HIGHLIGHT_COLOR,
+        },
+        active: {
+            innerFill: ACTIVE_COLOR,
+            outerFill: ACTIVE_COLOR,
+            stroke: ACTIVE_COLOR,
+        },
+        error: {
+            innerFill: ERROR_COLOR,
+            outerFill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+    feature: {
+        fill: '#888',
+        stroke: '#888',
+        strokeWidth: 0,
+        thickness: FEATURE_THICKNESS,
+        highlight: {
+            fill: HIGHLIGHT_COLOR,
+            stroke: HIGHLIGHT_COLOR,
+        },
+        active: {
+            fill: ACTIVE_COLOR,
+            stroke: ACTIVE_COLOR,
+        },
+        error: {
+            fill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+};
+exports.default = theme;

package/dist/hooks/useSpaces/themes/default.d.ts

@@ -0,0 +1,3 @@
+import type { ISpacesStyles } from '../types';
+declare const theme: ISpacesStyles;
+export default theme;