@inweb/viewer-visualize 25.3.17 → 25.3.18

package/dist/viewer-visualize.js

@@ -2777,10 +2777,10 @@
             updaterController.initialize(this.viewer);
             this.viewer._abortController = abortController;
             let isFireDatabaseChunk = false;
-            const chunkLoadHandler = (progress, data) => {
+            const chunkLoadHandler = (progress, chunk) => {
                 if (!this.viewer.visualizeJs)
                     return;
-                const status = visViewer.parseVsfx(data);
+                const status = visViewer.parseVsfx(chunk);
                 updaterController.update(UpdateType.kDelay);
                 this.viewer.emitEvent({ type: "geometryprogress", data: progress, model: this.model });
                 let state = false;
@@ -2794,16 +2794,16 @@
                     this.viewer.syncOpenCloudVisualStyle(false);
                     this.viewer.syncOptions();
                     this.viewer.resize();
-                    this.viewer.emitEvent({ type: "databasechunk", data, model: this.model });
+                    this.viewer.emitEvent({ type: "databasechunk", data: chunk, model: this.model });
                 }
                 else {
-                    this.viewer.emitEvent({ type: "geometrychunk", data, model: this.model });
+                    this.viewer.emitEvent({ type: "geometrychunk", data: chunk, model: this.model });
                 }
             };
             console.time("File load time");
             try {
                 this.viewer.emitEvent({ type: "geometrystart", model: this.model });
-                await this.model.partialDownloadResource(this.model.database, chunkLoadHandler, abortController.signal);
+                await this.model.downloadResource(this.model.database, chunkLoadHandler, abortController.signal);
                 console.timeEnd("File load time");
                 updaterController.update(UpdateType.kNormal);
                 this.viewer.emitEvent({ type: "geometryend", model: this.model });
@@ -2816,6 +2816,8 @@
     }
 
     ///////////////////////////////////////////////////////////////////////////////
+    const PENDING_REQUESTS_SIZE = 50;
+    const PENDING_REQUESTS_TIMEOUT = 250;
     class VsfXPartialLoader extends BaseLoader {
         async load() {
             if (!this.viewer.visualizeJs)
@@ -2826,8 +2828,6 @@
             const abortControllerForRequestMap = new Map();
             let servicePartAborted = false;
             const pendingRequestsMap = new Map();
-            const PENDING_REQUESTS_SIZE = 50;
-            const PENDING_REQUESTS_TIMEOUT = 250;
             let pendingRequestsTimerId = 0;
             const pendingRequestsAbortHandler = () => clearTimeout(pendingRequestsTimerId);
             const pendingRequestsAbortController = new AbortController();
@@ -2837,10 +2837,10 @@
             this.viewer._abortController = abortController;
             this.viewer._abortControllerForRequestMap = abortControllerForRequestMap;
             visViewer.memoryLimit = this.options.memoryLimit;
-            const requestLoadHandler = (progress, data, requestId) => {
+            const chunkLoadHandler = (progress, chunk, requestId = 0) => {
                 if (!this.viewer.visualizeJs)
                     return;
-                const state = visViewer.parseVsfxInPartialMode(requestId, data);
+                const state = visViewer.parseVsfxInPartialMode(requestId, chunk);
                 updaterController.update(UpdateType.kDelay);
                 this.viewer.emitEvent({ type: "geometryprogress", data: progress, model: this.model });
                 if (state) {
@@ -2848,103 +2848,111 @@
                     this.viewer.syncOpenCloudVisualStyle(false);
                     this.viewer.syncOptions();
                     this.viewer.resize();
-                    this.viewer.emitEvent({ type: "databasechunk", data, model: this.model });
+                    this.viewer.emitEvent({ type: "databasechunk", data: chunk, model: this.model });
                 }
                 else {
-                    this.viewer.emitEvent({ type: "geometrychunk", data, model: this.model });
+                    this.viewer.emitEvent({ type: "geometrychunk", data: chunk, model: this.model });
                 }
             };
-            const downloadPartOfFile = async (requestId, records, dataId, isMultipleParts = false) => {
+            const downloadResourceRange = async (dataId, requestId, ranges) => {
+                console.log("--- VsfXPartialLoader.downloadResourceRange", dataId, requestId, ranges);
                 const abortCtrl = new AbortController();
                 abortControllerForRequestMap.set(requestId, abortCtrl);
                 try {
-                    await this.model.downloadFileRange(requestId, records, dataId, requestLoadHandler, abortCtrl.signal);
+                    await this.model.downloadResourceRange(dataId, ranges, requestId, chunkLoadHandler, abortCtrl.signal);
                 }
                 catch (error) {
+                    console.log("--- VsfXPartialLoader.downloadResourceRange error", dataId, requestId, error);
                     this.viewer.emitEvent({ type: "geometryerror", data: error, model: this.model });
                 }
                 finally {
-                    const requests = isMultipleParts ? [...new Set(records.map((item) => item.reqId))] : [requestId];
-                    requests.forEach((requestId) => visViewer.onRequestResponseComplete(requestId));
+                    ranges.forEach((range) => visViewer.onRequestResponseComplete(range.requestId));
                     abortControllerForRequestMap.delete(requestId);
                     updaterController.update(UpdateType.kNormal);
                 }
             };
-            const recordsToArray = (requestId, records) => {
-                const res = [];
+            const requestRecordsToRanges = (requestId, records) => {
+                const ranges = [];
                 for (let i = 0; i < records.size(); i++) {
                     const record = records.get(i);
-                    res.push({
-                        reqId: requestId,
-                        begin: record.begin,
-                        end: record.end,
-                        size: parseInt(record.end, 10) - parseInt(record.begin, 10),
+                    ranges.push({
+                        requestId,
+                        begin: Number(record.begin),
+                        end: Number(record.end),
                     });
                     record.delete();
                 }
-                return res;
+                return ranges;
             };
             const objectHandler = {
                 onServicePartReceived: (bHasIndex) => {
+                    console.log("--- VsfXPartialLoader.onServicePartReceived", bHasIndex);
                     if (bHasIndex) {
                         servicePartAborted = true;
                         abortController.abort();
                     }
                 },
                 onRequest: (requestId, records) => {
-                    downloadPartOfFile(requestId, records, this.model.database);
+                    const ranges = requestRecordsToRanges(requestId, records);
+                    console.log("--- VsfXPartialLoader.onRequest", this.model.database, requestId, ranges);
+                    downloadResourceRange(this.model.database, requestId, ranges);
                 },
                 onFullLoaded: () => {
+                    console.log("--- VsfXPartialLoader.onFullLoaded");
                     updaterController.update(UpdateType.kNormal);
-                    console.timeEnd("File load time");
                 },
                 onRequestResponseParsed: (requestId) => {
+                    console.log("--- VsfXPartialLoader.onRequestResponseParsed", requestId);
                     abortControllerForRequestMap.delete(requestId);
                     updaterController.update(UpdateType.kNormal);
                 },
                 onRequestAborted: (requestId) => {
+                    console.log("--- VsfXPartialLoader.onRequestAborted", requestId);
                     const abortCtrl = abortControllerForRequestMap.get(requestId);
                     if (abortCtrl)
                         abortCtrl.abort();
                 },
-                onRequestResourceFile: async (requestId, _, records) => {
-                    const dataId = `${this.model.fileId}${this.model.file.type}`;
-                    let pendingRequests = [];
-                    let recNumber = 0;
-                    const pendingRequestsRecord = pendingRequestsMap.get(dataId);
-                    if (pendingRequestsRecord) {
-                        pendingRequests = pendingRequestsRecord.array;
-                        recNumber = pendingRequestsRecord.number;
+                onRequestResourceFile: (requestId, dataId, records) => {
+                    // const dataId = `${this.model.fileId}${this.model.file.type}`;
+                    const ranges = requestRecordsToRanges(requestId, records);
+                    console.log("--- VsfXPartialLoader.onRequestResourceFile", dataId, requestId, ranges);
+                    let pendingRanges = [];
+                    let requestNumber = 0;
+                    const pendingRequest = pendingRequestsMap.get(dataId);
+                    if (pendingRequest) {
+                        pendingRanges = pendingRequest.ranges;
+                        requestNumber = pendingRequest.number;
                     }
                     // first several records of each file are processed without grouping (they usually require to be processed sequentially)
-                    if (recNumber < 6) {
-                        pendingRequestsMap.set(dataId, { array: pendingRequests, number: recNumber + 1 });
-                        await downloadPartOfFile(requestId, records, dataId);
+                    if (requestNumber <= 5) {
+                        console.log("--- VsfXPartialLoader.onRequestResourceFile: requestNumber <= 5");
+                        pendingRequestsMap.set(dataId, { ranges: [], number: requestNumber + 1 });
+                        downloadResourceRange(dataId, requestId, ranges);
                         return;
                     }
+                    pendingRanges = pendingRanges.concat(ranges);
                     // group requests to each file to launch a combined server request
-                    if (pendingRequests.length >= PENDING_REQUESTS_SIZE) {
+                    if (pendingRanges.length >= PENDING_REQUESTS_SIZE) {
+                        console.log("--- VsfXPartialLoader.onRequestResourceFile: pendingRanges.length >", PENDING_REQUESTS_SIZE);
                         if (pendingRequestsTimerId) {
                             window.clearTimeout(pendingRequestsTimerId);
                             pendingRequestsTimerId = 0;
                         }
-                        downloadPartOfFile(requestId, pendingRequests, dataId, true);
-                        pendingRequests = [...recordsToArray(requestId, records)];
-                    }
-                    else {
-                        pendingRequests = [...pendingRequests, ...recordsToArray(requestId, records)];
+                        pendingRequestsMap.set(dataId, { ranges: [], number: requestNumber + 1 });
+                        downloadResourceRange(dataId, requestId, pendingRanges);
+                        return;
                     }
-                    pendingRequestsMap.set(dataId, { array: pendingRequests, number: recNumber + 1 });
+                    pendingRequestsMap.set(dataId, { ranges: pendingRanges, number: requestNumber + 1 });
                     // set timeout to wait for the new requests, after that process the remaining requests
                     if (pendingRequestsTimerId === 0) {
                         pendingRequestsTimerId = window.setTimeout(() => {
+                            console.log("--- VsfXPartialLoader.onRequestResourceFile: timer", PENDING_REQUESTS_SIZE);
                             pendingRequestsAbortController.signal.removeEventListener("abort", pendingRequestsAbortHandler);
                             pendingRequestsTimerId = 0;
-                            pendingRequestsMap.forEach((requestsRecord, keyFileName) => {
-                                const array = requestsRecord.array;
-                                if (array.length > 0) {
-                                    downloadPartOfFile(requestId, array, keyFileName, true);
-                                    pendingRequestsMap.set(keyFileName, { array: [], number: requestsRecord.number + 1 });
+                            pendingRequestsMap.forEach((request, dataId) => {
+                                if (request.ranges.length > 0) {
+                                    pendingRequestsMap.set(dataId, { ranges: [], number: request.number + 1 });
+                                    downloadResourceRange(dataId, requestId, request.ranges);
                                 }
                             });
                         }, PENDING_REQUESTS_TIMEOUT);
@@ -2953,11 +2961,10 @@
                 },
             };
             visViewer.attachPartialResolver(objectHandler);
-            console.time("File load time");
             try {
                 this.viewer.emitEvent({ type: "geometrystart", model: this.model });
                 await this.model
-                    .downloadFileRange(0, null, this.model.database, requestLoadHandler, abortController.signal)
+                    .downloadResource(this.model.database, chunkLoadHandler, abortController.signal)
                     .catch((error) => {
                     if (!servicePartAborted)
                         throw error;
@@ -2984,22 +2991,25 @@
             const visViewer = visLib.getViewer();
             const abortController = new AbortController();
             this.viewer._abortController = abortController;
+            const chunkLoadHandler = (progress) => {
+                this.viewer.emitEvent({ type: "geometryprogress", data: progress, model: this.model });
+            };
             console.time("File load time");
             try {
                 this.viewer.emitEvent({ type: "geometrystart", model: this.model });
-                const progressCb = (progress) => this.viewer.emitEvent({ type: "geometryprogress", data: progress, model: this.model });
-                const arrayBuffer = await this.model.downloadResource(this.model.database, progressCb, abortController.signal);
+                const arrayBuffer = await this.model.downloadResource(this.model.database, chunkLoadHandler, abortController.signal);
                 if (abortController.signal.aborted) {
                     await Promise.reject(new Error(`Open model aborted ${this.model.name}`));
                 }
+                const data = new Uint8Array(arrayBuffer);
                 if (this.viewer.visualizeJs) {
-                    visViewer.parseVsfx(new Uint8Array(arrayBuffer));
-                    this.viewer.update(true);
+                    visViewer.parseVsfx(data);
                     this.viewer.syncOpenCloudVisualStyle(false);
                     this.viewer.syncOptions();
                     this.viewer.resize();
                 }
                 console.timeEnd("File load time");
+                this.viewer.emitEvent({ type: "databasechunk", data, model: this.model });
                 this.viewer.emitEvent({ type: "geometryend", model: this.model });
             }
             catch (error) {
@@ -16662,9 +16672,9 @@
                 visualStyleId = visViewer.findVisualStyle("OpenCloud");
             }
             catch (e) {
-                if (!isInitializing) {
-                    console.log("OpenCloud visual style not found, creating it on client side");
-                }
+                // if (!isInitializing) {
+                //   console.log("OpenCloud visual style not found, creating it on client side");
+                // }
                 visualStyleId = visViewer.createVisualStyle("OpenCloud");
                 const colorDef = new visLib.OdTvColorDef(66, 66, 66);
                 const shadedVsId = visViewer.findVisualStyle("Realistic");
@@ -17023,7 +17033,7 @@
                 throw new Error("No default model found");
             const overrideOptions = new Options();
             overrideOptions.data = this.options.data;
-            if (file.type === ".rcs") {
+            if (file.type === ".rcs" && !overrideOptions.enablePartialMode) {
                 console.log("Partial load mode is forced for RCS file");
                 overrideOptions.enablePartialMode = true;
             }