@threekit-tools/treble 0.0.88 → 0.0.89-next-002

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/useRoomBuilder/types.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IUnits = exports.IModes = exports.IErrorTypes = 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 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 = {}));

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/http/request.js

@@ -14,11 +14,14 @@ var prepRequest = function (request, connection) {
         formData: undefined,
         config: undefined,
     }, request), url = _a.url, data = _a.data, formData = _a.formData, params = _a.params, config = _a.config, includeOrgId = _a.includeOrgId;
-    var _b = connection.getConnection(), authToken = _b.authToken, orgId = _b.orgId, threekitDomain = _b.threekitDomain;
+    var _b = connection.getConnection(), authToken = _b.authToken, orgId = _b.orgId, threekitDomain = _b.threekitDomain, cacheParameters = _b.cacheParameters;
     var urlRaw = "".concat(threekitDomain).concat(url);
     var query = (0, utils_1.objectToQueryStr)(Object.assign({}, includeOrgId ? { orgId: orgId } : {}, params));
     var urlPrepped = "".concat(urlRaw).concat(query);
     urlPrepped += "".concat(query.length ? "&" : "?", "bearer_token=").concat(authToken);
+    if (cacheParameters) {
+        urlPrepped += "&cacheMaxAge=".concat(cacheParameters.maxAge, "&cacheScope=").concat(cacheParameters.scope);
+    }
     return { url: urlPrepped, data: formData || data, config: config };
 };
 var get = function (request) {

package/dist/icons/Add.d.ts

@@ -1,3 +1,3 @@
-import { IIcon } from './index';
+import { IIcon } from './types';
 export declare const Add: IIcon;
 export default Add;