@threekit-tools/treble 0.0.95-next-01 → 0.0.96

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

@@ -0,0 +1,238 @@
+export declare type ICoordinate2D = [x: number, y: number];
+export declare type ICoordinate3D = [x: number, y: number, z: number];
+export declare type ICoordinatesLine = [
+    startPoint: ICoordinate2D,
+    endPoint: ICoordinate2D
+];
+export declare type ICoordinatesQuadrilateral = [
+    point1: ICoordinate2D,
+    point2: ICoordinate2D,
+    point3: ICoordinate2D,
+    point4: ICoordinate2D
+];
+export declare enum IElements {
+    WALL = "walls",
+    VERTEX = "vertex",
+    FEATURE = "features",
+    WINDOW = "windows",
+    DOOR = "doors",
+    OPENING = "openings"
+}
+export declare type IFeatureName = IElements.WINDOW | IElements.DOOR | IElements.OPENING;
+export declare type IElementName = IElements.WALL | IElements.VERTEX | IFeatureName;
+export interface IWall {
+    assetId: string;
+    line: ICoordinatesLine;
+    path?: ICoordinatesQuadrilateral;
+    height?: number;
+    thickness?: number;
+    connections: Array<[elementType: IFeatureName, index: number]>;
+}
+export interface IWalls extends Array<IWall> {
+}
+export interface INewWall {
+    start: ICoordinate2D;
+    end?: ICoordinate2D;
+    snapStartTo?: ISnapPoint;
+    snapEndTo?: ISnapPoint;
+}
+export interface IVertexConnections extends Array<[wallIndex: number, anchorIndex: number]> {
+}
+export interface IVerticesState extends Record<string, IVertexConnections> {
+}
+export interface IVertex {
+    point: ICoordinate2D;
+    connections: IVertexConnections;
+}
+export interface ILineDimensions {
+    label: string;
+    line: ICoordinatesLine;
+}
+export interface IEnclosedSpace {
+    area: string;
+    center: ICoordinate2D;
+    loop: Array<ICoordinate2D>;
+}
+export interface IFeature {
+    assetId: string;
+    offset: number;
+    length: number;
+    path?: ICoordinatesQuadrilateral;
+    connectedTo: [elementType: IElements.WALL, index: number];
+}
+export interface IFeatureHydrated extends IFeature {
+    line: ICoordinatesLine;
+}
+export interface IFeaturesShared<T> {
+    [IElements.WINDOW]?: Array<T>;
+    [IElements.DOOR]?: Array<T>;
+    [IElements.OPENING]?: Array<T>;
+}
+export interface IFeatures extends IFeaturesShared<IFeature> {
+}
+export interface IFeaturesHydrated extends IFeaturesShared<IFeatureHydrated> {
+}
+export declare enum IElementStyleModes {
+    HIGHLIGHT = "highlight",
+    ACTIVE = "active",
+    ERROR = "error"
+}
+export interface IRoomBuilderStylesShared {
+    fill: string;
+    stroke?: string;
+    strokeWidth?: number;
+    [IElementStyleModes.HIGHLIGHT]: {
+        fill: string;
+        stroke: string;
+    };
+    [IElementStyleModes.ACTIVE]: {
+        fill: string;
+        stroke: string;
+    };
+    [IElementStyleModes.ERROR]: {
+        fill: string;
+        stroke: string;
+    };
+}
+export interface IStylesGrid {
+    gridStepGap: number;
+    lineThickness: number;
+    secondaryLineThickness: number;
+    lineColor: string;
+    backgroundColor?: string;
+    secondaryLineIncrement?: number;
+}
+export interface IStylesFloor {
+    color: string;
+    textColor: string;
+}
+export interface IStylesDimension {
+    padding: number;
+    lineThickness: number;
+    lineColor: string;
+    fontSize: number;
+    font: string;
+    textColor: string;
+    textBackgroundColor: string;
+}
+export interface IStylesWall extends IRoomBuilderStylesShared {
+    thickness: number;
+}
+export interface IStylesVertex extends Omit<IRoomBuilderStylesShared, 'fill' | IElementStyleModes.HIGHLIGHT | IElementStyleModes.ACTIVE | IElementStyleModes.ERROR> {
+    innerFill: string;
+    outerFill: string;
+    innerRadius: number;
+    outerRadius?: number;
+    [IElementStyleModes.HIGHLIGHT]: {
+        innerFill: string;
+        outerFill: string;
+        stroke?: string;
+    };
+    [IElementStyleModes.ACTIVE]: {
+        innerFill: string;
+        outerFill: string;
+        stroke?: string;
+    };
+    [IElementStyleModes.ERROR]: {
+        innerFill: string;
+        outerFill: string;
+        stroke?: string;
+    };
+}
+export interface IStylesFeature extends IStylesWall {
+}
+export interface IRoomBuilderStyles {
+    grid: IStylesGrid;
+    floor: IStylesFloor;
+    dimensions: IStylesDimension;
+    wall: IStylesWall;
+    vertex: IStylesVertex;
+    feature: IStylesFeature;
+}
+export interface IRoomBuilderThemePartial {
+    grid: Partial<IStylesGrid>;
+    floor: Partial<IStylesFloor>;
+    dimensions: Partial<IStylesDimension>;
+    wall: Partial<IStylesWall>;
+    vertex: Partial<IStylesVertex>;
+    feature: Partial<IStylesFeature>;
+}
+export interface IElementAddress {
+    type: IElementName;
+    index: number;
+}
+export interface IFeatureAddress {
+    type: IFeatureName;
+    index: number;
+}
+export interface ISnapPointShared<T> {
+    type: T;
+    index: number;
+    point: ICoordinate2D;
+}
+export interface ISnapPointVertex extends ISnapPointShared<IElements.VERTEX> {
+}
+export interface ISnapPointWall extends ISnapPointShared<IElements.WALL> {
+    offset: number;
+}
+export interface ISnapPointFeature extends ISnapPointShared<IFeatureName> {
+}
+export interface ISnapPointAngle extends Omit<ISnapPointShared<'Angle'>, 'index'> {
+}
+export declare type ISnapPoint = ISnapPointVertex | ISnapPointWall | ISnapPointFeature | ISnapPointAngle;
+export interface IActiveElement extends IElementAddress {
+    snapPoint?: ISnapPoint;
+}
+export declare enum IErrorTypes {
+    HARD = "hard",
+    SOFT = "soft",
+    WARN = "warning"
+}
+export interface IErrorElement {
+    address?: IElementAddress;
+    message: string;
+    type: IErrorTypes;
+}
+export interface IElementUi {
+    path: [type: IFeatureName | IElements.WALL, index: number];
+    uiAnchor: ICoordinate2D;
+}
+export interface IElementPublic extends Pick<IElementUi, 'uiAnchor'> {
+    path: [attribute: string, index: number];
+}
+export declare enum IModes {
+    SELECT = "select",
+    DRAW = "draw"
+}
+export declare enum IUnits {
+    FEET = "feet",
+    METER = "meter",
+    INCH = "inch",
+    CM = "cm"
+}
+export interface IRoomBuilderConfigShared<T> {
+    scale: number;
+    unit: IUnits;
+    snapProximity: number;
+    styles: T;
+}
+export interface IRoomBuilderConfigInternal extends IRoomBuilderConfigShared<IRoomBuilderStyles> {
+}
+export interface IRoomBuilderConfigUser extends IRoomBuilderConfigShared<Partial<IRoomBuilderStyles>> {
+    theme?: string;
+}
+export interface IRoomBuilderAttributes {
+    [IElements.WALL]: string;
+    [IElements.WINDOW]?: string;
+    [IElements.DOOR]?: string;
+    [IElements.OPENING]?: string;
+}
+interface IRoomBuilderPropsShared<T> {
+    config: T;
+    attributes: IRoomBuilderAttributes;
+}
+export interface IRoomBuilderHookProps extends IRoomBuilderPropsShared<undefined | Partial<IRoomBuilderConfigUser>> {
+}
+export interface IRoomBuilderStateProps extends IRoomBuilderPropsShared<IRoomBuilderConfigInternal> {
+}
+export {};

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

@@ -1,6 +1,6 @@
 "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;
+exports.IUnits = exports.IModes = exports.IErrorTypes = exports.IElementStyleModes = exports.IElements = void 0;
 var IElements;
 (function (IElements) {
     IElements["WALL"] = "walls";
@@ -16,18 +16,6 @@ var IElementStyleModes;
     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";
@@ -46,9 +34,3 @@ var IUnits;
     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/useRoomBuilder/validators.d.ts

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,362 @@
+"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;

package/dist/icons/Draw.js

@@ -10,10 +10,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Draw = void 0;
 var react_1 = __importDefault(require("react"));
 var styled_components_1 = __importDefault(require("styled-components"));
-var Path = styled_components_1.default.path(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  fill: ", ";\n"], ["\n  fill: ", ";\n"])), function (props) { return props.color || props.theme.textColor; });
+var SVG = styled_components_1.default.svg(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  .tk-icon {\n    fill: ", ";\n  }\n"], ["\n  .tk-icon {\n    fill: ", ";\n  }\n"])), function (props) { return props.color || props.theme.textColor; });
 var Draw = function (props) {
-    return (react_1.default.createElement("svg", { width: "20", height: "20", viewBox: "0 0 20 20", fill: "none", xmlns: "http://www.w3.org/2000/svg" },
-        react_1.default.createElement(Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M3.74417 0.637287C4.59388 -0.212428 5.97154 -0.21243 6.82126 0.637287L19.3627 13.1787C19.7708 13.5868 20 14.1402 20 14.7173V20H14.7173C14.1402 20 13.5868 19.7708 13.1787 19.3627L0.637287 6.82126C-0.21243 5.97154 -0.21243 4.59388 0.637286 3.74417L3.74417 0.637287ZM5.50251 1.95604C5.38112 1.83465 5.18431 1.83465 5.06292 1.95604L1.95604 5.06292C1.83465 5.18431 1.83465 5.38112 1.95604 5.50251L4.20155 7.74802L7.74802 4.20155L5.50251 1.95604ZM9.06677 5.52031L18.044 14.4975C18.1023 14.5558 18.135 14.6348 18.135 14.7173V18.135H14.7173C14.6348 18.135 14.5558 18.1023 14.4975 18.044L5.52031 9.06677L9.06677 5.52031Z", color: props.color })));
+    return (react_1.default.createElement(SVG, { width: "20", height: "20", viewBox: "0 0 20 20", fill: "none", xmlns: "http://www.w3.org/2000/svg", color: props.color },
+        react_1.default.createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M3.74417 0.637287C4.59388 -0.212428 5.97154 -0.21243 6.82126 0.637287L19.3627 13.1787C19.7708 13.5868 20 14.1402 20 14.7173V20H14.7173C14.1402 20 13.5868 19.7708 13.1787 19.3627L0.637287 6.82126C-0.21243 5.97154 -0.21243 4.59388 0.637286 3.74417L3.74417 0.637287ZM5.50251 1.95604C5.38112 1.83465 5.18431 1.83465 5.06292 1.95604L1.95604 5.06292C1.83465 5.18431 1.83465 5.38112 1.95604 5.50251L4.20155 7.74802L7.74802 4.20155L5.50251 1.95604ZM9.06677 5.52031L18.044 14.4975C18.1023 14.5558 18.135 14.6348 18.135 14.7173V18.135H14.7173C14.6348 18.135 14.5558 18.1023 14.4975 18.044L5.52031 9.06677L9.06677 5.52031Z", className: "tk-icon" })));
 };
 exports.Draw = Draw;
 exports.Draw.iconName = 'draw';