@lingbi/studio 0.4.0 → 0.6.0

package/archive/ArchiveImportWorkerFactory.d.ts

@@ -0,0 +1,4 @@
+import type { ArchiveImportWorkerEndpoint } from './ArchiveImportWorkerEndpoint';
+export interface ArchiveImportWorkerFactory {
+    create(): ArchiveImportWorkerEndpoint;
+}

package/archive/ArchiveImportWorkerMessage.d.ts

@@ -0,0 +1,48 @@
+import type { ArchiveImportModelFormat } from './ArchiveImportModelFormat';
+import type { ArchiveImportRole } from './ArchiveImportRole';
+export interface ArchiveImportStartMessage {
+    readonly file: File;
+    readonly taskId: number;
+    readonly type: 'start';
+}
+export interface ArchiveImportAcknowledgeChunkMessage {
+    readonly chunkId: number;
+    readonly taskId: number;
+    readonly type: 'acknowledge-chunk';
+}
+export interface ArchiveImportCancelMessage {
+    readonly taskId: number;
+    readonly type: 'cancel';
+}
+export type ArchiveImportInboundMessage = ArchiveImportAcknowledgeChunkMessage | ArchiveImportCancelMessage | ArchiveImportStartMessage;
+export interface ArchiveImportEntryStartMessage {
+    readonly entryId: number;
+    readonly fileName: string;
+    readonly format?: ArchiveImportModelFormat;
+    readonly isModel: boolean;
+    readonly role: ArchiveImportRole;
+    readonly taskId: number;
+    readonly type: 'entry-start';
+}
+export interface ArchiveImportEntryChunkMessage {
+    readonly chunk: ArrayBuffer;
+    readonly chunkId: number;
+    readonly entryId: number;
+    readonly final: boolean;
+    readonly taskId: number;
+    readonly type: 'entry-chunk';
+}
+export interface ArchiveImportCancelledMessage {
+    readonly taskId: number;
+    readonly type: 'cancelled';
+}
+export interface ArchiveImportCompleteMessage {
+    readonly taskId: number;
+    readonly type: 'complete';
+}
+export interface ArchiveImportErrorMessage {
+    readonly message: string;
+    readonly taskId: number;
+    readonly type: 'error';
+}
+export type ArchiveImportOutboundMessage = ArchiveImportCancelledMessage | ArchiveImportCompleteMessage | ArchiveImportEntryChunkMessage | ArchiveImportEntryStartMessage | ArchiveImportErrorMessage;

package/archive/ArchiveImportWorkerMessageParser.d.ts

@@ -0,0 +1,16 @@
+import type { ArchiveImportInboundMessage, ArchiveImportOutboundMessage } from './ArchiveImportWorkerMessage';
+/** Narrows structured-clone data at the archive Worker boundary. */
+export declare class ArchiveImportWorkerMessageParser {
+    parseInbound(value: unknown): ArchiveImportInboundMessage | undefined;
+    parseOutbound(value: unknown): ArchiveImportOutboundMessage | undefined;
+    private getRecord;
+    private isFileLike;
+    private isFormat;
+    private isPositiveSafeInteger;
+    private isRecord;
+    private parseAcknowledgement;
+    private parseCancellation;
+    private parseEntryChunk;
+    private parseEntryStart;
+    private parseStart;
+}

package/archive/ArchiveImportWorkerPort.d.ts

@@ -0,0 +1,5 @@
+import type { ArchiveImportOutboundMessage } from './ArchiveImportWorkerMessage';
+export interface ArchiveImportWorkerPort {
+    addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void;
+    postMessage(message: ArchiveImportOutboundMessage, transfer?: readonly Transferable[]): void;
+}

package/archive/ArchiveImportWorkerRuntime.d.ts

@@ -0,0 +1,47 @@
+import type { ArchiveImportWorkerPort } from './ArchiveImportWorkerPort';
+/** Streams a ZIP file through fflate and returns validated role files by chunk. */
+export declare class ArchiveImportWorkerRuntime {
+    private readonly inputChunkSize;
+    private activeTask;
+    private readonly jobValidator;
+    private latestStartedTaskId;
+    private readonly centralDirectoryValidator;
+    private readonly messageParser;
+    private readonly pathValidator;
+    private readonly port;
+    constructor(port: ArchiveImportWorkerPort);
+    attach(): void;
+    private acknowledgeChunk;
+    private cancelTask;
+    private copyChunk;
+    private createUnzip;
+    private drainMessages;
+    private handleArchiveStream;
+    private handleDirectoryData;
+    private handleEntryData;
+    private handleFile;
+    private handleInboundMessage;
+    private handleCancellation;
+    private handleChunkAcknowledgement;
+    private handleDirectory;
+    private handleMessage;
+    private handleStart;
+    private isCurrentTask;
+    private postCancelled;
+    private postComplete;
+    private postError;
+    private processInputChunk;
+    private pushToUnzip;
+    private queueEntryChunk;
+    private queueEntryStart;
+    private registerEntry;
+    private runTask;
+    private sendQueuedMessage;
+    private throwIfCancelled;
+    private assertRoleOrder;
+    private validateArchive;
+    private validateChecksums;
+    private cancelReader;
+    private getErrorMessage;
+    private isCancelledError;
+}

package/archive/ArchiveImportWorkerTask.d.ts

@@ -0,0 +1,38 @@
+import type { ArchiveImportChunkAcknowledgement } from './ArchiveImportChunkAcknowledgement';
+import type { ArchiveImportCrc32 } from './ArchiveImportCrc32';
+import type { ArchiveImportJobRequest } from './ArchiveImportJobRequest';
+import type { ArchiveImportEntryChunkMessage, ArchiveImportEntryStartMessage } from './ArchiveImportWorkerMessage';
+export type ArchiveImportQueuedMessage = {
+    readonly kind: 'entry-start';
+    readonly message: ArchiveImportEntryStartMessage;
+} | {
+    readonly kind: 'entry-chunk';
+    readonly message: ArchiveImportEntryChunkMessage;
+};
+export interface ArchiveImportTaskEntryMetadata {
+    readonly entryId: number;
+    readonly fileName: string;
+    readonly format?: 'obj' | 'ply';
+    readonly isModel: boolean;
+    readonly role: 'base' | 'stone';
+}
+/** Runtime-local state for one streaming archive task. */
+export declare class ArchiveImportWorkerTask {
+    readonly abortController: AbortController;
+    awaitingAcknowledgement: ArchiveImportChunkAcknowledgement | undefined;
+    activeEntryId: number | undefined;
+    cancelled: boolean;
+    readonly entryByteCounts: Map<number, number>;
+    readonly entryChecksums: Map<number, ArchiveImportCrc32>;
+    readonly entries: ArchiveImportTaskEntryMetadata[];
+    readonly queuedMessages: ArchiveImportQueuedMessage[];
+    readonly request: ArchiveImportJobRequest;
+    readonly roleModelCounts: Map<"stone" | "base", number>;
+    readonly rolesSeen: Set<"stone" | "base">;
+    readonly seenFileNames: Set<string>;
+    nextChunkId: number;
+    nextEntryId: number;
+    lastRoleIndex: number;
+    constructor(request: ArchiveImportJobRequest);
+    cancel(): void;
+}

package/archive/BrowserArchiveImportWorkerEndpoint.d.ts

@@ -0,0 +1,15 @@
+import type { ArchiveImportWorkerEndpoint, ArchiveImportWorkerEndpointErrorListener, ArchiveImportWorkerEndpointMessageListener } from './ArchiveImportWorkerEndpoint';
+import type { ArchiveImportInboundMessage } from './ArchiveImportWorkerMessage';
+/** Native browser Worker adapter with the Vite-recognized module Worker constructor. */
+export declare class BrowserArchiveImportWorkerEndpoint implements ArchiveImportWorkerEndpoint {
+    private errorListener;
+    private messageListener;
+    private readonly worker;
+    constructor();
+    postMessage(message: ArchiveImportInboundMessage): void;
+    setErrorListener(listener: ArchiveImportWorkerEndpointErrorListener): void;
+    setMessageListener(listener: ArchiveImportWorkerEndpointMessageListener): void;
+    terminate(): void;
+    private handleError;
+    private handleMessage;
+}

package/archive/BrowserArchiveImportWorkerFactory.d.ts

@@ -0,0 +1,5 @@
+import type { ArchiveImportWorkerEndpoint } from './ArchiveImportWorkerEndpoint';
+import type { ArchiveImportWorkerFactory } from './ArchiveImportWorkerFactory';
+export declare class BrowserArchiveImportWorkerFactory implements ArchiveImportWorkerFactory {
+    create(): ArchiveImportWorkerEndpoint;
+}

package/archive/BrowserArchiveImportWorkerPort.d.ts

@@ -0,0 +1,7 @@
+import type { ArchiveImportOutboundMessage } from './ArchiveImportWorkerMessage';
+import type { ArchiveImportWorkerPort } from './ArchiveImportWorkerPort';
+/** Dedicated Worker global adapter for archive import. */
+export declare class BrowserArchiveImportWorkerPort implements ArchiveImportWorkerPort {
+    addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void;
+    postMessage(message: ArchiveImportOutboundMessage, transfer?: readonly Transferable[]): void;
+}