24153816851

Committed 08 Apr 2026 07:17PM UTC coverage: 53.247% (-12.1%) from 65.319%

Build # 24153816851

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Move from tape to vitest (#3351)

Coverage Stats

8651 of 17291 branches covered (50.03%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 1 file covered. (100.0%)

2031 existing lines in 296 files now uncovered.

17563 of 31940 relevant lines covered (54.99%)

5279.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1.54

/modules/worker-utils/src/lib/worker-api/create-worker.ts

// loaders.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import type {
  WorkerMessageType,
  WorkerMessagePayload,
  WorkerContext,
  Process,
  ProcessInBatches
} from '../../types';
import AsyncQueue from '../async-queue/async-queue';
import WorkerBody from '../worker-farm/worker-body';
// import {validateWorkerVersion} from './validate-worker-version';

/** Counter for jobs */
let requestId = 0;
let inputBatches: AsyncQueue<any>;
let options: {[key: string]: any};

export type ProcessOnMainThread = (
  data: any,
  options?: {[key: string]: any},
  context?: WorkerContext
) => any;

/**
 * Set up a WebWorkerGlobalScope to talk with the main thread
 */
export async function createWorker(
  process: Process,
  processInBatches?: ProcessInBatches
): Promise<void> {
  if (!(await WorkerBody.inWorkerThread())) {
    return;
  }

  const context: WorkerContext = {
    process: processOnMainThread
  };

  // eslint-disable-next-line complexity
  WorkerBody.onmessage = async (type: WorkerMessageType, payload: WorkerMessagePayload) => {
    try {
      switch (type) {
        case 'process':
          if (!process) {
            throw new Error('Worker does not support atomic processing');
          }
          const result = await process(payload.input, payload.options || {}, context);
          WorkerBody.postMessage('done', {result});
          break;

        case 'process-in-batches':
          if (!processInBatches) {
            throw new Error('Worker does not support batched processing');
          }
          inputBatches = new AsyncQueue<any>();
          options = payload.options || {};
          const resultIterator = processInBatches(inputBatches, options, context);
          for await (const batch of resultIterator) {
            WorkerBody.postMessage('output-batch', {result: batch});
          }
          WorkerBody.postMessage('done', {});
          break;

        case 'input-batch':
          inputBatches.push(payload.input);
          break;

        case 'input-done':
          inputBatches.close();
          break;

        default:
      }
    } catch (error) {
      const message = error instanceof Error ? error.message : '';
      WorkerBody.postMessage('error', {error: message});
    }
  };
}

function processOnMainThread(arrayBuffer: ArrayBuffer, options = {}) {
  return new Promise((resolve, reject) => {
    const id = requestId++;

    /**
     */
    const onMessage = (type: string, payload: WorkerMessagePayload) => {
      if (payload.id !== id) {
        // not ours
        return;
      }

      switch (type) {
        case 'done':
          WorkerBody.removeEventListener(onMessage);
          resolve(payload.result);
          break;

        case 'error':
          WorkerBody.removeEventListener(onMessage);
          reject(payload.error);
          break;

        default:
        // ignore
      }
    };

    WorkerBody.addEventListener(onMessage);

    // Ask the main thread to decode data
    const payload = {id, input: arrayBuffer, options};
    WorkerBody.postMessage('process', payload);
  });
}

1	// loaders.gl
2	// SPDX-License-Identifier: MIT
3	// Copyright (c) vis.gl contributors
4
5	import type {
6	WorkerMessageType,
7	WorkerMessagePayload,
8	WorkerContext,
9	Process,
10	ProcessInBatches
11	} from '../../types';
12	import AsyncQueue from '../async-queue/async-queue';
13	import WorkerBody from '../worker-farm/worker-body';
14	// import {validateWorkerVersion} from './validate-worker-version';
15
16	/** Counter for jobs */
17	let requestId = 0;	348✔
18	let inputBatches: AsyncQueue<any>;
19	let options: {[key: string]: any};
20
21	export type ProcessOnMainThread = (
22	data: any,
23	options?: {[key: string]: any},
24	context?: WorkerContext
25	) => any;
26
27	/**
28	* Set up a WebWorkerGlobalScope to talk with the main thread
29	*/
30	export async function createWorker(
31	process: Process,
32	processInBatches?: ProcessInBatches
33	): Promise<void> {
UNCOV 34	if (!(await WorkerBody.inWorkerThread())) {	×
35	return;	×
36	}
37
UNCOV 38	const context: WorkerContext = {	×
39	process: processOnMainThread
40	};
41
42	// eslint-disable-next-line complexity
UNCOV 43	WorkerBody.onmessage = async (type: WorkerMessageType, payload: WorkerMessagePayload) => {	×
UNCOV 44	try {	×
UNCOV 45	switch (type) {	×
46	case 'process':
UNCOV 47	if (!process) {	×
48	throw new Error('Worker does not support atomic processing');	×
49	}
UNCOV 50	const result = await process(payload.input, payload.options \|\| {}, context);	×
UNCOV 51	WorkerBody.postMessage('done', {result});	×
UNCOV 52	break;	×
53
54	case 'process-in-batches':
55	if (!processInBatches) {	×
56	throw new Error('Worker does not support batched processing');	×
57	}
58	inputBatches = new AsyncQueue<any>();	×
59	options = payload.options \|\| {};	×
60	const resultIterator = processInBatches(inputBatches, options, context);	×
61	for await (const batch of resultIterator) {	×
62	WorkerBody.postMessage('output-batch', {result: batch});	×
63	}
64	WorkerBody.postMessage('done', {});	×
65	break;	×
66
67	case 'input-batch':
68	inputBatches.push(payload.input);	×
69	break;	×
70
71	case 'input-done':
72	inputBatches.close();	×
73	break;	×
74
75	default:
76	}
77	} catch (error) {
78	const message = error instanceof Error ? error.message : '';	×
79	WorkerBody.postMessage('error', {error: message});	×
80	}
81	};
82	}
83
84	function processOnMainThread(arrayBuffer: ArrayBuffer, options = {}) {	×
85	return new Promise((resolve, reject) => {	×
86	const id = requestId++;	×
87
88	/**
89	*/
90	const onMessage = (type: string, payload: WorkerMessagePayload) => {	×
91	if (payload.id !== id) {	×
92	// not ours
93	return;	×
94	}
95
96	switch (type) {	×
97	case 'done':
98	WorkerBody.removeEventListener(onMessage);	×
99	resolve(payload.result);	×
100	break;	×
101
102	case 'error':
103	WorkerBody.removeEventListener(onMessage);	×
104	reject(payload.error);	×
105	break;	×
106
107	default:
108	// ignore
109	}
110	};
111
112	WorkerBody.addEventListener(onMessage);	×
113
114	// Ask the main thread to decode data
115	const payload = {id, input: arrayBuffer, options};	×
116	WorkerBody.postMessage('process', payload);	×
117	});
118	}

visgl / loaders.gl / 24153816851

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous