3dviewer-sdk 1.0.1 → 1.0.3

package/dist/index.js

@@ -194,12 +194,12 @@ var FilesModule = class {
     });
   }
   // Trigger conversion flow and resolve final viewer metadata.
-  async convert(file) {
+  async convert(file, options = {}) {
     const target = this.resolveFile(file);
     return this.withOperation({ stage: "converting", message: "Converting file..." }, async () => {
       this.viewer._emit("files:conversion:start", { fileName: target.name });
       try {
-        const prepared = await this.convertInternal(target);
+        const prepared = await this.convertInternal(target, options);
         this.viewer._emit("files:conversion:success", prepared);
         return prepared;
       } catch (e) {
@@ -209,11 +209,11 @@ var FilesModule = class {
     });
   }
   // Convenience API: upload first, then convert in one call.
-  async prepare(file) {
+  async prepare(file, options = {}) {
     const target = this.resolveFile(file);
     return this.withOperation({ stage: "uploading", message: "Preparing file..." }, async () => {
       await this.uploadInternal(target);
-      const prepared = await this.convertInternal(target);
+      const prepared = await this.convertInternal(target, options);
       return prepared;
     });
   }
@@ -230,11 +230,11 @@ var FilesModule = class {
     }
   }
   // Full pipeline: upload + convert + open iframe.
-  async render(file) {
+  async render(file, options = {}) {
     const target = this.resolveFile(file);
     return this.withOperation({ stage: "uploading", message: "Uploading + converting + opening..." }, async () => {
       await this.upload(target);
-      const prepared = await this.convert(target);
+      const prepared = await this.convert(target, options);
       this.updateState({ stage: "rendering", message: "Opening viewer..." });
       this.open(prepared);
       this.viewer._emit("files:load:success", prepared);
@@ -327,10 +327,11 @@ var FilesModule = class {
     }
   }
   // Build StreamFile payload compatible with conversion service.
-  buildCachePayload(file, baseFileId) {
+  buildCachePayload(file, baseFileId, options = {}) {
     const createdDate = (/* @__PURE__ */ new Date()).toISOString();
     return {
       filename: file.name,
+      ...options.downloadUrl ? { downloadUrl: options.downloadUrl } : {},
       baseFileId,
       baseMajorRev: 0,
       baseMinorRev: 0,
@@ -374,10 +375,10 @@ var FilesModule = class {
     };
   }
   // Submit conversion/caching request and return service response.
-  async cacheFile(file, baseFileId) {
+  async cacheFile(file, baseFileId, options = {}) {
     const hostConversion = await this.resolveHostConversion();
     const url = `${hostConversion}/api/StreamFile?overwrite=true&ignore_line_weight=1`;
-    const payload = this.buildCachePayload(file, baseFileId);
+    const payload = this.buildCachePayload(file, baseFileId, options);
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -394,12 +395,12 @@ var FilesModule = class {
     return await response.json();
   }
   // Convert file and generate final iframe URL with query string.
-  async convertInternal(file) {
+  async convertInternal(file, options = {}) {
     var _a, _b, _c, _d;
     this.updateState({ stage: "converting", message: "Converting file..." });
     const uploadSession = this.getUploadSessionForFile(file) || this.createUploadSession(file);
     const seedBaseFileId = uploadSession.baseFileId;
-    const cacheResult = await this.cacheFile(file, seedBaseFileId);
+    const cacheResult = await this.cacheFile(file, seedBaseFileId, options);
     const baseFileId = (_a = cacheResult.baseFileId) != null ? _a : seedBaseFileId;
     const baseMajorRev = (_b = cacheResult.baseMajorRev) != null ? _b : 0;
     const baseMinorRev = (_c = cacheResult.baseMinorRev) != null ? _c : 0;
@@ -801,6 +802,22 @@ var MarkupModule = class {
   }
 };
 
+// src/modules/language.module.ts
+var LanguageModule = class {
+  constructor(viewer) {
+    this.viewer = viewer;
+  }
+  change(language) {
+    this.viewer.postToViewer("viewer-language-change" /* LANGUAGE_CHANGE */, {
+      language,
+      timestamp: Date.now()
+    });
+  }
+  set(language) {
+    this.change(language);
+  }
+};
+
 // src/viewer.ts
 var Viewer3D = class {
   constructor(options) {
@@ -963,6 +980,7 @@ var Viewer3D = class {
     this.toolbar = new ToolbarModule(this);
     this.modelTree = new ModelTreeModule(this);
     this.markup = new MarkupModule(this);
+    this.language = new LanguageModule(this);
   }
   // ===== options helpers =====
   getOptions() {

package/dist/index.mjs

@@ -168,12 +168,12 @@ var FilesModule = class {
     });
   }
   // Trigger conversion flow and resolve final viewer metadata.
-  async convert(file) {
+  async convert(file, options = {}) {
     const target = this.resolveFile(file);
     return this.withOperation({ stage: "converting", message: "Converting file..." }, async () => {
       this.viewer._emit("files:conversion:start", { fileName: target.name });
       try {
-        const prepared = await this.convertInternal(target);
+        const prepared = await this.convertInternal(target, options);
         this.viewer._emit("files:conversion:success", prepared);
         return prepared;
       } catch (e) {
@@ -183,11 +183,11 @@ var FilesModule = class {
     });
   }
   // Convenience API: upload first, then convert in one call.
-  async prepare(file) {
+  async prepare(file, options = {}) {
     const target = this.resolveFile(file);
     return this.withOperation({ stage: "uploading", message: "Preparing file..." }, async () => {
       await this.uploadInternal(target);
-      const prepared = await this.convertInternal(target);
+      const prepared = await this.convertInternal(target, options);
       return prepared;
     });
   }
@@ -204,11 +204,11 @@ var FilesModule = class {
     }
   }
   // Full pipeline: upload + convert + open iframe.
-  async render(file) {
+  async render(file, options = {}) {
     const target = this.resolveFile(file);
     return this.withOperation({ stage: "uploading", message: "Uploading + converting + opening..." }, async () => {
       await this.upload(target);
-      const prepared = await this.convert(target);
+      const prepared = await this.convert(target, options);
       this.updateState({ stage: "rendering", message: "Opening viewer..." });
       this.open(prepared);
       this.viewer._emit("files:load:success", prepared);
@@ -301,10 +301,11 @@ var FilesModule = class {
     }
   }
   // Build StreamFile payload compatible with conversion service.
-  buildCachePayload(file, baseFileId) {
+  buildCachePayload(file, baseFileId, options = {}) {
     const createdDate = (/* @__PURE__ */ new Date()).toISOString();
     return {
       filename: file.name,
+      ...options.downloadUrl ? { downloadUrl: options.downloadUrl } : {},
       baseFileId,
       baseMajorRev: 0,
       baseMinorRev: 0,
@@ -348,10 +349,10 @@ var FilesModule = class {
     };
   }
   // Submit conversion/caching request and return service response.
-  async cacheFile(file, baseFileId) {
+  async cacheFile(file, baseFileId, options = {}) {
     const hostConversion = await this.resolveHostConversion();
     const url = `${hostConversion}/api/StreamFile?overwrite=true&ignore_line_weight=1`;
-    const payload = this.buildCachePayload(file, baseFileId);
+    const payload = this.buildCachePayload(file, baseFileId, options);
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -368,12 +369,12 @@ var FilesModule = class {
     return await response.json();
   }
   // Convert file and generate final iframe URL with query string.
-  async convertInternal(file) {
+  async convertInternal(file, options = {}) {
     var _a, _b, _c, _d;
     this.updateState({ stage: "converting", message: "Converting file..." });
     const uploadSession = this.getUploadSessionForFile(file) || this.createUploadSession(file);
     const seedBaseFileId = uploadSession.baseFileId;
-    const cacheResult = await this.cacheFile(file, seedBaseFileId);
+    const cacheResult = await this.cacheFile(file, seedBaseFileId, options);
     const baseFileId = (_a = cacheResult.baseFileId) != null ? _a : seedBaseFileId;
     const baseMajorRev = (_b = cacheResult.baseMajorRev) != null ? _b : 0;
     const baseMinorRev = (_c = cacheResult.baseMinorRev) != null ? _c : 0;
@@ -775,6 +776,22 @@ var MarkupModule = class {
   }
 };
 
+// src/modules/language.module.ts
+var LanguageModule = class {
+  constructor(viewer) {
+    this.viewer = viewer;
+  }
+  change(language) {
+    this.viewer.postToViewer("viewer-language-change" /* LANGUAGE_CHANGE */, {
+      language,
+      timestamp: Date.now()
+    });
+  }
+  set(language) {
+    this.change(language);
+  }
+};
+
 // src/viewer.ts
 var Viewer3D = class {
   constructor(options) {
@@ -937,6 +954,7 @@ var Viewer3D = class {
     this.toolbar = new ToolbarModule(this);
     this.modelTree = new ModelTreeModule(this);
     this.markup = new MarkupModule(this);
+    this.language = new LanguageModule(this);
   }
   // ===== options helpers =====
   getOptions() {

package/dist/modules/camera.module.d.ts

@@ -0,0 +1,13 @@
+import { Viewer3D } from "../viewer";
+export declare class CameraModule {
+    private viewer;
+    on: {
+        home: (cb: (payload: {
+            timestamp: number;
+        }) => void) => () => void;
+    };
+    constructor(viewer: Viewer3D);
+    zoomIn(percent: number): void;
+    zoomOut(percent: number): void;
+    home(): void;
+}

package/dist/modules/camera.module.js

@@ -0,0 +1,18 @@
+import { ViewerMessageType } from "../contracts/messages";
+export class CameraModule {
+    constructor(viewer) {
+        this.viewer = viewer;
+        this.on = {
+            home: (cb) => this.viewer._on("camera:home", cb),
+        };
+    }
+    zoomIn(percent) {
+        this.viewer.postToViewer(ViewerMessageType.ZOOM, { action: "in", percent });
+    }
+    zoomOut(percent) {
+        this.viewer.postToViewer(ViewerMessageType.ZOOM, { action: "out", percent });
+    }
+    home() {
+        this.viewer.postToViewer(ViewerMessageType.HOME, {});
+    }
+}

package/dist/modules/files.module.d.ts

@@ -0,0 +1,84 @@
+import type { LoadStatePayload, PreparedViewerData } from "../contracts/events";
+import { Viewer3D } from "../viewer";
+export declare type FilesConfig = {
+    baseUrl?: string;
+    viewerPath?: string;
+    uploadPath?: string;
+};
+export declare type ConvertOptions = {
+    downloadUrl?: string;
+};
+export declare class FilesModule {
+    private viewer;
+    on: {
+        state: (cb: (payload: LoadStatePayload) => void) => () => void;
+        uploadStart: (cb: (payload: {
+            fileName: string;
+        }) => void) => () => void;
+        uploadSuccess: (cb: (payload: {
+            fileName: string;
+            baseFileId: string;
+        }) => void) => () => void;
+        uploadError: (cb: (payload: {
+            fileName: string;
+            error: string;
+        }) => void) => () => void;
+        conversionStart: (cb: (payload: {
+            fileName: string;
+        }) => void) => () => void;
+        conversionSuccess: (cb: (payload: PreparedViewerData) => void) => () => void;
+        conversionError: (cb: (payload: {
+            fileName: string;
+            error: string;
+        }) => void) => () => void;
+        renderStart: (cb: (payload: {
+            url: string;
+        }) => void) => () => void;
+        renderSuccess: (cb: (payload: {
+            url: string;
+        }) => void) => () => void;
+        renderError: (cb: (payload: {
+            url?: string;
+            error: string;
+        }) => void) => () => void;
+        loadSuccess: (cb: (payload: PreparedViewerData) => void) => () => void;
+        loadError: (cb: (payload: {
+            error: string;
+        }) => void) => () => void;
+    };
+    private config;
+    private operationStartTime;
+    private state;
+    private lastUploadSession;
+    constructor(viewer: Viewer3D);
+    setConfig(next: FilesConfig): void;
+    getState(): LoadStatePayload;
+    upload(file?: File): Promise<{
+        fileName: string;
+        baseFileId: string;
+    }>;
+    convert(file?: File, options?: ConvertOptions): Promise<PreparedViewerData>;
+    prepare(file?: File, options?: ConvertOptions): Promise<PreparedViewerData>;
+    open(input: PreparedViewerData | {
+        url: string;
+    }): void;
+    render(file?: File, options?: ConvertOptions): Promise<PreparedViewerData>;
+    private resolveFile;
+    private normalizeBaseUrl;
+    private resolveBaseUrl;
+    private resolveViewerPath;
+    private resolveViewerOrigin;
+    private resolveHostConversion;
+    private getUploadPath;
+    private fileSignature;
+    private createBaseFileId;
+    private createUploadSession;
+    private getUploadSessionForFile;
+    private uploadInternal;
+    private buildCachePayload;
+    private cacheFile;
+    private convertInternal;
+    private updateState;
+    private withOperation;
+    private toErrorMessage;
+}

package/dist/modules/files.module.js

@@ -0,0 +1,315 @@
+const DEFAULT_API_BASE_URL = "https://dev.3dviewer.anybim.vn";
+const DEFAULT_VIEWER_ORIGIN = "http://localhost:3000";
+export class FilesModule {
+    constructor(viewer) {
+        this.viewer = viewer;
+        this.config = {};
+        this.operationStartTime = 0;
+        this.state = {
+            isLoading: false,
+            stage: "idle",
+        };
+        this.lastUploadSession = null;
+        // Bind external event helpers to internal typed emitter events.
+        this.on = {
+            state: (cb) => this.viewer._on("files:state", cb),
+            uploadStart: (cb) => this.viewer._on("files:upload:start", cb),
+            uploadSuccess: (cb) => this.viewer._on("files:upload:success", cb),
+            uploadError: (cb) => this.viewer._on("files:upload:error", cb),
+            conversionStart: (cb) => this.viewer._on("files:conversion:start", cb),
+            conversionSuccess: (cb) => this.viewer._on("files:conversion:success", cb),
+            conversionError: (cb) => this.viewer._on("files:conversion:error", cb),
+            renderStart: (cb) => this.viewer._on("files:render:start", cb),
+            renderSuccess: (cb) => this.viewer._on("files:render:success", cb),
+            renderError: (cb) => this.viewer._on("files:render:error", cb),
+            loadSuccess: (cb) => this.viewer._on("files:load:success", cb),
+            loadError: (cb) => this.viewer._on("files:load:error", cb),
+        };
+    }
+    // Merge file-pipeline runtime config.
+    setConfig(next) {
+        this.config = { ...this.config, ...next };
+    }
+    // Return a snapshot of current loading state.
+    getState() {
+        return { ...this.state };
+    }
+    // ---------- public pipeline ----------
+    // Upload file to conversion server and keep generated baseFileId in session.
+    async upload(file) {
+        const target = this.resolveFile(file);
+        return this.withOperation({ stage: "uploading", message: "Uploading file..." }, async () => {
+            var _a;
+            this.viewer._emit("files:upload:start", { fileName: target.name });
+            await this.uploadInternal(target);
+            const baseFileId = ((_a = this.getUploadSessionForFile(target)) === null || _a === void 0 ? void 0 : _a.baseFileId) || "";
+            this.viewer._emit("files:upload:success", { fileName: target.name, baseFileId });
+            return { fileName: target.name, baseFileId };
+        });
+    }
+    // Trigger conversion flow and resolve final viewer metadata.
+    async convert(file, options = {}) {
+        const target = this.resolveFile(file);
+        return this.withOperation({ stage: "converting", message: "Converting file..." }, async () => {
+            this.viewer._emit("files:conversion:start", { fileName: target.name });
+            try {
+                const prepared = await this.convertInternal(target, options);
+                this.viewer._emit("files:conversion:success", prepared);
+                return prepared;
+            }
+            catch (e) {
+                this.viewer._emit("files:conversion:error", { fileName: target.name, error: this.toErrorMessage(e) });
+                throw e;
+            }
+        });
+    }
+    // Convenience API: upload first, then convert in one call.
+    async prepare(file, options = {}) {
+        const target = this.resolveFile(file);
+        return this.withOperation({ stage: "uploading", message: "Preparing file..." }, async () => {
+            await this.uploadInternal(target);
+            const prepared = await this.convertInternal(target, options);
+            return prepared;
+        });
+    }
+    // Open iframe with an already prepared viewer URL.
+    open(input) {
+        const url = input.url;
+        this.viewer._emit("files:render:start", { url });
+        try {
+            this.viewer.open(url);
+            this.viewer._emit("files:render:success", { url });
+        }
+        catch (e) {
+            this.viewer._emit("files:render:error", { url, error: this.toErrorMessage(e) });
+            throw e;
+        }
+    }
+    // Full pipeline: upload + convert + open iframe.
+    async render(file, options = {}) {
+        const target = this.resolveFile(file);
+        return this.withOperation({ stage: "uploading", message: "Uploading + converting + opening..." }, async () => {
+            await this.upload(target);
+            const prepared = await this.convert(target, options);
+            // open viewer
+            this.updateState({ stage: "rendering", message: "Opening viewer..." });
+            this.open(prepared);
+            this.viewer._emit("files:load:success", prepared);
+            return prepared;
+        });
+    }
+    // Resolve file argument, fallback to options.file, and persist it back.
+    resolveFile(file) {
+        const optFile = this.viewer.getOptions().file;
+        const target = file || optFile;
+        if (!target)
+            throw new Error("No file provided. Pass a File or set options.file");
+        // store back to viewer options (optional)
+        this.viewer.patchOptions({ file: target });
+        return target;
+    }
+    // Trim input URL and remove trailing slash.
+    normalizeBaseUrl(input) {
+        return input.trim().replace(/\/+$/, "");
+    }
+    // Resolve API base URL with default fallback.
+    resolveBaseUrl() {
+        const raw = this.config.baseUrl || this.viewer.getOptions().baseUrl || DEFAULT_API_BASE_URL;
+        return this.normalizeBaseUrl(raw);
+    }
+    // Resolve viewer route path (e.g. /mainviewer).
+    resolveViewerPath() {
+        const p = (this.config.viewerPath || this.viewer.getOptions().viewerPath || "/mainviewer").trim();
+        if (!p)
+            return "/mainviewer";
+        return p.startsWith("/") ? p : `/${p}`;
+    }
+    // Viewer host used to open iframe after conversion completes.
+    resolveViewerOrigin() {
+        return this.normalizeBaseUrl(DEFAULT_VIEWER_ORIGIN);
+    }
+    // Build conversion service root from API base URL.
+    resolveHostConversion() {
+        const baseUrl = this.resolveBaseUrl();
+        return baseUrl.endsWith("/service/conversion") ? baseUrl : `${baseUrl}/service/conversion`;
+    }
+    // Resolve upload path sent to conversion APIs.
+    getUploadPath() {
+        return this.config.uploadPath || this.viewer.getOptions().uploadPath || ".";
+    }
+    // Build a stable in-memory signature to identify same file uploads.
+    fileSignature(file) {
+        return `${file.name}::${file.size}::${file.lastModified}`;
+    }
+    // Create a UUID-like baseFileId when caller does not provide one.
+    createBaseFileId() {
+        if (typeof crypto !== "undefined" && "randomUUID" in crypto)
+            return crypto.randomUUID();
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = Math.floor(Math.random() * 16);
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    // Create upload session metadata reused between upload and convert.
+    createUploadSession(file) {
+        return {
+            signature: this.fileSignature(file),
+            baseFileId: this.createBaseFileId(),
+            fileName: file.name,
+            uploadPath: this.getUploadPath(),
+        };
+    }
+    // Return previous upload session for same file and upload path.
+    getUploadSessionForFile(file) {
+        if (!this.lastUploadSession)
+            return null;
+        const sameFile = this.lastUploadSession.signature === this.fileSignature(file);
+        const samePath = this.lastUploadSession.uploadPath === this.getUploadPath();
+        return sameFile && samePath ? this.lastUploadSession : null;
+    }
+    // Call upload endpoint and persist upload session on success.
+    async uploadInternal(file) {
+        this.updateState({ stage: "uploading", message: "Uploading file..." });
+        try {
+            const existing = this.getUploadSessionForFile(file);
+            const session = existing || this.createUploadSession(file);
+            const hostConversion = this.resolveHostConversion();
+            const path = this.getUploadPath();
+            // upload endpoint
+            const url = `${hostConversion}/api/File/upload?path=${encodeURIComponent(path)}`;
+            const formData = new FormData();
+            formData.append("file", file, file.name);
+            const res = await fetch(url, { method: "POST", body: formData, headers: { Accept: "text/plain" } });
+            if (!res.ok)
+                throw new Error(`Upload failed (${res.status} ${res.statusText})`);
+            this.lastUploadSession = session;
+        }
+        catch (e) {
+            const msg = this.toErrorMessage(e);
+            this.viewer._emit("files:upload:error", { fileName: file.name, error: msg });
+            throw e;
+        }
+    }
+    // Build StreamFile payload compatible with conversion service.
+    buildCachePayload(file, baseFileId, options = {}) {
+        const createdDate = new Date().toISOString();
+        return {
+            filename: file.name,
+            ...(options.downloadUrl ? { downloadUrl: options.downloadUrl } : {}),
+            baseFileId,
+            baseMajorRev: 0,
+            baseMinorRev: 0,
+            isChecked: false,
+            status: { size: file.size },
+            child: [],
+            isDirectory: false,
+            createdDate,
+            cacheStatus: 0,
+            modelFileId: "",
+            id: "",
+            originalFilePath: this.getUploadPath(),
+            streamLocation: null,
+            converter: "Hoops",
+            originalSize: 0,
+            cacheSize: 0,
+            importTime: 0,
+            importAssemblyTreeTime: 0,
+            creator: {
+                id: "00000000-0000-0000-0000-000000000000",
+                name: "Anonymous",
+            },
+            originalFile: file.name,
+            multiStream: false,
+            isRootModel: 0,
+            extraConvertOutput: "",
+            cacheFilename: null,
+            errorMassage: null,
+            convertOptions: {
+                convert3DModel: 1,
+                convert2DSheet: 1,
+                extractProperties: 1,
+                childModels: 0,
+            },
+            drawingConvertStatus: {
+                convert3DModel: 5,
+                convert2DSheet: 5,
+                extractProperties: 5,
+            },
+            attemptedConvertTimes: 0,
+        };
+    }
+    // Submit conversion/caching request and return service response.
+    async cacheFile(file, baseFileId, options = {}) {
+        const hostConversion = await this.resolveHostConversion();
+        const url = `${hostConversion}/api/StreamFile?overwrite=true&ignore_line_weight=1`;
+        const payload = this.buildCachePayload(file, baseFileId, options);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Cache/convert failed (${response.status} ${response.statusText})`);
+        }
+        return (await response.json());
+    }
+    // Convert file and generate final iframe URL with query string.
+    async convertInternal(file, options = {}) {
+        var _a, _b, _c, _d;
+        this.updateState({ stage: "converting", message: "Converting file..." });
+        const uploadSession = this.getUploadSessionForFile(file) || this.createUploadSession(file);
+        const seedBaseFileId = uploadSession.baseFileId;
+        // 1) request cache/convert
+        const cacheResult = await this.cacheFile(file, seedBaseFileId, options);
+        const baseFileId = (_a = cacheResult.baseFileId) !== null && _a !== void 0 ? _a : seedBaseFileId;
+        const baseMajorRev = (_b = cacheResult.baseMajorRev) !== null && _b !== void 0 ? _b : 0;
+        const baseMinorRev = (_c = cacheResult.baseMinorRev) !== null && _c !== void 0 ? _c : 0;
+        const fileName = cacheResult.filename || file.name;
+        const cacheListItem = { baseFileId, baseMajorRev, baseMinorRev, fileName };
+        // Single-shot mode: one conversion request only, no polling retry.
+        if (cacheResult.cacheStatus !== 2) {
+            throw new Error(`Conversion not ready after first request (cacheStatus=${(_d = cacheResult.cacheStatus) !== null && _d !== void 0 ? _d : "unknown"})`);
+        }
+        // 3) build viewer url
+        const query = new URLSearchParams({ fileList: JSON.stringify([cacheListItem]) }).toString();
+        const viewerBase = this.resolveViewerOrigin();
+        const viewerPath = this.resolveViewerPath();
+        const url = `${viewerBase}${viewerPath}?${query}`;
+        return { baseFileId, baseMajorRev, baseMinorRev, fileName, query, url };
+    }
+    // Update internal loading state and emit state event.
+    updateState(next) {
+        const elapsedMs = this.operationStartTime > 0 ? Date.now() - this.operationStartTime : 0;
+        this.state = { ...this.state, ...next, elapsedMs };
+        this.viewer._emit("files:state", this.state);
+    }
+    // Shared wrapper to handle loading state lifecycle and top-level errors.
+    async withOperation(initial, run) {
+        // shared operation wrapper for loading state and errors
+        this.operationStartTime = Date.now();
+        this.updateState({
+            isLoading: true,
+            stage: initial.stage,
+            message: initial.message,
+        });
+        try {
+            const result = await run();
+            this.updateState({ isLoading: false, stage: "completed", message: "Completed" });
+            return result;
+        }
+        catch (e) {
+            const msg = this.toErrorMessage(e);
+            this.updateState({ isLoading: false, stage: "error", message: msg });
+            this.viewer._emit("files:load:error", { error: msg });
+            throw e;
+        }
+    }
+    // Normalize unknown error shape into displayable message.
+    toErrorMessage(e) {
+        return e instanceof Error ? e.message : String(e);
+    }
+}

package/dist/modules/interaction.module.d.ts

@@ -0,0 +1,28 @@
+import { Viewer3D } from "../viewer";
+export declare class InteractionModule {
+    private viewer;
+    on: {
+        panChange: (cb: (payload: {
+            enabled: boolean;
+        }) => void) => () => void;
+    };
+    constructor(viewer: Viewer3D);
+    enablePan(): void;
+    disablePan(): void;
+    select(): void;
+    areaSelect(): void;
+    orbit(): void;
+    rotateZ(): void;
+    walkThrough(): void;
+    zoomWindow(): void;
+    zoomFit(): void;
+    drawModeShaded(): void;
+    drawModeWireframe(): void;
+    drawModeHiddenLine(): void;
+    drawModeShadedWire(): void;
+    drawModeXRay(): void;
+    drawModeGhosting(): void;
+    explode(magnitude: number): void;
+    explodeOff(): void;
+    private setDrawMode;
+}