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

package/dist/hooks/useRoomBuilder/themes.js

@@ -1,273 +0,0 @@
-"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',
-        textColor: '#666',
-    },
-    dimensions: {
-        padding: DEFAULT_WALL_THICKNESS / 2 + 12,
-        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',
-        textColor: '#666',
-    },
-    dimensions: {
-        padding: DEFAULT_WALL_THICKNESS / 2 + 12,
-        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',
-        textColor: '#666',
-    },
-    dimensions: {
-        padding: DEFAULT_WALL_THICKNESS / 2 + 12,
-        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);

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

@@ -1,36 +0,0 @@
-import { IWall, IFeatures, IElementAddress, IWalls, IErrorElement, IFeature, INewWall, ICoordinate2D, IVertex, ISnapPoint } from './types';
-export interface IFeatureValidatorInput {
-    updatedFeature: Pick<IFeature, 'length' | 'offset'> & {
-        address: IElementAddress;
-    };
-    wall: IWall;
-    features: IFeatures;
-}
-export interface IAddWallValidatorInput {
-    newWall: Pick<IWall, 'line'> & Pick<INewWall, 'snapStartTo' | 'snapEndTo'>;
-    walls: IWalls;
-    features: IFeatures;
-}
-export interface IMoveVertexValidatorInput {
-    updatedPosition: {
-        point: ICoordinate2D;
-        snapTo?: ISnapPoint;
-    };
-    walls: IWalls;
-    vertex: IVertex;
-    features: IFeatures;
-}
-declare type IValidatorFunction<T> = (input: T) => false | IErrorElement;
-export declare function isWallTooShort(input: IAddWallValidatorInput): false | IErrorElement;
-export declare function isWallIntersectingFeature(input: IAddWallValidatorInput): false | IErrorElement;
-export declare function isWallOverlappingExisitingWalls(input: IAddWallValidatorInput): false | IErrorElement;
-export declare function isWallEndingOnFeature(input: IAddWallValidatorInput): false | IErrorElement;
-export declare function isFeatureOutsideWallBounds(input: IFeatureValidatorInput): false | IErrorElement;
-export declare function isFeatureCollidingWithExistingFeature(input: IFeatureValidatorInput): false | IErrorElement;
-export declare function areWallsTooShort(input: IMoveVertexValidatorInput): false | IErrorElement;
-export declare function areWallsIntersecting(input: IMoveVertexValidatorInput): false | IErrorElement;
-export declare function areWallsOrphaningFeatures(input: IMoveVertexValidatorInput): false | IErrorElement;
-export declare function areWallsDuplicated(input: IMoveVertexValidatorInput): false | IErrorElement;
-export declare function isVertexLandingOnFeature(input: IMoveVertexValidatorInput): false | IErrorElement;
-export declare function runValidators<T>(validators: Array<IValidatorFunction<T>>, input: T): IErrorElement[] | null;
-export {};

package/dist/hooks/useRoomBuilder/validators.js

@@ -1,362 +0,0 @@
-"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 });
-exports.runValidators = exports.isVertexLandingOnFeature = exports.areWallsDuplicated = exports.areWallsOrphaningFeatures = exports.areWallsIntersecting = exports.areWallsTooShort = exports.isFeatureCollidingWithExistingFeature = exports.isFeatureOutsideWallBounds = exports.isWallEndingOnFeature = exports.isWallOverlappingExisitingWalls = exports.isWallIntersectingFeature = exports.isWallTooShort = void 0;
-var types_1 = require("./types");
-var geometry_1 = require("./geometry");
-var messaging_1 = require("./messaging");
-var constants_1 = require("./constants");
-function isLineTooShort(wallOrLine) {
-    var minLength = constants_1.MIN_WALL_LENGTH;
-    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;
-}
-function isWallTooShort(input) {
-    return isLineTooShort(input.newWall.line);
-}
-exports.isWallTooShort = isWallTooShort;
-function isWallIntersectingFeature(input) {
-    var _a;
-    var newWall = input.newWall, walls = input.walls, features = input.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.isWallIntersectingFeature = isWallIntersectingFeature;
-function isWallOverlappingExisitingWalls(input) {
-    var newWall = input.newWall, walls = input.walls;
-    var snapStartTo = newWall.snapStartTo, snapEndTo = newWall.snapEndTo;
-    if ((snapStartTo === null || snapStartTo === void 0 ? void 0 : snapStartTo.type) === types_1.IElements.WALL &&
-        (snapEndTo === null || snapEndTo === void 0 ? void 0 : snapEndTo.type) === types_1.IElements.WALL &&
-        snapStartTo.index === snapEndTo.index) {
-        return {
-            address: {
-                type: types_1.IElements.WALL,
-                index: snapStartTo.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 ((snapStartTo === null || snapStartTo === void 0 ? void 0 : snapStartTo.type) === types_1.IElements.VERTEX &&
-            ((0, geometry_1.arePointsEqual)(snapStartTo.point, line[0]) ||
-                (0, geometry_1.arePointsEqual)(snapStartTo.point, line[1])) &&
-            (snapEndTo === null || snapEndTo === void 0 ? void 0 : snapEndTo.type) === types_1.IElements.WALL &&
-            snapEndTo.index === i) {
-            return true;
-        }
-        if ((snapEndTo === null || snapEndTo === void 0 ? void 0 : snapEndTo.type) === types_1.IElements.VERTEX &&
-            ((0, geometry_1.arePointsEqual)(snapEndTo.point, line[0]) ||
-                (0, geometry_1.arePointsEqual)(snapEndTo.point, line[1])) &&
-            (snapStartTo === null || snapStartTo === void 0 ? void 0 : snapStartTo.type) === types_1.IElements.WALL &&
-            snapStartTo.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.isWallOverlappingExisitingWalls = isWallOverlappingExisitingWalls;
-function isWallEndingOnFeature(input) {
-    var snapPoint = input.newWall.snapEndTo;
-    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.isWallEndingOnFeature = isWallEndingOnFeature;
-function isFeatureOutsideWallBounds(input) {
-    var wall = input.wall, updatedFeature = input.updatedFeature;
-    var padding = constants_1.WALL_PADDING_FOR_FEATURE;
-    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.isFeatureOutsideWallBounds = isFeatureOutsideWallBounds;
-function isFeatureCollidingWithExistingFeature(input) {
-    var _a, _b;
-    var features = input.features, wall = input.wall, updatedFeature = input.updatedFeature;
-    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.isFeatureCollidingWithExistingFeature = isFeatureCollidingWithExistingFeature;
-function areWallsTooShort(input) {
-    var walls = input.walls, vertex = input.vertex, updatedPosition = input.updatedPosition;
-    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 (isLineTooShort(line))
-            return {
-                address: { type: types_1.IElements.WALL, index: index },
-                message: messaging_1.errorMessages.wallTooShort(),
-                type: types_1.IErrorTypes.HARD,
-            };
-    }
-    return false;
-}
-exports.areWallsTooShort = areWallsTooShort;
-function areWallsIntersecting(input) {
-    var walls = input.walls, vertex = input.vertex, updatedPosition = input.updatedPosition;
-    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.areWallsIntersecting = areWallsIntersecting;
-function areWallsOrphaningFeatures(input) {
-    var _a;
-    var walls = input.walls, vertex = input.vertex, features = input.features, updatedPosition = input.updatedPosition;
-    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 < constants_1.WALL_PADDING_FOR_FEATURE)
-                return error;
-            else if (feat.offset + feat.length >
-                updatedWallLength - constants_1.WALL_PADDING_FOR_FEATURE) {
-                return error;
-            }
-        }
-    }
-    return false;
-}
-exports.areWallsOrphaningFeatures = areWallsOrphaningFeatures;
-function areWallsDuplicated(input) {
-    var _a, _b, _c;
-    var walls = input.walls, vertex = input.vertex, updatedPosition = input.updatedPosition;
-    var point = (_b = (_a = updatedPosition.snapTo) === null || _a === void 0 ? void 0 : _a.point) !== null && _b !== void 0 ? _b : updatedPosition.point;
-    var _d = 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 = _d.wallIndexes, updatedVerticesMap = _d.updatedVerticesMap;
-    for (var _i = 0, _e = Array.from(wallIndexes); _i < _e.length; _i++) {
-        var wallIdx = _e[_i];
-        var wall = walls[wallIdx];
-        var updatedLine = JSON.parse(JSON.stringify(wall.line));
-        updatedLine[updatedVerticesMap[wallIdx]] = point;
-        if (((_c = updatedPosition.snapTo) === null || _c === void 0 ? void 0 : _c.type) === types_1.IElements.WALL &&
-            updatedPosition.snapTo.index !== wallIdx) {
-            var _f = walls[updatedPosition.snapTo.index].line, xTest = _f[0], yTest = _f[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.snapTo.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.areWallsDuplicated = areWallsDuplicated;
-function isVertexLandingOnFeature(input) {
-    var snapPoint = input.updatedPosition.snapTo;
-    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.isVertexLandingOnFeature = isVertexLandingOnFeature;
-function runValidators(validators, input) {
-    var errors = validators.reduce(function (output, validate) {
-        var error = validate(input);
-        if (error)
-            output.push(error);
-        return output;
-    }, []);
-    if (errors.length)
-        return errors;
-    return null;
-}
-exports.runValidators = runValidators;