@x-viewer/core 0.21.7 → 0.21.8

package/dist/types/core/helpers/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./InstantiateHelper";
 export * from "./RafHelper";
 export * from "./BinaryReader";
-export * from "./LoadingHelper";
 export * from "./MeshBvhHelper";
 export * from "./ObjectPixelSizeHelper";
 export * from "./OSnapHelper";

package/dist/types/core/index.d.ts

@@ -8,6 +8,7 @@ export * from "./dxf-parser";
 export * from "./effect";
 export * from "./geometry-offset";
 export * from "./helpers";
+export * from "./loaders";
 export * from "./input-manager";
 export * from "./interactions";
 export * from "./text-texture";

package/dist/types/core/loaders/DaeLoader.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import type { ModelLoadContext, ModelLoadFromBufferContext } from "./ModelLoader";
+import { BaseModelLoader } from "./ModelLoader";
+export declare class DaeLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.dae";
+    readonly priority = 0;
+    readonly formats: readonly ["dae"];
+    constructor(manager?: THREE.LoadingManager | undefined);
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    private applyRequestHeader;
+}

package/dist/types/core/loaders/DxfModelLoader.d.ts

@@ -0,0 +1,21 @@
+import type * as THREE from "three";
+import { BaseModelLoader } from "./ModelLoader";
+import type { ModelLoadContext, ModelLoadFromBufferContext } from "./ModelLoader";
+import type { DxfData, DxfLoaderConfig } from "../../core/dxf";
+import type { FontManager } from "../../core/font";
+export declare class DxfModelLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.dxf";
+    readonly priority = 0;
+    readonly formats: readonly ["dxf", "dwg"];
+    private font?;
+    constructor(manager?: THREE.LoadingManager | undefined);
+    setFont(font?: FontManager): void;
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    loadEx(url: string, dxfDataId?: string, onProgress?: (event: ProgressEvent) => void, onLoad?: () => void, cfg?: DxfLoaderConfig, requestHeader?: {
+        [header: string]: string;
+    }): Promise<DxfData>;
+    loadExFromBuffer(data: ArrayBuffer | Uint8Array, dxfDataId?: string, onProgress?: (event: ProgressEvent) => void, onLoad?: () => void, cfg?: DxfLoaderConfig): Promise<DxfData>;
+    private applyRequestHeader;
+}

package/dist/types/core/loaders/FbxLoader.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+import type { ModelLoadContext, ModelLoadFromBufferContext } from "./ModelLoader";
+import { BaseModelLoader } from "./ModelLoader";
+export declare class FbxLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.fbx";
+    readonly priority = 0;
+    readonly formats: readonly ["fbx"];
+    constructor(manager?: THREE.LoadingManager | undefined);
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    private static toArrayBuffer;
+    private applyRequestHeader;
+    private applyUnitScaleToMeters;
+    private fixMaterials;
+    private hasSuspiciousDarkVertexColors;
+}

package/dist/types/core/loaders/GltfLoader.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+import type { ModelLoadContext, ModelLoadFromBufferContext } from "./ModelLoader";
+import { BaseModelLoader } from "./ModelLoader";
+/**
+ * glTF / GLB model loader wrapping GLTFLoader, DRACO path, and progress handling.
+ */
+export declare class GltfLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.gltf";
+    readonly priority = 0;
+    readonly formats: readonly ["gltf", "glb"];
+    private static dracoDecoderPath;
+    static setDracoDecoderPath(path: string): void;
+    private gltfLoader?;
+    constructor(manager?: THREE.LoadingManager | undefined);
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    parseToScene(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    private obtainLoader;
+    private applyRequestHeader;
+    private sanitizeUrlForLoad;
+    /**
+     * Filter invalid early progress events from three.js loadAsync.
+     */
+    private wrapProgress;
+}

package/dist/types/core/loaders/ModelLoader.d.ts

@@ -0,0 +1,49 @@
+import type * as THREE from "three";
+/**
+ * Shared fields for one model load request.
+ */
+interface BaseModelLoadContext {
+    /** Normalized lowercase format token; same semantics as historical `endsWith` checks. */
+    readonly format: string;
+    readonly onProgress?: (event: ProgressEvent) => void;
+}
+/**
+ * Context for model loading from URL.
+ */
+export interface ModelLoadContext extends BaseModelLoadContext {
+    readonly url: string;
+    readonly requestHeader?: {
+        [header: string]: string;
+    };
+}
+export interface ObjLoadContext extends ModelLoadContext {
+    readonly mtlUrls?: string[];
+}
+/**
+ * Context for model loading from memory buffer.
+ */
+export interface ModelLoadFromBufferContext extends BaseModelLoadContext {
+    readonly data: ArrayBuffer | Uint8Array;
+}
+/**
+ * Pluggable model loader (strategy). Built-ins and extensions share this contract.
+ */
+export declare abstract class BaseModelLoader {
+    /** Stable id for unregister and diagnostics. */
+    abstract readonly id: string;
+    /** Higher runs first; use a value above built-in `0` to override built-ins. */
+    readonly priority?: number;
+    /**
+     * Lowercase extension tokens without a leading dot (e.g. `glb`, `gltf`).
+     * Aggregated by `ModelLoaderManager.getSupportedModelFormats`; default {@link match} uses suffix checks on these entries.
+     */
+    abstract readonly formats: readonly string[];
+    /**
+     * True when `format` (often a lowercased filename or extension token) ends with one of {@link formats}.
+     * Override for non-suffix matching.
+     */
+    match(format: string): boolean;
+    load?(ctx: ModelLoadContext): Promise<THREE.Object3D | void>;
+    loadFromBuffer?(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D | void>;
+}
+export {};

package/dist/types/core/loaders/ModelLoaderManager.d.ts

@@ -0,0 +1,33 @@
+import * as THREE from "three";
+import type { BaseModelLoader } from "./ModelLoader";
+import type { FontManager } from "../../core/font";
+export declare class ModelLoaderManager {
+    private font?;
+    private manager?;
+    /** Built-in loaders; rebuilt when {@link setLoadManager} / {@link setFont} runs. */
+    private readonly builtinLoaders;
+    /** Extension loaders (e.g. from plugins); preserved across builtin rebuilds. */
+    private readonly extensionLoaders;
+    constructor(manager?: THREE.LoadingManager);
+    register(loader: BaseModelLoader): void;
+    unregister(id: string): void;
+    private unregisterFromList;
+    private rebuildBuiltinLoaders;
+    private allLoaders;
+    /**
+     * Unique extension tokens from all registered loaders (extensions first, then built-ins), sorted.
+     */
+    getSupportedModelFormats(): string[];
+    private createBuiltinModelLoaders;
+    private resolveModelLoader;
+    private computeUrlModelFormat;
+    private loadModelInternal;
+    private loadModelFromBufferInternal;
+    setLoadManager(manager?: THREE.LoadingManager): void;
+    loadLocalModel(url: string, src: string, onProgress?: (event: ProgressEvent) => void, mtlUrls?: string[]): Promise<THREE.Object3D>;
+    loadModel(src: string, fileFormat?: string, onProgress?: (event: ProgressEvent) => void, requestHeader?: {
+        [header: string]: string;
+    }): Promise<THREE.Object3D | void>;
+    loadModelFromBuffer(data: ArrayBuffer | Uint8Array, fileFormat: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
+    setFont(font: FontManager): void;
+}

package/dist/types/core/loaders/ObjLoader.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from "three";
+import type { ModelLoadFromBufferContext, ObjLoadContext } from "./ModelLoader";
+import { BaseModelLoader } from "./ModelLoader";
+export declare class ObjLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.obj";
+    readonly priority = 0;
+    readonly formats: readonly ["obj"];
+    constructor(manager?: THREE.LoadingManager | undefined);
+    load(ctx: ObjLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    private static toArrayBuffer;
+    private applyRequestHeader;
+    private parseMtlUrlsFromObj;
+}

package/dist/types/core/loaders/PlyLoader.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from "three";
+import type { ModelLoadContext, ModelLoadFromBufferContext } from "./ModelLoader";
+import { BaseModelLoader } from "./ModelLoader";
+export declare class PlyLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.ply";
+    readonly priority = 0;
+    readonly formats: readonly ["ply"];
+    constructor(manager?: THREE.LoadingManager | undefined);
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    private static toArrayBuffer;
+    private applyRequestHeader;
+    /**
+     * PLYLoader always does `channel / 255` for vertex rgb. Float colors already in 0..1 become ~0.004 (near black).
+     * Also ensure normals exist so MeshStandardMaterial is lit correctly.
+     */
+    private static preparePlyGeometry;
+    private static ensureVertexNormals;
+    private static fixVertexColorEncoding;
+    private finalizeLoadedObject;
+}

package/dist/types/core/loaders/RasterLoader.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import type { ModelLoadContext, ModelLoadFromBufferContext } from "./ModelLoader";
+import { BaseModelLoader } from "./ModelLoader";
+export declare class RasterLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.raster";
+    readonly priority = 0;
+    readonly formats: readonly ["jpg", "jpeg", "png"];
+    constructor(manager?: THREE.LoadingManager | undefined);
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    private applyRequestHeader;
+}

package/dist/types/core/loaders/StlLoader.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from "three";
+import type { ModelLoadContext, ModelLoadFromBufferContext } from "./ModelLoader";
+import { BaseModelLoader } from "./ModelLoader";
+export declare class StlLoader extends BaseModelLoader {
+    private readonly manager?;
+    readonly id = "loader.builtin.stl";
+    readonly priority = 0;
+    readonly formats: readonly ["stl"];
+    constructor(manager?: THREE.LoadingManager | undefined);
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    private static toArrayBuffer;
+    private applyRequestHeader;
+    private meshFromGeometry;
+}

package/dist/types/core/loaders/index.d.ts

@@ -0,0 +1,11 @@
+export { BaseModelLoader } from "./ModelLoader";
+export type { ModelLoadContext, ModelLoadFromBufferContext, ObjLoadContext } from "./ModelLoader";
+export { ModelLoaderManager } from "./ModelLoaderManager";
+export { DaeLoader } from "./DaeLoader";
+export { DxfModelLoader } from "./DxfModelLoader";
+export { FbxLoader } from "./FbxLoader";
+export { GltfLoader } from "./GltfLoader";
+export { ObjLoader } from "./ObjLoader";
+export { PlyLoader } from "./PlyLoader";
+export { RasterLoader } from "./RasterLoader";
+export { StlLoader } from "./StlLoader";

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

@@ -10,9 +10,9 @@ import { CanvasRender } from "../../core/canvas";
 import { Container } from "../../core/components/Container";
 import { FontManager } from "../../core/font";
 import { ZoomToRectHelper } from "../../core/helpers";
-import { LoadingHelper } from "../../core/helpers/LoadingHelper";
 import { InputManager } from "../../core/input-manager";
 import { Interaction } from "../../core/interactions/Interaction";
+import { BaseModelLoader, ModelLoaderManager } from "../../core/loaders";
 import { Model } from "../../core/model";
 import { PickManager } from "../../core/pick";
 import { SceneManager } from "../../core/scene/SceneManager";
@@ -45,7 +45,7 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
     protected spinner: Spinner;
     protected progressBar?: ProgressBar;
     protected watermark?: Watermark;
-    protected loaderHelper: LoadingHelper;
+    protected loaderManager: ModelLoaderManager;
     protected zoomToRectHelper?: ZoomToRectHelper;
     protected interaction?: Interaction;
     /**
@@ -103,9 +103,7 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
     protected animate(timeStamp?: number): void;
     resize(): void;
     /**
-     * Sets decoder path for draco loader.
-     * Draco decoder will be used if a model is draco encoded.
-     * @param decoderPath e.g., "libs/draco/gltf/"
+     * @deprecated use GltfLoader.setDracoDecoderPath instead
      * @hidden
      */
     setDracoDecoderPath(path: string): void;
@@ -243,5 +241,18 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
      * Finds a Plugin.
      */
     findPlugin(id: string): Plugin | undefined;
+    /**
+     * Adds a model format loader (typically from a plugin).
+     * Extension loaders are kept when the viewer refreshes built-in loaders (font / loading manager changes).
+     */
+    addModelLoader(loader: BaseModelLoader): void;
+    /**
+     * Removes a previously added extension loader by id.
+     */
+    removeModelLoader(id: string): void;
+    /**
+     * Extension tokens (e.g. `glb`, `dxf`) supported by the current model loader stack, including plugins.
+     */
+    getSupportedModelFormats(): string[];
 }
 export {};

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

@@ -209,6 +209,7 @@ export declare class Viewer2d extends BaseViewer {
      */
     parseFile(modelCfg: Model2dConfig, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<DxfData>;
     addModel(model: Model2d): void;
+    private createDxfModelLoader;
     setObjectHighlight(object: THREE.Object3D): void;
     setObjectUnHighlight(object: THREE.Object3D): void;
     clearHighlight(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@x-viewer/core",
-    "version": "0.21.7",
+    "version": "0.21.8",
     "homepage": "https://dwg.thingraph.site/",
     "description": "WebGL-based 2D/3D viewer engine built on Three.js. View DWG/DXF/PDF files in the browser with no server required. Supports glTF, OBJ, FBX, IFC, STL and BimTiles formats.",
     "author": "thingraph",
@@ -56,6 +56,7 @@
     "types": "dist/types/index.d.ts",
     "scripts": {
         "build": "pnpm run clean:build && pnpm run data-type && rollup -c --environment BUILD:production",
+        "build:dev": "cross-env OBFUSCATE=false pnpm run build",
         "clean:build": "rimraf ./dist",
         "data-type": "tsc --project tsconfig.bundle.json && tsc-alias -p tsconfig.bundle.json",
         "dev": "pnpm run data-type && rollup -c -w",