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

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

@@ -0,0 +1,44 @@
+import { ICoordinate2D, ISpacesAttributes, IWallsValidationConfig } from './types';
+export declare enum WallMetadata {
+    MIN_LENGTH = "_tkSpace_minLength",
+    PADDING = "_tkSpace_padding"
+}
+export declare enum DoorOrientations {
+    LEFT = "Left",
+    RIGHT = "Right"
+}
+export declare enum DoorOpeningDirections {
+    INSIDE = "inside",
+    OUTSIDE = "outside"
+}
+export declare const ATTRIBUTE_NAME_DEFAULTS: ISpacesAttributes;
+export declare const SCALE = 0.02;
+export declare const SNAP_PROXIMITY = 16;
+export declare const ZOOM_MAX = 100;
+export declare const ZOOM_MIN = 20;
+export declare const ZOOM_DEFAULT = 40;
+export declare const ZOOM_SENSITIVITY = 0.8;
+export declare const TRANSLATE_MAX: ICoordinate2D;
+export declare const TRANSLATE_MIN: ICoordinate2D;
+export declare const TRANSLATE_DEFAULT: ICoordinate2D;
+export declare const UNIT_LABELS: {
+    feet: string;
+    meter: string;
+    inch: string;
+    cm: string;
+};
+export declare const UNIT_FACTORS: {
+    cm: number;
+    meter: number;
+    feet: number;
+    inch: number;
+};
+export declare const FEATURE_LABELS: {
+    windows: string;
+    doors: string;
+    openings: string;
+};
+export declare const VALIDATION_CONFIG_DEFAULT: IWallsValidationConfig;
+export declare const FEATURE_LENGTH = 120;
+export declare const UI_ANCHOR_DISTANCE = -60;
+export declare const WALL_SNAP_DISTANCE = 12;

package/dist/hooks/useSpaces/constants.js

@@ -0,0 +1,105 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WALL_SNAP_DISTANCE = exports.UI_ANCHOR_DISTANCE = exports.FEATURE_LENGTH = exports.VALIDATION_CONFIG_DEFAULT = exports.FEATURE_LABELS = exports.UNIT_FACTORS = exports.UNIT_LABELS = exports.TRANSLATE_DEFAULT = exports.TRANSLATE_MIN = exports.TRANSLATE_MAX = exports.ZOOM_SENSITIVITY = exports.ZOOM_DEFAULT = exports.ZOOM_MIN = exports.ZOOM_MAX = exports.SNAP_PROXIMITY = exports.SCALE = exports.ATTRIBUTE_NAME_DEFAULTS = exports.DoorOpeningDirections = exports.DoorOrientations = exports.WallMetadata = void 0;
+var types_1 = require("./types");
+var SpacesAttributes;
+(function (SpacesAttributes) {
+    SpacesAttributes["WALLS"] = "_tkSpace_walls";
+    SpacesAttributes["WINDOWS"] = "_tkSpace_windows";
+    SpacesAttributes["DOORS"] = "_tkSpace_doors";
+    SpacesAttributes["OPENINGS"] = "_tkSpace_openings";
+})(SpacesAttributes || (SpacesAttributes = {}));
+var WallAttributes;
+(function (WallAttributes) {
+    WallAttributes["START_X"] = "_tkSpace_startX";
+    WallAttributes["START_Y"] = "_tkSpace_startY";
+    WallAttributes["START_Z"] = "_tkSpace_startZ";
+    WallAttributes["END_X"] = "_tkSpace_endX";
+    WallAttributes["END_Y"] = "_tkSpace_endY";
+    WallAttributes["END_Z"] = "_tkSpace_endZ";
+    WallAttributes["CONNECTIONS"] = "_tkSpace_connections";
+    WallAttributes["WALL_HEIGHT"] = "_tkSpace_wallHeight";
+    WallAttributes["WALL_THICKNESS"] = "_tkSpace_wallThickness";
+})(WallAttributes || (WallAttributes = {}));
+var WallMetadata;
+(function (WallMetadata) {
+    WallMetadata["MIN_LENGTH"] = "_tkSpace_minLength";
+    WallMetadata["PADDING"] = "_tkSpace_padding";
+})(WallMetadata = exports.WallMetadata || (exports.WallMetadata = {}));
+var FeatureAttributes;
+(function (FeatureAttributes) {
+    FeatureAttributes["POSITION_X"] = "_tkSpace_offsetX";
+    FeatureAttributes["POSITION_Y"] = "_tkSpace_offsetY";
+    FeatureAttributes["CONNECTED_TO"] = "_tkSpace_connectedTo";
+    FeatureAttributes["FEATURE_HEIGHT"] = "_tkSpace_featureHeight";
+    FeatureAttributes["FEATURE_LENGTH"] = "_tkSpace_featureWidth";
+})(FeatureAttributes || (FeatureAttributes = {}));
+var DoorAttributes;
+(function (DoorAttributes) {
+    DoorAttributes["ORIENTATION"] = "_tkSpace_doorOrientation";
+    DoorAttributes["OPENING_DIRECTION"] = "_tkSpace_doorOpeningDirection";
+})(DoorAttributes || (DoorAttributes = {}));
+var DoorOrientations;
+(function (DoorOrientations) {
+    DoorOrientations["LEFT"] = "Left";
+    DoorOrientations["RIGHT"] = "Right";
+})(DoorOrientations = exports.DoorOrientations || (exports.DoorOrientations = {}));
+var DoorOpeningDirections;
+(function (DoorOpeningDirections) {
+    DoorOpeningDirections["INSIDE"] = "inside";
+    DoorOpeningDirections["OUTSIDE"] = "outside";
+})(DoorOpeningDirections = exports.DoorOpeningDirections || (exports.DoorOpeningDirections = {}));
+exports.ATTRIBUTE_NAME_DEFAULTS = (_a = {},
+    _a[types_1.IElements.WALL] = SpacesAttributes.WALLS,
+    _a[types_1.IElements.WINDOW] = SpacesAttributes.WINDOWS,
+    _a[types_1.IElements.OPENING] = SpacesAttributes.OPENINGS,
+    _a[types_1.IElements.DOOR] = SpacesAttributes.DOORS,
+    _a.featurePositionX = FeatureAttributes.POSITION_X,
+    _a.featurePositionY = FeatureAttributes.POSITION_Y,
+    _a.featureConnectedTo = FeatureAttributes.CONNECTED_TO,
+    _a.featureHeight = FeatureAttributes.FEATURE_HEIGHT,
+    _a.featureLength = FeatureAttributes.FEATURE_LENGTH,
+    _a.wallStartX = WallAttributes.START_X,
+    _a.wallStartY = WallAttributes.START_Y,
+    _a.wallStartZ = WallAttributes.START_Z,
+    _a.wallEndX = WallAttributes.END_X,
+    _a.wallEndY = WallAttributes.END_Y,
+    _a.wallEndZ = WallAttributes.END_Z,
+    _a.wallConnections = WallAttributes.CONNECTIONS,
+    _a.doorOrientation = DoorAttributes.ORIENTATION,
+    _a.doorOpeningDirection = DoorAttributes.OPENING_DIRECTION,
+    _a);
+exports.SCALE = 0.02;
+exports.SNAP_PROXIMITY = 16;
+exports.ZOOM_MAX = 100;
+exports.ZOOM_MIN = 20;
+exports.ZOOM_DEFAULT = 40;
+exports.ZOOM_SENSITIVITY = 0.8;
+exports.TRANSLATE_MAX = [-400, -400];
+exports.TRANSLATE_MIN = [400, 400];
+exports.TRANSLATE_DEFAULT = [-200, -200];
+exports.UNIT_LABELS = (_b = {},
+    _b[types_1.IUnits.FEET] = 'ft',
+    _b[types_1.IUnits.METER] = 'm',
+    _b[types_1.IUnits.INCH] = 'in',
+    _b[types_1.IUnits.CM] = 'cm',
+    _b);
+exports.UNIT_FACTORS = (_c = {},
+    _c[types_1.IUnits.CM] = 100,
+    _c[types_1.IUnits.METER] = 1,
+    _c[types_1.IUnits.FEET] = 3.28084,
+    _c[types_1.IUnits.INCH] = 39.37,
+    _c);
+exports.FEATURE_LABELS = (_d = {},
+    _d[types_1.IElements.WINDOW] = 'Window',
+    _d[types_1.IElements.DOOR] = 'Door',
+    _d[types_1.IElements.OPENING] = 'Opening',
+    _d);
+exports.VALIDATION_CONFIG_DEFAULT = {
+    padding: 0.2,
+    minLength: 0.5,
+};
+exports.FEATURE_LENGTH = 120;
+exports.UI_ANCHOR_DISTANCE = -60;
+exports.WALL_SNAP_DISTANCE = 12;

package/dist/hooks/{useRoomBuilder → useSpaces}/dataHandlers.d.ts

@@ -1,12 +1,14 @@
-import type { IWalls, IRoomBuilderStateProps, IVerticesState, IFeatures } from './types';
+import type { IWalls, ISpacesStateProps, IVerticesState, IFeatures, IWallsValidationConfig, IAttributeDefaults } from './types';
 import { IUnits } from './types';
 import type { IConfiguration, IHydratedAttribute } from '../../types';
-export declare function prepAttributesIncoming(attributes: Record<string, IHydratedAttribute>, config: IRoomBuilderStateProps): {
-    features: IFeatures;
+export declare function prepAttributesIncoming(attributes: Record<string, IHydratedAttribute>, config: ISpacesStateProps): {
+    validationConfig: IWallsValidationConfig;
+    features: {};
     walls: IWalls;
     vertex: IVerticesState;
 };
-export declare function prepAttributesOutgoing(walls: IWalls, features: IFeatures, config: IRoomBuilderStateProps): {
+export declare function getAttributeDefaults(attributes: Record<string, IHydratedAttribute>, config: ISpacesStateProps): IAttributeDefaults;
+export declare function prepAttributesOutgoing(walls: IWalls, features: IFeatures, config: ISpacesStateProps): {
     [x: string]: import("../../types").IConfigurationAttribute | {
         assetId: string;
         configuration: IConfiguration;

package/dist/hooks/{useRoomBuilder → useSpaces}/dataHandlers.js

@@ -11,10 +11,21 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepAreaForUser = exports.prepLengthForUser = exports.convertAreaUnit = exports.convertLengthUnit = exports.prepAttributesOutgoing = exports.prepAttributesIncoming = void 0;
+exports.prepAreaForUser = exports.prepLengthForUser = exports.convertAreaUnit = exports.convertLengthUnit = exports.prepAttributesOutgoing = exports.getAttributeDefaults = exports.prepAttributesIncoming = void 0;
 var types_1 = require("./types");
 var constants_1 = require("./constants");
 var geometry_1 = require("./geometry");
+function filterRestConfiguration(configuration, attributeNames) {
+    var keysToFilter = new Set(Object.values(attributeNames));
+    var filteredConfiguration = Object.entries(configuration).reduce(function (output, _a) {
+        var _b;
+        var key = _a[0], value = _a[1];
+        if (keysToFilter.has(key))
+            return output;
+        return Object.assign(output, (_b = {}, _b[key] = value, _b));
+    }, {});
+    return filteredConfiguration;
+}
 function prepConnectionOutgoing(connection) {
     return "".concat(connection[0], ".").concat(connection[1]);
 }
@@ -26,15 +37,16 @@ function prepWallsAndVerticesIncoming(wallsAttribute, config) {
     var _a;
     var walls = [];
     var vertices = {};
+    var attributeName = config.attributes;
     ((wallsAttribute === null || wallsAttribute === void 0 ? void 0 : wallsAttribute.value) || []).forEach(function (_a, i) {
         var assetId = _a.assetId, configuration = _a.configuration;
         var point1 = [
-            (configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IWallAttributes.START_X]) / config.config.scale,
-            (configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IWallAttributes.START_Z]) / config.config.scale,
+            (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.wallStartX]) / config.config.scale,
+            (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.wallStartZ]) / config.config.scale,
         ];
         var point2 = [
-            (configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IWallAttributes.END_X]) / config.config.scale,
-            (configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IWallAttributes.END_Z]) / config.config.scale,
+            (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.wallEndX]) / config.config.scale,
+            (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.wallEndZ]) / config.config.scale,
         ];
         var point1Str = JSON.stringify(point1);
         var point2Str = JSON.stringify(point2);
@@ -51,66 +63,119 @@ function prepWallsAndVerticesIncoming(wallsAttribute, config) {
             assetId: assetId,
             line: [point1, point2],
             path: (0, geometry_1.addThicknessToLine)([point1, point2], config.config.styles.wall.thickness),
-            height: configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IWallAttributes.HEIGHT],
-            thickness: configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IWallAttributes.THICKNESS],
             connections: connections,
+            restConfiguration: JSON.stringify(filterRestConfiguration(configuration, config.attributes)),
         });
     });
     return _a = {}, _a[types_1.IElements.WALL] = walls, _a[types_1.IElements.VERTEX] = vertices, _a;
 }
-function prepFeatureIncoming(walls, featureAttribute, config) {
+function getWallsVaidationConfig(wallsAttribute, config) {
+    var _a, _b;
+    var metadata = (wallsAttribute === null || wallsAttribute === void 0 ? void 0 : wallsAttribute.values[0].metadata) || {};
+    var validation = {
+        minLength: ((_a = metadata[constants_1.WallMetadata.MIN_LENGTH]) !== null && _a !== void 0 ? _a : constants_1.VALIDATION_CONFIG_DEFAULT.minLength) / config.config.scale,
+        padding: ((_b = metadata[constants_1.WallMetadata.PADDING]) !== null && _b !== void 0 ? _b : constants_1.VALIDATION_CONFIG_DEFAULT.padding) / config.config.scale,
+    };
+    return validation;
+}
+function prepFeatureIncoming(type, walls, featureAttribute, config) {
     var _a;
+    var attributeName = config.attributes;
     var feature = [];
     (_a = featureAttribute === null || featureAttribute === void 0 ? void 0 : featureAttribute.value) === null || _a === void 0 ? void 0 : _a.forEach(function (_a) {
         var assetId = _a.assetId, configuration = _a.configuration;
-        var offset = (configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IFeatureAttribute.POSITION_X]) / config.config.scale;
-        var length = (configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IFeatureAttribute.LENGTH]) / config.config.scale ||
-            constants_1.FEATURE_LENGTH;
-        var connectedTo = (configuration === null || configuration === void 0 ? void 0 : configuration[constants_1.IFeatureAttribute.CONNECTED_TO]) || '';
+        var offset = (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.featurePositionX]) / config.config.scale;
+        var length = (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.featureLength]) / config.config.scale;
+        var height = (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.featureHeight]) / config.config.scale;
+        var altitude = (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.featurePositionY]) / config.config.scale;
+        var connectedTo = (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.featureConnectedTo]) || '';
         var wallIndex = prepConnectionIncoming(connectedTo)[1];
         var featureLine = (0, geometry_1.getLineAtOffsetOnLineSegment)(walls[wallIndex].line, offset, length);
-        var path = (0, geometry_1.addThicknessToLine)(featureLine, config.config.styles.feature.thickness);
-        feature.push({
+        var element = {
             assetId: assetId,
             offset: offset,
             length: length,
-            path: path,
+            height: height,
+            altitude: altitude,
             connectedTo: [types_1.IElements.WALL, wallIndex],
-        });
+            path: (0, geometry_1.addThicknessToLine)(featureLine, config.config.styles.feature.thickness),
+            restConfiguration: JSON.stringify(filterRestConfiguration(configuration, config.attributes)),
+        };
+        if (type === types_1.IElements.DOOR) {
+            element.orientation =
+                (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.doorOrientation]) || constants_1.DoorOrientations.LEFT;
+            element.openingDirection =
+                (configuration === null || configuration === void 0 ? void 0 : configuration[attributeName.doorOpeningDirection]) ||
+                    constants_1.DoorOpeningDirections.INSIDE;
+        }
+        feature.push(element);
     });
     return feature;
 }
 function prepAttributesIncoming(attributes, config) {
     var _a;
-    var featuresList = [types_1.IElements.WINDOW, types_1.IElements.DOOR, types_1.IElements.OPENING];
-    var wallsAndVertices = prepWallsAndVerticesIncoming(attributes[config.attributes[types_1.IElements.WALL]], config);
+    var wallsAttribute = attributes[config.attributes[types_1.IElements.WALL]];
+    var wallsAndVertices = prepWallsAndVerticesIncoming(wallsAttribute, config);
+    var wallsValidation = getWallsVaidationConfig(wallsAttribute, config);
+    var featuresList = [
+        types_1.IElements.WINDOW,
+        types_1.IElements.DOOR,
+        types_1.IElements.OPENING,
+    ];
     var featuresData = featuresList.reduce(function (output, type) {
-        output[type] = prepFeatureIncoming(wallsAndVertices[types_1.IElements.WALL], attributes[config.attributes[type]], config);
+        output[type] = prepFeatureIncoming(type, wallsAndVertices[types_1.IElements.WALL], attributes[config.attributes[type]], config);
         return output;
     }, {});
-    return __assign(__assign({}, wallsAndVertices), (_a = {}, _a[types_1.IElements.FEATURE] = featuresData, _a));
+    return __assign(__assign({}, wallsAndVertices), (_a = { validationConfig: wallsValidation }, _a[types_1.IElements.FEATURE] = featuresData, _a));
 }
 exports.prepAttributesIncoming = prepAttributesIncoming;
-function prepFeaturesOutgoing(features, config) {
+function getAttributeDefaults(attributes, config) {
+    return [
+        types_1.IElements.WALL,
+        types_1.IElements.WINDOW,
+        types_1.IElements.DOOR,
+        types_1.IElements.OPENING,
+    ].reduce(function (output, elementName) {
+        var _a;
+        if (!config.attributes[elementName])
+            return output;
+        var attribute = attributes[config.attributes[elementName]];
+        if (!attribute)
+            return output;
+        return Object.assign(output, (_a = {},
+            _a[elementName] = attribute.values[0].assetId,
+            _a));
+    }, {});
+}
+exports.getAttributeDefaults = getAttributeDefaults;
+function prepFeaturesOutgoing(type, features, config) {
+    var attributeName = config.attributes;
     return features.map(function (feature) {
         var _a, _b;
-        var assetId = feature.assetId, offset = feature.offset, length = feature.length;
+        var assetId = feature.assetId, offset = feature.offset, length = feature.length, height = feature.height, altitude = feature.altitude, restConfiguration = feature.restConfiguration;
         var connectedTo = prepConnectionOutgoing([
             config.attributes[feature.connectedTo[0]],
             feature.connectedTo[1],
         ]);
-        var configuration = Object.entries((_a = {},
-            _a[constants_1.IFeatureAttribute.LENGTH] = length,
-            _a[constants_1.IFeatureAttribute.POSITION_X] = offset,
-            _a)).reduce(function (output, _a) {
+        var configurationToScale = (_a = {},
+            _a[attributeName.featureLength] = length,
+            _a[attributeName.featurePositionX] = offset,
+            _a);
+        if (altitude)
+            configurationToScale[attributeName.featurePositionY] = altitude;
+        if (height)
+            configurationToScale[attributeName.featureHeight] = height;
+        var configuration = Object.entries(configurationToScale).reduce(function (output, _a) {
             var _b;
             var key = _a[0], value = _a[1];
             return Object.assign(output, (_b = {},
                 _b[key] = value ? value * config.config.scale : value,
                 _b));
-        }, (_b = {},
-            _b[constants_1.IFeatureAttribute.CONNECTED_TO] = connectedTo,
-            _b));
+        }, __assign((_b = {}, _b[attributeName.featureConnectedTo] = connectedTo, _b), JSON.parse(restConfiguration)));
+        if (type === types_1.IElements.DOOR) {
+            configuration[attributeName.doorOrientation] = feature.orientation;
+            configuration[attributeName.doorOpeningDirection] = feature.openingDirection;
+        }
         return {
             assetId: assetId,
             configuration: configuration,
@@ -118,9 +183,10 @@ function prepFeaturesOutgoing(features, config) {
     });
 }
 function prepWallsOutgoing(walls, config) {
+    var attributeName = config.attributes;
     return walls.map(function (wall) {
         var _a, _b;
-        var line = wall.line, height = wall.height, thickness = wall.thickness;
+        var line = wall.line, restConfiguration = wall.restConfiguration;
         var connections = wall.connections.map(function (connection) {
             var attributeName = config.attributes[connection[0]];
             if (!attributeName)
@@ -129,21 +195,17 @@ function prepWallsOutgoing(walls, config) {
         });
         var _c = line.flat(), x1 = _c[0], y1 = _c[1], x2 = _c[2], y2 = _c[3];
         var configuration = Object.entries((_a = {},
-            _a[constants_1.IWallAttributes.START_X] = x1,
-            _a[constants_1.IWallAttributes.START_Z] = y1,
-            _a[constants_1.IWallAttributes.END_X] = x2,
-            _a[constants_1.IWallAttributes.END_Z] = y2,
-            _a[constants_1.IWallAttributes.HEIGHT] = height,
-            _a[constants_1.IWallAttributes.THICKNESS] = thickness,
+            _a[attributeName.wallStartX] = x1,
+            _a[attributeName.wallStartZ] = y1,
+            _a[attributeName.wallEndX] = x2,
+            _a[attributeName.wallEndZ] = y2,
             _a)).reduce(function (output, _a) {
             var _b;
             var key = _a[0], value = _a[1];
             return Object.assign(output, (_b = {},
                 _b[key] = value ? value * config.config.scale : value,
                 _b));
-        }, (_b = {},
-            _b[constants_1.IWallAttributes.CONNECTIONS] = JSON.stringify(connections),
-            _b));
+        }, __assign((_b = {}, _b[attributeName.wallConnections] = JSON.stringify(connections), _b), JSON.parse(restConfiguration)));
         return {
             assetId: wall.assetId,
             configuration: configuration,
@@ -158,7 +220,7 @@ function prepAttributesOutgoing(walls, features, config) {
         var attributeName = config.attributes[type];
         if (!attributeName)
             return output;
-        output[attributeName] = prepFeaturesOutgoing(features, config);
+        output[attributeName] = prepFeaturesOutgoing(type, features, config);
         return output;
     }, {});
     return __assign(__assign({}, featuresAttributes), (_a = {}, _a[config.attributes[types_1.IElements.WALL]] = wallsAttribute, _a));
@@ -175,8 +237,8 @@ exports.convertAreaUnit = convertAreaUnit;
 function prepLengthForUser(value, unit) {
     if (unit === types_1.IUnits.FEET) {
         var feet = Math.floor(value);
-        var inches = 1.2 * (value % 1);
-        return "".concat(feet).concat(constants_1.UNIT_LABELS[types_1.IUnits.FEET], " ").concat(inches.toFixed(2)).concat(constants_1.UNIT_LABELS[types_1.IUnits.INCH]);
+        var inches = 12 * (value % 1);
+        return "".concat(feet).concat(constants_1.UNIT_LABELS[types_1.IUnits.FEET], " ").concat(inches.toFixed(1)).concat(constants_1.UNIT_LABELS[types_1.IUnits.INCH]);
     }
     return "".concat(value.toFixed(2), " ").concat(constants_1.UNIT_LABELS[unit]);
 }

package/dist/hooks/useSpaces/draw/clearCanvas.d.ts

@@ -0,0 +1,2 @@
+declare function clearCanvas(canvas: HTMLCanvasElement): void;
+export default clearCanvas;

package/dist/hooks/useSpaces/draw/clearCanvas.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function clearCanvas(canvas) {
+    var ctx = canvas.getContext('2d');
+    if (!ctx)
+        return;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+}
+exports.default = clearCanvas;

package/dist/hooks/useSpaces/draw/drawBackground.d.ts

@@ -0,0 +1,2 @@
+declare function drawBackground(canvas: HTMLCanvasElement, color?: string): void;
+export default drawBackground;

package/dist/hooks/useSpaces/draw/drawBackground.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function drawBackground(canvas, color) {
+    if (!color)
+        return;
+    var ctx = canvas.getContext('2d');
+    if (!ctx)
+        return;
+    ctx.fillStyle = color;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+}
+exports.default = drawBackground;

package/dist/hooks/useSpaces/draw/drawDimensions.d.ts

@@ -0,0 +1,3 @@
+import { ICoordinatesLine, ILineDimensions, ISpacesConfigInternal, IStylesDimension } from '../types';
+export declare function drawDimension(canvas: HTMLCanvasElement, line: ICoordinatesLine, styles: IStylesDimension, message: string): void;
+export declare function drawDimensions(canvas: HTMLCanvasElement, dimensions: Array<ILineDimensions>, config: ISpacesConfigInternal): void;

package/dist/hooks/useSpaces/draw/drawDimensions.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawDimensions = exports.drawDimension = void 0;
+var geometry_1 = require("../geometry");
+function drawDimension(canvas, line, styles, message) {
+    var ctx = canvas.getContext('2d');
+    if (!ctx)
+        return;
+    var dimensionsBoxHeight = styles.fontSize + 6;
+    var dimensionsHeight = dimensionsBoxHeight + 6;
+    var line1 = (0, geometry_1.getParallelLineSegmentAtDistance)(line, styles.padding);
+    var line2 = (0, geometry_1.getParallelLineSegmentAtDistance)(line, styles.padding + dimensionsHeight / 2);
+    var line3 = (0, geometry_1.getParallelLineSegmentAtDistance)(line, styles.padding + dimensionsHeight);
+    var textLine = (0, geometry_1.getParallelLineSegmentAtDistance)(line, styles.padding + dimensionsHeight / 3);
+    var textCoordinates = (0, geometry_1.getMidpointOfLineSegment)(textLine);
+    var textAngle = (0, geometry_1.getAngleOfLineSegment)(textLine);
+    if (2 < textAngle || textAngle < -2)
+        textAngle += Math.PI;
+    ctx.strokeStyle = styles.lineColor;
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    ctx.moveTo.apply(ctx, line2[0]);
+    ctx.lineTo.apply(ctx, line2[1]);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo.apply(ctx, line1[0]);
+    ctx.lineTo.apply(ctx, line3[0]);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo.apply(ctx, line1[1]);
+    ctx.lineTo.apply(ctx, line3[1]);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.font = "".concat(styles.fontSize, "px ").concat(styles.font);
+    ctx.font = "".concat(styles.fontSize, "px ").concat(styles.font);
+    ctx.translate.apply(ctx, textCoordinates);
+    ctx.rotate(textAngle);
+    ctx.fillStyle = styles.textBackgroundColor;
+    var textWidth = ctx.measureText(message).width + 12;
+    ctx.fillRect(-(textWidth / 2), -((dimensionsBoxHeight * 3) / 4), textWidth, dimensionsBoxHeight);
+    ctx.fillStyle = styles.textColor;
+    ctx.textAlign = 'center';
+    ctx.fillText(message, 0, 0);
+    ctx.resetTransform();
+}
+exports.drawDimension = drawDimension;
+function drawDimensions(canvas, dimensions, config) {
+    dimensions.forEach(function (_a) {
+        var line = _a.line, label = _a.label;
+        drawDimension(canvas, line, config.styles.dimensions, label);
+    });
+}
+exports.drawDimensions = drawDimensions;

package/dist/hooks/useSpaces/draw/drawDoors.d.ts

@@ -0,0 +1,9 @@
+import { IFeatureDoor, ISpacesStyles } from '../types';
+import { IWallToDraw } from './drawWalls';
+declare function drawDoors(canvas: HTMLCanvasElement, walls: Array<IWallToDraw>, doors: Array<IFeatureDoor>, selections: {
+    active: Array<number>;
+    highlighted: Array<number>;
+    error: Array<number>;
+    hidden: Array<number>;
+}, styles: ISpacesStyles): void;
+export default drawDoors;

package/dist/hooks/useSpaces/draw/drawDoors.js

@@ -0,0 +1,93 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var constants_1 = require("../constants");
+var geometry_1 = require("../geometry");
+var types_1 = require("../types");
+function drawDoor(canvas, wall, offset, length, openingDirection, orientation, style, mode) {
+    var ctx = canvas.getContext('2d');
+    if (!ctx)
+        return;
+    var doorLine = (0, geometry_1.getLineAtOffsetOnLineSegment)(wall.line, offset, length);
+    var points = (0, geometry_1.addThicknessToLine)(doorLine, style.thickness);
+    var angle = (0, geometry_1.getAngleOfLineSegment)(doorLine);
+    var stroke = style.stroke, fill = style.fill, strokeWidth = style.strokeWidth;
+    if (mode) {
+        stroke = style[mode].stroke;
+        fill = style[mode].fill;
+    }
+    ctx.beginPath();
+    ctx.strokeStyle = stroke || fill;
+    ctx.lineWidth = 2;
+    if (openingDirection === constants_1.DoorOpeningDirections.INSIDE) {
+        if (orientation === constants_1.DoorOrientations.LEFT) {
+            ctx.moveTo.apply(ctx, points[0]);
+            ctx.arc.apply(ctx, __spreadArray(__spreadArray([], points[0], false), [length, angle - Math.PI / 2, angle], false));
+        }
+        else {
+            ctx.moveTo.apply(ctx, points[1]);
+            ctx.arc.apply(ctx, __spreadArray(__spreadArray([], points[1], false), [length, angle - Math.PI / 2, angle - Math.PI, true], false));
+        }
+    }
+    else {
+        if (orientation === constants_1.DoorOrientations.LEFT) {
+            ctx.moveTo.apply(ctx, points[2]);
+            ctx.arc.apply(ctx, __spreadArray(__spreadArray([], points[2], false), [length, angle + Math.PI / 2, angle + Math.PI], false));
+        }
+        else {
+            ctx.moveTo.apply(ctx, points[3]);
+            ctx.arc.apply(ctx, __spreadArray(__spreadArray([], points[3], false), [length, angle + Math.PI / 2, angle, true], false));
+        }
+    }
+    ctx.stroke();
+    ctx.strokeStyle = stroke || fill;
+    ctx.fillStyle = fill;
+    ctx.lineWidth = strokeWidth || 1;
+    ctx.beginPath();
+    ctx.moveTo.apply(ctx, points[0]);
+    for (var i = 1; i < points.length; i++) {
+        ctx.lineTo.apply(ctx, points[i]);
+    }
+    ctx.lineTo.apply(ctx, points[0]);
+    ctx.fill();
+    if (style.stroke)
+        ctx.stroke();
+}
+function drawDoors(canvas, walls, doors, selections, styles) {
+    var styled = [
+        selections.active,
+        selections.highlighted,
+        selections.error,
+        selections.hidden,
+    ];
+    var defaultOpenings = doors.reduce(function (output, _, i) {
+        if (!styled.flat().includes(i))
+            output.push(i);
+        return output;
+    }, []);
+    var doorsMap = [
+        [types_1.IElementStyleModes.ACTIVE, selections.active],
+        [types_1.IElementStyleModes.HIGHLIGHT, selections.highlighted],
+        [types_1.IElementStyleModes.ERROR, selections.error],
+        [undefined, defaultOpenings],
+    ];
+    doorsMap.forEach(function (_a) {
+        var mode = _a[0], doorsIndexes = _a[1];
+        return doorsIndexes.forEach(function (index) {
+            var door = doors[index];
+            if (!(door === null || door === void 0 ? void 0 : door.connectedTo.length))
+                return;
+            var wallIndex = door.connectedTo[1];
+            drawDoor(canvas, walls[wallIndex], door.offset, door.length, door.openingDirection, door.orientation, styles.feature, mode);
+        });
+    });
+}
+exports.default = drawDoors;

package/dist/hooks/useSpaces/draw/drawFloor.d.ts

@@ -0,0 +1,3 @@
+import { IEnclosedSpace, IStylesFloor } from '../types';
+export declare function drawFloor(canvas: HTMLCanvasElement, enclosedSpaces: Array<IEnclosedSpace>, styles: IStylesFloor): void;
+export declare function drawFloorArea(canvas: HTMLCanvasElement, enclosedSpaces: Array<IEnclosedSpace>, styles: IStylesFloor): void;

package/dist/hooks/useSpaces/draw/drawFloor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawFloorArea = exports.drawFloor = void 0;
+function drawFloor(canvas, enclosedSpaces, styles) {
+    var ctx = canvas.getContext('2d');
+    if (!ctx)
+        return;
+    if (!enclosedSpaces.length)
+        return;
+    for (var _i = 0, enclosedSpaces_1 = enclosedSpaces; _i < enclosedSpaces_1.length; _i++) {
+        var enclosedSpace = enclosedSpaces_1[_i];
+        var loop = enclosedSpace.loop;
+        ctx.fillStyle = styles.color;
+        ctx.beginPath();
+        ctx.moveTo.apply(ctx, loop[0]);
+        for (var i = 1; i < loop.length; i++)
+            ctx.lineTo.apply(ctx, loop[i]);
+        ctx.fill();
+    }
+}
+exports.drawFloor = drawFloor;
+function drawFloorArea(canvas, enclosedSpaces, styles) {
+    var ctx = canvas.getContext('2d');
+    if (!ctx)
+        return;
+    if (!enclosedSpaces.length)
+        return;
+    for (var _i = 0, enclosedSpaces_2 = enclosedSpaces; _i < enclosedSpaces_2.length; _i++) {
+        var enclosedSpace = enclosedSpaces_2[_i];
+        var center = enclosedSpace.center, area = enclosedSpace.area;
+        ctx.font = '20px Arial';
+        ctx.fillStyle = styles.textColor;
+        ctx.fillText(area, center[0], center[1]);
+    }
+}
+exports.drawFloorArea = drawFloorArea;

package/dist/hooks/useSpaces/draw/drawGrid.d.ts

@@ -0,0 +1,3 @@
+import { IGridToDraw, IStylesGrid } from '../types';
+declare function drawGrid(canvas: HTMLCanvasElement, grid: IGridToDraw, styles: IStylesGrid): void;
+export default drawGrid;