25070233425

Committed 28 Apr 2026 06:20PM UTC coverage: 59.434% (+0.01%) from 59.423%

Build # 25070233425

Build Type

push

github

Committed by

web-flow

Commit Message

website: Add tabs for navigating between format docs (#3407)

Coverage Stats

11310 of 20887 branches covered (54.15%)

Branch coverage included in aggregate %.

89 of 136 new or added lines in 13 files covered. (65.44%)

1742 existing lines in 132 files now uncovered.

23500 of 37682 relevant lines covered (62.36%)

16296.63 hits per line

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

79.31

/modules/loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts

import {
  WorkerJob,
  WorkerMessageType,
  WorkerMessagePayload,
  isBrowser,
  WorkerFarm,
  getWorkerURL
} from '@loaders.gl/worker-utils';
import type {Loader, LoaderOptions, LoaderContext} from '../../loader-types';

/**
 * Determines if a loader can parse with worker
 * @param loader
 * @param options
 */
export function canParseWithWorker(loader: Loader, options?: LoaderOptions) {
  if (!WorkerFarm.isSupported()) {
    return false;
  }

  // Node workers are still experimental
  const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;
  if (!isBrowser && !nodeWorkers) {
    return false;
  }

  // Some Arrow table outputs need main-thread class instances; structured clone
  // preserves data but strips methods like `table.getChild()` from Arrow tables.
  if (
    (loader.id === 'excel' &&
      (options as {excel?: {shape?: string}} | undefined)?.excel?.shape === 'arrow-table') ||
    (loader.id === 'ply' &&
      (options as {ply?: {shape?: string}} | undefined)?.ply?.shape === 'arrow-table')
  ) {
    return false;
  }

  const useWorkers = options?.worker ?? options?.core?.worker;
  return Boolean(loader.worker && useWorkers);
}

/**
 * this function expects that the worker function sends certain messages,
 * this can be automated if the worker is wrapper by a call to createLoaderWorker in @loaders.gl/loader-utils.
 */
export async function parseWithWorker(
  loader: Loader,
  data: any,
  options?: LoaderOptions,
  context?: LoaderContext,
  parseOnMainThread?: (arrayBuffer: ArrayBuffer, options: {[key: string]: any}) => Promise<unknown>
) {
  const name = loader.id; // TODO
  const url = getWorkerURL(loader, options);

  const workerFarm = WorkerFarm.getWorkerFarm(options?.core);
  const workerPool = workerFarm.getWorkerPool({name, url});

  // options.log object contains functions which cannot be transferred
  // context.fetch & context.parse functions cannot be transferred
  // TODO - decide how to handle logging on workers
  options = JSON.parse(JSON.stringify(options));
  context = JSON.parse(JSON.stringify(context || {}));

  const job = await workerPool.startJob(
    'process-on-worker',
    // @ts-expect-error
    onMessage.bind(null, parseOnMainThread) // eslint-disable-line @typescript-eslint/no-misused-promises
  );

  job.postMessage('process', {
    // @ts-ignore
    input: data,
    options,
    context
  });

  const result = await job.result;
  // TODO - what is going on here?
  return await result.result;
}

/**
 * Handle worker's responses to the main thread
 * @param job
 * @param type
 * @param payload
 */
async function onMessage(
  parseOnMainThread: (arrayBuffer: ArrayBuffer, options?: {[key: string]: any}) => Promise<void>,
  job: WorkerJob,
  type: WorkerMessageType,
  payload: WorkerMessagePayload
) {
  switch (type) {
    case 'done':
      job.done(payload);
      break;

    case 'error':
      job.error(new Error(payload.error));
      break;

    case 'process':
      // Worker is asking for main thread to parseO
      const {id, input, options} = payload;
      try {
        const result = await parseOnMainThread(input, options);
        job.postMessage('done', {id, result});
      } catch (error) {
        const message = error instanceof Error ? error.message : 'unknown error';
        job.postMessage('error', {id, error: message});
      }
      break;

    default:
      // eslint-disable-next-line
      console.warn(`parse-with-worker unknown message ${type}`);
  }
}

1	import {
2	WorkerJob,
3	WorkerMessageType,
4	WorkerMessagePayload,
5	isBrowser,
6	WorkerFarm,
7	getWorkerURL
8	} from '@loaders.gl/worker-utils';
9	import type {Loader, LoaderOptions, LoaderContext} from '../../loader-types';
10
11	/**
12	* Determines if a loader can parse with worker
13	* @param loader
14	* @param options
15	*/
16	export function canParseWithWorker(loader: Loader, options?: LoaderOptions) {
17	if (!WorkerFarm.isSupported()) {	1,770!
18	return false;	×
19	}
20
21	// Node workers are still experimental
22	const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;	1,770✔
23	if (!isBrowser && !nodeWorkers) {	1,770✔
24	return false;	833✔
25	}
26
27	// Some Arrow table outputs need main-thread class instances; structured clone
28	// preserves data but strips methods like `table.getChild()` from Arrow tables.
UNCOV 29	if (	937✔
30	(loader.id === 'excel' &&	1,886✔
31	(options as {excel?: {shape?: string}} \| undefined)?.excel?.shape === 'arrow-table') \|\|
32	(loader.id === 'ply' &&
33	(options as {ply?: {shape?: string}} \| undefined)?.ply?.shape === 'arrow-table')
34	) {
UNCOV 35	return false;	7✔
36	}
37
UNCOV 38	const useWorkers = options?.worker ?? options?.core?.worker;	930✔
39	return Boolean(loader.worker && useWorkers);	1,770✔
40	}
41
42	/**
43	* this function expects that the worker function sends certain messages,
44	* this can be automated if the worker is wrapper by a call to createLoaderWorker in @loaders.gl/loader-utils.
45	*/
46	export async function parseWithWorker(
47	loader: Loader,
48	data: any,
49	options?: LoaderOptions,
50	context?: LoaderContext,
51	parseOnMainThread?: (arrayBuffer: ArrayBuffer, options: {[key: string]: any}) => Promise<unknown>
52	) {
UNCOV 53	const name = loader.id; // TODO	100✔
UNCOV 54	const url = getWorkerURL(loader, options);	100✔
55
UNCOV 56	const workerFarm = WorkerFarm.getWorkerFarm(options?.core);	100✔
UNCOV 57	const workerPool = workerFarm.getWorkerPool({name, url});	100✔
58
59	// options.log object contains functions which cannot be transferred
60	// context.fetch & context.parse functions cannot be transferred
61	// TODO - decide how to handle logging on workers
UNCOV 62	options = JSON.parse(JSON.stringify(options));	100✔
UNCOV 63	context = JSON.parse(JSON.stringify(context \|\| {}));	100!
64
UNCOV 65	const job = await workerPool.startJob(	100✔
66	'process-on-worker',
67	// @ts-expect-error
68	onMessage.bind(null, parseOnMainThread) // eslint-disable-line @typescript-eslint/no-misused-promises
69	);
70
UNCOV 71	job.postMessage('process', {	100✔
72	// @ts-ignore
73	input: data,
74	options,
75	context
76	});
77
UNCOV 78	const result = await job.result;	100✔
79	// TODO - what is going on here?
UNCOV 80	return await result.result;	100✔
81	}
82
83	/**
84	* Handle worker's responses to the main thread
85	* @param job
86	* @param type
87	* @param payload
88	*/
89	async function onMessage(
90	parseOnMainThread: (arrayBuffer: ArrayBuffer, options?: {[key: string]: any}) => Promise<void>,
91	job: WorkerJob,
92	type: WorkerMessageType,
93	payload: WorkerMessagePayload
94	) {
UNCOV 95	switch (type) {	107!
96	case 'done':
UNCOV 97	job.done(payload);	100✔
UNCOV 98	break;	100✔
99
100	case 'error':
101	job.error(new Error(payload.error));	×
102	break;	×
103
104	case 'process':
105	// Worker is asking for main thread to parseO
UNCOV 106	const {id, input, options} = payload;	7✔
UNCOV 107	try {	7✔
UNCOV 108	const result = await parseOnMainThread(input, options);	7✔
UNCOV 109	job.postMessage('done', {id, result});	7✔
110	} catch (error) {
111	const message = error instanceof Error ? error.message : 'unknown error';	×
112	job.postMessage('error', {id, error: message});	×
113	}
UNCOV 114	break;	7✔
115
116	default:
117	// eslint-disable-next-line
118	console.warn(`parse-with-worker unknown message ${type}`);	×
119	}
120	}

visgl / loaders.gl / 25070233425

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