@threekit-tools/treble 0.0.91 → 0.0.92

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

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IThemes = void 0;
+var default_1 = __importDefault(require("./default"));
+var blueprint_1 = __importDefault(require("./blueprint"));
+var light_1 = __importDefault(require("./light"));
+var IThemes;
+(function (IThemes) {
+    IThemes["DEFAULT"] = "default";
+    IThemes["BLUEPRINT"] = "blueprint";
+    IThemes["LIGHT"] = "light";
+})(IThemes = exports.IThemes || (exports.IThemes = {}));
+exports.default = (_a = {},
+    _a[IThemes.DEFAULT] = default_1.default,
+    _a[IThemes.BLUEPRINT] = blueprint_1.default,
+    _a[IThemes.LIGHT] = light_1.default,
+    _a);

package/dist/hooks/useSpaces/themes/light.d.ts

@@ -0,0 +1,3 @@
+import type { ISpacesStyles } from '../types';
+declare const theme: ISpacesStyles;
+export default theme;

package/dist/hooks/useSpaces/themes/light.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var HIGHCOLOR = '#36738E';
+var ACTIVE_COLOR = 'green';
+var ERROR_COLOR = 'red';
+var WALL_THICKNESS = 8;
+var VERTEX_RADIUS = (WALL_THICKNESS + 8) / 2;
+var FEATURE_THICKNESS = WALL_THICKNESS + 4;
+var theme = {
+    grid: {
+        lineThickness: 2,
+        lineColor: '#ddd',
+        showSubdivisions: true,
+        subdivisionLineThickness: 1,
+        subdivisionLineColor: '#ddd',
+        subdivisionThreshold: 20,
+        backgroundColor: '#fff',
+    },
+    guides: {
+        color: '#00F8FB',
+        thickness: 1,
+    },
+    floor: {
+        color: '#eee',
+        textColor: '#666',
+    },
+    dimensions: {
+        padding: WALL_THICKNESS / 2 + 12,
+        lineThickness: 1,
+        lineColor: '#444',
+        fontSize: 14,
+        font: 'Helvetica',
+        textColor: '#444',
+        textBackgroundColor: '#fff',
+    },
+    wall: {
+        fill: '#000',
+        stroke: '#000',
+        strokeWidth: 0,
+        thickness: WALL_THICKNESS,
+        highlight: {
+            fill: HIGHCOLOR,
+            stroke: HIGHCOLOR,
+        },
+        active: {
+            fill: ACTIVE_COLOR,
+            stroke: ACTIVE_COLOR,
+        },
+        error: {
+            fill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+    vertex: {
+        innerFill: '#aaa',
+        outerFill: '#fff',
+        stroke: '#000',
+        strokeWidth: 1,
+        outerRadius: VERTEX_RADIUS,
+        innerRadius: (VERTEX_RADIUS / 5) * 3,
+        highlight: {
+            innerFill: HIGHCOLOR,
+            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: FEATURE_THICKNESS,
+        highlight: {
+            fill: HIGHCOLOR,
+            stroke: HIGHCOLOR,
+        },
+        active: {
+            fill: ACTIVE_COLOR,
+            stroke: ACTIVE_COLOR,
+        },
+        error: {
+            fill: ERROR_COLOR,
+            stroke: ERROR_COLOR,
+        },
+    },
+};
+exports.default = theme;

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

@@ -0,0 +1,339 @@
+export type ICoordinate2D = [x: number, y: number];
+export type ICoordinate3D = [x: number, y: number, z: number];
+export type ICoordinatesLine = [
+    startPoint: ICoordinate2D,
+    endPoint: ICoordinate2D
+];
+export 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 type IFeatureName = IElements.WINDOW | IElements.DOOR | IElements.OPENING;
+export type IElementName = IElements.WALL | IElements.VERTEX | IFeatureName;
+export interface IWall {
+    assetId: string;
+    line: ICoordinatesLine;
+    path?: ICoordinatesQuadrilateral;
+    connections: Array<[elementType: IFeatureName, index: number]>;
+    restConfiguration: string;
+    visible: boolean;
+}
+export interface IWalls extends Array<IWall> {
+}
+export interface INewWall {
+    start: ISnapPoint;
+    end?: 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;
+    height: number;
+    altitude: number;
+    path?: ICoordinatesQuadrilateral;
+    connectedTo: [elementType: IElements.WALL, index: number];
+    restConfiguration: string;
+}
+export interface IFeatureDoor extends IFeature {
+    orientation: string;
+    openingDirection: string;
+    showSwing: boolean;
+}
+interface IFeatureHydratedShared {
+    line: ICoordinatesLine;
+}
+export interface IFeatureHydrated extends IFeature, IFeatureHydratedShared {
+}
+export interface IFeatureDoorHydrated extends IFeatureDoor, IFeatureHydratedShared {
+}
+export interface IFeaturesShared<T, D> {
+    [IElements.WINDOW]?: Array<T>;
+    [IElements.DOOR]?: Array<D>;
+    [IElements.OPENING]?: Array<T>;
+}
+export interface IFeatures extends IFeaturesShared<IFeature, IFeatureDoor> {
+}
+export interface IFeaturesHydrated extends IFeaturesShared<IFeatureHydrated, IFeatureDoorHydrated> {
+}
+export declare enum IElementStyleModes {
+    HIGHLIGHT = "highlight",
+    ACTIVE = "active",
+    ERROR = "error"
+}
+export interface ISpacesStylesShared {
+    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 {
+    lineThickness: number;
+    lineColor: string;
+    showSubdivisions: boolean;
+    subdivisionLineThickness: number;
+    subdivisionLineColor: string;
+    subdivisionThreshold: number;
+    backgroundColor?: string;
+}
+export interface IStylesGuides {
+    color: string;
+    thickness: 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 ISpacesStylesShared {
+    thickness: number;
+}
+export interface IStylesVertex extends Omit<ISpacesStylesShared, '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 ISpacesStyles {
+    grid: IStylesGrid;
+    guides: IStylesGuides;
+    floor: IStylesFloor;
+    dimensions: IStylesDimension;
+    wall: IStylesWall;
+    vertex: IStylesVertex;
+    feature: IStylesFeature;
+}
+export interface ISpacesThemePartial {
+    grid: Partial<IStylesGrid>;
+    guides: Partial<IStylesGuides>;
+    floor: Partial<IStylesFloor>;
+    dimensions: Partial<IStylesDimension>;
+    wall: Partial<IStylesWall>;
+    vertex: Partial<IStylesVertex>;
+    feature: Partial<IStylesFeature>;
+}
+export interface IGridToDraw {
+    unitLength: number;
+    offset: ICoordinate2D;
+    subdivisions: number;
+    showSubdivisions: boolean;
+}
+export interface IWallsValidationConfig {
+    minLength: number;
+    padding: number;
+}
+export interface ISharedValidatorInput {
+    walls: IWalls;
+    features: IFeatures;
+}
+export interface IFeatureValidatorInput {
+    wall: IWall;
+    updatedFeature: Pick<IFeature, 'length' | 'offset'> & {
+        address: IElementAddress;
+    };
+}
+export interface IAddWallValidatorInput {
+    newWall: Pick<IWall, 'line'> & Pick<INewWall, 'start' | 'end'>;
+}
+export interface IMoveVertexValidatorInput {
+    updatedPosition: ISnapPoint;
+    vertex: IVertex;
+}
+export type IValidatorFunction<T> = (input: T, wallsAndFeatures: ISharedValidatorInput, validationConfig: IWallsValidationConfig) => false | IErrorElement;
+export declare enum SNAPPING_TYPES {
+    NONE = "none",
+    ANGLE = "angle",
+    GUIDE = "guide",
+    GRID = "grid"
+}
+export declare enum GUIDE_ORIENTATIONS {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+export interface IGuides {
+    point: ICoordinate2D;
+    orientations: Array<GUIDE_ORIENTATIONS>;
+}
+export interface IElementAddress {
+    type: IElementName;
+    index: number;
+}
+export interface IFeatureAddress {
+    type: IFeatureName;
+    index: number;
+}
+export interface ISnapPointShared<T> {
+    type: T;
+    point: ICoordinate2D;
+    locked: [boolean, boolean];
+}
+export interface ISnapPointNone extends ISnapPointShared<SNAPPING_TYPES.NONE> {
+    locked: [false, false];
+}
+export interface ISnapPointVertex extends ISnapPointShared<IElements.VERTEX> {
+    index: number;
+    locked: [true, true];
+}
+export interface ISnapPointWall extends ISnapPointShared<IElements.WALL> {
+    offset: number;
+    index: number;
+}
+export interface ISnapPointFeature extends ISnapPointShared<IFeatureName> {
+    index: number;
+}
+export interface ISnapPointAngle extends ISnapPointShared<SNAPPING_TYPES.ANGLE>, Pick<IGuides, 'orientations'> {
+}
+export interface ISnapPointGuide extends ISnapPointShared<SNAPPING_TYPES.GUIDE>, Pick<IGuides, 'orientations'> {
+}
+export interface ISnapPointGrid extends ISnapPointShared<SNAPPING_TYPES.GRID>, Pick<IGuides, 'orientations'> {
+    locked: [true, true];
+}
+export type ISnapPoint = ISnapPointNone | ISnapPointVertex | ISnapPointWall | ISnapPointFeature | ISnapPointAngle | ISnapPointGuide | ISnapPointGrid;
+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];
+    type: IFeatureName | IElements.WALL;
+    deleteElement: () => void;
+    splitWall?: (offset?: number) => void;
+    addFeature?: (type: IFeatureName, feature?: Partial<IFeature>) => void;
+}
+export declare enum IModes {
+    SELECT = "select",
+    DRAW = "draw"
+}
+export declare enum IUnits {
+    FEET = "feet",
+    METER = "meter",
+    INCH = "inch",
+    CM = "cm"
+}
+export declare enum IDimensionOptions {
+    NONE = "none",
+    DEFAULT = "default",
+    DETAILED = "detailed"
+}
+export interface ISpacesConfigShared<T> {
+    scale: number;
+    unit: IUnits;
+    snapProximity: number;
+    styles: T;
+    zoomDefault: number;
+    translateDefault: ICoordinate2D;
+    disableGuides: boolean;
+}
+export interface ISpacesConfigInternal extends ISpacesConfigShared<ISpacesStyles> {
+}
+export interface ISpacesConfigUser extends ISpacesConfigShared<Partial<ISpacesStyles>> {
+    theme: string;
+    zoomDisabled: boolean;
+    translateDisabled: boolean;
+    zoomSensitivity: number;
+}
+export interface ISpacesAttributes {
+    [IElements.WALL]: string;
+    [IElements.WINDOW]: string;
+    [IElements.DOOR]: string;
+    [IElements.OPENING]: string;
+    featurePositionX: string;
+    featurePositionY: string;
+    featureConnectedTo: string;
+    featureHeight: string;
+    featureLength: string;
+    wallStartX: string;
+    wallStartY: string;
+    wallStartZ: string;
+    wallEndX: string;
+    wallEndY: string;
+    wallEndZ: string;
+    wallConnections: string;
+}
+export interface IAttributeDefaults extends Partial<Record<IElements.WALL | IElements.WINDOW | IElements.DOOR | IElements.OPENING, string>> {
+}
+interface ISpacesPropsShared<T, U> {
+    config: T;
+    attributes: U;
+    layouts?: Array<string>;
+}
+export interface ISpacesHookProps extends ISpacesPropsShared<undefined | Partial<ISpacesConfigUser>, undefined | Partial<ISpacesAttributes>> {
+}
+export interface ISpacesStateProps extends ISpacesPropsShared<ISpacesConfigInternal, ISpacesAttributes> {
+}
+export {};

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;