24206843587

Committed 09 Apr 2026 06:32PM UTC coverage: 53.526% (+0.1%) from 53.425%

Build # 24206843587

Build Type

push

github

Committed by

web-flow

Commit Message

chore: parquet reader no longer uses Buffer (#3355)

Coverage Stats

8779 of 17435 branches covered (50.35%)

Branch coverage included in aggregate %.

157 of 202 new or added lines in 11 files covered. (77.72%)

12 existing lines in 2 files now uncovered.

17787 of 32197 relevant lines covered (55.24%)

5228.91 hits per line

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

61.4

/modules/schema-utils/src/lib/utils/async-queue.ts

// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license
// http://2ality.com/2016/10/asynchronous-iteration.html

class ArrayQueue<T> extends Array<T> {
  enqueue(value: T) {
    // Add at the end
    return this.push(value);
  }
  dequeue(): T {
    // Remove first element
    return this.shift() as T;
  }
}

export default class AsyncQueue<T> {
  private _values: ArrayQueue<T | Error>;
  private _settlers: ArrayQueue<{resolve: (value: any) => void; reject: (reason?: any) => void}>;
  private _closed: boolean;

  constructor() {
    // enqueues > dequeues
    this._values = new ArrayQueue<T>();
    // dequeues > enqueues
    this._settlers = new ArrayQueue<{
      resolve: (value: any) => void;
      reject: (reason?: any) => void;
    }>();
    this._closed = false;
  }

  close(): void {
    while (this._settlers.length > 0) {
      this._settlers.dequeue().resolve({done: true});
    }
    this._closed = true;
  }

  [Symbol.asyncIterator](): AsyncIterator<T> {
    return this;
  }

  enqueue(value: T | Error): void {
    if (this._closed) {
      throw new Error('Closed');
    }

    if (this._settlers.length > 0) {
      if (this._values.length > 0) {
        throw new Error('Illegal internal state');
      }
      const settler = this._settlers.dequeue();
      if (value instanceof Error) {
        settler.reject(value);
      } else {
        settler.resolve({value});
      }
    } else {
      this._values.enqueue(value);
    }
  }

  /**
   * @returns a Promise for an IteratorResult
   */
  next(): Promise<any> {
    if (this._values.length > 0) {
      const value = this._values.dequeue();
      if (value instanceof Error) {
        return Promise.reject(value);
      }
      return Promise.resolve({value});
    }

    if (this._closed) {
      if (this._settlers.length > 0) {
        throw new Error('Illegal internal state');
      }
      return Promise.resolve({done: true});
    }
    // Wait for new values to be enqueued
    return new Promise((resolve, reject) => {
      this._settlers.enqueue({resolve, reject});
    });
  }
}

/**
 * @returns a Promise for an Array with the elements in `asyncIterable`
 */
export async function takeAsync(
  asyncIterable: AsyncIterable<any>,
  count = Infinity
): Promise<any[]> {
  const result: Array<any> = [];
  const iterator = asyncIterable[Symbol.asyncIterator]();
  while (result.length < count) {
    const {value, done} = await iterator.next();
    if (done) {
      break;
    }
    result.push(value);
  }
  return result;
}

1	// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license
2	// http://2ality.com/2016/10/asynchronous-iteration.html
3
4	class ArrayQueue<T> extends Array<T> {
5	enqueue(value: T) {
6	// Add at the end
7	return this.push(value);	135✔
8	}
9	dequeue(): T {
10	// Remove first element
11	return this.shift() as T;	60✔
12	}
13	}
14
15	export default class AsyncQueue<T> {
16	private _values: ArrayQueue<T \| Error>;
17	private _settlers: ArrayQueue<{resolve: (value: any) => void; reject: (reason?: any) => void}>;
18	private _closed: boolean;
19
20	constructor() {
21	// enqueues > dequeues
22	this._values = new ArrayQueue<T>();	40✔
23	// dequeues > enqueues
24	this._settlers = new ArrayQueue<{	40✔
25	resolve: (value: any) => void;
26	reject: (reason?: any) => void;
27	}>();
28	this._closed = false;	40✔
29	}
30
31	close(): void {
32	while (this._settlers.length > 0) {	40✔
UNCOV 33	this._settlers.dequeue().resolve({done: true});	×
34	}
35	this._closed = true;	40✔
36	}
37
38	[Symbol.asyncIterator](): AsyncIterator<T> {
39	return this;	39✔
40	}
41
42	enqueue(value: T \| Error): void {
43	if (this._closed) {	135!
44	throw new Error('Closed');	×
45	}
46
47	if (this._settlers.length > 0) {	135✔
48	if (this._values.length > 0) {	40!
49	throw new Error('Illegal internal state');	×
50	}
51	const settler = this._settlers.dequeue();	40✔
52	if (value instanceof Error) {	40!
53	settler.reject(value);	×
54	} else {
55	settler.resolve({value});	40✔
56	}
57	} else {
58	this._values.enqueue(value);	95✔
59	}
60	}
61
62	/**
63	* @returns a Promise for an IteratorResult
64	*/
65	next(): Promise<any> {
66	if (this._values.length > 0) {	98✔
67	const value = this._values.dequeue();	20✔
68	if (value instanceof Error) {	20!
69	return Promise.reject(value);	×
70	}
71	return Promise.resolve({value});	20✔
72	}
73
74	if (this._closed) {	78✔
75	if (this._settlers.length > 0) {	38!
76	throw new Error('Illegal internal state');	×
77	}
78	return Promise.resolve({done: true});	38✔
79	}
80	// Wait for new values to be enqueued
81	return new Promise((resolve, reject) => {	40✔
82	this._settlers.enqueue({resolve, reject});	40✔
83	});
84	}
85	}
86
87	/**
88	* @returns a Promise for an Array with the elements in `asyncIterable`
89	*/
90	export async function takeAsync(
91	asyncIterable: AsyncIterable<any>,
92	count = Infinity	×
93	): Promise<any[]> {
94	const result: Array<any> = [];	×
95	const iterator = asyncIterable[Symbol.asyncIterator]();	×
96	while (result.length < count) {	×
97	const {value, done} = await iterator.next();	×
98	if (done) {	×
99	break;	×
100	}
101	result.push(value);	×
102	}
103	return result;	×
104	}

visgl / loaders.gl / 24206843587

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