@threekit-tools/treble 0.0.93 → 0.0.94-next-01

package/dist/hooks/useShare/index.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {
@@ -53,9 +53,7 @@ var useShare = function () {
             var configuration;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4, window.threekit.treble.saveConfiguration({
-                            creator: 'threekit share button',
-                        })];
+                    case 0: return [4, window.threekit.treble.saveConfiguration()];
                     case 1:
                         configuration = _a.sent();
                         if (!configuration)

package/dist/hooks/useSingleAnimation/index.js

@@ -25,7 +25,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+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

@@ -0,0 +1,74 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 _a = loops.reduce(function (output, loop, i) {
+        loop.forEach(function (_a, j) {
+            var x = _a[0], y = _a[1];
+            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("path", { key: "path-".concat(i), d: path, stroke: props.color, strokeWidth: strokeWidth }));
+    })));
+}
+exports.default = SpacesLayout;

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

@@ -0,0 +1,177 @@
+import type { IWalls, IVerticesState, ICoordinate2D, IFeature, IFeatures, ICoordinatesLine, ISpacesStateProps, IElementAddress, IFeatureName, IVertex, IFeaturesHydrated, IElementUi, IElementName, IActiveElement, IEnclosedSpace, IFeatureDoor, IWallsValidationConfig, IGuides, IAttributeDefaults, IGridToDraw, ISpacesSync } from './types';
+import { IUnits, IDimensionOptions } from './types';
+import type { IHydratedAttribute } from '../../types';
+import { WallModes } from './constants';
+export declare class SpacesState {
+    private _config;
+    private _attributesState;
+    private _attributeDefaults;
+    private _activeWallMode;
+    private _activeWallModeAssetId;
+    private _newWall;
+    private _activeElement;
+    private _selectedElement;
+    private _highlightedElement;
+    private _errorElement;
+    private _showDimensions;
+    private _angleSnappingEnabled;
+    private _guideSnappingEnabled;
+    private _guides;
+    private _gridSnappingEnabled;
+    private _zoom;
+    private _zoomLimits;
+    private _canvasDimensions;
+    private _translate;
+    private _translateLimits;
+    private _unit;
+    private _validationConfig;
+    private _state;
+    private _setPendingStatus;
+    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;
+        path: undefined;
+        assetId: string;
+        connections: [elementType: IFeatureName, index: number][];
+        restConfiguration: string;
+        mode: WallModes;
+    }[];
+    set walls(walls: IWalls);
+    get wallCount(): number;
+    get wallLines(): ICoordinatesLine[];
+    get vertices(): IVerticesState;
+    get verticesToDraw(): IVerticesState;
+    set vertices(vertices: IVerticesState);
+    get verticesList(): Array<IVertex>;
+    get verticesListToDraw(): Array<IVertex>;
+    get features(): IFeatures;
+    get featuresToDraw(): Record<string, IFeature[] | IFeatureDoor[]>;
+    set features(features: IFeatures);
+    get getHydratedFeatures(): undefined | IFeaturesHydrated;
+    get featureCount(): number;
+    get activeElement(): IActiveElement | null;
+    get selectedElement(): null | IElementAddress;
+    set selectedElement(element: null | IElementAddress);
+    get showDimensions(): IDimensionOptions;
+    set showDimensions(val: IDimensionOptions);
+    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;
+    get canvasHeight(): number;
+    set canvasDimensions(dimensions: ICoordinate2D);
+    get zoom(): number;
+    get zoomFactor(): number;
+    set zoomFactor(val: number);
+    get zoomMin(): number;
+    get zoomMax(): number;
+    set zoom(delta: number);
+    get unit(): IUnits;
+    set unit(unit: IUnits);
+    get translate(): ICoordinate2D;
+    get translateMin(): ICoordinate2D;
+    get translateMax(): ICoordinate2D;
+    set translate(position: ICoordinate2D);
+    get isDrawWallActive(): boolean;
+    get validationConfig(): IWallsValidationConfig;
+    set validationConfig(config: IWallsValidationConfig);
+    set wallMode(mode: {
+        value: WallModes;
+        assetId: string;
+    });
+    get wallMode(): {
+        value: WallModes;
+        assetId: string;
+    };
+    sync(state: Partial<ISpacesSync>): void;
+    private transformLengthFromCanvas;
+    private transformLengthToCanvas;
+    private transformPointToCanvas;
+    private transformPointFromCanvas;
+    private transformLineToCanvas;
+    private prepLineLength;
+    private getWall;
+    private addWall;
+    private addWalls;
+    private updateWall;
+    private getWallConnectionCount;
+    private getWallConnectionsHydrated;
+    private getWallDimensions;
+    private getWallDimensionsByIndex;
+    private getWallDetailedDimensionsByIndex;
+    private getDimensionToDraw;
+    private shiftAllFeaturesOnWall;
+    private addFeatureToWall;
+    private removeFeatureFromWall;
+    splitWallAtOffset(wallIndex: number, offset?: number): void;
+    private splitWallAtPoint;
+    deleteWall(index: number): void;
+    private getFirstVacantLocationOnWallIndex;
+    private getFirstVacantLocation;
+    getWallUiAnchorPoint(index: number): undefined | ICoordinate2D;
+    private getVertex;
+    private getWallsConnectedToVertex;
+    private repositionVertex;
+    private getFeatureType;
+    private setFeatureType;
+    private getFeature;
+    private updateFeature;
+    private repositionFeature;
+    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 getVertexIndexInProximity;
+    private getWallIndexInProximity;
+    private getSnapPointToVertexInProximity;
+    private getSnapPointToWallInProximity;
+    private getSnapPointToAngleInProximity;
+    private getSnapVertexToGuideInProximity;
+    private getSnapActiveVertexToGuideInProximity;
+    private getSnapPointToGridInProximity;
+    private getFeatureAtPoint;
+    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>;
+    private moveActiveVertex;
+    private finishMoveActiveVertex;
+    private moveActiveFeature;
+    private finishMoveActiveFeature;
+    selectElementIfInProximity(canvas: HTMLCanvasElement, cursorPoint: ICoordinate2D): void;
+    moveActiveElement(canvas: HTMLCanvasElement, moveToPoint: ICoordinate2D): void;
+    finishMoveActiveElement(canvas: HTMLCanvasElement): void;
+    cancelMoveActiveElement(canvas: HTMLCanvasElement): void;
+    drawSpaces(canvas: HTMLCanvasElement | null): void;
+}
+export default SpacesState;