@ifc-lite/viewer 1.26.0 → 1.28.0

package/src/hooks/ingest/resolveDataStoreOrAbort.test.ts

@@ -1,61 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-import { resolveDataStoreOrAbort } from './resolveDataStoreOrAbort.js';
-
-const isAbortError = (err: unknown): boolean =>
-  err instanceof DOMException && err.name === 'AbortError';
-
-describe('resolveDataStoreOrAbort', () => {
-  it('returns the parse result when not aborted', async () => {
-    const store = { id: 'store' };
-    const result = await resolveDataStoreOrAbort(Promise.resolve(store), { aborted: false });
-    assert.equal(result, store);
-  });
-
-  it('throws AbortError and terminates without awaiting a blocked parse', async () => {
-    let terminated = false;
-    // A promise that never settles — mirrors a worker parse blocked on
-    // waitForEntityIndex after the geometry loop was cancelled. The previous
-    // code awaited this directly and hung forever.
-    const neverSettles = new Promise<unknown>(() => {});
-
-    await assert.rejects(
-      resolveDataStoreOrAbort(neverSettles, {
-        aborted: true,
-        terminate: () => {
-          terminated = true;
-        },
-      }),
-      isAbortError,
-    );
-
-    assert.equal(terminated, true, 'the worker parser should be terminated on abort');
-  });
-
-  it('swallows the abandoned parse rejection on abort', async () => {
-    // A parse that rejects after we bail must not surface as an unhandled
-    // rejection (this test would fail the process if the .catch guard were
-    // removed from resolveDataStoreOrAbort).
-    const rejecting = Promise.reject(new Error('worker died after abort'));
-
-    await assert.rejects(
-      resolveDataStoreOrAbort(rejecting, { aborted: true }),
-      isAbortError,
-    );
-
-    // Give the swallowed rejection a tick to settle.
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  });
-
-  it('works without a terminate callback', async () => {
-    await assert.rejects(
-      resolveDataStoreOrAbort(new Promise<unknown>(() => {}), { aborted: true }),
-      isAbortError,
-    );
-  });
-});

package/src/hooks/ingest/resolveDataStoreOrAbort.ts

@@ -1,28 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-
-/**
- * Resolve a parse promise, unless the load was cancelled.
- *
- * A worker parse started with `waitForEntityIndex` blocks until the streaming
- * geometry pre-pass hands over the entity index. If the geometry loop is
- * cancelled before that handoff, the index never arrives and the parse promise
- * never settles — awaiting it would hang the whole ingest. On abort we instead
- * terminate the worker, abandon (and swallow) the parse promise, and throw an
- * `AbortError` so callers treat it as a clean cancellation (matching the
- * federated loader's `err.name === 'AbortError'` convention).
- */
-export async function resolveDataStoreOrAbort<T>(
-  parsePromise: Promise<T>,
-  opts: { aborted: boolean; terminate?: () => void },
-): Promise<T> {
-  if (opts.aborted) {
-    opts.terminate?.();
-    // Swallow the abandoned parse's eventual rejection so it doesn't surface
-    // as an unhandled rejection after we've already bailed out.
-    void parsePromise.catch(() => {});
-    throw new DOMException('Model load aborted', 'AbortError');
-  }
-  return parsePromise;
-}

package/src/hooks/ingest/watchedGeometryStream.test.ts

@@ -1,78 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-import { watchedGeometryStream } from './watchedGeometryStream.js';
-
-/** Build a controllable async source that records when return() is called. */
-function makeSource<T>(values: T[]): { source: AsyncIterable<T>; returned: () => boolean } {
-  let didReturn = false;
-  const source: AsyncIterable<T> = {
-    [Symbol.asyncIterator]() {
-      let i = 0;
-      return {
-        next: async () => (i < values.length
-          ? { done: false, value: values[i++] }
-          : { done: true, value: undefined as unknown as T }),
-        return: async () => {
-          didReturn = true;
-          return { done: true, value: undefined as unknown as T };
-        },
-      };
-    },
-  };
-  return { source, returned: () => didReturn };
-}
-
-const baseOpts = {
-  fileName: 'test.ifc',
-  fileSizeMB: 1,
-  getBatchCount: () => 0,
-  getLastTotalMeshes: () => 0,
-  cleanupMs: 50,
-};
-
-describe('watchedGeometryStream', () => {
-  it('re-yields every event in order then completes', async () => {
-    const { source } = makeSource([1, 2, 3]);
-    const seen: number[] = [];
-    for await (const v of watchedGeometryStream(source, baseOpts)) seen.push(v);
-    assert.deepStrictEqual(seen, [1, 2, 3]);
-  });
-
-  it('stops early when shouldAbort() turns true', async () => {
-    const { source } = makeSource([1, 2, 3, 4]);
-    const seen: number[] = [];
-    let calls = 0;
-    for await (const v of watchedGeometryStream(source, {
-      ...baseOpts,
-      // Abort after the second event has been consumed.
-      shouldAbort: () => (++calls > 2),
-    })) {
-      seen.push(v);
-    }
-    assert.deepStrictEqual(seen, [1, 2]);
-  });
-
-  it('tears down the underlying iterator on normal completion', async () => {
-    const { source, returned } = makeSource([1]);
-    let count = 0;
-    for await (const v of watchedGeometryStream(source, baseOpts)) count += v;
-    assert.strictEqual(count, 1);
-    assert.strictEqual(returned(), true);
-  });
-
-  it('tears down the underlying iterator when the consumer breaks early', async () => {
-    const { source, returned } = makeSource([1, 2, 3]);
-    const seen: number[] = [];
-    for await (const v of watchedGeometryStream(source, baseOpts)) {
-      seen.push(v);
-      break;
-    }
-    assert.deepStrictEqual(seen, [1]);
-    assert.strictEqual(returned(), true);
-  });
-});

package/src/hooks/ingest/watchedGeometryStream.ts

@@ -1,76 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-
-import { getGeometryStreamWatchdogMs } from '@ifc-lite/geometry';
-import { boundedIteratorReturn } from './streamCleanup.js';
-
-export interface WatchedGeometryStreamOptions {
-  /** File name, for the stall error message. */
-  fileName: string;
-  /** File size in MB, feeds the size-aware watchdog deadline. */
-  fileSizeMB: number;
-  /** Abort the stream cooperatively (e.g. user cancelled the load). */
-  shouldAbort?: () => boolean;
-  /** Current batch index — feeds the size-aware watchdog deadline. */
-  getBatchCount: () => number;
-  /** Meshes rendered so far, for the stall error message. */
-  getLastTotalMeshes: () => number;
-  /** Override the abandon-cleanup deadline (mostly for tests). */
-  cleanupMs?: number;
-}
-
-/**
- * Drive a geometry stream under a size-aware watchdog, re-yielding every event.
- *
- * The parallel pipeline only ends once EVERY spawned geometry worker reports
- * `complete`; if the browser fails to instantiate a worker (the "Attempting to
- * create a Worker from an empty source" warning) that worker never reports
- * `ready`/`complete` and never fires `onerror`, so the underlying generator can
- * wedge forever, stranding the load on "Processing geometry (N meshes)". Racing
- * each `next()` against a deadline converts that silent wedge into a thrown,
- * recoverable error. On ANY exit — normal completion, abort, consumer `break`,
- * or a watchdog throw — the `finally` bounds the underlying iterator's shutdown
- * so cleanup (the generator's own `finally`: freeing WASM handles, tearing down
- * workers) runs without re-blocking on the very stall the watchdog just escaped.
- *
- * Generic over the event type so the consumer keeps full type-narrowing in its
- * own `switch`.
- */
-export async function* watchedGeometryStream<T>(
-  source: AsyncIterable<T>,
-  options: WatchedGeometryStreamOptions,
-): AsyncGenerator<T> {
-  const iterator = source[Symbol.asyncIterator]();
-  try {
-    while (true) {
-      const watchdogMs = getGeometryStreamWatchdogMs({
-        desktopStableWasm: false,
-        batchCount: options.getBatchCount(),
-        fileSizeMB: options.fileSizeMB,
-      });
-      let watchdogId: ReturnType<typeof setTimeout> | null = null;
-      let result: IteratorResult<T>;
-      try {
-        result = await Promise.race([
-          iterator.next(),
-          new Promise<never>((_, reject) => {
-            watchdogId = setTimeout(() => {
-              reject(new Error(
-                `Geometry stream stalled after ${watchdogMs}ms while loading ${options.fileName}. `
-                + `Last rendered meshes: ${options.getLastTotalMeshes()}. A geometry worker likely failed to start.`,
-              ));
-            }, watchdogMs);
-          }),
-        ]);
-      } finally {
-        if (watchdogId !== null) clearTimeout(watchdogId);
-      }
-      if (result.done) return;
-      if (options.shouldAbort?.()) return;
-      yield result.value;
-    }
-  } finally {
-    await boundedIteratorReturn(iterator, options.cleanupMs);
-  }
-}