@bimdata/viewer 2.0.0-beta.74 → 2.0.0-beta.76

package/types/plugins.d.ts

@@ -1,75 +1,79 @@
 declare namespace BDV {
-  interface PluginConfig {
+  interface PluginDefinition {
     name: string;
     isViewer?: boolean;
-    i18n: Object;
-    component?: Object;
+    i18n: any;
+    addToWindows?: string[];
+    component?: any;
+    window?: Window;
     button?: {
       position: string;
       stance?: number;
       tooltip: string;
       content: "free" | "simple" | "panel";
       keepOpen?: boolean;
+      overlapWith?: string[];
       icon: {
         imgUri?: string;
-        component?: Object;
-        options?: {
-          props: Object;
-        };
+        component?: any;
+        options?: { props: Object; };
       };
     };
     startupScript?: ($viewer: $Viewer) => void;
-    addToWindows?: string[];
-    window?: Window;
+
+    // Appended properties
+    id?: number;
+    componentInstance?: PluginInstance;
+    shown?: boolean;
   }
 
-  interface Plugin {
+  interface PluginInstance {
     name: string;
+    plugin: PluginDefinition;
     $cfg: any;
-    $plugin: any;
     $viewer: $Viewer;
-    viewer?: any;
+    $show(): void;
+    $hide(): void;
     $open?: () => void;
     onOpen?: () => void;
     $close?: () => void;
     onClose?: () => void;
   }
 
-  interface PluginViewer extends Plugin {
+  interface ModelViewerConfig {
+    modelLoader?: "hidden" | "disabled";
+  }
+
+  interface ModelViewerInstance extends PluginInstance {
+    viewer?: any;
     modelTypes?: string[];
+    annotationMode: boolean;
 
     getLoadedModels: () => StateModel[];
     loadModels: (models: StateModel[]) => Promise<void>;
     unloadModels: (models: StateModel[]) => Promise<void>;
-
-    getViewpoint: (options: any) => void | Promise<void>;
+    getViewpoint: (options?: any) => any | Promise<any>;
     setViewpoint: (viewpoint: any, options?: any) => void | Promise<void>;
-
-    annotationMode: boolean;
     startAnnotationMode: (callback: AnnotationCallback) => void;
     stopAnnotationMode: () => void;
-
     fitView: (options?: any) => void;
     showUI: (options?: any) => void;
     hideUI: (options?: { exceptions: string[] }) => Promise<void>;
   }
 
   interface PluginManager {
-    cfg: ViewerConfigPlugins; // ?
-    windows: Window[];
-    pluginsUnits: PluginsUnit[];
-    readonly pluginsUnit: PluginsUnit;
-    readonly registeredPlugins: Plugin[];
+    cfg: ViewerConfigPlugins;
+    readonly registeredPlugins: Map<string, PluginDefinition>;
+    readonly pluginsUnits: PluginsUnit[];
 
-    getWindow(name: string): Window;
-    registerWindow(window: Window): Window;
-    unregisterWindow(name: string): boolean;
-    getPluginCopy(name: string, silent?: boolean): Plugin;
-    registerPlugin(plugin: Plugin, cfg: PluginConfig): void;
+    getPluginCopy(name: string, silent?: boolean): PluginDefinition;
+    registerPlugin(plugin: PluginDefinition): void;
     registerPluginsTranslations(i18nPlugin: any): void;
     runPluginsScripts($viewer: $Viewer): void;
+  }
 
-    getLocalContext(component: any): LocalContext;
+  interface PluginsUnit {
+    localContext: LocalContext;
   }
 
   type AnnotationCallback = (params: AnnotationParams) => void;

package/types/shortcuts.d.ts

@@ -1,7 +1,7 @@
 declare namespace BDV {
   interface Shortcut {
     name: string;
-    context: Object;
+    context: GlobalContext | LocalContext;
     key: string;
     ctrlKey: boolean;
     shiftKey: boolean;
@@ -11,12 +11,13 @@ declare namespace BDV {
 
   interface ShortcutManager {
     active: boolean;
+    activeLocalContext?: LocalContext;
     shortcuts: Shortcut[];
-    currentContext: any;
 
     getShortcuts(context: GlobalContext | LocalContext): Shortcut[];
     getShortcut(name: string, context: GlobalContext | LocalContext): Shortcut;
     registerShortcut(shortcut: Shortcut, context: GlobalContext | LocalContext): boolean;
     unregisterShortcut(name: string, context: GlobalContext | LocalContext): boolean;
+    destroy(): void;
   }
 }

package/types/state.d.ts

@@ -3,51 +3,102 @@ declare namespace BDV {
     hub: EventHandler<StateEvents>;
 
     /**** models ****/
-    models: StateModel[];
-    modelsMap: Map<number, StateModel>;
-    loadModels(modelIds: string[]): Promise<StateModel[]>;
-    unloadModels(modelIds: string[]);
-    getModel(id: number): StateModel;
+    readonly models: StateModel[];
+    readonly modelsMap: Map<number, StateModel>;
+    loadModels(modelIds: number[]): Promise<StateModel[]>;
+    unloadModels(modelIds: number[]);
+    getStoreyFromAbsoluteElevation(model: StateModel, elevation: number): StateStorey;
 
     /**** objects ****/
-    objects: StateObject[];
-    objectsMap: Map<number, StateObject>;
-    uuidsMap: { get(uuid: string): StateObject[]; };
-    selectedObjects: StateObject[];
-    colorizedObjects: StateObject[];
-    deselectedObjects: StateObject[];
-    highlightedObjects: StateObject[];
-    unhighlightedObjects: StateObject[];
-    visibleObjects: StateObject[];
-    unvisibleObjects: StateObject[];
-    xrayedObjects: StateObject[];
-    unxrayedObjects: StateObject[];
+    readonly objects: StateObject[];
+    readonly objectsIds: number[];
+    readonly objectsUuids: string[];
+    readonly objectsMap: Map<number, StateObject>;
+    readonly uuidsMap: { get(uuid: string): StateObject[]; };
     getObject(id: number): StateObject;
     getObjectsByUuids(uuids: string[]): StateObject[];
-    selectObjects(ids: number[]): void;
-    colorizeObjects(ids: number[], color?: string): void;
-    deselectObjects(ids: number[]): void;
-    highlightObjects(ids: number[]): void;
-    unhighlightObjects(ids: number[]): void;
-    showObjects(ids: number[]): void;
-    hideObjects(ids: number[]): void;
-    xrayObjects(ids: number[]): void;
-    unxrayObjects(ids: number[]): void;
-    isolateObjects(ids: number[]): void;
-    reintegrateObjects(): void;
+    getObjectsOfType(type: string): StateObject[];
+    getObjectsWithTheSameTypeAs(ids: number[]): StateObject[];
+    getTypesOf(ids: number[]): string[];
+
+    readonly visibleObjects: StateObject[];
+    readonly visibleObjectsIds: number[];
+    readonly visibleObjectsUuids: string[];
+    showObjects(ids: number[], options?: any): void;
+    showObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly unvisibleObjects: StateObject[];
+    readonly unvisibleObjectsIds: number[];
+    readonly unvisibleObjectsUuids: string[];
+    hideObjects(ids: number[], options?: any): void;
+    hideObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly pickableObjects: StateObject[];
+    readonly pickableObjectsIds: number[];
+    readonly pickableObjectsUuids: string[];
+    setObjectsPickable(ids: number[], options?: any): void;
+    setObjectsPickableByUuids(uuids: string[], options?: any): void;
+
+    readonly unpickableObjects: StateObject[];
+    readonly unpickableObjectsIds: number[];
+    readonly unpickableObjectsUuids: string[];
+    setObjectsUnpickable(ids: number[], options?: any): void;
+    setObjectsUnpickableByUuids(uuids: string[], options?: any): void;
+
+    readonly selectedObjects: StateObject[];
+    readonly selectedObjectsIds: number[];
+    readonly selectedObjectsUuids: string[];
+    selectObjects(ids: number[], options?: any): void;
+    selectObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly deselectedObjects: StateObject[];
+    readonly deselectedObjectsIds: number[];
+    readonly deselectedObjectsUuids: string[];
+    deselectObjects(ids: number[], options?: any): void;
+    deselectObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly highlightedObjects: StateObject[];
+    readonly highlightedObjectsIds: number[];
+    readonly highlightedObjectsUuids: string[];
+    highlightObjects(ids: number[], options?: any): void;
+    highlightObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly unhighlightedObjects: StateObject[];
+    readonly unhighlightedObjectsIds: number[];
+    readonly unhighlightedObjectsUuids: string[];
+    unhighlightObjects(ids: number[], options?: any): void;
+    unhighlightObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly xrayedObjects: StateObject[];
+    readonly xrayedObjectsIds: number[];
+    readonly xrayedObjectsUuids: string[];
+    xrayObjects(ids: number[], options?: any): void;
+    xrayObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly unxrayedObjects: StateObject[];
+    readonly unxrayedObjectsIds: number[];
+    readonly unxrayedObjectsUuids: string[];
+    unxrayObjects(ids: number[], options?: any): void;
+    unxrayObjectsByUuids(uuids: string[], options?: any): void;
+
+    readonly colorizedObjects: StateObject[];
+    readonly colorizedObjectsIds: number[];
+    readonly colorizedObjectsUuids: string[];
+    colorizeObjects(ids: number[], color?: string, options?: any): void;
+    colorizeObjectsByUuids(uuids: string[], color?: string, options?: any): void;
 
     /**** annotations ****/
     readonly annotations: StateAnnotation[];
-    addAnnotation(annotation: StateAnnotation, options: any): StateAnnotation;
-    removeAnnotation(annotation: any, options: any): boolean;
+    addAnnotation(annotation: StateAnnotation, options?: any): StateAnnotation;
+    removeAnnotation(annotation: StateAnnotation, options?: any): boolean;
     clearAnnotations(): void;
 
     // ---
 
     /** @deprecated use `models` instead */
-    ifcs: StateModel[];
+    readonly ifcs: StateModel[];
     /** @deprecated use `modelsMap` instead */
-    ifcsMap: Map<number, StateModel>;
+    readonly ifcsMap: Map<number, StateModel>;
     /** @deprecated use `loadModels` instead */
     loadIfcs(ifcIds: string[]): Promise<StateModel[]>;
     /** @deprecated use `unloadModels` instead */
@@ -71,55 +122,63 @@ declare namespace BDV {
     "objects-removed": {
       objects: StateObject[];
     };
-    "objects-selected": {
+    "objects-shown": {
       objects: StateObject[];
-      options?: Object;
+      options?: any;
     };
-    "objects-deselected": {
+    "objects-hidden": {
       objects: StateObject[];
-      options?: Object;
+      options?: any;
     };
-    "objects-highlighted": {
+    "objects-pickable": {
       objects: StateObject[];
-      options?: Object;
+      options?: any;
     };
-    "objects-unhighlighted": {
+    "objects-unpickable": {
       objects: StateObject[];
-      options?: Object;
+      options?: any;
     };
-    "objects-shown": {
+    "objects-selected": {
       objects: StateObject[];
-      options?: Object;
+      options?: any;
     };
-    "objects-hidden": {
+    "objects-deselected": {
+      objects: StateObject[];
+      options?: any;
+    };
+    "objects-highlighted": {
       objects: StateObject[];
-      $options?: Object;
+      options?: any;
+    };
+    "objects-unhighlighted": {
+      objects: StateObject[];
+      options?: any;
     };
     "objects-xrayed": {
       objects: StateObject[];
-      options?: Object;
+      options?: any;
     };
     "objects-unxrayed": {
       objects: StateObject[];
-      options?: Object;
+      options?: any;
     };
     "objects-colorized": {
       objects: StateObject[];
       color: number;
-      options?: Object;
+      options?: any;
     };
     // annotations events
     "annotation-added": {
-      annotation: Object;
-      options?: Object;
+      annotation: StateAnnotation;
+      options?: any;
     };
     "annotation-updated": {
-      annotation: Object;
-      options?: Object;
+      annotation: StateAnnotation;
+      options?: any;
     };
     "annotation-removed": {
-      annotation: Object;
-      options?: Object;
+      annotation: StateAnnotation;
+      options?: any;
     };
 
     // ---
@@ -134,20 +193,18 @@ declare namespace BDV {
     };
   };
 
-  interface StateModel {
-    id: number;
-    name: string;
-    type: ModelType;
-    status: ModelStatus;
+  interface StateModel extends ApiModel {
     structure: Object;
-    objects: StateObject[];
     uuids: Map<string, StateObject>;
+    objects: StateObject[];
     storeys: StateStorey[];
   }
 
   interface StateObject extends ApiObject {
     id: number;
     model: StateModel;
+
+    // Object state
     visible: boolean;
     pickable: boolean;
     selected: boolean;
@@ -158,9 +215,12 @@ declare namespace BDV {
     // Advanced getters
     readonly descendants: StateObject[];
     readonly ancestors: StateObject[];
+    readonly site: StateObject;
+    readonly building: StateObject;
+    readonly storey: StateObject;
+    readonly layout: StateObject;
+    readonly space: StateObject;
     getFirstAncestorWithType: (type: string) => StateObject;
-    storey: StateObject;
-    space: StateObject;
 
     // ---
 
@@ -185,6 +245,7 @@ declare namespace BDV {
   }
 
   interface StatePlan extends ApiPlan {
+    plan?: ApiPlan;
     model: StateModel;
     storey: StateStorey;
     positioning: StatePositionning;
@@ -209,6 +270,6 @@ declare namespace BDV {
     y: number;
     z: number;
     component: any;
-    props: any;
+    props?: any;
   }
 }

package/types/windows.d.ts

@@ -5,5 +5,13 @@ declare namespace BDV {
     icon: { imgUri: string; };
     plugins?: string[];
     menu?: boolean;
+    modelTypes?: string[];
+    multiModel: boolean;
+  }
+
+  interface WindowManager {
+    registeredWindows: Map<string, Window>;
+    registerWindow(window: Window): Window;
+    unregisterWindow(name: string): void;
   }
 }

package/types/plugins-unit.d.ts

@@ -1,5 +0,0 @@
-declare namespace BDV {
-  interface PluginsUnit {
-    localContext: LocalContext;
-  }
-}