@inweb/viewer-visualize 26.7.0 → 26.7.2

package/dist/viewer-visualize.module.js

@@ -2425,35 +2425,121 @@ components.registerComponent("ZoomWheelComponent", (viewer => new ZoomWheelCompo
 
 components.registerComponent("GestureManagerComponent", (viewer => new GestureManagerComponent(viewer)));
 
-class VSFBufferLoader extends Loader {
+class FileLoader {
+    constructor() {
+        this.requestHeader = {};
+        this.withCredentials = false;
+        this.abortSignal = undefined;
+    }
+    setRequestHeader(requestHeader) {
+        this.requestHeader = requestHeader;
+    }
+    setWithCredentials(withCredentials) {
+        this.withCredentials = withCredentials;
+    }
+    setAbortSignal(abortSignal) {
+        this.abortSignal = abortSignal;
+    }
+    load(file, onProgress) {
+        if (typeof file === "string") {
+            const request = new Request(file, {
+                headers: new Headers(this.requestHeader),
+                credentials: this.withCredentials ? "include" : "same-origin",
+                signal: this.abortSignal
+            });
+            return fetch(request).then((response => {
+                if (!response.ok) throw new Error(`Failed to fetch "${response.url}", status ${response.status}`);
+                const contentLength = response.headers.get("X-File-Size") || response.headers.get("Content-Length");
+                const total = parseInt(contentLength || "", 10) || 0;
+                const lengthComputable = total > 0;
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        const reader = response.body.getReader();
+                        let loaded = 0;
+                        try {
+                            while (true) {
+                                const {done: done, value: value} = await reader.read();
+                                if (done) break;
+                                if (onProgress) {
+                                    loaded += value.byteLength;
+                                    onProgress(new ProgressEvent("progress", {
+                                        lengthComputable: lengthComputable,
+                                        loaded: loaded,
+                                        total: total
+                                    }));
+                                }
+                                controller.enqueue(value);
+                            }
+                            controller.close();
+                        } catch (e) {
+                            controller.error(e);
+                        }
+                    }
+                });
+                return new Response(stream);
+            })).then((response => response.arrayBuffer()));
+        }
+        if (file instanceof globalThis.File) {
+            return new Promise(((resolve, reject) => {
+                const reader = new FileReader;
+                reader.onload = () => resolve(reader.result);
+                reader.onerror = () => reject(reader.error);
+                reader.onprogress = onProgress;
+                reader.readAsArrayBuffer(new Blob([ file ]));
+            }));
+        }
+        if (onProgress) {
+            const total = file.byteLength;
+            const lengthComputable = total > 0;
+            const loaded = total;
+            onProgress(new ProgressEvent("progress", {
+                lengthComputable: lengthComputable,
+                loaded: loaded,
+                total: total
+            }));
+        }
+        return Promise.resolve(file);
+    }
+}
+
+class VSFFileLoader extends Loader {
     constructor(viewer) {
         super();
         this.viewer = viewer;
     }
     isSupport(file, format) {
-        return file instanceof ArrayBuffer && /vsf$/i.test(format);
+        return (typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) && /vsf$/i.test(format);
     }
-    load(buffer, format) {
-        if (!this.viewer.visualizeJs) return Promise.resolve(this);
+    async load(file, format, params) {
+        if (!this.viewer.visualizeJs) return this;
+        const progress = event => {
+            const {lengthComputable: lengthComputable, loaded: loaded, total: total} = event;
+            const progress = lengthComputable ? loaded / total : 1;
+            this.viewer.emitEvent({
+                type: "geometryprogress",
+                data: progress,
+                file: file
+            });
+        };
+        const loader = new FileLoader;
+        loader.setRequestHeader(params.requestHeader);
+        loader.setWithCredentials(params.withCredentials);
+        loader.setAbortSignal(this.abortController.signal);
+        const buffer = await loader.load(file, progress);
+        const data = new Uint8Array(buffer);
         const visLib = this.viewer.visLib();
         const visViewer = visLib.getViewer();
-        const data = new Uint8Array(buffer);
         visViewer.parseFile(data);
         this.viewer.syncOpenCloudVisualStyle(false);
         this.viewer.syncOptions();
         this.viewer.syncOverlay();
         this.viewer.resize();
-        this.viewer.emitEvent({
-            type: "geometryprogress",
-            data: 1,
-            file: buffer
-        });
         this.viewer.emitEvent({
             type: "databasechunk",
             data: data,
-            file: buffer
+            file: file
         });
-        return Promise.resolve(this);
+        return this;
     }
 }
 
@@ -2513,35 +2599,44 @@ class VSFCloudLoader extends Loader {
     }
 }
 
-class VSFXBufferLoader extends Loader {
+class VSFXFileLoader extends Loader {
     constructor(viewer) {
         super();
         this.viewer = viewer;
     }
     isSupport(file, format) {
-        return file instanceof ArrayBuffer && /vsfx$/i.test(format);
+        return (typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) && /vsfx$/i.test(format);
     }
-    load(buffer, format) {
-        if (!this.viewer.visualizeJs) return Promise.resolve(this);
+    async load(file, format, params) {
+        if (!this.viewer.visualizeJs) return this;
+        const progress = event => {
+            const {lengthComputable: lengthComputable, loaded: loaded, total: total} = event;
+            const progress = lengthComputable ? loaded / total : 1;
+            this.viewer.emitEvent({
+                type: "geometryprogress",
+                data: progress,
+                file: file
+            });
+        };
+        const loader = new FileLoader;
+        loader.setRequestHeader(params.requestHeader);
+        loader.setWithCredentials(params.withCredentials);
+        loader.setAbortSignal(this.abortController.signal);
+        const buffer = await loader.load(file, progress);
+        const data = new Uint8Array(buffer);
         const visLib = this.viewer.visLib();
         const visViewer = visLib.getViewer();
-        const data = new Uint8Array(buffer);
         visViewer.parseVsfx(data);
         this.viewer.syncOpenCloudVisualStyle(false);
         this.viewer.syncOptions();
         this.viewer.syncOverlay();
         this.viewer.resize();
-        this.viewer.emitEvent({
-            type: "geometryprogress",
-            data: 1,
-            file: buffer
-        });
         this.viewer.emitEvent({
             type: "databasechunk",
             data: data,
-            file: buffer
+            file: file
         });
-        return Promise.resolve(this);
+        return this;
     }
 }
 
@@ -2875,11 +2970,11 @@ class VSFXCloudPartialLoader extends Loader {
 
 const loaders = loadersRegistry("visualizejs");
 
-loaders.registerLoader("vsf-buffer", (viewer => new VSFBufferLoader(viewer)));
+loaders.registerLoader("vsf-file", (viewer => new VSFFileLoader(viewer)));
 
 loaders.registerLoader("vsf-cloud", (viewer => new VSFCloudLoader(viewer)));
 
-loaders.registerLoader("vsfx-buffer", (viewer => new VSFXBufferLoader(viewer)));
+loaders.registerLoader("vsfx-file", (viewer => new VSFXFileLoader(viewer)));
 
 loaders.registerLoader("vsfx-cloud", (viewer => new VSFXCloudLoader(viewer)));
 
@@ -3835,6 +3930,7 @@ class Viewer extends EventEmitter2 {
         return this;
     }
     openVsfFile(buffer) {
+        console.warn("Viewer.openVsfFile() has been deprecated since 26.4 and will be removed in a future release, use Viewer.open() instead.");
         if (!this.visualizeJs) return this;
         this.cancel();
         this.clear();
@@ -3880,6 +3976,7 @@ class Viewer extends EventEmitter2 {
         return this;
     }
     openVsfxFile(buffer) {
+        console.warn("Viewer.openVsfxFile() has been deprecated since 26.4 and will be removed in a future release, use Viewer.open() instead.");
         if (!this.visualizeJs) return this;
         this.cancel();
         this.clear();
@@ -4097,5 +4194,5 @@ class Viewer extends EventEmitter2 {
     }
 }
 
-export { OdBaseDragger, Viewer, commands, components, draggers, loaders };
+export { FileLoader, OdBaseDragger, Viewer, commands, components, draggers, loaders };
 //# sourceMappingURL=viewer-visualize.module.js.map