@threekit-tools/treble 0.0.89 → 0.0.90

package/dist/Treble/Treble.d.ts

@@ -26,7 +26,7 @@ declare class Treble {
     _debugMode: boolean;
     constructor({ player, orgId }: ITreble);
     createOrder: (order?: IOrder) => Promise<import("../http/orders").IOrderResponse>;
-    saveConfiguration: (config?: Partial<Omit<ISaveConfiguration, 'configuration'>>) => Promise<{
+    saveConfiguration: (config?: Partial<ISaveConfiguration>) => Promise<{
         resumableUrl: string;
     } & import("../http/configurations").IConfigurationResponse & {
         thumbnail: string;

package/dist/Treble/Treble.js

@@ -80,18 +80,18 @@ var Treble = (function () {
             });
         }); };
         this.saveConfiguration = function (config) { return __awaiter(_this, void 0, void 0, function () {
-            var threekitDomain, _a, customerId, metadata, productVersion, attachments, player, response, params, url;
+            var threekitDomain, _a, customerId, metadata, configuration, productVersion, attachments, player, response, params, url;
             var _b;
             var _c;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
                         threekitDomain = connection_1.default.getConnection().threekitDomain;
-                        _a = Object.assign({}, config), customerId = _a.customerId, metadata = _a.metadata, productVersion = _a.productVersion, attachments = _a.attachments;
+                        _a = Object.assign({}, config), customerId = _a.customerId, metadata = _a.metadata, configuration = _a.configuration, productVersion = _a.productVersion, attachments = _a.attachments;
                         player = window.threekit.player.enableApi(types_1.PRIVATE_APIS.PLAYER);
                         return [4, api_1.default.configurations.save({
                                 assetId: window.threekit.player.assetId,
-                                configuration: player.getConfigurator().getFullConfiguration(),
+                                configuration: configuration || player.getConfigurator().getFullConfiguration(),
                                 customerId: customerId,
                                 metadata: metadata,
                                 productVersion: productVersion,

package/dist/components/AttributeValue/index.js

@@ -17,6 +17,8 @@ var AttributeValue = function (props) {
     if (!attributeData)
         return null;
     var value;
+    if (attributeData.type === types_1.ATTRIBUTE_TYPES.ARRAY)
+        return null;
     if (attributeData.type === types_1.ATTRIBUTE_TYPES.ASSET) {
         var assetAttribute_1 = attributeData;
         if (!((_a = assetAttribute_1.value) === null || _a === void 0 ? void 0 : _a.assetId))

package/dist/components/Wishlist/index.d.ts

@@ -27,6 +27,6 @@ export declare const Wishlist: {
         type: string;
     };
     componentName: string;
-    Icon: import("../../icons").IIcon;
+    Icon: import("../../icons/types").IIcon;
 };
 export default Wishlist;

package/dist/components/Zoom/index.d.ts

@@ -29,7 +29,7 @@ export declare const Zoom: {
         type: string;
     };
     componentName: string;
-    Icon: import("../../icons").IIcon;
+    Icon: import("../../icons/types").IIcon;
     ZoomOut: (props: ZoomComponentProps) => JSX.Element | null;
     ZoomIn: (props: ZoomComponentProps) => JSX.Element | null;
 };

package/dist/components/containers/formInputContainer.d.ts

@@ -41,7 +41,7 @@ interface IHydrateAttributeConfig {
     sort?: string;
 }
 export declare const hydrateAttributeForComponent: (attribute: IHydratedAttribute, config: IHydrateAttributeConfig) => {
-    selected: string | number | boolean | import("../../types").IConfigurationAsset | import("../../types").IConfigurationColor;
+    selected: string | number | boolean | import("../../types").IConfigurationAsset | import("../../types").IConfigurationArray | import("../../types").IConfigurationColor;
     options: {
         name: string;
         handleSelect: () => Promise<void>;

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

@@ -0,0 +1,95 @@
+import { IWalls, IVerticesState, ICoordinate2D, IFeature, IFeatures, ICoordinatesLine, IRoomBuilderStateProps, IElementAddress, IFeatureName, IVertex, IFeaturesHydrated, IElementUi, IElementName, IActiveElement, IEnclosedSpace } from './types';
+import type { IHydratedAttribute } from '../../types';
+export declare class RoomBuilderState {
+    private _config;
+    private _attributesState;
+    private _newWall;
+    private _activeElement;
+    private _selectedElement;
+    private _highlightedElement;
+    private _errorElement;
+    private _showDimensions;
+    private _angleSnappingEnabled;
+    private _state;
+    constructor(config: IRoomBuilderStateProps);
+    get walls(): IWalls;
+    set walls(walls: IWalls);
+    get wallCount(): number;
+    get wallLines(): ICoordinatesLine[];
+    get vertices(): IVerticesState;
+    set vertices(vertices: IVerticesState);
+    get verticesList(): Array<IVertex>;
+    get features(): IFeatures;
+    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(): boolean;
+    set showDimensions(val: boolean);
+    get angleSnappingEnabled(): boolean;
+    set angleSnappingEnabled(val: boolean);
+    get enclosedSpaces(): Array<IEnclosedSpace>;
+    private getWall;
+    private addWall;
+    private addWalls;
+    private updateWall;
+    private getWallConnectionCount;
+    private getWallConnectionsHydrated;
+    private getWallDimensions;
+    private getWallDetailedDimensions;
+    private getAllWallDimensions;
+    private shiftAllFeaturesOnWall;
+    private addFeatureToWall;
+    private removeFeatureFromWall;
+    private splitWall;
+    deleteWall(index: number): void;
+    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, feature: Omit<IFeature, 'path' | 'connectedTo' | 'offset'> & {
+        offset?: number;
+    }, addToWallIndex?: number): 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 getFeatureAtPoint;
+    private getElementAtPoint;
+    getClickedElement(point: ICoordinate2D): undefined | IElementUi;
+    private getPointProximity;
+    private reevaluateFeatureConnections;
+    private pushStateToConfigurator;
+    setAttributesToState(attributes?: Record<string, IHydratedAttribute>): void;
+    deleteAll(): void;
+    private resetInternalState;
+    highlightElementIfInProximity(canvas: HTMLCanvasElement, point: 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, point: ICoordinate2D): void;
+    moveActiveElement(canvas: HTMLCanvasElement, moveToPoint: ICoordinate2D): void;
+    finishMoveActiveElement(canvas: HTMLCanvasElement): void;
+    cancelMoveActiveElement(canvas: HTMLCanvasElement): void;
+    drawRoom(canvas: HTMLCanvasElement | null): void;
+}
+export default RoomBuilderState;