fcs-core-viewer 0.2.4 → 0.3.1

package/fcs-core-viewer@types/CloudViewer/FcsViewer.d.ts

@@ -4,7 +4,6 @@ import { VisibilitySettings } from './Settings/VisibilitySettings';
 import { CameraSettings } from "./Settings/CameraSettings";
 import { AnnotationEntities } from "../ViewerEntities/VisibleEntities/AnnotationEntities";
 import { AbstractEntities } from '../ViewerEntities/AbstractEntities';
-import { ContainerEntities } from "../ViewerEntities/ContainerEntities";
 import { TemporaryEntities } from '../ViewerEntities/VisibleEntities/TemporaryEntities';
 /**
  * Contains all control methods to the cloud viewer.
@@ -50,7 +49,6 @@ export declare namespace CloudViewer {
          * @param stlFileUrl Public download URL for STL file.
          * @param t2gFileUrl Public download URL for T2G file.
          */
-        addToDocument(itemId: number, itemName: string, stlFileUrl: string, t2gFileUrl?: string): Promise<void>;
         /**
          * Places an item with geometric definition under a specified already existing item.
          * @param itemId Unique ID of the item.
@@ -59,7 +57,7 @@ export declare namespace CloudViewer {
          * @param stlFileUrl Public download URL for STL file.
          * @param t2gFileUrl Public download URL for T2G file.
          */
-        addToDocumentUnder(itemId: number, parentId: number, itemName: string, stlFileUrl: string, t2gFileUrl?: string): Promise<void>;
+        addToDocumentUnder(itemId: number, parentId: number, itemName: string, stlFileUrl: string, t2gFileUrl: string, isCADModel: boolean): Promise<void>;
         /**
          * Generates a unique id in the viewer
          */
@@ -278,7 +276,6 @@ export declare namespace CloudViewer {
         /**
          * Functions required for manipulating the model tree
          */
-        getTreeCore(): ContainerEntities.ModelTreeStructure;
         /**
          * The returned JSON contains detailed hierarchical informations
          * how the model is setup.

package/fcs-core-viewer@types/DataStorage/MaterialData.d.ts

@@ -0,0 +1,87 @@
+import * as THREE from '../three/build/three.module';
+import { SceneWrapper } from "../Model/SceneWrapper";
+export declare class MaterialData {
+    sceneWrapper: SceneWrapper;
+    constructor(sceneWrapper: SceneWrapper);
+    /**
+     * Itt definialunk a THREE.Mesh objektumoknak material-t
+     */
+    setMeshMaterial(): void;
+    /**
+     * Itt definialunk a THREE.Line2 objektumoknak material-t
+     */
+    setLineMaterial(): void;
+    /**
+     * Itt definialunk a THREE.Point objektumoknak material-t
+     */
+    setPointMaterial(): void;
+    /**
+     * Kigeneralja a custom shader-t, amit argumentumknet beadunk a THREE.ShaderMaterial-nak
+     * @param currentCamera
+     * @param graySphereTexture
+     * @param yellowSphereTexture
+     * @param violetSphereTexture
+     * @returns
+     */
+    createShader(currentCamera: THREE.OrthographicCamera, graySphereTexture: THREE.Texture, yellowSphereTexture: THREE.Texture, violetSphereTexture: THREE.Texture): {
+        uniforms: {
+            graySphereTexture: {
+                value: THREE.Texture;
+            };
+            yellowSphereTexture: {
+                value: THREE.Texture;
+            };
+            violetSphereTexture: {
+                value: THREE.Texture;
+            };
+            pointSize: {
+                value: number;
+            };
+            alphaTest_gray: {
+                value: number;
+            };
+            alphaTest_yellow: {
+                value: number;
+            };
+            alphaTest_violet: {
+                value: number;
+            };
+            near: {
+                value: any;
+            };
+            far: {
+                value: any;
+            };
+            pixelWidth: {
+                value: number;
+            };
+            pixelHeight: {
+                value: number;
+            };
+        };
+        vertexShader: string;
+        fragmentShader: string;
+        transparent: boolean;
+        depthTest: boolean;
+        visible: boolean;
+        depthWrite: boolean;
+        uniformsNeedUpdate: boolean;
+    };
+    /**
+     * Custom shader-t general THREE.Mesh objektumnak
+     * @returns
+     */
+    meshCustomShader(): {
+        uniforms: {};
+        vertexShader: string;
+        fragmentShader: string;
+        vertexColors: boolean;
+        visible: boolean;
+        depthTest: boolean;
+        depthWrite: boolean;
+        colorWrite: boolean;
+        alphaToCoverage: boolean;
+        transparent: boolean;
+        side: any;
+    };
+}

package/fcs-core-viewer@types/DataStorage/ModelData.d.ts

@@ -0,0 +1,222 @@
+import * as THREE from '../three/build/three.module';
+import { SceneWrapper } from '../Model/SceneWrapper';
+import { FaceSelectionMethods } from "../SelectionTools/SelectionMethods/FaceSelectionMethods";
+import { FaceUnselectionMethods } from "../SelectionTools/SelectionMethods/FaceUnselectionMethods";
+import { EdgeSelectionMethods } from "../SelectionTools/SelectionMethods/EdgeSelectionMethods";
+import { EdgeUnselectionMethods } from "../SelectionTools/SelectionMethods/EdgeUnselectionMethods";
+import { VertexSelectionMethods } from "../SelectionTools/SelectionMethods/VertexSelectionMethods";
+import { VertexUnselectionMethods } from "../SelectionTools/SelectionMethods/VertexUnselectionMethods";
+import { Entity } from "../SelectionTools/SelectionControls/SelectionControls";
+import { ElementSelectionMethods } from '../SelectionTools/SelectionMethods/ElementSelectionMethods';
+import { ElementUnselectionMethods } from '../SelectionTools/SelectionMethods/ElementUnselectionMethods';
+import { NodeSelectionMethods } from '../SelectionTools/SelectionMethods/NodeSelectionMethods';
+import { NodeUnselectionMethods } from '../SelectionTools/SelectionMethods/NodeUnselectionMethods';
+export declare namespace ModelData {
+    namespace ContainerType {
+        class MeshContainer {
+            static instance: MeshContainer;
+            sceneWrapper: SceneWrapper;
+            componentVIDs: number[];
+            cntMesh: THREE.Mesh;
+            generalMeshMaterial: THREE.MeshPhongMaterial;
+            sharedPositionBuffer: ArrayBuffer;
+            sharedNormalBuffer: ArrayBuffer;
+            sharedColorBuffer: ArrayBuffer;
+            sharedVisibilityBuffer: ArrayBuffer;
+            sharedPositionArray: Float32Array;
+            sharedNormalArray: Float32Array;
+            sharedColorArray: Float32Array;
+            sharedVisibilityArray: Float32Array;
+            constructor(sceneWrapper: SceneWrapper);
+            static getInstance(): MeshContainer;
+            updateColorAttribute(): void;
+            private createContainer;
+            addMeshToScene(data: {}): void;
+            removeFace(): void;
+        }
+        class LineContainer {
+            static instance: LineContainer;
+            sceneWrapper: SceneWrapper;
+            componentVIDs: number[];
+            cntLine: THREE.Line;
+            generalLineMaterial: THREE.LineMaterial;
+            sharedPositionBuffer: ArrayBuffer;
+            sharedColorBuffer: ArrayBuffer;
+            sharedWidthBuffer: ArrayBuffer;
+            sharedVisibilityBuffer: ArrayBuffer;
+            sharedPositionArray: Float32Array;
+            sharedColorArray: Float32Array;
+            sharedWidthArray: Float32Array;
+            sharedVisibilityArray: Float32Array;
+            constructor(sceneWrapper: SceneWrapper);
+            static getInstance(): LineContainer;
+            updateColorAttribute(): void;
+            createContainer(): any;
+            addLineToScene(data: {}): void;
+        }
+        class PointContainer {
+            static instance: PointContainer;
+            sceneWrapper: SceneWrapper;
+            componentVIDs: number[];
+            cntPoint: THREE.Point;
+            generalPointMaterial: THREE.ShaderMaterial;
+            sharedPositionBuffer: ArrayBuffer;
+            sharedTextureIDBuffer: ArrayBuffer;
+            sharedVisibilityBuffer: ArrayBuffer;
+            sharedPositionArray: Float32Array;
+            sharedTextureIDArray: Float32Array;
+            sharedVisibilityArray: Float32Array;
+            constructor(sceneWrapper: SceneWrapper);
+            static getInstance(): PointContainer;
+            updateColorAttribute(): Promise<void>;
+            createContainer(): any;
+            addPointToScene(data: {}): void;
+        }
+    }
+    namespace Associations {
+    }
+    namespace Types {
+        class Face {
+            select: FaceSelectionMethods;
+            unselect: FaceUnselectionMethods;
+            type: Entity;
+            itemVID: number;
+            itemUID: string;
+            componentVID: number;
+            componentUID: number;
+            faceVID: number;
+            faceUIDs: number[];
+            count: number;
+            polygonsXYZ: [];
+            edges: Edge[];
+            baseColor: number[];
+            baseOpacity: number;
+            isVisible: number;
+            isSelected: boolean;
+            byteOffsetPosition: number;
+            byteOffsetNormal: number;
+            byteOffsetColor: number;
+            byteOffsetVisibility: number;
+            lengthPosition: number;
+            lengthNormal: number;
+            lengthColor: number;
+            lengthVisibility: number;
+            constructor(itemVID: number, itemUID: string, componentVID: number, componentUID: number, faceVID: number, faceUIDs: number[], countVertices: number, polygonsXYZ: []);
+            setColor(r: number, g: number, b: number, alpha: number): void;
+            setBaseColor(r: number, g: number, b: number, alpha: number): void;
+            setOpacity(alpha: number): void;
+            setBaseOpacity(alpha: number): void;
+            addToScene(): void;
+        }
+        class Edge {
+            select: EdgeSelectionMethods;
+            unselect: EdgeUnselectionMethods;
+            type: Entity;
+            itemVID: number;
+            componentVID: number;
+            edgeVID: number;
+            edgeUIDs: number[];
+            segmentsXYZ: number[];
+            count: number;
+            faces: Face[];
+            vertices: Vertex[];
+            elements: Element[];
+            nodes: Node[];
+            baseColor: number[];
+            lineWidth: number;
+            isVisible: number;
+            isSelected: boolean;
+            byteOffsetPosition: number;
+            byteOffsetColor: number;
+            byteOffsetWidth: number;
+            byteOffsetVisibility: number;
+            lengthPosition: number;
+            lengthColor: number;
+            lengthWidth: number;
+            lengthVisibility: number;
+            constructor(itemVID: number, componentVID: number, edgeVID: number, edgeUIDs: number[], segmentsXYZ: number[], count: number, faces?: Face[], elements?: Element[]);
+            setColor(r: number, g: number, b: number, lineWidth: number): void;
+            setBaseColor(r: number, g: number, b: number, lineWidth: number): void;
+        }
+        class Vertex {
+            select: VertexSelectionMethods;
+            unselect: VertexUnselectionMethods;
+            type: Entity;
+            itemVID: number;
+            componentVID: number;
+            vertexVID: number;
+            vertexUIDs: number[];
+            positionXYZ: number[];
+            count: number;
+            edges: Edge[];
+            faces: Face[];
+            textureID: number;
+            isVisible: number;
+            isSelected: boolean;
+            byteOffsetPosition: number;
+            byteOffsetTextureID: number;
+            byteOffsetVisibility: number;
+            lengthPosition: number;
+            lengthTextureID: number;
+            lengthVisibility: number;
+            constructor(itemVID: number, componentVID: number, vertexVID: number, vertexUIDs: number[], positionXYZ: number[], edges?: Edge[], faces?: Face[]);
+            setColor(textureID: number): void;
+        }
+        class Element {
+            select: ElementSelectionMethods;
+            unselect: ElementUnselectionMethods;
+            type: Entity;
+            itemVID: number;
+            itemUID: string;
+            componentVID: number;
+            componentUID: number;
+            elementVID: number;
+            elementUIDs: number[];
+            count: number;
+            polygonsXYZ: [];
+            edges: Edge[];
+            baseColor: number[];
+            baseOpacity: number;
+            isVisible: number;
+            isSelected: boolean;
+            byteOffsetPosition: number;
+            byteOffsetNormal: number;
+            byteOffsetColor: number;
+            byteOffsetVisibility: number;
+            lengthPosition: number;
+            lengthNormal: number;
+            lengthColor: number;
+            lengthVisibility: number;
+            constructor(itemVID: number, itemUID: string, componentVID: number, componentUID: number, elementVID: number, elementUIDs: number[], countNodes: number, polygonsXYZ: []);
+            setColor(r: number, g: number, b: number, alpha: number): void;
+            setBaseColor(r: number, g: number, b: number, alpha: number): void;
+            setOpacity(alpha: number): void;
+            setBaseOpacity(alpha: number): void;
+            addToScene(): void;
+        }
+        class Node {
+            select: NodeSelectionMethods;
+            unselect: NodeUnselectionMethods;
+            type: Entity;
+            itemVID: number;
+            componentVID: number;
+            nodeVID: number;
+            nodeUIDs: number[];
+            positionXYZ: number[];
+            count: number;
+            elements: Element[];
+            textureID: number;
+            isVisible: number;
+            isSelected: boolean;
+            byteOffsetPosition: number;
+            byteOffsetTextureID: number;
+            byteOffsetVisibility: number;
+            lengthPosition: number;
+            lengthTextureID: number;
+            lengthVisibility: number;
+            constructor(itemVID: number, componentVID: number, nodeVID: number, nodeUIDs: number[], positionXYZ: number[], elements?: Element[]);
+            setColor(textureID: number): void;
+        }
+        function myFunction(): void;
+    }
+}

package/fcs-core-viewer@types/DataStorage/TreeData.d.ts

@@ -0,0 +1,3 @@
+export declare class TreeData {
+    constructor();
+}

package/fcs-core-viewer@types/FrontendEvents/MenuEvents.d.ts

@@ -29,7 +29,6 @@ export declare class MenuEvents {
     cutView: CutView;
     explodedView: ExplodedView;
     readonly div_treeHTML: HTMLElement;
-    readonly section_geom: HTMLElement;
     readonly a_color: HTMLElement;
     readonly input_range_color: HTMLInputElement;
     readonly table_color: HTMLElement;

package/fcs-core-viewer@types/FrontendEvents/SidebarEvents.d.ts

@@ -4,15 +4,12 @@ export declare class SidebarEvents {
     readonly menuSections: any[];
     readonly topbarSections_L1: any[];
     readonly a_geom: HTMLElement;
-    readonly section_geom: HTMLElement;
     readonly a_1D: HTMLElement;
-    readonly section_1D: HTMLElement;
     readonly a_dev: HTMLElement;
     readonly section_dev: HTMLElement;
     readonly a_beam: HTMLElement;
     readonly section_beam: HTMLElement;
     readonly a_node: HTMLElement;
-    readonly section_node: HTMLElement;
     readonly icon_options: HTMLElement;
     readonly section_options: HTMLElement;
     constructor(sceneWrapper: SceneWrapper);

package/fcs-core-viewer@types/FrontendEvents/TopbarEvents.d.ts

@@ -56,6 +56,10 @@ export declare class TopbarEvents {
     readonly a_vertex: HTMLElement;
     readonly a_edge: HTMLElement;
     readonly a_face: HTMLElement;
+    readonly a_elem: HTMLElement;
+    readonly a_node: HTMLElement;
+    readonly a_line: HTMLElement;
+    readonly a_point: HTMLElement;
     readonly section_entities: HTMLElement;
     readonly a_sktch: HTMLElement;
     readonly a_views: HTMLElement;

package/fcs-core-viewer@types/Loader/Loader.d.ts

@@ -1,6 +1,7 @@
-import { LoadVertex } from './LoadVertex';
-import { LoadEdge } from './LoadEdge';
-import { STEPLoader } from './LoadSTEP';
+import { VertexLoader } from './STEPLoader/VertexLoader';
+import { EdgeLoader } from './STEPLoader/EdgeLoader';
+import { FaceLoader } from './STEPLoader/FaceLoader';
+import { TriangleLoader } from './STLLoader/ElementLoader';
 import { BackendManager } from '../Common/CommsChannels/BackendClient';
 import { TaskUtils } from '../TaskHandler/TaskUtils';
 import { Appearance } from '../TaskHandler/Context/Context';
@@ -20,9 +21,10 @@ import { MeshWrapper } from '../Model/MeshWrapper';
  * - Az endpontrol huzzuk be az STL-t es a JSON-t
  */
 export declare class Loader {
-    loadVertex: LoadVertex;
-    loadEdge: LoadEdge;
-    stepLoader: STEPLoader;
+    vertexLoader: VertexLoader;
+    edgeLoader: EdgeLoader;
+    faceLoader: FaceLoader;
+    triangleLoader: TriangleLoader;
     taskUtils: TaskUtils;
     name: any;
     stlPath: any;
@@ -38,7 +40,7 @@ export declare class Loader {
      * @param loadEdge
      * @param stepLoader
      */
-    constructor(loadVertex: LoadVertex, loadEdge: LoadEdge, stepLoader: STEPLoader, taskUtils: TaskUtils, meshWrapper: MeshWrapper, appearance: Appearance, treeView: TreeView);
+    constructor(vertexLoader: VertexLoader, edgeLoader: EdgeLoader, faceLoader: FaceLoader, triangleLoader: TriangleLoader, taskUtils: TaskUtils, meshWrapper: MeshWrapper, appearance: Appearance, treeView: TreeView);
     importModelFrontend(backendManager: BackendManager): void;
     /**
      * This method serves to save the current document locally.
@@ -53,7 +55,7 @@ export declare class Loader {
      * @param extension The extension of the uploadable file
      */
     private _guessFileType;
-    importSTLBackend(name: string, itemUID: number, parentUID: number, stlPathStatic: string): Promise<void>;
+    importSTLBackend(name: any, itemUID: any, parentUID: any, stlPathStatic: any, t2gPathStatic: any): Promise<void>;
     /**
      * Import model from console
      * @param name

package/fcs-core-viewer@types/Loader/LoaderUtils.d.ts

@@ -1,11 +1,15 @@
 import * as THREE from '../three/build/three.module.js';
 import { MeshWrapper } from '../Model/MeshWrapper';
 import { SceneWrapper } from '../Model/SceneWrapper';
+import { ModelData } from '../DataStorage/ModelData';
 export declare class LoaderUtils {
     sceneWrapper: SceneWrapper;
     meshWrapper: MeshWrapper;
     uniqueToViewer: {};
     components: {};
+    meshContainer: ModelData.ContainerType.MeshContainer;
+    lineContainer: ModelData.ContainerType.LineContainer;
+    pointContainer: ModelData.ContainerType.PointContainer;
     cntMesh: THREE.Mesh;
     cntLine: THREE.Line;
     cntPoint: THREE.Point;
@@ -18,7 +22,6 @@ export declare class LoaderUtils {
      * @param meshWrapper
      */
     constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper);
-    addToScene(mesh?: any, line?: any, point?: any): void;
     /**
      * Ide jon minden, ami mesh, de nem modell, pl. szerkeszteshez hasznalt seged geometriak (plane, (bounding) sphere, (bounding) box, cone, cylinder, ...)
      */
@@ -34,12 +37,10 @@ export declare class LoaderUtils {
     /**
      * Kigeneralja a "cntMesh" container-t, ami a component-ek THREE.Mesh objektumait tartalmazza omlesztve
      */
-    addCntMesh(): any;
     /**
      * Importalasnal hozzaadjuk a component THREE.Mesh objektumait a cntMesh container-hez
      * @param mesh
      */
-    addToCntMesh(mesh: THREE.Mesh): void;
     /**
      * Kitorli a modellt alkoto THREE.Mesh objektumot a container-bol
      * @param mesh
@@ -52,16 +53,6 @@ export declare class LoaderUtils {
      * @param isVisible
      */
     setMeshVisibility(mesh_arr: THREE.Mesh[], isVisible: boolean): void;
-    /**
-     * Kigeneralja a "cntMesh" container-t, ami a component-ek THREE.Line2 objektumait tartalmazza omlesztve
-     * @returns
-     */
-    addCntLine(): any;
-    /**
-     * Importalasnal hozzaadjuk a component THREE.Line2 objektumait a cntLine container-hez
-     * @param line
-     */
-    addToCntLine(line: THREE.Line2): void;
     /**
      * Kitorli a modellt alkoto THREE.Line2 objektumot a container-bol
      * @param line
@@ -74,15 +65,6 @@ export declare class LoaderUtils {
      * @param isVisible
      */
     setLineVisibility(line_arr: THREE.Line2[], isVisible: boolean): void;
-    /**
-     * Kigeneralja a "cntPoint" container-t, ami a component-ek THREE.Point objektumait tartalmazza omlesztve
-     * @returns
-     */
-    addCntPoint(): any;
-    /**
-     * Importalasnal hozzaadjuk a component THREE.Point objektumait a cntPoint container-hez
-     */
-    addToCntPoint(point: THREE.Point): void;
     /**
      * Kitorli a modellt alkoto THREE.Point objektumot a container-bol
      * @param point
@@ -103,132 +85,4 @@ export declare class LoaderTools {
     alpha: number;
     components: {};
     constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper);
-    /**
-     * Itt definialunk a THREE.Mesh objektumoknak material-t
-     */
-    setMeshMaterial(): void;
-    /**
-     * Itt definialunk a THREE.Line2 objektumoknak material-t
-     */
-    setLineMaterial(): void;
-    /**
-     * Itt definialunk a THREE.Point objektumoknak material-t
-     */
-    setPointMaterial(): void;
-    /**
-     * Kigeneralja a custom shader-t, amit argumentumknet beadunk a THREE.ShaderMaterial-nak
-     * @param currentCamera
-     * @param graySphereTexture
-     * @param yellowSphereTexture
-     * @param violetSphereTexture
-     * @returns
-     */
-    createShader(currentCamera: THREE.OrthographicCamera, graySphereTexture: THREE.Texture, yellowSphereTexture: THREE.Texture, violetSphereTexture: THREE.Texture): {
-        uniforms: {
-            graySphereTexture: {
-                value: THREE.Texture;
-            };
-            yellowSphereTexture: {
-                value: THREE.Texture;
-            };
-            violetSphereTexture: {
-                value: THREE.Texture;
-            };
-            pointSize: {
-                value: number;
-            };
-            alphaTest_gray: {
-                value: number;
-            };
-            alphaTest_yellow: {
-                value: number;
-            };
-            alphaTest_violet: {
-                value: number;
-            };
-            near: {
-                value: any;
-            };
-            far: {
-                value: any;
-            };
-            pixelWidth: {
-                value: number;
-            };
-            pixelHeight: {
-                value: number;
-            };
-        };
-        vertexShader: string;
-        fragmentShader: string;
-        transparent: boolean;
-        depthTest: boolean;
-        visible: boolean;
-        depthWrite: boolean;
-        uniformsNeedUpdate: boolean;
-    };
-    /**
-     * Custom shader-t general THREE.Mesh objektumnak
-     * @returns
-     */
-    meshCustomShader(): {
-        uniforms: {};
-        vertexShader: string;
-        fragmentShader: string;
-        vertexColors: boolean;
-        visible: boolean;
-        depthTest: boolean;
-        depthWrite: boolean;
-        colorWrite: boolean;
-        alphaToCoverage: boolean;
-        transparent: boolean;
-        side: any;
-    };
-}
-export declare class Face {
-    type: string;
-    itemVID: number;
-    itemUID: string;
-    componentVID: number;
-    componentUID: number;
-    faceVID: number;
-    faceUIDs: number[];
-    polygonsXYZ: number[];
-    startIndex: number;
-    count: number;
-    edges: Edge[];
-    isVisible: number;
-    isSelected: boolean;
-    constructor(itemVID: number, itemUID: string, componentVID: number, componentUID: number, faceVID: number, faceUIDs: number[], polygonsXYZ: number[], startIndex: number, count: number);
-}
-export declare class Edge {
-    type: string;
-    itemVID: number;
-    componentVID: number;
-    edgeVID: number;
-    edgeUIDs: number[];
-    segmentsXYZ: number[];
-    startIndex: number;
-    count: number;
-    faces: Face[];
-    vertices: Vertex[];
-    lineWidth: number;
-    isVisible: number;
-    isSelected: boolean;
-    constructor(itemVID: number, componentVID: number, edgeVID: number, edgeUIDs: number[], segmentsXYZ: number[], startIndex: number, count: number, faces?: Face[]);
-}
-export declare class Vertex {
-    type: string;
-    itemVID: number;
-    componentVID: number;
-    vertexVID: number;
-    vertexUIDs: number[];
-    vertexXYZ: number[];
-    startIndex: number;
-    edges: Edge[];
-    faces: Face[];
-    textureID: number;
-    isVisible: number;
-    isSelected: boolean;
-    constructor(itemVID: number, componentVID: number, vertexVID: number, vertexUIDs: number[], vertexXYZ: number[], startIndex: number, edges?: Edge[], faces?: Face[]);
 }

package/fcs-core-viewer@types/Loader/{LoadEdge.d.ts → STEPLoader/EdgeLoader.d.ts}

@@ -1,12 +1,12 @@
-import { MeshWrapper } from '../Model/MeshWrapper';
-import { SceneWrapper } from '../Model/SceneWrapper';
-import { LoaderUtils, LoaderTools } from './LoaderUtils';
-import { Appearance } from '../TaskHandler/Context/Context';
-import { TreeView } from '../UserInterface/UIComponents/TreeView';
+import { MeshWrapper } from '../../Model/MeshWrapper';
+import { SceneWrapper } from '../../Model/SceneWrapper';
+import { LoaderUtils, LoaderTools } from '../LoaderUtils';
+import { Appearance } from '../../TaskHandler/Context/Context';
+import { TreeView } from '../../UserInterface/UIComponents/TreeView';
 /**
  * Load Edge
  */
-export declare class LoadEdge {
+export declare class EdgeLoader {
     generalLineMaterial: any;
     generalPointMaterial: any;
     loaderTools: LoaderTools;
@@ -43,5 +43,5 @@ export declare class LoadEdge {
      * @param objParsed
      * @returns
      */
-    importEdge(name: any, itemUID: any, parentUID: any, objParsed: any): Promise<string>;
+    perform(name: any, itemUID: any, parentUID: any, objParsed: any): Promise<string>;
 }