@threekit-tools/treble 0.0.90-next-07 → 0.0.90-next-09

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

@@ -3,6 +3,9 @@ import type { ICoordinate2D } from './types';
 interface ISpacesLayout {
     loops?: Array<ICoordinate2D[]>;
     size?: number;
+    color?: string;
+    padding?: number;
+    strokeWidth?: number;
 }
 export default function SpacesLayout(props: ISpacesLayout): JSX.Element;
 export {};

package/dist/hooks/useSpaces/SpacesLayout.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,16 +18,57 @@ var react_1 = __importDefault(require("react"));
 function SpacesLayout(props) {
     var loops = props.loops;
     var size = props.size || 20;
+    var padding = props.padding || 2;
+    var strokeWidth = props.strokeWidth || 2;
     if (!(loops === null || loops === void 0 ? void 0 : loops.length))
         return react_1.default.createElement(react_1.default.Fragment, null);
-    var paths = loops.map(function (loop) {
-        return loop
-            .map(function (_a, i) {
+    var _a = loops.reduce(function (output, loop, i) {
+        loop.forEach(function (_a, j) {
             var x = _a[0], y = _a[1];
-            return (i === 0 ? 'M ' : 'L ') + x + ' ' + y;
+            if (!i && !j) {
+                output = {
+                    xMin: x,
+                    yMin: y,
+                    xMax: x,
+                    yMax: y,
+                };
+            }
+            else {
+                if (x < output.xMin)
+                    output.xMin = x;
+                else if (x > output.xMax)
+                    output.xMax = x;
+                if (y < output.yMin)
+                    output.yMin = y;
+                else if (y > output.yMax)
+                    output.yMax = y;
+            }
+        });
+        return output;
+    }, {
+        xMin: 0,
+        yMin: 0,
+        xMax: 0,
+        yMax: 0,
+    }), xMin = _a.xMin, yMin = _a.yMin, xMax = _a.xMax, yMax = _a.yMax;
+    var xSpan = xMax - xMin;
+    var ySpan = yMax - yMin;
+    var xCenter = xMin + xSpan / 2;
+    var yCenter = yMin + ySpan / 2;
+    var scaleFactor = (size - 2 * padding) / Math.max(xSpan, ySpan);
+    var translate = [
+        xCenter * scaleFactor - size / 2,
+        yCenter * scaleFactor - size / 2,
+    ];
+    return (react_1.default.createElement("svg", __assign({ width: size, height: size, fill: "none", xmlns: "http://www.w3.org/2000/svg" }, props), loops.map(function (loop, i) {
+        var path = loop
+            .map(function (point, i) {
+            var x = point[0] * scaleFactor - translate[0];
+            var y = point[1] * scaleFactor - translate[1];
+            return (!i ? 'M ' : 'L ') + x + ' ' + y;
         })
             .join(' ') + ' Z';
-    });
-    return (react_1.default.createElement("svg", { width: size, height: size, viewBox: "0 0 ".concat(size, " ").concat(size), fill: "none", xmlns: "http://www.w3.org/2000/svg" }, paths.map(function (path, i) { return (react_1.default.createElement("path", { key: "path-".concat(i), d: path, stroke: "white", strokeWidth: 1 })); })));
+        return (react_1.default.createElement("path", { key: "path-".concat(i), d: path, stroke: props.color, strokeWidth: strokeWidth }));
+    })));
 }
 exports.default = SpacesLayout;

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

@@ -1,8 +1,10 @@
-import { IWalls, IVerticesState, ICoordinate2D, IFeature, IFeatures, ICoordinatesLine, ISpacesStateProps, IElementAddress, IFeatureName, IVertex, IFeaturesHydrated, IElementUi, IElementName, IActiveElement, IEnclosedSpace, IFeatureDoor, IWallsValidationConfig } from './types';
+import type { IWalls, IVerticesState, ICoordinate2D, IFeature, IFeatures, ICoordinatesLine, ISpacesStateProps, IElementAddress, IFeatureName, IVertex, IFeaturesHydrated, IElementUi, IElementName, IActiveElement, IEnclosedSpace, IFeatureDoor, IWallsValidationConfig, IGuides, IAttributeDefaults, IGridToDraw } from './types';
+import { IUnits } from './types';
 import type { IHydratedAttribute } from '../../types';
 export declare class SpacesState {
     private _config;
     private _attributesState;
+    private _attributeDefaults;
     private _newWall;
     private _activeElement;
     private _selectedElement;
@@ -10,14 +12,27 @@ export declare class SpacesState {
     private _errorElement;
     private _showDimensions;
     private _angleSnappingEnabled;
-    private _canvasDimensions;
+    private _guideSnappingEnabled;
+    private _guides;
+    private _gridSnappingEnabled;
     private _zoom;
     private _zoomLimits;
+    private _canvasDimensions;
     private _translate;
     private _translateLimits;
+    private _unit;
     private _validationConfig;
     private _state;
     constructor(config: ISpacesStateProps);
+    get styles(): import("./types").ISpacesStyles;
+    get attributeDefaults(): IAttributeDefaults;
+    set attributeDefaults(val: IAttributeDefaults);
+    get scale(): number;
+    get snapProximity(): number;
+    get gridUnitLength(): number;
+    get gridUnitLengthToDraw(): number;
+    get gridOffset(): ICoordinate2D;
+    get gridToDraw(): IGridToDraw;
     get walls(): IWalls;
     get wallsToDraw(): {
         line: ICoordinatesLine;
@@ -46,6 +61,12 @@ export declare class SpacesState {
     set showDimensions(val: boolean);
     get angleSnappingEnabled(): boolean;
     set angleSnappingEnabled(val: boolean);
+    get guideSnappingEnabled(): boolean;
+    set guideSnappingEnabled(val: boolean);
+    get gridSnappingEnabled(): boolean;
+    set gridSnappingEnabled(val: boolean);
+    get guides(): IGuides | null;
+    set guides(val: IGuides | null);
     get enclosedSpacesToDraw(): Array<IEnclosedSpace>;
     get canvasDimensions(): ICoordinate2D;
     get canvasWidth(): number;
@@ -53,9 +74,12 @@ export declare class SpacesState {
     set canvasDimensions(dimensions: ICoordinate2D);
     get zoom(): number;
     get zoomFactor(): number;
+    set zoomFactor(val: number);
     get zoomMin(): number;
     get zoomMax(): number;
-    setZoom(delta: number): number | undefined;
+    set zoom(delta: number);
+    get unit(): IUnits;
+    set unit(unit: IUnits);
     get translate(): ICoordinate2D;
     get translateMin(): ICoordinate2D;
     get translateMax(): ICoordinate2D;
@@ -63,12 +87,11 @@ export declare class SpacesState {
     get isDrawWallActive(): boolean;
     get validationConfig(): IWallsValidationConfig;
     set validationConfig(config: IWallsValidationConfig);
-    transformLengthFromCanvas(length: number): number;
-    transformLengthToCanvas(length: number): number;
-    transformPointToCanvas(point: ICoordinate2D): ICoordinate2D;
-    transformPointFromCanvas(point: ICoordinate2D): ICoordinate2D;
-    transformLineToCanvas(line: ICoordinatesLine): ICoordinatesLine;
-    transformLineFromCanvas(line: ICoordinatesLine): ICoordinatesLine;
+    private transformLengthFromCanvas;
+    private transformLengthToCanvas;
+    private transformPointToCanvas;
+    private transformPointFromCanvas;
+    private transformLineToCanvas;
     private getWall;
     private addWall;
     private addWalls;
@@ -82,8 +105,10 @@ export declare class SpacesState {
     private shiftAllFeaturesOnWall;
     private addFeatureToWall;
     private removeFeatureFromWall;
-    private splitWall;
+    splitWallAtOffset(wallIndex: number, offset?: number): void;
+    private splitWallAtPoint;
     deleteWall(index: number): void;
+    private getFirstVacantLocationOnWallIndex;
     private getFirstVacantLocation;
     getWallUiAnchorPoint(index: number): undefined | ICoordinate2D;
     private getVertex;
@@ -94,36 +119,36 @@ export declare class SpacesState {
     private getFeature;
     private updateFeature;
     private repositionFeature;
-    addFeature(type: IFeatureName, feature: Pick<IFeature, 'assetId' | 'length'> & {
-        offset?: number;
-        height?: number;
-        altitude?: number;
-    }, addToWallIndex?: number): void;
+    addFeature(type: IFeatureName, addToWallIndex?: number, feature?: Partial<Pick<IFeature, 'assetId' | 'offset' | 'length' | 'height' | 'altitude'>>): void;
     deleteFeature(type: IFeatureName, index: number): void;
     private getHydratedFeature;
     getFeatureUiAnchorPoint(type: IFeatureName, index: number): undefined | ICoordinate2D;
     deleteElement(type: IElementName, index: number): void;
-    private getVertexInProximity;
-    private getWallInProximity;
-    private snapPointToVertex;
-    private snapPointToWall;
-    private snapPointToAbsoluteAngle;
-    private snapVertexToAbsoluteAngle;
+    private getVertexIndexInProximity;
+    private getWallIndexInProximity;
+    private getSnapPointToVertexInProximity;
+    private getSnapPointToWallInProximity;
+    private getSnapPointToAngleInProximity;
+    private getSnapVertexToGuideInProximity;
+    private getSnapActiveVertexToGuideInProximity;
+    private getSnapPointToGridInProximity;
     private getFeatureAtPoint;
-    private getElementAtPoint;
-    getClickedElement(cursorPoint: ICoordinate2D): undefined | IElementUi;
-    private getPointProximity;
+    private getElementAddressAtPoint;
+    getElementUiAtPoint(cursorPoint: ICoordinate2D): undefined | IElementUi;
+    private getSnapPointToElementInProximity;
+    private runValidators;
     private reevaluateFeatureConnections;
     private pushStateToConfigurator;
     setAttributesToState(attributes?: Record<string, IHydratedAttribute>): void;
     deleteAll(): void;
     private resetInternalState;
     highlightElementIfInProximity(canvas: HTMLCanvasElement, cursorPoint: ICoordinate2D): void;
+    centerSpace(canvas: HTMLCanvasElement | null, zoomToFit?: boolean): void;
+    showGuideAtPoint(canvas: HTMLCanvasElement, cursorPoint: ICoordinate2D): void;
     startDrawNewWall(startPoint: ICoordinate2D): void;
     drawNewWall(canvas: HTMLCanvasElement, endPoint: ICoordinate2D): void;
     cancelDrawNewWall(canvas: HTMLCanvasElement): void;
-    finishDrawNewWall(canvas: HTMLCanvasElement, assetId: string): Promise<void>;
-    drawNewWallGuides(canvas: HTMLCanvasElement, cursorPoint: ICoordinate2D): void;
+    finishDrawNewWall(canvas: HTMLCanvasElement, assetId?: string): Promise<void>;
     private moveActiveVertex;
     private finishMoveActiveVertex;
     private moveActiveFeature;