@threekit-tools/treble 0.0.87 → 0.0.89-next-001

package/dist/hooks/useRoomBuilder/index.js

@@ -0,0 +1,299 @@
+"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 RoomBuilderState_1 = __importDefault(require("./RoomBuilderState"));
+var constants_1 = require("./constants");
+var themes_1 = __importStar(require("./themes"));
+var useRoomBuilder = function (props) {
+    var _a;
+    var attributesState = (0, useConfigurator_1.default)()[0];
+    var _b = (0, react_1.useState)(types_1.IModes.DRAW), modeValue = _b[0], setMode = _b[1];
+    var _c = (0, react_1.useState)(true), showDimensions = _c[0], setShowDimensions = _c[1];
+    var _d = (0, react_1.useState)(true), angleSnappingEnabled = _d[0], setAngleSnappingEnabled = _d[1];
+    var _e = (0, react_1.useState)(null), selectedElement = _e[0], setSelectedElement = _e[1];
+    var _f = (0, react_1.useState)(null), selectedWallAsset = _f[0], setSelectedWallAsset = _f[1];
+    var canvasRef = (0, react_1.useRef)(null);
+    var selectElementPending = (0, react_1.useRef)(null);
+    var preppedConfig = Object.assign({
+        scale: constants_1.SCALE,
+        unit: types_1.IUnits.FEET,
+        snapProximity: constants_1.SNAP_PROXIMITY,
+        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 roomBuilderRef = (0, react_1.useRef)(new RoomBuilderState_1.default(__assign(__assign({}, props), { config: preppedConfig })));
+    var drawRoom = function () { return roomBuilderRef.current.drawRoom(canvasRef.current); };
+    (0, react_1.useEffect)(function () {
+        if (!canvasRef.current)
+            return;
+        canvasRef.current.height = constants_1.CANVAS_HEIGHT;
+        canvasRef.current.width = constants_1.CANVAS_WIDTH;
+    }, [canvasRef.current]);
+    (0, react_1.useEffect)(function () {
+        var _a;
+        if (!selectedWallAsset &&
+            (attributesState === null || attributesState === void 0 ? void 0 : attributesState[props.attributes[types_1.IElements.WALL]]))
+            setSelectedWallAsset(((_a = attributesState === null || attributesState === void 0 ? void 0 : attributesState[props.attributes[types_1.IElements.WALL]]) === null || _a === void 0 ? void 0 : _a.values[0].assetId) || null);
+        var attributesDelinked = JSON.parse(JSON.stringify(attributesState));
+        roomBuilderRef.current.setAttributesToState(attributesDelinked);
+        drawRoom();
+    }, [attributesState]);
+    (0, react_1.useEffect)(function () {
+        if (canvasRef === null || canvasRef === void 0 ? void 0 : canvasRef.current) {
+            canvasRef.current.addEventListener('mousedown', handleDrawWallStart);
+            canvasRef.current.addEventListener('mousemove', handleDrawWallMouseMove);
+            canvasRef.current.addEventListener('mouseup', handleDrawWallFinish);
+            canvasRef.current.addEventListener('mousemove', handleSelectModeHover);
+            canvasRef.current.addEventListener('mousedown', handleSelectElement);
+            canvasRef.current.addEventListener('mousemove', handleMoveSelectedElement);
+            canvasRef.current.addEventListener('mouseup', handleSetSelectedElement);
+        }
+        return function () {
+            if (canvasRef === null || canvasRef === void 0 ? void 0 : canvasRef.current) {
+                canvasRef.current.removeEventListener('mousedown', handleDrawWallStart);
+                canvasRef.current.removeEventListener('mousemove', handleDrawWallMouseMove);
+                canvasRef.current.removeEventListener('mouseup', handleDrawWallFinish);
+                canvasRef.current.removeEventListener('mousemove', handleSelectModeHover);
+                canvasRef.current.removeEventListener('mousedown', handleSelectElement);
+                canvasRef.current.removeEventListener('mousemove', handleMoveSelectedElement);
+                canvasRef.current.removeEventListener('mouseup', handleSetSelectedElement);
+            }
+        };
+    });
+    (0, react_1.useEffect)(function () {
+        roomBuilderRef.current.showDimensions = showDimensions;
+        roomBuilderRef.current.angleSnappingEnabled = angleSnappingEnabled;
+        roomBuilderRef.current.selectedElement = selectedElement
+            ? {
+                type: selectedElement.path[0],
+                index: selectedElement.path[1],
+            }
+            : null;
+        drawRoom();
+    }, [selectedElement, showDimensions, angleSnappingEnabled]);
+    var handleSelectModeHover = function (e) {
+        if (!canvasRef.current)
+            return;
+        if (modeValue !== types_1.IModes.SELECT)
+            return;
+        if (roomBuilderRef.current.activeElement !== null)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        roomBuilderRef.current.highlightElementIfInProximity(canvasRef.current, cursorPoint);
+    };
+    var handleSelectElement = function (e) {
+        if (!canvasRef.current)
+            return;
+        if (modeValue !== types_1.IModes.SELECT)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        roomBuilderRef.current.selectElementIfInProximity(canvasRef.current, cursorPoint);
+        var element = roomBuilderRef.current.getClickedElement(cursorPoint);
+        if (!element) {
+            if (selectedElement !== null)
+                setSelectedElement(null);
+            return;
+        }
+        if (roomBuilderRef.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];
+        roomBuilderRef.current.moveActiveElement(canvasRef.current, point);
+        selectElementPending.current = null;
+    };
+    var handleSetSelectedElement = function () {
+        if (modeValue !== types_1.IModes.SELECT)
+            return;
+        if (!canvasRef.current)
+            return;
+        roomBuilderRef.current.finishMoveActiveElement(canvasRef.current);
+        if (selectElementPending.current) {
+            setSelectedElement(selectElementPending.current);
+            selectElementPending.current = null;
+        }
+    };
+    var handleDrawWallStart = function (e) {
+        if (modeValue !== types_1.IModes.DRAW)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        roomBuilderRef.current.startDrawNewWall(cursorPoint);
+    };
+    var handleDrawWallMouseMove = function (e) {
+        if (modeValue !== types_1.IModes.DRAW)
+            return;
+        if (!canvasRef.current)
+            return;
+        var cursorPoint = [e.offsetX, e.offsetY];
+        roomBuilderRef.current.drawNewWall(canvasRef.current, cursorPoint);
+    };
+    var handleDrawWallFinish = function () {
+        if (modeValue !== types_1.IModes.DRAW)
+            return;
+        if (!canvasRef.current)
+            return;
+        if (!selectedWallAsset)
+            return;
+        roomBuilderRef.current.finishDrawNewWall(canvasRef.current, selectedWallAsset);
+    };
+    var prepFeatureAttributeForOutput = function (type, attribute) {
+        if (!attribute)
+            return undefined;
+        var values = attribute.values.map(function (val) { return (__assign(__assign({}, val), { add: function (addToWallIndex, offset) {
+                return roomBuilderRef.current.addFeature(type, {
+                    assetId: val.assetId,
+                    length: constants_1.FEATURE_LENGTH,
+                    offset: offset,
+                }, addToWallIndex);
+            } })); });
+        var value = attribute.value.map(function (val, i) { return (__assign(__assign({}, val), { delete: function () { return roomBuilderRef.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(__assign({}, val), { selected: val.assetId === selectedWallAsset, selectToDraw: function () {
+                setMode(types_1.IModes.DRAW);
+                setSelectedWallAsset(val.assetId);
+            } })); });
+        var value = attribute.value.map(function (val, i) { return (__assign(__assign({}, val), { delete: function () { var _a; return (_a = roomBuilderRef.current) === null || _a === void 0 ? void 0 : _a.deleteWall(i); } })); });
+        return __assign(__assign({}, attribute), { values: values, value: value });
+    };
+    var getElementFromAttributeName = function (attributeName) {
+        var elementAttr = Object.entries(props.attributes).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;
+        drawRoom();
+        setMode(mode);
+        setSelectedElement(null);
+    };
+    var handleDeleteAll = function () {
+        var _a;
+        (_a = roomBuilderRef.current) === null || _a === void 0 ? void 0 : _a.deleteAll();
+        setSelectedElement(null);
+    };
+    var handleDeleteElement = function (type, index) {
+        var _a;
+        var elementType = type;
+        if (Object.values(props.attributes).includes(type)) {
+            var updatedType = getElementFromAttributeName(type);
+            if (!updatedType)
+                return;
+            elementType = updatedType;
+        }
+        (_a = roomBuilderRef.current) === null || _a === void 0 ? void 0 : _a.deleteElement(elementType, index);
+        setSelectedElement(null);
+    };
+    var handleToggleDimensions = function (val) {
+        if (val === undefined)
+            setShowDimensions(!showDimensions);
+        else
+            setShowDimensions(val);
+        setSelectedElement(null);
+    };
+    var handleToggleAngleSnapping = function (val) {
+        if (val === undefined)
+            setAngleSnappingEnabled(!angleSnappingEnabled);
+        else
+            setAngleSnappingEnabled(val);
+        setSelectedElement(null);
+    };
+    return {
+        canvasRef: canvasRef,
+        selectedElement: selectedElement === null
+            ? selectedElement
+            : __assign(__assign({}, selectedElement), { path: [
+                    props.attributes[selectedElement.path[0]],
+                    selectedElement.path[1],
+                ] }),
+        mode: {
+            value: modeValue,
+            options: [types_1.IModes.DRAW, types_1.IModes.SELECT].map(function (el) { return ({
+                value: el,
+                label: el,
+                selected: modeValue === el,
+                handleSelect: function () { return handleSetMode(el); },
+            }); }),
+            handleChange: handleSetMode,
+        },
+        dimensions: {
+            show: showDimensions,
+            handleToggle: handleToggleDimensions,
+        },
+        snapping: {
+            enabled: angleSnappingEnabled,
+            handleToggle: handleToggleAngleSnapping,
+        },
+        deleteAll: handleDeleteAll,
+        deleteElement: handleDeleteElement,
+        walls: prepWallAttributeForOutput(attributesState === null || attributesState === void 0 ? void 0 : attributesState[props.attributes[types_1.IElements.WALL]]),
+        windows: props.attributes[types_1.IElements.WINDOW]
+            ? prepFeatureAttributeForOutput(types_1.IElements.WINDOW, attributesState === null || attributesState === void 0 ? void 0 : attributesState[props.attributes[types_1.IElements.WINDOW]])
+            : undefined,
+        doors: props.attributes[types_1.IElements.DOOR]
+            ? prepFeatureAttributeForOutput(types_1.IElements.DOOR, attributesState === null || attributesState === void 0 ? void 0 : attributesState[props.attributes[types_1.IElements.DOOR]])
+            : undefined,
+        openings: props.attributes[types_1.IElements.OPENING]
+            ? prepFeatureAttributeForOutput(types_1.IElements.OPENING, attributesState === null || attributesState === void 0 ? void 0 : attributesState[props.attributes[types_1.IElements.OPENING]])
+            : undefined,
+    };
+};
+useRoomBuilder.themes = themes_1.IThemes;
+useRoomBuilder.units = types_1.IUnits;
+useRoomBuilder.modes = types_1.IModes;
+exports.default = useRoomBuilder;

package/dist/hooks/useRoomBuilder/messaging.d.ts

@@ -0,0 +1,8 @@
+export declare const errorMessages: {
+    addWallCollidingWithWall: () => string;
+    addWallCollidingWithFeature: () => string;
+    featuresColliding: () => string;
+    featureOutsideWallBounds: () => string;
+    wallsNotUnique: () => string;
+    wallTooShort: () => string;
+};

package/dist/hooks/useRoomBuilder/messaging.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessages = void 0;
+exports.errorMessages = {
+    addWallCollidingWithWall: function () { return 'Wall colliding with other wall'; },
+    addWallCollidingWithFeature: function () {
+        return 'Cannot add a wall that collides with a feature on the wall';
+    },
+    featuresColliding: function () { return 'Feature is colliding with another feature'; },
+    featureOutsideWallBounds: function () { return 'Feature is too close to the end of the wall'; },
+    wallsNotUnique: function () { return 'walls cannot overlap'; },
+    wallTooShort: function () { return 'wall too short'; },
+};

package/dist/hooks/useRoomBuilder/themes.d.ts

@@ -0,0 +1,12 @@
+import type { IRoomBuilderStyles } from './types';
+export declare enum IThemes {
+    DEFAULT = "default",
+    BLUEPRINT = "blueprint",
+    LIGHT = "light"
+}
+declare const _default: {
+    default: IRoomBuilderStyles;
+    blueprint: IRoomBuilderStyles;
+    light: IRoomBuilderStyles;
+};
+export default _default;

package/dist/hooks/useRoomBuilder/themes.js

@@ -0,0 +1,270 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IThemes = void 0;
+var IThemes;
+(function (IThemes) {
+    IThemes["DEFAULT"] = "default";
+    IThemes["BLUEPRINT"] = "blueprint";
+    IThemes["LIGHT"] = "light";
+})(IThemes = exports.IThemes || (exports.IThemes = {}));
+var HIGHLIGHT_COLOR = '#36738E';
+var ACTIVE_COLOR = 'green';
+var ERROR_COLOR = 'red';
+var DEFAULT_WALL_THICKNESS = 18;
+var DEFAULT_VERTEX_RADIUS = (DEFAULT_WALL_THICKNESS - 6) / 2;
+var DEFAULT_FEATURE_THICKNESS = DEFAULT_WALL_THICKNESS + 6;
+var defaultTheme = {
+    grid: {
+        gridStepGap: 12,
+        lineThickness: 1,
+        secondaryLineThickness: 2,
+        lineColor: '#ddd',
+        backgroundColor: '#fff',
+        secondaryLineIncrement: 4,
+    },
+    floor: {
+        color: '#eee',
+    },
+    dimensions: {
+        padding: DEFAULT_WALL_THICKNESS / 2 + 24,
+        lineThickness: 1,
+        lineColor: '#444',
+        fontSize: 14,
+        font: 'Helvetica',
+        textColor: '#444',
+        textBackgroundColor: 'white',
+    },
+    wall: {
+        fill: '#d9d9d9',
+        stroke: '#d9d9d9',
+        strokeWidth: 0,
+        thickness: DEFAULT_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: '#36738E',
+        outerFill: 'white',
+        stroke: '#36738E',
+        strokeWidth: 2,
+        outerRadius: DEFAULT_VERTEX_RADIUS,
+        innerRadius: DEFAULT_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: DEFAULT_FEATURE_THICKNESS,
+        highlight: {
+            fill: HIGHLIGHT_COLOR,
+            stroke: HIGHLIGHT_COLOR,
+        },
+        active: {
+            fill: ACTIVE_COLOR,
+            stroke: ACTIVE_COLOR,
+        },
+        error: {
+            fill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+};
+var BLUEPRINT_WALL_THICKNESS = 22;
+var BLUEPRINT_VERTEX_RADIUS = (BLUEPRINT_WALL_THICKNESS - 8) / 2;
+var BLUEPRINT_FEATURE_THICKNESS = BLUEPRINT_WALL_THICKNESS + 6;
+var blueprint = {
+    grid: {
+        gridStepGap: 20,
+        lineThickness: 1,
+        secondaryLineThickness: 2,
+        lineColor: '#fff',
+        backgroundColor: '#37588B',
+        secondaryLineIncrement: 3,
+    },
+    floor: {
+        color: '#eee',
+    },
+    dimensions: {
+        padding: BLUEPRINT_WALL_THICKNESS / 2 + 24,
+        lineThickness: 1,
+        lineColor: '#fff',
+        fontSize: 14,
+        font: 'Helvetica',
+        textColor: '#444',
+        textBackgroundColor: '#fff',
+    },
+    wall: {
+        fill: '#848484',
+        stroke: '#fff',
+        strokeWidth: 1,
+        thickness: BLUEPRINT_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: BLUEPRINT_VERTEX_RADIUS,
+        innerRadius: BLUEPRINT_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: BLUEPRINT_FEATURE_THICKNESS,
+        highlight: {
+            fill: HIGHLIGHT_COLOR,
+            stroke: HIGHLIGHT_COLOR,
+        },
+        active: {
+            fill: ACTIVE_COLOR,
+            stroke: ACTIVE_COLOR,
+        },
+        error: {
+            fill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+};
+var LIGHT_WALL_THICKNESS = 8;
+var LIGHT_VERTEX_RADIUS = (LIGHT_WALL_THICKNESS + 8) / 2;
+var LIGHT_FEATURE_THICKNESS = LIGHT_WALL_THICKNESS + 4;
+var light = {
+    grid: {
+        gridStepGap: 15,
+        lineThickness: 1,
+        secondaryLineThickness: 2,
+        lineColor: '#ddd',
+        backgroundColor: '#fff',
+        secondaryLineIncrement: undefined,
+    },
+    floor: {
+        color: '#eee',
+    },
+    dimensions: {
+        padding: LIGHT_WALL_THICKNESS / 2 + 24,
+        lineThickness: 1,
+        lineColor: '#444',
+        fontSize: 14,
+        font: 'Helvetica',
+        textColor: '#444',
+        textBackgroundColor: '#fff',
+    },
+    wall: {
+        fill: '#000',
+        stroke: '#000',
+        strokeWidth: 0,
+        thickness: LIGHT_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: '#aaa',
+        outerFill: '#fff',
+        stroke: '#000',
+        strokeWidth: 1,
+        outerRadius: LIGHT_VERTEX_RADIUS,
+        innerRadius: (LIGHT_VERTEX_RADIUS / 5) * 3,
+        highlight: {
+            innerFill: HIGHLIGHT_COLOR,
+            outerFill: '#fff',
+            stroke: '#000',
+        },
+        active: {
+            innerFill: ACTIVE_COLOR,
+            outerFill: '#fff',
+            stroke: '#000',
+        },
+        error: {
+            innerFill: ERROR_COLOR,
+            outerFill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+    feature: {
+        fill: '#888',
+        stroke: '#888',
+        strokeWidth: 0,
+        thickness: LIGHT_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 = (_a = {},
+    _a[IThemes.DEFAULT] = defaultTheme,
+    _a[IThemes.BLUEPRINT] = blueprint,
+    _a[IThemes.LIGHT] = light,
+    _a);