@lingbi/studio 0.8.2 → 0.9.0

package/Application.d.ts

@@ -5,6 +5,7 @@ import type { ObjImportResult } from './ObjImportResult';
 export declare class Application {
     private archiveImportController;
     private archiveImporting;
+    private archiveImportProgress;
     private booleanEditConfirmationVisible;
     private disposed;
     private downloadController;
@@ -17,6 +18,7 @@ export declare class Application {
     private editedArchiveResourceContext;
     private importGeneration;
     private importPerformanceMode;
+    private readonly importProgressCompositor;
     private inventoryConfirmationController;
     private inventoryConfirming;
     private inventoryError;
@@ -88,6 +90,7 @@ export declare class Application {
     private handleEditRequested;
     private handleBooleanEditConfirmed;
     private handleBooleanEditCancelled;
+    private handleArchiveImportProgress;
     private handleRendererWorkspaceStateChanged;
     private hasValidSceneSource;
     private mapModelResourceListSource;

package/ImportProgressCompositor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Composes the archive extraction segment and the renderer load segment into
+ * one integer 0-100 import percentage. URL imports carry renderer progress
+ * only; archive imports map extraction onto 0-20 and the renderer pipeline
+ * onto 20-100.
+ */
+export declare class ImportProgressCompositor {
+    compose(input: {
+        readonly archiveProgress: number | undefined;
+        readonly rendererProgress: number | undefined;
+    }): number | undefined;
+    private clampPercent;
+}

package/StudioToolbarState.d.ts

@@ -16,6 +16,8 @@ export interface StudioToolbarState {
     readonly editEnabled: boolean;
     readonly editVisible: boolean;
     readonly editStatusMessage?: string;
+    readonly importInProgress?: boolean;
+    readonly importProgress?: number;
     readonly inventoryEnabled?: boolean;
     readonly inventoryError?: string;
     readonly inventoryInProgress?: boolean;

package/StudioWorkspace.d.ts

@@ -16,7 +16,12 @@ export declare class StudioWorkspace {
     private readonly booleanButtonElement;
     private readonly simulationButtonElement;
     private readonly booleanOperationOverlayElement;
+    private readonly booleanOperationSpinnerElement;
     private readonly booleanOperationStatusElement;
+    private readonly importPercentElement;
+    private readonly importProgressElement;
+    private readonly importProgressFillElement;
+    private readonly importProgressRowElement;
     private readonly booleanEditConfirmationElement;
     private readonly bottomToolbarElement;
     private readonly downloadButtonElement;

package/archive/ArchiveImportWorkerClient.d.ts

@@ -9,14 +9,16 @@ export declare class ArchiveImportWorkerClient implements ArchiveImportWorkerEnd
     private readonly jobValidator;
     private lastStartedTaskId;
     private readonly messageParser;
+    private readonly onProgress;
     private readonly workerFactory;
-    constructor(workerFactory?: ArchiveImportWorkerFactory);
+    constructor(workerFactory?: ArchiveImportWorkerFactory, onProgress?: (percent: number) => void);
     cancel(taskId?: number): void;
     dispose(): void;
     handleWorkerEndpointError(message: string): void;
     handleWorkerEndpointMessage(message: unknown): void;
     start(job: ArchiveImportJobRequest): Promise<ArchiveImportResult>;
     private acceptChunk;
+    private handleProgress;
     private rejectTask;
     private resolveTask;
     private toError;

package/archive/ArchiveImportWorkerMessage.d.ts

@@ -45,4 +45,10 @@ export interface ArchiveImportErrorMessage {
     readonly taskId: number;
     readonly type: 'error';
 }
-export type ArchiveImportOutboundMessage = ArchiveImportCancelledMessage | ArchiveImportCompleteMessage | ArchiveImportEntryChunkMessage | ArchiveImportEntryStartMessage | ArchiveImportErrorMessage;
+export interface ArchiveImportProgressMessage {
+    readonly bytesLoaded: number;
+    readonly bytesTotal: number;
+    readonly taskId: number;
+    readonly type: 'progress';
+}
+export type ArchiveImportOutboundMessage = ArchiveImportCancelledMessage | ArchiveImportCompleteMessage | ArchiveImportEntryChunkMessage | ArchiveImportEntryStartMessage | ArchiveImportErrorMessage | ArchiveImportProgressMessage;

package/archive/ArchiveImportWorkerMessageParser.d.ts

@@ -7,6 +7,8 @@ export declare class ArchiveImportWorkerMessageParser {
     private isFileLike;
     private isFormat;
     private isPositiveSafeInteger;
+    private isNonNegativeSafeInteger;
+    private parseProgress;
     private isRecord;
     private parseAcknowledgement;
     private parseCancellation;

package/archive/ArchiveImportWorkerRuntime.d.ts

@@ -1,10 +1,12 @@
 import type { ArchiveImportWorkerPort } from './ArchiveImportWorkerPort';
 /** Streams a ZIP file through fflate and returns validated role files by chunk. */
 export declare class ArchiveImportWorkerRuntime {
+    private static readonly MIN_PROGRESS_STEP_BYTES;
     private readonly inputChunkSize;
     private activeTask;
     private readonly jobValidator;
     private latestStartedTaskId;
+    private postedProgressBytes;
     private readonly centralDirectoryValidator;
     private readonly messageParser;
     private readonly pathValidator;
@@ -30,6 +32,7 @@ export declare class ArchiveImportWorkerRuntime {
     private postCancelled;
     private postComplete;
     private postError;
+    private postProgress;
     private processInputChunk;
     private pushToUnzip;
     private queueEntryChunk;

package/assets/{ArchiveImportWorkerEntry-Dh4RZo22.js → ArchiveImportWorkerEntry-wkxjE56k.js}

@@ -1013,6 +1013,8 @@
           return this.parseEntryStart(record, taskId);
         case "error":
           return typeof record["message"] === "string" ? { message: record["message"], taskId, type: "error" } : void 0;
+        case "progress":
+          return this.parseProgress(record, taskId);
         default:
           return void 0;
       }
@@ -1030,6 +1032,17 @@
     isPositiveSafeInteger(value) {
       return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
     }
+    isNonNegativeSafeInteger(value) {
+      return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+    }
+    parseProgress(record, taskId) {
+      const bytesLoaded = record["bytesLoaded"];
+      const bytesTotal = record["bytesTotal"];
+      if (!this.isNonNegativeSafeInteger(bytesLoaded) || !this.isNonNegativeSafeInteger(bytesTotal)) {
+        return void 0;
+      }
+      return { bytesLoaded, bytesTotal, taskId, type: "progress" };
+    }
     isRecord(value) {
       return typeof value === "object" && value !== null && !Array.isArray(value);
     }
@@ -1112,10 +1125,12 @@
     }
   }
   class ArchiveImportWorkerRuntime {
+    static MIN_PROGRESS_STEP_BYTES = 256 * 1024;
     inputChunkSize = 64 * 1024;
     activeTask;
     jobValidator = new ArchiveImportJobValidator();
     latestStartedTaskId = 0;
+    postedProgressBytes = 0;
     centralDirectoryValidator = new ArchiveImportCentralDirectoryValidator();
     messageParser = new ArchiveImportWorkerMessageParser();
     pathValidator = new ArchiveImportPathValidator();
@@ -1171,6 +1186,9 @@
       }
       const unzip = this.createUnzip(task);
       const signature = new ArchiveImportSignatureValidator();
+      const bytesTotal = task.request.file.size;
+      let bytesLoaded = 0;
+      this.postedProgressBytes = 0;
       try {
         for (; ; ) {
           this.throwIfCancelled(task);
@@ -1179,6 +1197,8 @@
             break;
           }
           await this.processInputChunk(task, unzip, signature, result.value);
+          bytesLoaded += result.value.byteLength;
+          this.postProgress(task, bytesLoaded, bytesTotal);
         }
         signature.finish();
         this.pushToUnzip(task, unzip, new Uint8Array(0), true);
@@ -1326,6 +1346,22 @@
         type: "error"
       });
     }
+    postProgress(task, bytesLoaded, bytesTotal) {
+      const minStepBytes = Math.max(
+        Math.ceil(bytesTotal / 100),
+        ArchiveImportWorkerRuntime.MIN_PROGRESS_STEP_BYTES
+      );
+      if (bytesLoaded !== bytesTotal && bytesLoaded - this.postedProgressBytes < minStepBytes) {
+        return;
+      }
+      this.postedProgressBytes = bytesLoaded;
+      this.port.postMessage({
+        bytesLoaded,
+        bytesTotal,
+        taskId: task.request.taskId,
+        type: "progress"
+      });
+    }
     async processInputChunk(task, unzip, signature, chunk) {
       for (let offset = 0; offset < chunk.byteLength; offset += this.inputChunkSize) {
         const part = chunk.subarray(offset, offset + this.inputChunkSize);