architwin 1.12.4 → 1.13.0

package/lib/loaders/pathLoader.js

@@ -0,0 +1,451 @@
+import { Pane } from 'tweakpane';
+import { dispatchSpaceEvent } from "../architwin";
+import { SPACE_EVENTS } from "../types";
+export class PathLine {
+    constructor(mpSdk) {
+        this.time = 0;
+        this.closed = false;
+        this.billboard = undefined;
+        this.hovered = false;
+        this.length = 0;
+        this.inputs = {
+            name: '',
+            label: 'Path Line',
+            description: '',
+            node: null,
+            tubes: null,
+            path: null,
+            enabled: true,
+            active: false,
+            editMode: false,
+            direction: -1,
+            curveType: 'catmullrom',
+            opacity: 0.3,
+            tubularSegments: 100,
+            radialSegments: 20,
+            fillColor: 'none',
+            textColor: 'rgb(255,255,255)',
+            text: '➡︎',
+            font: '48px sans-serif',
+            radius: 0.05,
+            scrollSpeed: 1.35,
+            collider: true,
+            visible: true,
+            pathOptions: null
+        };
+        //@ts-expect-error
+        this.outputs = {
+            length: 0,
+            gui: {},
+        };
+        this.emits = {
+            active: true,
+            destroyed: true,
+        };
+        this.events = {
+            'INTERACTION.CLICK': true,
+            'INTERACTION.HOVER': false,
+        };
+        this.onInit = () => {
+            const THREE = this.context.three;
+            this.groupedMesh = new THREE.Group();
+            if (this.inputs.active) {
+                //this.renderGUI();
+            }
+            if (this.inputs.path.length > 1) {
+                this.renderPathLine();
+            }
+        };
+        this.onInputsUpdated = (prevInputs) => {
+            if (this.inputs !== prevInputs) {
+                const THREE = this.context.three;
+                this.groupedMesh = new THREE.Group();
+                if (!this.inputs.active && this.panel) {
+                    this.panel.dispose();
+                    //@ts-expect-error
+                    this.panel = false;
+                }
+                else {
+                    if (!this.panel || this.inputs.label !== prevInputs.label) {
+                        //console.log('Rendering GUI...');
+                        // this.renderGUI();
+                    }
+                }
+                if (this.inputs.pathOptions) {
+                    const excludedKeys = ['id', 'pathOptions'];
+                    for (let key in this.inputs) {
+                        if (!excludedKeys.includes(key)) {
+                            if (this.inputs.pathOptions[key]) {
+                                this.inputs[key] = this.inputs.pathOptions[key];
+                            }
+                        }
+                    }
+                }
+                if (this.inputs.path.length > 1) {
+                    this.renderPathLine();
+                    console.log("paths ", this.inputs.path);
+                }
+            }
+        };
+        this.renderPathLine = () => {
+            const THREE = this.context.three;
+            // Find Length
+            let sections = this.inputs.path.length - 1;
+            this.length = 0;
+            for (let i = 0; i < sections; i++) {
+                const start = new THREE.Vector3(this.inputs.path[i].x, this.inputs.path[i].y, this.inputs.path[i].z);
+                const end = new THREE.Vector3(this.inputs.path[i + 1].x, this.inputs.path[i + 1].y, this.inputs.path[i + 1].z);
+                this.length += start.distanceTo(end);
+            }
+            const ctx = document.createElement('canvas').getContext('2d');
+            if (!ctx) {
+                return;
+            }
+            ctx.canvas.width = 64;
+            ctx.canvas.height = 64;
+            if (this.inputs.fillColor == 'none') {
+                ctx.clearRect(0, 0, 64, 64);
+            }
+            else {
+                // background
+                let fillColorRGBA = this.inputs.fillColor.replace(/rgb/i, 'rgba');
+                fillColorRGBA = fillColorRGBA.replace(/\)/i, ',' + (this.hovered ? 0.9 : this.inputs.opacity) + ')');
+                ctx.fillStyle = fillColorRGBA;
+                ctx.fillRect(0, 0, 64, 64);
+            }
+            // render out text measurement in the rendered line
+            ctx.translate(32, 32);
+            ctx.fillStyle = this.inputs.textColor;
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'middle';
+            ctx.font = this.inputs.font;
+            ctx.fillText(this.inputs.text, 0, 0);
+            this.texture = new THREE.CanvasTexture(ctx.canvas);
+            this.texture.wrapS = THREE.RepeatWrapping;
+            this.texture.wrapT = THREE.RepeatWrapping;
+            this.texture.repeat.set(this.length, 3);
+            this.material = new THREE.MeshBasicMaterial({
+                map: this.texture,
+                side: THREE.DoubleSide,
+                depthWrite: false,
+                depthTest: true,
+                transparent: true,
+                //@ts-expect-error
+                flatShading: true,
+                emissive: 0x072534,
+            });
+            if (this.inputs.path !== null) {
+                this.tubeGeometry && this.tubeGeometry.dispose();
+                this.tubeGeometry = new THREE.TubeGeometry(new THREE.CatmullRomCurve3(this.inputs.path, false, 
+                //@ts-expect-error
+                this.inputs.curveType, this.inputs.curveType == 'catmullrom' ? 0.25 : 0), this.inputs.tubularSegments, // tubularSegments
+                this.inputs.radius, this.inputs.radialSegments, // radialSegments
+                this.closed // closed
+                );
+                this.mesh = new THREE.Mesh(this.tubeGeometry, this.material);
+            }
+            this.mesh.name = this.inputs.name;
+            this.outputs.length = this.length;
+            this.groupedMesh.add(this.mesh);
+            this.mesh.visible = this.inputs.visible;
+            if (this.inputs.enabled) {
+                this.outputs.objectRoot = this.mesh;
+                this.outputs.collider = this.inputs.collider ? this.mesh : null;
+            }
+            else {
+                this.outputs.objectRoot = null;
+                this.outputs.collider = null;
+            }
+            if (this.panel) {
+                this.panel.refresh();
+            }
+            dispatchSpaceEvent(SPACE_EVENTS.PATH_UPDATED, {
+                path: this.inputs.path,
+                textColor: this.inputs.textColor
+            });
+        };
+        this.setBillboard = (value) => {
+            this.billboard = value;
+        };
+        //This is just a temp gui I need for debugging and experimentation purposes. Will be commented out once I am done
+        this.renderGUI = () => {
+            if (this.panel) {
+                this.panel.dispose();
+            }
+            this.panel = new Pane({
+                //width: 260,
+                title: 'Scrolling Tube Creator',
+                container: document.getElementById('objgui'),
+            });
+            const tab = this.panel.addTab({
+                pages: [{ title: 'Edit' }, { title: 'All Drawings' }],
+            });
+            const folder1 = tab.pages[0].addFolder({ title: 'Inputs' });
+            folder1.addBinding(this.inputs, 'name');
+            folder1.addBinding(this.inputs, 'label');
+            folder1.addBinding(this.inputs, 'description', {
+                readonly: false,
+                multiline: true,
+                rows: 5,
+            });
+            folder1.addBinding(this.inputs, 'text', {
+                options: { ' ': ' ', '➡︎': '➡︎', '✳': '✳', '☠': '☠' },
+            });
+            folder1.addBinding(this.inputs, 'textColor');
+            folder1.addBinding(this.inputs, 'fillColor');
+            folder1.addBinding(this.inputs, 'direction', {
+                options: { 'Left to Right': -1, 'Right to Left': 1 },
+            });
+            folder1.addBinding(this.outputs, 'length', {
+                readonly: true,
+            });
+            // If the node was passed as an input, we can run node.destroy();
+            if (this.inputs.node) {
+                const remove = folder1.addButton({ title: 'Remove', label: 'Remove' });
+                remove.on('click', () => {
+                    //@ts-expect-error
+                    this.notify('destroyed');
+                    this.panel.dispose();
+                    //@ts-expect-error
+                    this.panel = false;
+                    this.inputs.active = false;
+                    this.inputs.node.stop();
+                });
+            }
+            const folder2 = tab.pages[0].addFolder({
+                title: 'Advanced',
+                expanded: true,
+            });
+            folder2.addBinding(this.inputs, 'enabled');
+            folder2.addBinding(this.inputs, 'opacity', { min: 0, max: 1, step: 0.05 });
+            folder2.addBinding(this.inputs, 'radius', {
+                min: 0.01,
+                max: 1,
+                step: 0.01,
+            });
+            folder2.addBinding(this.inputs, 'scrollSpeed', {
+                min: 0,
+                max: 5,
+                step: 0.05,
+            });
+            folder2.addBinding(this.inputs, 'tubularSegments', {
+                min: 1,
+                max: 100,
+                step: 1,
+            });
+            folder2.addBinding(this.inputs, 'radialSegments', {
+                min: 1,
+                max: 20,
+                step: 1,
+            });
+            folder2.addBinding(this.inputs, 'collider');
+            if (this.inputs.tubes !== null) {
+                const nodeIterator = this.inputs.tubes.nodeIterator();
+                let nodes = nodeIterator.next();
+                while (!nodes.done) {
+                    const componentIterator = nodes.value.componentIterator();
+                    let component = componentIterator.next();
+                    nodes = nodeIterator.next();
+                    const button = tab.pages[1].addButton({
+                        title: component.value.inputs.label,
+                        label: '=',
+                    });
+                    button.on('click', (data) => {
+                        // This needs to be reviewed
+                        if (!component.value.inputs.active) {
+                            //@ts-expect-error
+                            this.notify('active', { component: component.value });
+                        }
+                    });
+                }
+            }
+        };
+        this.mpSdk = mpSdk;
+    }
+    onEvent(eventType, data) {
+        if (eventType === 'INTERACTION.CLICK') {
+            //@ts-expect-error
+            this.notify('active', { component: this });
+            // Show a Tag Billboard with the info of this tube
+            if (!this.billboard) {
+                // Allow access to these variables within then callbacks.
+                var mpSdk = this.mpSdk;
+                mpSdk.Tag.toggleNavControls(false);
+                mpSdk.Tag.add({
+                    label: this.inputs.label,
+                    description: this.inputs.description +
+                        ' - ' +
+                        Math.round(this.length * 1000) / 1000 +
+                        'm',
+                    anchorPosition: {
+                        x: data.point.x,
+                        y: data.point.y,
+                        z: data.point.z,
+                    },
+                    stemVector: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                    },
+                }).then((tags) => {
+                    this.setBillboard(tags[0]);
+                    mpSdk.Tag.allowAction(tags[0], {
+                        opening: true,
+                        navigating: true,
+                    });
+                    mpSdk.Tag.editOpacity(tags[0], 0);
+                    mpSdk.Tag.open(tags[0]).then(() => {
+                        let tagDestroyer = mpSdk.Tag.openTags.subscribe((newState) => {
+                            if (newState.selected.size == 0) {
+                                let thisTag = newState.selected;
+                                //@ts-expect-error
+                                if (thisTag != tags[0]) {
+                                    mpSdk.Tag.remove(tags[0]);
+                                    tagDestroyer.cancel();
+                                    this.setBillboard(false);
+                                    mpSdk.Tag.toggleNavControls(true);
+                                }
+                            }
+                        });
+                    });
+                });
+            }
+        }
+    }
+    onTick(tickDelta) {
+        if (this.inputs.scrollSpeed > 0) {
+            this.time += tickDelta;
+            if (this.texture) {
+                this.texture.offset.x =
+                    (this.inputs.direction *
+                        ((this.inputs.scrollSpeed * this.time) / 1000)) %
+                        1;
+            }
+        }
+    }
+    onDestroy() {
+        this.texture.dispose();
+        if (this.panel) {
+            this.panel.dispose();
+            //@ts-expect-error
+            this.panel = false;
+        }
+        if (this.billboard) {
+            this.mpSdk.Tag.remove(this.billboard);
+            console.log('Nav Controls On');
+            this.mpSdk.Tag.toggleNavControls(true);
+        }
+    }
+}
+export const pathLineType = 'pathLine';
+export const pathLineFactory = function (mpSdk) {
+    return function () {
+        return new PathLine(mpSdk);
+    };
+};
+export class PathPoint {
+    constructor(mpSdk) {
+        this.inputs = {
+            index: null,
+            radius: 0.05,
+            position: null,
+            fillColor: 'rgb(11,57,72)',
+            hoverColor: 'rgb(255,0,0)',
+            ringVisibility: false
+        };
+        this.emits = {
+            active: true,
+            changed: true,
+        };
+        this.events = {
+            'INTERACTION.DRAG': true,
+            'INTERACTION.DRAG_BEGIN': true,
+            'INTERACTION.DRAG_END': true,
+            'INTERACTION.HOVER': true,
+        };
+        this.onInputsUpdated = (prevInputs) => {
+            this.renderVertice(false);
+        };
+        this.onInit = () => {
+            this.renderVertice();
+        };
+        this.renderVertice = (hovered = false) => {
+            const THREE = this.context.three;
+            const group = new THREE.Group();
+            //This is just a visual marker so that the user can see the points they have already marked
+            this.geometry = new THREE.SphereGeometry(this.inputs.radius, 16, 16);
+            this.material = new THREE.MeshBasicMaterial({
+                color: (hovered ? this.inputs.hoverColor : this.inputs.fillColor),
+                transparent: true,
+                opacity: 0.6,
+            });
+            this.mesh = new THREE.Mesh(this.geometry, this.material);
+            this.mesh.position.set(this.inputs.position.x, this.inputs.position.y, this.inputs.position.z);
+            this.outputs.objectRoot = this.mesh;
+            this.outputs.collider = this.mesh;
+        };
+        this.mpSdk = mpSdk;
+    }
+    onEvent(eventType, data) {
+        var _a;
+        if (eventType === 'INTERACTION.DRAG') {
+            //this.pointerIntersection.object  === 'intersectedobject.model'
+            //this.pointerIntersection.object
+            console.log("group this.pointerIntersection ", this.pointerIntersection);
+            if (this.pointerIntersection.object === 'intersectedobject.model') {
+                let e = Object.assign({}, this.pointerIntersection.position);
+                this.mesh.position.set(e.x, e.y, e.z);
+                //this.mesh.children[0].position.set(e.x, e.y, e.z)
+                //@ts-expect-error
+                this.notify('changed', {
+                    index: this.inputs.index,
+                    position: this.mesh.position,
+                    collider: null,
+                });
+            }
+        }
+        if (eventType === 'INTERACTION.DRAG_BEGIN') {
+            this.mpSdk.Pointer.setVisible(false);
+            //@ts-expect-error
+            this.mesh.material.opacity = 0.5;
+            //this.mesh.children[0].material.opacity = 0.5
+            // will make it smaller later. Setting this to 0.5 to make it easier to see in the space
+            this.mesh.scale.set(0.5, 0.5, 0.5);
+            if (this.pointerSub == null) {
+                this.pointerSub = this.mpSdk.Pointer.intersection.subscribe((data) => {
+                    this.pointerIntersection = data;
+                });
+            }
+            //@ts-expect-error
+            this.notify('changed', {
+                index: this.inputs.index,
+                position: this.mesh.position,
+                collider: false,
+            });
+        }
+        if (eventType === 'INTERACTION.DRAG_END') {
+            //@ts-expect-error
+            this.mesh.material.opacity = 1;
+            this.mesh.scale.set(1, 1, 1);
+            this.mpSdk.Pointer.setVisible(true);
+            (_a = this.pointerSub) === null || _a === void 0 ? void 0 : _a.cancel();
+            //renderPolygonFromPath()
+            //@ts-expect-error
+            this.notify('changed', {
+                index: this.inputs.index,
+                position: this.mesh.position,
+                collider: false,
+            });
+            dispatchSpaceEvent(SPACE_EVENTS.VERTEX_DRAG_END, {
+                index: this.inputs.index,
+                position: this.mesh.position
+            });
+        }
+    }
+}
+export const pathPointType = 'pathPoint';
+export const pathPointFactory = function (mpSdk) {
+    return function () {
+        return new PathPoint(mpSdk);
+    };
+};

package/lib/tag.d.ts

@@ -28,7 +28,7 @@ declare function attachTagMedia(payload: {
     sdk: MpSdk;
     tag: MpSdk.Tag.TagData;
     attachments: string[];
-}): Promise<void>;
+}): Promise<string[]>;
 declare function detachTagMedia(payload: {
     sdk: MpSdk;
     tag: ITag;

package/lib/tag.js

@@ -136,10 +136,12 @@ function attachTagMedia(payload) {
         payload.tag.attachments = [];
         for (let i in payload.attachments) {
             const [attachmentId] = yield payload.sdk.Tag.registerAttachment(payload.attachments[i]);
+            log.info("media attachmentId ", attachmentId);
             payload.tag.attachments.push(attachmentId);
         }
         yield payload.sdk.Tag.attach(payload.tag.id, ...payload.tag.attachments);
         log.info('__@ Attach successfully');
+        return payload.tag.attachments;
     });
 }
 function detachTagMedia(payload) {

package/lib/types.d.ts

@@ -446,6 +446,8 @@ export interface ComponentOptions {
     polygonData?: PolygonData | undefined;
     wallHeight?: number | undefined;
     floorLevel?: number | undefined;
+    lineComponentType?: string | undefined;
+    id?: number | undefined;
 }
 export interface VectorCoords {
     object_position: Vector3;
@@ -730,7 +732,24 @@ export declare enum SPACE_EVENTS {
     CUSTOM_SWEEP_OFFSETX_UPDATED = "CUSTOM_SWEEP_OFFSETX_UPDATED",
     CUSTOM_SWEEP_OFFSETY_UPDATED = "CUSTOM_SWEEP_OFFSETY_UPDATED",
     CUSTOM_MAP_SETTINGS_UPDATED = "CUSTOM_MAP_SETTINGS_UPDATED",
-    SPACE_METADATA_RETRIEVED = "SPACE_METADATA_RETRIEVED"
+    SPACE_METADATA_RETRIEVED = "SPACE_METADATA_RETRIEVED",
+    RENDER_PIPE_CATEGORY = "RENDER_PIPE_CATEGORY",
+    PIPE_CATEGORY_REMOVED = "PIPE_CATEGORY_REMOVED",
+    PIPE_CATEGORY_SAVED = "PIPE_CATEGORY_SAVED",
+    PIPE_CATEGORY_SELECTED = "PIPE_CATEGORY_SELECTED",
+    PIPE_CATEGORY_ON_CHANGE = "PIPE_CATEGORY_ON_CHANGE",
+    PIPE_SAVED = "PIPE_SAVED",
+    PIPE_REMOVED = "PIPE_REMOVED",
+    PIPE_ON_CHANGE = "PIPE_ON_CHANGE",
+    PIPE_CLICKED = "PIPE_CLICKED",
+    PIPE_ADD = "PIPE_ADD",
+    PIPE_SELECTED = "PIPE_SELECTED",
+    DRAW_PIPE = "DRAW_PIPE",
+    DRAW_PIPE_UNDO = "DRAW_PIPE_UNDO",
+    DRAW_PIPE_REDO = "DRAW_PIPE_REDO",
+    PIPE_VERTEX_REMOVED = "PIPE_VERTEX_REMOVED",
+    TAG_MESSAGE_UNSEND = "TAG_MESSAGE_UNSEND",
+    PATH_UPDATED = "PATH_UPDATED"
 }
 export declare const enum TAG_COLOR {
     MAROON = "MAROON",
@@ -884,6 +903,7 @@ export interface IToolbarConfig {
             includeMeasurements?: boolean;
             includeViews?: boolean;
         };
+        pipe?: boolean;
         models?: boolean;
         minimap?: boolean;
         theme?: boolean;
@@ -1279,6 +1299,18 @@ export interface SpaceMetadata {
         };
     };
 }
+export interface PathConfig {
+    lineType: string;
+    verticeType: string;
+    lineTypeComponentConfig?: ComponentOptions;
+    verticeTypeComponentConfig?: ComponentOptions;
+}
+export interface ModelPayload {
+    mediaUrl: string;
+    objectType: string;
+    config?: ObjectConfig;
+    object_data?: I3DObject;
+}
 export declare enum COORDINATE_SYSTEM {
     MATTERPORT = "YUP",
     BIM = "ZUP"
@@ -1303,3 +1335,50 @@ export declare enum MAP_OPTIONS {
     DEFAULT_MAP = "Default Minimap",
     CUSTOM_MAP = "Custom Minimap"
 }
+export interface VetexData {
+    uuid: string;
+    name: string;
+    path: Array<Vector3>;
+}
+export interface IPipeCategory {
+    uuid: string;
+    space_uuid: string;
+    name: string;
+    parent_uuid: string;
+    json_data: string;
+    color?: string;
+    pipes: Array<IPipe>;
+    owner_uuid?: string;
+    created_on: Date;
+}
+export interface IPipe {
+    uuid: string;
+    space_uuid: string;
+    name: string;
+    category_uuid: string;
+    json_data: string;
+    created_on: Date;
+}
+export declare enum COLLAPSE {
+    TOGGLE_ID = "at-collapse-toggle-btn",
+    CONTENT_ID = "at-collapse-content",
+    ACTIVE = "active",
+    EXPAND = "expand",
+    TOGGLE = "toggle",
+    INACTIVE = "inactive",
+    LIST = "at-collapse-list",
+    HEADER = "at-collapse-header",
+    FORM = "at-collapse-form",
+    ITEM = "item"
+}
+export declare enum DRAWING_MODE {
+    ACTIVE = "active",
+    INACTIVE = "inactive"
+}
+export interface PipePayload {
+    uuid?: string | undefined;
+    space_uuid?: string | undefined;
+    name?: string | undefined;
+    parent_uuid?: string | undefined;
+    json_data: PolygonData;
+}

package/lib/types.js

@@ -107,6 +107,23 @@ export var SPACE_EVENTS;
     SPACE_EVENTS["CUSTOM_SWEEP_OFFSETY_UPDATED"] = "CUSTOM_SWEEP_OFFSETY_UPDATED";
     SPACE_EVENTS["CUSTOM_MAP_SETTINGS_UPDATED"] = "CUSTOM_MAP_SETTINGS_UPDATED";
     SPACE_EVENTS["SPACE_METADATA_RETRIEVED"] = "SPACE_METADATA_RETRIEVED";
+    SPACE_EVENTS["RENDER_PIPE_CATEGORY"] = "RENDER_PIPE_CATEGORY";
+    SPACE_EVENTS["PIPE_CATEGORY_REMOVED"] = "PIPE_CATEGORY_REMOVED";
+    SPACE_EVENTS["PIPE_CATEGORY_SAVED"] = "PIPE_CATEGORY_SAVED";
+    SPACE_EVENTS["PIPE_CATEGORY_SELECTED"] = "PIPE_CATEGORY_SELECTED";
+    SPACE_EVENTS["PIPE_CATEGORY_ON_CHANGE"] = "PIPE_CATEGORY_ON_CHANGE";
+    SPACE_EVENTS["PIPE_SAVED"] = "PIPE_SAVED";
+    SPACE_EVENTS["PIPE_REMOVED"] = "PIPE_REMOVED";
+    SPACE_EVENTS["PIPE_ON_CHANGE"] = "PIPE_ON_CHANGE";
+    SPACE_EVENTS["PIPE_CLICKED"] = "PIPE_CLICKED";
+    SPACE_EVENTS["PIPE_ADD"] = "PIPE_ADD";
+    SPACE_EVENTS["PIPE_SELECTED"] = "PIPE_SELECTED";
+    SPACE_EVENTS["DRAW_PIPE"] = "DRAW_PIPE";
+    SPACE_EVENTS["DRAW_PIPE_UNDO"] = "DRAW_PIPE_UNDO";
+    SPACE_EVENTS["DRAW_PIPE_REDO"] = "DRAW_PIPE_REDO";
+    SPACE_EVENTS["PIPE_VERTEX_REMOVED"] = "PIPE_VERTEX_REMOVED";
+    SPACE_EVENTS["TAG_MESSAGE_UNSEND"] = "TAG_MESSAGE_UNSEND";
+    SPACE_EVENTS["PATH_UPDATED"] = "PATH_UPDATED";
 })(SPACE_EVENTS || (SPACE_EVENTS = {}));
 export var MEETING_SIDEBAR;
 (function (MEETING_SIDEBAR) {
@@ -150,3 +167,21 @@ export var MAP_OPTIONS;
     MAP_OPTIONS["DEFAULT_MAP"] = "Default Minimap";
     MAP_OPTIONS["CUSTOM_MAP"] = "Custom Minimap";
 })(MAP_OPTIONS || (MAP_OPTIONS = {}));
+export var COLLAPSE;
+(function (COLLAPSE) {
+    COLLAPSE["TOGGLE_ID"] = "at-collapse-toggle-btn";
+    COLLAPSE["CONTENT_ID"] = "at-collapse-content";
+    COLLAPSE["ACTIVE"] = "active";
+    COLLAPSE["EXPAND"] = "expand";
+    COLLAPSE["TOGGLE"] = "toggle";
+    COLLAPSE["INACTIVE"] = "inactive";
+    COLLAPSE["LIST"] = "at-collapse-list";
+    COLLAPSE["HEADER"] = "at-collapse-header";
+    COLLAPSE["FORM"] = "at-collapse-form";
+    COLLAPSE["ITEM"] = "item";
+})(COLLAPSE || (COLLAPSE = {}));
+export var DRAWING_MODE;
+(function (DRAWING_MODE) {
+    DRAWING_MODE["ACTIVE"] = "active";
+    DRAWING_MODE["INACTIVE"] = "inactive";
+})(DRAWING_MODE || (DRAWING_MODE = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "architwin",
-  "version": "1.12.4",
+  "version": "1.13.0",
   "description": "ArchiTwin Library for Matterport",
   "main": "./lib/architwin.js",
   "types": "./lib/architwin.d.ts",