@threekit-tools/treble 0.0.93 → 0.0.94-next-01

package/dist/hooks/useSpaces/types.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDimensionOptions = exports.IUnits = exports.IModes = exports.IErrorTypes = exports.GUIDE_ORIENTATIONS = exports.SNAPPING_TYPES = exports.IElementStyleModes = exports.IElements = void 0;
+var IElements;
+(function (IElements) {
+    IElements["WALL"] = "walls";
+    IElements["VERTEX"] = "vertex";
+    IElements["FEATURE"] = "features";
+    IElements["WINDOW"] = "windows";
+    IElements["DOOR"] = "doors";
+    IElements["OPENING"] = "openings";
+})(IElements = exports.IElements || (exports.IElements = {}));
+var IElementStyleModes;
+(function (IElementStyleModes) {
+    IElementStyleModes["HIGHLIGHT"] = "highlight";
+    IElementStyleModes["ACTIVE"] = "active";
+    IElementStyleModes["ERROR"] = "error";
+})(IElementStyleModes = exports.IElementStyleModes || (exports.IElementStyleModes = {}));
+var SNAPPING_TYPES;
+(function (SNAPPING_TYPES) {
+    SNAPPING_TYPES["NONE"] = "none";
+    SNAPPING_TYPES["ANGLE"] = "angle";
+    SNAPPING_TYPES["GUIDE"] = "guide";
+    SNAPPING_TYPES["GRID"] = "grid";
+})(SNAPPING_TYPES = exports.SNAPPING_TYPES || (exports.SNAPPING_TYPES = {}));
+var GUIDE_ORIENTATIONS;
+(function (GUIDE_ORIENTATIONS) {
+    GUIDE_ORIENTATIONS["HORIZONTAL"] = "horizontal";
+    GUIDE_ORIENTATIONS["VERTICAL"] = "vertical";
+})(GUIDE_ORIENTATIONS = exports.GUIDE_ORIENTATIONS || (exports.GUIDE_ORIENTATIONS = {}));
+var IErrorTypes;
+(function (IErrorTypes) {
+    IErrorTypes["HARD"] = "hard";
+    IErrorTypes["SOFT"] = "soft";
+    IErrorTypes["WARN"] = "warning";
+})(IErrorTypes = exports.IErrorTypes || (exports.IErrorTypes = {}));
+var IModes;
+(function (IModes) {
+    IModes["SELECT"] = "select";
+    IModes["DRAW"] = "draw";
+})(IModes = exports.IModes || (exports.IModes = {}));
+var IUnits;
+(function (IUnits) {
+    IUnits["FEET"] = "feet";
+    IUnits["METER"] = "meter";
+    IUnits["INCH"] = "inch";
+    IUnits["CM"] = "cm";
+})(IUnits = exports.IUnits || (exports.IUnits = {}));
+var IDimensionOptions;
+(function (IDimensionOptions) {
+    IDimensionOptions["NONE"] = "none";
+    IDimensionOptions["DEFAULT"] = "default";
+    IDimensionOptions["DETAILED"] = "detailed";
+})(IDimensionOptions = exports.IDimensionOptions || (exports.IDimensionOptions = {}));

package/dist/hooks/useSpaces/validators/areWallsDuplicated.d.ts

@@ -0,0 +1,3 @@
+import type { IErrorElement, IMoveVertexValidatorInput, ISharedValidatorInput } from '../types';
+declare function areWallsDuplicated(input: IMoveVertexValidatorInput, wallAndFeatures: ISharedValidatorInput): false | IErrorElement;
+export default areWallsDuplicated;

package/dist/hooks/useSpaces/validators/areWallsDuplicated.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function areWallsDuplicated(input, wallAndFeatures) {
+    var vertex = input.vertex, updatedPosition = input.updatedPosition;
+    var walls = wallAndFeatures.walls;
+    var point = updatedPosition.point;
+    var _a = vertex.connections.reduce(function (output, connection) {
+        var _a;
+        var wallIndex = connection[0], vertexIndex = connection[1];
+        output.wallIndexes.add(wallIndex);
+        output.updatedVerticesMap = Object.assign(output.updatedVerticesMap, (_a = {},
+            _a[wallIndex] = vertexIndex,
+            _a));
+        return output;
+    }, {
+        wallIndexes: new Set([]),
+        updatedVerticesMap: {},
+    }), wallIndexes = _a.wallIndexes, updatedVerticesMap = _a.updatedVerticesMap;
+    for (var _i = 0, _b = Array.from(wallIndexes); _i < _b.length; _i++) {
+        var wallIdx = _b[_i];
+        var wall = walls[wallIdx];
+        var updatedLine = JSON.parse(JSON.stringify(wall.line));
+        updatedLine[updatedVerticesMap[wallIdx]] = point;
+        if ((updatedPosition === null || updatedPosition === void 0 ? void 0 : updatedPosition.type) === types_1.IElements.WALL &&
+            updatedPosition.index !== wallIdx) {
+            var _c = walls[updatedPosition.index].line, xTest = _c[0], yTest = _c[1];
+            var unmovedPoint = updatedLine[updatedVerticesMap[wallIdx] === 1 ? 0 : 1];
+            if ((0, geometry_1.arePointsEqual)(unmovedPoint, xTest) ||
+                (0, geometry_1.arePointsEqual)(unmovedPoint, yTest))
+                return {
+                    address: {
+                        type: types_1.IElements.WALL,
+                        index: updatedPosition.index,
+                    },
+                    type: types_1.IErrorTypes.SOFT,
+                    message: messaging_1.errorMessages.wallsNotUnique(),
+                };
+        }
+        for (var i = 0; i < walls.length; i++) {
+            if (wallIdx === i)
+                continue;
+            var existingWall = walls[i];
+            var error = {
+                address: { type: types_1.IElements.WALL, index: i },
+                type: types_1.IErrorTypes.SOFT,
+                message: messaging_1.errorMessages.wallsNotUnique(),
+            };
+            if (((0, geometry_1.arePointsEqual)(existingWall[0], wall.line[0]) &&
+                (0, geometry_1.arePointsEqual)(existingWall[1], wall.line[1])) ||
+                ((0, geometry_1.arePointsEqual)(existingWall[0], wall.line[1]) &&
+                    (0, geometry_1.arePointsEqual)(existingWall[1], wall.line[0]))) {
+                return error;
+            }
+        }
+    }
+    return false;
+}
+exports.default = areWallsDuplicated;

package/dist/hooks/useSpaces/validators/areWallsIntersecting.d.ts

@@ -0,0 +1,3 @@
+import type { IErrorElement, IMoveVertexValidatorInput, ISharedValidatorInput } from '../types';
+declare function areWallsIntersecting(input: IMoveVertexValidatorInput, wallAndFeatures: ISharedValidatorInput): false | IErrorElement;
+export default areWallsIntersecting;

package/dist/hooks/useSpaces/validators/areWallsIntersecting.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function areWallsIntersecting(input, wallAndFeatures) {
+    var vertex = input.vertex, updatedPosition = input.updatedPosition;
+    var walls = wallAndFeatures.walls;
+    var _a = vertex.connections.reduce(function (output, connection) {
+        var _a;
+        var wallIndex = connection[0], vertexIndex = connection[1];
+        output.wallIndexes.add(wallIndex);
+        output.updatedVerticesMap = Object.assign(output.updatedVerticesMap, (_a = {},
+            _a[wallIndex] = vertexIndex,
+            _a));
+        return output;
+    }, {
+        wallIndexes: new Set([]),
+        updatedVerticesMap: {},
+    }), wallIndexes = _a.wallIndexes, updatedVerticesMap = _a.updatedVerticesMap;
+    for (var _i = 0, _b = Array.from(wallIndexes); _i < _b.length; _i++) {
+        var validateWallIndex = _b[_i];
+        var line = walls[validateWallIndex].line;
+        line[updatedVerticesMap[validateWallIndex]] = updatedPosition.point;
+        for (var i = 0; i < walls.length; i++) {
+            if (wallIndexes.has(i))
+                continue;
+            var wall = walls[i];
+            if (!wall)
+                continue;
+            var intersectionPoint = (0, geometry_1.getLineSegmentsIntersection)(line, wall.line);
+            if (intersectionPoint)
+                return {
+                    address: { type: types_1.IElements.WALL, index: i },
+                    message: messaging_1.errorMessages.addWallCollidingWithWall(),
+                    type: types_1.IErrorTypes.SOFT,
+                };
+        }
+    }
+    return false;
+}
+exports.default = areWallsIntersecting;

package/dist/hooks/useSpaces/validators/areWallsOrphaningFeatures.d.ts

@@ -0,0 +1,3 @@
+import type { IErrorElement, IMoveVertexValidatorInput, ISharedValidatorInput, IWallsValidationConfig } from '../types';
+declare function areWallsOrphaningFeatures(input: IMoveVertexValidatorInput, wallAndFeatures: ISharedValidatorInput, validationConfig: IWallsValidationConfig): false | IErrorElement;
+export default areWallsOrphaningFeatures;

package/dist/hooks/useSpaces/validators/areWallsOrphaningFeatures.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+var types_1 = require("../types");
+function areWallsOrphaningFeatures(input, wallAndFeatures, validationConfig) {
+    var _a;
+    var vertex = input.vertex, updatedPosition = input.updatedPosition;
+    var walls = wallAndFeatures.walls, features = wallAndFeatures.features;
+    var padding = validationConfig.padding;
+    var _b = vertex.connections.reduce(function (output, connection) {
+        var _a;
+        var wallIndex = connection[0], vertexIndex = connection[1];
+        output.wallIndexes.add(wallIndex);
+        output.updatedVerticesMap = Object.assign(output.updatedVerticesMap, (_a = {},
+            _a[wallIndex] = vertexIndex,
+            _a));
+        return output;
+    }, {
+        wallIndexes: new Set([]),
+        updatedVerticesMap: {},
+    }), wallIndexes = _b.wallIndexes, updatedVerticesMap = _b.updatedVerticesMap;
+    for (var _i = 0, _c = Array.from(wallIndexes); _i < _c.length; _i++) {
+        var wallIdx = _c[_i];
+        var wall = walls[wallIdx];
+        if (!wall.connections.length)
+            continue;
+        var updatedLine = JSON.parse(JSON.stringify(wall.line));
+        updatedLine[updatedVerticesMap[wallIdx]] = updatedPosition.point;
+        var currentWallLength = (0, geometry_1.getLengthOfLineSegment)(wall.line);
+        var updatedWallLength = (0, geometry_1.getLengthOfLineSegment)(updatedLine);
+        var wallLengthDelta = updatedWallLength - currentWallLength;
+        for (var i = 0; i < wall.connections.length; i++) {
+            var _d = wall.connections[i], type = _d[0], index = _d[1];
+            var feat = (_a = features[type]) === null || _a === void 0 ? void 0 : _a[index];
+            if (!feat)
+                continue;
+            var error = {
+                address: { type: type, index: index },
+                message: 'feature collision',
+                type: types_1.IErrorTypes.HARD,
+            };
+            if (updatedVerticesMap[wallIdx] === 0 &&
+                feat.offset - wallLengthDelta < padding)
+                return error;
+            else if (feat.offset + feat.length > updatedWallLength - padding) {
+                return error;
+            }
+        }
+    }
+    return false;
+}
+exports.default = areWallsOrphaningFeatures;

package/dist/hooks/useSpaces/validators/areWallsTooShort.d.ts

@@ -0,0 +1,3 @@
+import type { IErrorElement, IWallsValidationConfig, IMoveVertexValidatorInput, ISharedValidatorInput } from '../types';
+declare function areWallsTooShort(input: IMoveVertexValidatorInput, wallAndFeatures: ISharedValidatorInput, validationConfig: IWallsValidationConfig): false | IErrorElement;
+export default areWallsTooShort;

package/dist/hooks/useSpaces/validators/areWallsTooShort.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+var isLineTooShort_1 = __importDefault(require("./isLineTooShort"));
+function areWallsTooShort(input, wallAndFeatures, validationConfig) {
+    var vertex = input.vertex, updatedPosition = input.updatedPosition;
+    var walls = wallAndFeatures.walls;
+    var _a = vertex.connections.reduce(function (output, connection) {
+        var _a;
+        var wallIndex = connection[0], vertexIndex = connection[1];
+        output.wallIndexes.push(wallIndex);
+        output.updatedVerticesMap = Object.assign(output.updatedVerticesMap, (_a = {},
+            _a[wallIndex] = vertexIndex,
+            _a));
+        return output;
+    }, {
+        wallIndexes: [],
+        updatedVerticesMap: {},
+    }), wallIndexes = _a.wallIndexes, updatedVerticesMap = _a.updatedVerticesMap;
+    for (var _i = 0, wallIndexes_1 = wallIndexes; _i < wallIndexes_1.length; _i++) {
+        var index = wallIndexes_1[_i];
+        var line = walls[index].line;
+        line[updatedVerticesMap[index]] = updatedPosition.point;
+        if ((0, isLineTooShort_1.default)(line, validationConfig))
+            return {
+                address: { type: types_1.IElements.WALL, index: index },
+                message: messaging_1.errorMessages.wallTooShort(),
+                type: types_1.IErrorTypes.HARD,
+            };
+    }
+    return false;
+}
+exports.default = areWallsTooShort;

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

@@ -0,0 +1,15 @@
+import { IErrorElement, IWallsValidationConfig } from '../types';
+import { ISharedValidatorInput, IValidatorFunction } from '../types';
+import isFeatureOutsideWallBounds from './isFeatureOutsideWallBounds';
+import isFeatureCollidingWithExistingFeature from './isFeatureCollidingWithExistingFeature';
+import isWallIntersectingFeature from './isWallIntersectingFeature';
+import isWallOverlappingExisitingWalls from './isWallOverlappingExisitingWalls';
+import isWallTooShort from './isWallTooShort';
+import areWallsTooShort from './areWallsTooShort';
+import areWallsIntersecting from './areWallsIntersecting';
+import areWallsOrphaningFeatures from './areWallsOrphaningFeatures';
+import areWallsDuplicated from './areWallsDuplicated';
+import isWallEndingOnFeature from './isWallEndingOnFeature';
+import isVertexLandingOnFeature from './isVertexLandingOnFeature';
+export { isFeatureOutsideWallBounds, isFeatureCollidingWithExistingFeature, isWallIntersectingFeature, isWallOverlappingExisitingWalls, isWallTooShort, areWallsTooShort, areWallsIntersecting, areWallsOrphaningFeatures, areWallsDuplicated, isWallEndingOnFeature, isVertexLandingOnFeature, };
+export declare function runValidators<T>(validators: Array<IValidatorFunction<T>>, input: T, wallAndFeatures: ISharedValidatorInput, validationConfig: IWallsValidationConfig): IErrorElement[] | null;

package/dist/hooks/useSpaces/validators/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runValidators = exports.isVertexLandingOnFeature = exports.isWallEndingOnFeature = exports.areWallsDuplicated = exports.areWallsOrphaningFeatures = exports.areWallsIntersecting = exports.areWallsTooShort = exports.isWallTooShort = exports.isWallOverlappingExisitingWalls = exports.isWallIntersectingFeature = exports.isFeatureCollidingWithExistingFeature = exports.isFeatureOutsideWallBounds = void 0;
+var isFeatureOutsideWallBounds_1 = __importDefault(require("./isFeatureOutsideWallBounds"));
+exports.isFeatureOutsideWallBounds = isFeatureOutsideWallBounds_1.default;
+var isFeatureCollidingWithExistingFeature_1 = __importDefault(require("./isFeatureCollidingWithExistingFeature"));
+exports.isFeatureCollidingWithExistingFeature = isFeatureCollidingWithExistingFeature_1.default;
+var isWallIntersectingFeature_1 = __importDefault(require("./isWallIntersectingFeature"));
+exports.isWallIntersectingFeature = isWallIntersectingFeature_1.default;
+var isWallOverlappingExisitingWalls_1 = __importDefault(require("./isWallOverlappingExisitingWalls"));
+exports.isWallOverlappingExisitingWalls = isWallOverlappingExisitingWalls_1.default;
+var isWallTooShort_1 = __importDefault(require("./isWallTooShort"));
+exports.isWallTooShort = isWallTooShort_1.default;
+var areWallsTooShort_1 = __importDefault(require("./areWallsTooShort"));
+exports.areWallsTooShort = areWallsTooShort_1.default;
+var areWallsIntersecting_1 = __importDefault(require("./areWallsIntersecting"));
+exports.areWallsIntersecting = areWallsIntersecting_1.default;
+var areWallsOrphaningFeatures_1 = __importDefault(require("./areWallsOrphaningFeatures"));
+exports.areWallsOrphaningFeatures = areWallsOrphaningFeatures_1.default;
+var areWallsDuplicated_1 = __importDefault(require("./areWallsDuplicated"));
+exports.areWallsDuplicated = areWallsDuplicated_1.default;
+var isWallEndingOnFeature_1 = __importDefault(require("./isWallEndingOnFeature"));
+exports.isWallEndingOnFeature = isWallEndingOnFeature_1.default;
+var isVertexLandingOnFeature_1 = __importDefault(require("./isVertexLandingOnFeature"));
+exports.isVertexLandingOnFeature = isVertexLandingOnFeature_1.default;
+function runValidators(validators, input, wallAndFeatures, validationConfig) {
+    var errors = validators.reduce(function (output, validate) {
+        var error = validate(input, wallAndFeatures, validationConfig);
+        if (error)
+            output.push(error);
+        return output;
+    }, []);
+    if (errors.length)
+        return errors;
+    return null;
+}
+exports.runValidators = runValidators;

package/dist/hooks/useSpaces/validators/isFeatureCollidingWithExistingFeature.d.ts

@@ -0,0 +1,3 @@
+import type { IFeatureValidatorInput, ISharedValidatorInput, IErrorElement } from '../types';
+declare function isFeatureCollidingWithExistingFeature(input: IFeatureValidatorInput, wallAndFeatures: ISharedValidatorInput): false | IErrorElement;
+export default isFeatureCollidingWithExistingFeature;

package/dist/hooks/useSpaces/validators/isFeatureCollidingWithExistingFeature.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function isFeatureCollidingWithExistingFeature(input, wallAndFeatures) {
+    var _a, _b;
+    var wall = input.wall, updatedFeature = input.updatedFeature;
+    var features = wallAndFeatures.features;
+    if (!features || !((_a = wall.connections) === null || _a === void 0 ? void 0 : _a.length))
+        return false;
+    if (!Object.values(updatedFeature).flat().length)
+        return false;
+    for (var i = 0; i < wall.connections.length; i++) {
+        var _c = wall.connections[i], type = _c[0], index = _c[1];
+        if (updatedFeature.address.type === type &&
+            updatedFeature.address.index === index)
+            continue;
+        var existingFeature = (_b = features[type]) === null || _b === void 0 ? void 0 : _b[index];
+        if (!existingFeature)
+            continue;
+        if ((0, geometry_1.doLinesOverlap)([updatedFeature.offset, updatedFeature.length], [existingFeature.offset, existingFeature.length]))
+            return {
+                address: { type: type, index: index },
+                type: types_1.IErrorTypes.SOFT,
+                message: messaging_1.errorMessages.featuresColliding(type),
+            };
+    }
+    return false;
+}
+exports.default = isFeatureCollidingWithExistingFeature;

package/dist/hooks/useSpaces/validators/isFeatureOutsideWallBounds.d.ts

@@ -0,0 +1,3 @@
+import type { IErrorElement, IWallsValidationConfig, IFeatureValidatorInput, ISharedValidatorInput } from '../types';
+declare function isFeatureOutsideWallBounds(input: IFeatureValidatorInput, _: ISharedValidatorInput, validationConfig: IWallsValidationConfig): false | IErrorElement;
+export default isFeatureOutsideWallBounds;

package/dist/hooks/useSpaces/validators/isFeatureOutsideWallBounds.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function isFeatureOutsideWallBounds(input, _, validationConfig) {
+    var wall = input.wall, updatedFeature = input.updatedFeature;
+    var padding = validationConfig.padding;
+    var wallLength = (0, geometry_1.getLengthOfLineSegment)(wall.line);
+    if (updatedFeature.offset < padding ||
+        updatedFeature.offset + updatedFeature.length > wallLength - padding)
+        return {
+            address: updatedFeature.address,
+            type: types_1.IErrorTypes.HARD,
+            message: messaging_1.errorMessages.featureOutsideWallBounds(),
+        };
+    return false;
+}
+exports.default = isFeatureOutsideWallBounds;

package/dist/hooks/useSpaces/validators/isLineTooShort.d.ts

@@ -0,0 +1,3 @@
+import type { ICoordinatesLine, IErrorElement, IWall, IWallsValidationConfig } from '../types';
+declare function isLineTooShort(wallOrLine: ICoordinatesLine | IWall, validationConfig: IWallsValidationConfig): false | IErrorElement;
+export default isLineTooShort;

package/dist/hooks/useSpaces/validators/isLineTooShort.js

@@ -0,0 +1,26 @@
+"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 geometry_1 = require("../geometry");
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function isLineTooShort(wallOrLine, validationConfig) {
+    var minLength = validationConfig.minLength;
+    var line = Array.isArray(wallOrLine) ? wallOrLine : wallOrLine.line;
+    var tooClose = geometry_1.arePointsWithinProximity.apply(void 0, __spreadArray(__spreadArray([], line, false), [minLength], false));
+    if (tooClose)
+        return {
+            message: messaging_1.errorMessages.wallTooShort(),
+            type: types_1.IErrorTypes.HARD,
+        };
+    return false;
+}
+exports.default = isLineTooShort;

package/dist/hooks/useSpaces/validators/isVertexLandingOnFeature.d.ts

@@ -0,0 +1,4 @@
+import { IErrorElement } from '../types';
+import type { IMoveVertexValidatorInput } from '../types';
+declare function isVertexLandingOnFeature(input: IMoveVertexValidatorInput): false | IErrorElement;
+export default isVertexLandingOnFeature;

package/dist/hooks/useSpaces/validators/isVertexLandingOnFeature.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function isVertexLandingOnFeature(input) {
+    var snapPoint = input.updatedPosition;
+    if (!snapPoint)
+        return false;
+    if (snapPoint.type === types_1.IElements.WINDOW ||
+        snapPoint.type === types_1.IElements.DOOR ||
+        snapPoint.type === types_1.IElements.OPENING)
+        return {
+            address: snapPoint,
+            message: messaging_1.errorMessages.addWallCollidingWithFeature(snapPoint.type),
+            type: types_1.IErrorTypes.SOFT,
+        };
+    return false;
+}
+exports.default = isVertexLandingOnFeature;

package/dist/hooks/useSpaces/validators/isWallEndingOnFeature.d.ts

@@ -0,0 +1,3 @@
+import type { IErrorElement, IAddWallValidatorInput } from '../types';
+declare function isWallEndingOnFeature(input: IAddWallValidatorInput): false | IErrorElement;
+export default isWallEndingOnFeature;

package/dist/hooks/useSpaces/validators/isWallEndingOnFeature.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function isWallEndingOnFeature(input) {
+    var snapPoint = input.newWall.end;
+    if (!snapPoint)
+        return false;
+    if (snapPoint.type === types_1.IElements.WINDOW ||
+        snapPoint.type === types_1.IElements.DOOR ||
+        snapPoint.type === types_1.IElements.OPENING)
+        return {
+            address: snapPoint,
+            message: messaging_1.errorMessages.addWallCollidingWithFeature(snapPoint.type),
+            type: types_1.IErrorTypes.SOFT,
+        };
+    return false;
+}
+exports.default = isWallEndingOnFeature;

package/dist/hooks/useSpaces/validators/isWallIntersectingFeature.d.ts

@@ -0,0 +1,3 @@
+import type { IAddWallValidatorInput, ISharedValidatorInput, IErrorElement } from '../types';
+declare function isWallIntersectingFeature(input: IAddWallValidatorInput, wallAndFeatures: ISharedValidatorInput): false | IErrorElement;
+export default isWallIntersectingFeature;

package/dist/hooks/useSpaces/validators/isWallIntersectingFeature.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function isWallIntersectingFeature(input, wallAndFeatures) {
+    var _a;
+    var newWall = input.newWall;
+    var walls = wallAndFeatures.walls, features = wallAndFeatures.features;
+    if (!walls.length || !Object.values(features).flat().length)
+        return false;
+    var intersectingFeature;
+    for (var i = 0; i < walls.length && !intersectingFeature; i++) {
+        if (!walls[i].connections)
+            continue;
+        var intersectionPoint = (0, geometry_1.getLineSegmentsIntersection)(newWall.line, walls[i].line);
+        if (!intersectionPoint)
+            continue;
+        var intersectionOffset = (0, geometry_1.getLengthOfLineSegment)([
+            walls[i].line[0],
+            intersectionPoint,
+        ]);
+        for (var j = 0; j < walls[i].connections.length && !intersectingFeature; j++) {
+            var _b = walls[i].connections[j], type = _b[0], index = _b[1];
+            var feature = (_a = features[type]) === null || _a === void 0 ? void 0 : _a[index];
+            if (!feature)
+                continue;
+            if (feature.offset < intersectionOffset &&
+                intersectionOffset < feature.offset + feature.length)
+                intersectingFeature = { type: type, index: index };
+        }
+    }
+    if (!intersectingFeature)
+        return false;
+    return ({
+        address: intersectingFeature,
+        message: messaging_1.errorMessages.addWallCollidingWithFeature(intersectingFeature.type),
+        type: types_1.IErrorTypes.SOFT,
+    } || false);
+}
+exports.default = isWallIntersectingFeature;

package/dist/hooks/useSpaces/validators/isWallOverlappingExisitingWalls.d.ts

@@ -0,0 +1,3 @@
+import type { IErrorElement, IAddWallValidatorInput, ISharedValidatorInput } from '../types';
+declare function isWallOverlappingExisitingWalls(input: IAddWallValidatorInput, wallAndFeatures: ISharedValidatorInput): false | IErrorElement;
+export default isWallOverlappingExisitingWalls;

package/dist/hooks/useSpaces/validators/isWallOverlappingExisitingWalls.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var geometry_1 = require("../geometry");
+var messaging_1 = require("./messaging");
+var types_1 = require("../types");
+function isWallOverlappingExisitingWalls(input, wallAndFeatures) {
+    var newWall = input.newWall;
+    var walls = wallAndFeatures.walls;
+    var start = newWall.start, end = newWall.end;
+    if (start.type === types_1.IElements.WALL &&
+        (end === null || end === void 0 ? void 0 : end.type) === types_1.IElements.WALL &&
+        start.index === end.index) {
+        return {
+            address: {
+                type: types_1.IElements.WALL,
+                index: start.index,
+            },
+            type: types_1.IErrorTypes.SOFT,
+            message: messaging_1.errorMessages.wallsNotUnique(),
+        };
+    }
+    var overlappingIndex = walls.findIndex(function (wall, i) {
+        var line = wall.line;
+        if ((0, geometry_1.areLinesEqual)(line, newWall.line))
+            return true;
+        if (start.type === types_1.IElements.VERTEX &&
+            ((0, geometry_1.arePointsEqual)(start.point, line[0]) ||
+                (0, geometry_1.arePointsEqual)(start.point, line[1])) &&
+            (end === null || end === void 0 ? void 0 : end.type) === types_1.IElements.WALL &&
+            end.index === i) {
+            return true;
+        }
+        if ((end === null || end === void 0 ? void 0 : end.type) === types_1.IElements.VERTEX &&
+            ((0, geometry_1.arePointsEqual)(end.point, line[0]) ||
+                (0, geometry_1.arePointsEqual)(end.point, line[1])) &&
+            start.type === types_1.IElements.WALL &&
+            start.index === i) {
+            return true;
+        }
+        return false;
+    });
+    if (overlappingIndex !== -1) {
+        return {
+            address: {
+                type: types_1.IElements.WALL,
+                index: overlappingIndex,
+            },
+            type: types_1.IErrorTypes.SOFT,
+            message: messaging_1.errorMessages.wallsNotUnique(),
+        };
+    }
+    return false;
+}
+exports.default = isWallOverlappingExisitingWalls;

package/dist/hooks/useSpaces/validators/isWallTooShort.d.ts

@@ -0,0 +1,3 @@
+import type { IAddWallValidatorInput, ISharedValidatorInput, IErrorElement, IWallsValidationConfig } from '../types';
+declare function isWallTooShort(input: IAddWallValidatorInput, _: ISharedValidatorInput, validationConfig: IWallsValidationConfig): false | IErrorElement;
+export default isWallTooShort;

package/dist/hooks/useSpaces/validators/isWallTooShort.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var isLineTooShort_1 = __importDefault(require("./isLineTooShort"));
+function isWallTooShort(input, _, validationConfig) {
+    return (0, isLineTooShort_1.default)(input.newWall.line, validationConfig);
+}
+exports.default = isWallTooShort;

package/dist/hooks/{useRoomBuilder → useSpaces/validators}/messaging.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorMessages = void 0;
-var constants_1 = require("./constants");
+var constants_1 = require("../constants");
 exports.errorMessages = {
     addWallCollidingWithWall: function () { return 'Wall cannot collide with another wall.'; },
     addWallCollidingWithFeature: function (feature) {

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

@@ -5,7 +5,7 @@ interface HydratedWishlistItem extends IConfigurationResponse {
     handleRemove: () => void;
     handleShare: () => void;
 }
-type UseWishlistHook = [
+declare type UseWishlistHook = [
     Array<HydratedWishlistItem>,
     (config?: Omit<ISaveConfiguration, 'configuration'>) => void,
     () => void

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

@@ -1,3 +1,3 @@
-type UseZoom = [(step: number) => void, (step: number) => void];
+declare type UseZoom = [(step: number) => void, (step: number) => void];
 declare const useZoom: () => UseZoom;
 export default useZoom;

package/dist/http/index.d.ts

@@ -1,13 +1,13 @@
-import * as assets from './assets';
 import * as orders from './orders';
+import * as products from './products';
 import * as configurations from './configurations';
 import * as pricebook from './pricebook';
 import * as catalog from './catalog';
 import * as datatables from './datatables';
 import * as server from './server';
 declare const _default: {
-    assets: typeof assets;
     orders: typeof orders;
+    products: typeof products;
     configurations: typeof configurations;
     pricebook: typeof pricebook;
     catalog: typeof catalog;