@x-viewer/core 0.21.12 → 0.21.14

package/dist/types/core/dxf-parser/DxfParser.d.ts

@@ -1,118 +1,5 @@
-import type { DwgDatabase } from "@mlightcad/libredwg-web";
-import IGeometry, { IEntity, IPoint } from "./entities/geomtry";
-import { IClass, IObjectParser } from "./objects/common";
-import { IDictionaryObject } from "./objects/dictionary";
-import { IImageDefObject } from "./objects/imagedef";
-import { ILayoutObject } from "./objects/layout";
-import { ISortEntsTableObject } from "./objects/sortentstable";
-import { ISpatialFilterObject } from "./objects/spatialfilter";
-import { IXRecord } from "./objects/xrecord";
-/**
- * Definition of a block. Which contains entities, name, handle, etc.
- * @hidden
- */
-export interface IBlock {
-    entities: IEntity[];
-    ownerHandle: string;
-    xrefPath: string;
-    name: string;
-    name2: string;
-    handle: string;
-    layer: string;
-    position: IPoint;
-    paperSpace: boolean;
-    blockType: BlockTypeFlags;
-    description?: string;
-}
-/**
- * Definition of a viewport.
- * @hidden
- */
-export interface IViewport {
-    name: string;
-    handle?: string;
-    lowerLeftCorner: IPoint;
-    upperRightCorner: IPoint;
-    center: IPoint;
-    snapBasePoint: IPoint;
-    snapSpacing: IPoint;
-    gridSpacing: IPoint;
-    viewDirectionFromTarget: IPoint;
-    viewTarget: IPoint;
-    aspectRatio: number;
-    lensLength: number;
-    frontClippingPlane: string | number | boolean;
-    backClippingPlane: string | number | boolean;
-    viewHeight: number;
-    snapRotationAngle: number;
-    viewTwistAngle: number;
-    orthographicType: number;
-    ucsOrigin: IPoint;
-    ucsXAxis: IPoint;
-    ucsYAxis: IPoint;
-    renderMode: string;
-    defaultLightingType: number;
-    defaultLightingOn: boolean;
-    ownerHandle: string;
-    ambientColor: number;
-}
-/**
- * Viewport table definition.
- * @hidden
- */
-export interface IViewportTableDefinition {
-    dxfSymbolName: "VPORT";
-    parseTableRecords(): IViewport[];
-}
-/**
- * Reference to DwgLineTypeElement
- */
-export interface LineTypeElement {
-    elementLength: number;
-    /**
-     * 0: Dash
-     * 1: Element is a shape (a vector glyph from a compiled .SHX file)
-     * 2: Element is a text string
-     * 3: Reserved
-     */
-    elementTypeFlag: number;
-    /**
-     * Index of the shape inside the .SHX file defined by styleObjectId.
-     * It should be useful when elementTypeFlag is 1.
-     */
-    shapeNumber?: number;
-    styleObjectId?: string;
-    scale?: number;
-    rotation?: number;
-    offsetX?: number;
-    offsetY?: number;
-    text?: string;
-}
-/**
- * Line type.
- * @hidden
- */
-export interface ILineType {
-    /**
-     * AutoCAD entity handle as hex string
-     */
-    handle?: string;
-    name: string;
-    description: string;
-    pattern: LineTypeElement[];
-    /**
-     * The sum length of each pattern segment.
-     */
-    patternLength: number;
-}
-/**
- * Line type table definition.
- * @hidden
- */
-export interface ILineTypeTableDefinition {
-    dxfSymbolName: "LTYPE";
-    parseTableRecords(): Record<string, ILineType>;
-}
+import IGeometry from "./entities/geomtry";
+import { IObjectParser } from "./objects/common";
 /**
  * Definition of a layer.
  */
@@ -152,301 +39,6 @@ export interface ILayer {
      */
     lineweight: 0 | 5 | 9 | 13 | 15 | 18 | 20 | 25 | 30 | 35 | 40 | 50 | 53 | 60 | 70 | 80 | 90 | 100 | 106 | 120 | 140 | 158 | 200 | 211 | -3 | -2 | -1;
 }
-/**
- * Layer table definition.
- * @hidden
- */
-export interface ILayerTableDefinition {
-    dxfSymbolName: "LAYER";
-    parseTableRecords(): Record<string, ILayer>;
-}
-/**
- * BlockRecord
- * @hidden
- */
-export interface IBlockRecord {
-    handle: string;
-    ownerHandle: string;
-    blockName: string;
-    layoutHandle: string;
-    blockInsertUnits: number;
-    blockExplodability: number;
-    blockScalability: number;
-    bitmap?: string;
-}
-/**
- * @hidden
- */
-export interface IBlockRecordTableDefinition {
-    dxfSymbolName: "BLOCK_RECORD";
-    parseTableRecords(): Record<string, IBlockRecord>;
-}
-/**
- * Definition of a style.
- * @hidden
- */
-export interface IStyle {
-    handle: string;
-    ownerHandle: string;
-    styleName: string;
-    priorTextHeight: number;
-    textHeight: number;
-    xScale: number;
-    rotation: number;
-    mirrorType: number;
-    fontFile: string;
-    bigFontFile: string;
-}
-/**
- * Style table definition.
- * @hidden
- */
-export interface IStyleTableDefinition {
-    dxfSymbolName: "STYLE";
-    parseTableRecords(): Record<string, IStyle>;
-}
-/**
- * Dim style.
- * @hidden
- */
-export interface IDimStyle {
-    /**
-     * AutoCAD entity handle as hex string
-     */
-    handle?: string;
-    styleName: string;
-    DIMSCALE: number;
-    DIMASZ: number;
-    DIMEXO: string;
-    DIMEXE: string;
-    DIMSE1: string;
-    DIMSE2: string;
-    DIMTAD: string;
-    DIMTXT: string;
-    DIMGAP: number;
-    DIMCLRD: number;
-    DIMCLRT: number;
-    DIMLFAC: number;
-    DIMDEC: string;
-    DIMLDRBLK: string;
-}
-/**
- * Dim style table definition
- * @hidden
- */
-export interface IDimStyleTableDefinition {
-    dxfSymbolName: "DIMSTYLE";
-    parseTableRecords(): Record<string, IDimStyle>;
-}
-/**
- * Table definitions.
- * @hidden
- */
-export interface ITableDefinitions {
-    VPORT: IViewportTableDefinition;
-    LTYPE: ILineTypeTableDefinition;
-    LAYER: ILayerTableDefinition;
-    BLOCK_RECORD: IBlockRecordTableDefinition;
-    STYLE: IStyleTableDefinition;
-    DIMSTYLE: IDimStyleTableDefinition;
-}
-/**
- * Base table
- * @hidden
- */
-export interface IBaseTable {
-    handle: string;
-    ownerHandle: string;
-}
-/**
- * Viewport table
- * @hidden
- */
-export interface IViewportTable extends IBaseTable {
-    entries: IViewport[];
-}
-/**
- * @hidden
- */
-export interface ILayerTypesTable extends IBaseTable {
-    entries: Record<string, ILineType>;
-}
-/**
- * @hidden
- */
-export interface ILayersTable extends IBaseTable {
-    entries: Record<string, ILayer>;
-}
-/**
- * @hidden
- */
-export interface IStylesTable extends IBaseTable {
-    entries: Record<string, IStyle>;
-}
-/**
- * @hidden
- */
-export interface IDimStyleTable extends IBaseTable {
-    entries: Record<string, IDimStyle>;
-}
-/**
- * Block records table containing metadata for all blocks defined in the DXF file.
- * Each block record provides information about a block, including:
- * - Block name and handle
- * - Associated layout handle (for model space and paper space blocks)
- * - Block insertion units, explodability, and scalability
- * - Preview bitmap (if available)
- *
- * Block records are used to link blocks with their corresponding layouts and provide
- * additional metadata beyond what is stored in the blocks themselves.
- *
- * @hidden
- */
-export interface IBlockRecordsTable extends IBaseTable {
-    /**
-     * Block record entries, keyed by block record handle (hex string).
-     * Each entry corresponds to a block definition in the DXF file.
-     */
-    entries: Record<string, IBlockRecord>;
-}
-/**
- * Collection of all DXF tables.
- * DXF tables are used to define named resources that can be referenced by entities.
- * Each table contains entries that define reusable objects with specific properties.
- * @hidden
- */
-export interface ITables {
-    /**
-     * Viewport table containing viewport configurations.
-     * Viewports define how the drawing is displayed, including view direction,
-     * zoom level, and clipping planes.
-     */
-    VPORT: IViewportTable;
-    /**
-     * Linetype table containing line pattern definitions.
-     * Linetypes define how lines are drawn (solid, dashed, dotted, etc.).
-     * Common linetypes include "CONTINUOUS", "DASHED", "DOTTED", and custom patterns.
-     */
-    LTYPE: ILayerTypesTable;
-    /**
-     * Layer table containing layer definitions.
-     * Layers organize entities and control their visibility, color, linetype, and other properties.
-     * Every entity in a DXF file belongs to a layer.
-     */
-    LAYER: ILayersTable;
-    /**
-     * Block records table containing block metadata.
-     * Block records provide information about blocks and link them to layouts.
-     * This table is essential for understanding the relationship between blocks and layouts.
-     */
-    BLOCK_RECORD: IBlockRecordsTable;
-    /**
-     * Text style table containing font and text formatting definitions.
-     * Text styles define how text entities are displayed, including font file,
-     * height, width factor, and rotation.
-     */
-    STYLE: IStylesTable;
-    /**
-     * Dimension style table containing dimension formatting definitions.
-     * Dimension styles control how dimensions are displayed, including arrow types,
-     * text placement, precision, and colors.
-     */
-    DIMSTYLE: IDimStyleTable;
-}
-/**
- * Collection of all DXF objects.
- * Provides typed access to common object arrays so callers don't need to use string keys like "LAYOUT" or "DICTIONARY".
- * @hidden
- */
-export interface IObjects {
-    LAYOUT?: ILayoutObject[];
-    DICTIONARY?: IDictionaryObject[];
-    IMAGEDEF?: IImageDefObject[];
-    SORTENTSTABLE?: ISortEntsTableObject[];
-    SPATIAL_FILTER?: ISpatialFilterObject[];
-    XRECORD?: IXRecord[];
-}
-/**
- * Union type representing any DXF table.
- * This type can be used when a function or method needs to accept any table type
- * without being specific about which table it is.
- *
- * @hidden
- */
-export type ITable = IViewportTable | ILayerTypesTable | ILayersTable | IBlockRecordsTable | IStylesTable | IDimStyleTable;
-/**
- * Represents the complete structure of a DXF (Drawing Exchange Format) file.
- * A DXF file is organized into several sections: HEADER, ENTITIES, BLOCKS, TABLES, OBJECTS, and CLASSES.
- *
- * @hidden
- */
-export interface IDxf {
-    /**
-     * Header section containing system variables.
-     * These variables control various drawing settings such as:
-     * - `$ACADVER`: AutoCAD version (e.g., "AC1032" for AutoCAD 2018)
-     * - `$CLAYER`: Current layer name
-     * - `$LTSCALE`: Global linetype scale
-     * - `$INSUNITS`: Units for insertion
-     * - And many other system variables
-     * Values can be points (IPoint), numbers, or strings.
-     */
-    header: Record<string, IPoint | number | string>;
-    /**
-     * Entities section containing all drawing entities.
-     * This includes geometric objects such as:
-     * - Lines, arcs, circles, ellipses
-     * - Polylines, splines, hatches
-     * - Text, dimensions, leaders
-     * - Blocks (inserts), images, viewports
-     * - And other entity types
-     * Note that, it should include entities in model space and paper space.
-     * But it should not include entities in blocks.
-     */
-    entities: IEntity[];
-    /**
-     * Blocks section containing block definitions.
-     * The key is the block name (e.g., "*Model_Space", "*Paper_Space", or user-defined block names).
-     * Each block contains a collection of entities that can be inserted multiple times via INSERT entities.
-     * Blocks can represent:
-     * - Model space and paper space definitions
-     * - User-defined reusable components
-     * - Dimension blocks
-     */
-    blocks: Record<string, IBlock>;
-    /**
-     * Tables section containing various DXF tables.
-     * Includes:
-     * - `VPORT`: Viewport table (view configurations)
-     * - `LTYPE`: Linetype table (line pattern definitions)
-     * - `LAYER`: Layer table (layer definitions with properties)
-     * - `BLOCK_RECORD`: Block record table (block metadata)
-     * - `STYLE`: Text style table (font and text formatting)
-     * - `DIMSTYLE`: Dimension style table (dimension formatting)
-     */
-    tables: ITables;
-    /**
-     * Objects section containing non-graphical objects.
-     * The key is the object type name (e.g., "LAYOUT", "DICTIONARY", "XRECORD").
-     * Common object types include:
-     * - `LAYOUT`: Layout definitions (Model space and paper space layouts)
-     * - `DICTIONARY`: Named object dictionaries
-     * - `XRECORD`: Extended record objects
-     * - `MATERIAL`: Material definitions
-     * - And other application-specific objects
-     */
-    objects: IObjects;
-    /**
-     * Classes section containing application-defined class definitions.
-     * Classes define custom entity types or objects that may be used by specific applications.
-     * Each class entry describes:
-     * - Application name
-     * - Class name and C++ class name
-     * - DXF name
-     * - Capabilities and proxy information
-     */
-    classes: IClass[];
-}
 export default class DxfParser {
     constructor(encoding?: string);
     parse(source: string | ArrayBuffer): IDxf | undefined;
@@ -457,17 +49,4 @@ export default class DxfParser {
     parseAsync(source: string | ArrayBuffer): Promise<IDxf | undefined>;
     registerEntityHandler(handlerType: new () => IGeometry): void;
     registerObjectHandler(handlerType: new () => IObjectParser): void;
-    /**
-     * Loads libredwg if needed, then returns raw convertEx() output plus version/codepage.
-     * Used by dwg_json_viewer and debugging tools.
-     */
-    libredwgConvertExAsync(data: ArrayBuffer): Promise<{
-        version: string;
-        codepage: string;
-        database: DwgDatabase;
-        stats: {
-            unknownEntityCount: number;
-        };
-    } | undefined>;
-    private parseDwgDb;
 }

package/dist/types/core/model/Model3d.d.ts

@@ -37,6 +37,11 @@ export declare class Model3d extends Model {
      * Gets the THREE.Object3D of this model.
      */
     getModelObject(): THREE.Object3D;
+    /**
+     * Clears cached bounds so the next {@link getBBox} recomputes from the scene graph
+     * (e.g. after transform gizmo edits).
+     */
+    invalidateBBox(): void;
     /**
      * Gets the bounding box of this model.
      */

package/dist/types/core/utils/TextureUtils.d.ts

@@ -12,5 +12,14 @@ export declare class TextureUtils {
      * Creates default environment texture
      */
     static createEnvTextureFromDataArray(pmremGenerator: THREE.PMREMGenerator | undefined, data?: Uint16Array, width?: number, height?: number): Promise<THREE.Texture>;
+    private static readonly MISSING_MAP_KEYS;
+    private static fallbackGrayMaterial?;
+    private static getFallbackGrayMaterial;
+    /**
+     * If any 2D map on a mesh material failed to load, replace the whole material with a shared gray MeshStandardMaterial.
+     */
+    static replaceBrokenMaterialMaps(root: THREE.Object3D): void;
+    private static materialHasBroken2DMap;
+    private static isTextureImageInvalid;
     private static readonly HDR_CITY_STREET_64x32;
 }

package/dist/types/core/viewers/BaseViewer.d.ts

@@ -3,17 +3,16 @@ import { CSS2DRenderer } from "three/examples/jsm/renderers/CSS2DRenderer.js";
 import { ViewerName } from "./Constants";
 import type { Plugin } from "./Plugin";
 import { ViewerEvent } from "./ViewerEvent";
-import { ProgressBar, Spinner } from "../components";
+import { Spinner } from "../components";
 import { BaseViewerConfig, CameraInfo, CameraProjection, ModelConfig, Viewpoint } from "../../core/Configs";
 import { CameraManager } from "../../core/camera";
 import { CanvasRender } from "../../core/canvas";
 import { Container } from "../../core/components/Container";
 import { EffectManager } from "../../core/effect";
 import { FontManager } from "../../core/font";
-import { ZoomToRectHelper } from "../../core/helpers";
 import { InputManager } from "../../core/input-manager";
 import { Interaction } from "../../core/interactions/Interaction";
-import { BaseModelLoader, ModelLoaderManager } from "../../core/loaders";
+import { BaseModelLoader } from "../../core/loaders";
 import { Model } from "../../core/model";
 import { PickManager } from "../../core/pick";
 import { SceneManager } from "../../core/scene/SceneManager";
@@ -24,30 +23,12 @@ type ViewerEvents = {
 };
 export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents = Record<ViewerEvent, any>> extends Event<BaseViewerEvents> {
     name: ViewerName;
-    protected viewerCfg: BaseViewerConfig;
-    protected targetMaxFps: number;
-    protected timeStamp: number;
+    container: Container;
     /**
-     * @hidden
+     * A map to store model file and id.
      */
-    protected requestAnimationFrameHandle?: number;
-    container: Container;
-    protected plugins: Plugin[];
     loadedModels: Model[];
-    protected homeView?: Viewpoint;
     protected inputManager: InputManager;
-    protected cameraManager: CameraManager;
-    protected sceneManager: SceneManager;
-    protected fontManager?: FontManager;
-    protected pickManager: PickManager;
-    protected undoManager: UndoManager;
-    protected overlayRender: CanvasRender;
-    protected css2dRenderer: CSS2DRenderer;
-    protected spinner: Spinner;
-    protected progressBar?: ProgressBar;
-    protected loaderManager: ModelLoaderManager;
-    protected zoomToRectHelper?: ZoomToRectHelper;
-    protected interaction?: Interaction;
     /**
      * Enables selecting an object
      */
@@ -86,11 +67,6 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
     abstract clearHighlight(): void;
     getRaycaster(): THREE.Raycaster;
     getPickManager(): PickManager;
-    /**
-     * Post-processing (GLSL watermark, optional FXAA/SSAO, …). Shared by 2D and 3D viewers.
-     * Created on first access so construction never runs before {@link BaseViewer.cameraManager} exists.
-     */
-    protected get effect(): EffectManager;
     /** Visual effects / composer (same instance as {@link BaseViewer.effect}). */
     get effectManager(): EffectManager;
     getViewerConfig(): BaseViewerConfig;
@@ -107,13 +83,7 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
      * @hidden
      */
     enableRender: (time?: number) => void;
-    protected animate(timeStamp?: number): void;
     resize(): void;
-    /**
-     * @deprecated use GltfLoader.setDracoDecoderPath instead
-     * @hidden
-     */
-    setDracoDecoderPath(path: string): void;
     abstract loadModel(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<void>;
     addModel(model: Model): void;
     removeModelById(modelId: string): void;
@@ -139,14 +109,6 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
      * ```
      */
     zoomToRect(): void;
-    /**
-     * @hidden
-     */
-    deactivateZoomRect(): void;
-    /**
-     * Gets an unique modelId in case the expected id is duplicated.
-     */
-    protected getUniqueModelId(expectedModelId: string): string;
     /**
      * Gets all objects' bounding box.
      */

package/dist/types/core/viewers/BimTilesViewer.d.ts

@@ -53,6 +53,8 @@ export declare class BimTilesViewer extends BaseViewer {
     setDoubleSidedMaterials(): void;
     revertDoubleSidedMaterials(): void;
     clearSelection(): void;
+    /** True when the user has an active tile pick selection (independent of the current cursor hit). */
+    hasSelectedObject(): boolean;
     /**
      * Gets if selection is enabled.
      */
@@ -112,6 +114,11 @@ export declare class BimTilesViewer extends BaseViewer {
      * First get the object through the gpu, and then get the specific intersection point
      */
     pickObjects(mousePosition: THREE.Vector2, layerChannels?: number[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
+    /**
+     * GPU pick on the BimTiles compositing pass (same as pointer interaction). Call before reading picking buffer.
+     * @returns `{ tilesetId, userId }` when a tile was hit, otherwise `undefined`.
+     */
+    pickTileObject(mousePosition: THREE.Vector2): TileObject | undefined;
     /**
      * `errorTarget` refers to The target screenspace error in pixels to target when updating the geometry.
      * It represents the maximum acceptable error in pixels for the tiles' geometry.

package/dist/types/core/viewers/Viewer2d.d.ts

@@ -3,7 +3,6 @@ import { BaseViewer } from "./BaseViewer";
 import { ViewerName } from "./Constants";
 import { Model2dConfig, Viewer2dConfig } from "../../core/Configs";
 import { DxfData, DxfLayer } from "../../core/dxf";
-import { EventInfo } from "../../core/input-manager/InputManager";
 import { Model2d } from "../../core/model";
 export interface EntityData {
     modelId: string;
@@ -157,10 +156,6 @@ export declare const GroundPlaneRenderOrder = -1000;
 export declare class Viewer2d extends BaseViewer {
     name: ViewerName;
     loadedModels: Model2d[];
-    /**
-     * @hidden
-     */
-    masterModelId: string;
     groundPlane?: THREE.Mesh;
     raycastableObjects?: THREE.Object3D[];
     constructor(viewerCfg: Viewer2dConfig);
@@ -260,21 +255,6 @@ export declare class Viewer2d extends BaseViewer {
      * Upper right coordinate: (1, 1)
      */
     protected getHitResultByNdcCoordinate(coord: THREE.Vector2): THREE.Vector2 | undefined;
-    /**
-     * Gets mouse hit result in world coordinate
-     * @example
-     * ``` typescript
-     * document.addEventListener("click", (event) => {
-     *     const result = viewer.getHitResult(event);
-     *     const loc = result?.location;
-     *     if (loc) {
-     *         console.log(`Clicked at x: ${loc[0]}, y: ${loc[1]}`);
-     *     }
-     * });
-     * ```
-     * @hidden
-     */
-    getHitResult(event: MouseEvent | PointerEvent | EventInfo): THREE.Vector2 | undefined;
     /**
      * Returns the active layout name, or undefined if none.
      * @example
@@ -299,12 +279,6 @@ export declare class Viewer2d extends BaseViewer {
      * ```
      */
     getLayers(): (DxfLayers | PdfLayers)[];
-    /**
-     * Sets model's (aka, a dxf file) visibility.
-     * @throws Throws exception if modelId doesn't exist.
-     * @hidden
-     */
-    setModelVisibility(modelId: string, visible: boolean): void;
     /**
      * Sets visibility of a layer by name.
      * @param layerName Layer to show or hide.
@@ -318,22 +292,6 @@ export declare class Viewer2d extends BaseViewer {
      * ```
      */
     setLayerVisibility(layerName: string, visible: boolean, modelId?: string): void;
-    /**
-     * Sets layer's opacity
-     * @hidden
-     */
-    setLayerOpacity(layerName: string, opacity: number, modelId?: string): void;
-    /**
-     * Sets layer's color
-     * @throws Throws exception if layer doesn't exist.
-     * @hidden
-     */
-    setLayerColor(layerName: string, color: number, modelId?: string): void;
-    /**
-     * Resets a layer's color.
-     * @hidden
-     */
-    resetLayerColor(layerName: string, modelId?: string): void;
     /**
      * Enables small feature culling in order to improve performance.
      */