@loaders.gl/core 5.0.0-alpha.12 → 5.0.0-alpha.13

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

@@ -0,0 +1,109 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+//
+// Adapted from async-iter-demo under the MIT License
+// Copyright (c) 2016 Axel Rauschmayer
+// https://github.com/rauschma/async-iter-demo
+
+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;
+}

package/src/schema-utils/types/types.ts

@@ -0,0 +1,45 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Any typed array */
+export type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Uint8ClampedArray
+  | Float32Array
+  | Float64Array;
+
+export type BigTypedArray = TypedArray | BigInt64Array | BigUint64Array;
+
+export type TypedArrayConstructor =
+  | Int8ArrayConstructor
+  | Uint8ArrayConstructor
+  | Int16ArrayConstructor
+  | Uint16ArrayConstructor
+  | Int32ArrayConstructor
+  | Uint32ArrayConstructor
+  | Float32ArrayConstructor
+  | Float64ArrayConstructor;
+
+export type BigTypedArrayConstructor =
+  | TypedArrayConstructor
+  | BigInt64ArrayConstructor
+  | BigUint64ArrayConstructor;
+
+/** Any numeric array: typed array or `number[]` */
+export type NumberArray = number[] | TypedArray;
+
+export type NumericArray = number[] | TypedArray;
+
+export interface ArrayType<T = unknown> {
+  readonly length: number;
+  [n: number]: T;
+}
+
+/** Any array: typed array or js array (`any[]`) */
+export type AnyArray = any[] | TypedArray;

package/src/worker-utils/index.ts

@@ -0,0 +1,80 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {WorkerObject} from './types';
+import {VERSION} from './lib/env-utils/version';
+
+// TYPES
+export type {
+  LoadWorker,
+  WorkerObject,
+  WorkerOptions,
+  WorkerContext,
+  WorkerJobContext,
+  Process,
+  ProcessInBatches,
+  // Protocol
+  WorkerMessage,
+  WorkerMessageType,
+  WorkerMessageData,
+  WorkerMessagePayload
+} from './types';
+
+// GENERAL UTILS
+export {assert} from './lib/env-utils/assert';
+export {isBrowser, isWorker} from './lib/env-utils/globals';
+
+// WORKER UTILS - TYPES
+export {default as WorkerJob} from './lib/worker-farm/worker-job';
+export {default as WorkerThread} from './lib/worker-farm/worker-thread';
+
+// WORKER FARMS
+export {default as WorkerFarm} from './lib/worker-farm/worker-farm';
+export {default as WorkerPool} from './lib/worker-farm/worker-pool';
+export {default as WorkerBody} from './lib/worker-farm/worker-body';
+
+// PROCESS ON WORKER
+export type {ProcessOnWorkerOptions} from './lib/worker-api/process-on-worker';
+export type {PreloadWorkerOptions} from './lib/worker-api/process-on-worker';
+export {
+  processOnWorker,
+  processOnWorkerInBatches,
+  preloadWorker,
+  canProcessOnWorker
+} from './lib/worker-api/process-on-worker';
+export {createWorker} from './lib/worker-api/create-worker';
+
+// WORKER UTILS - EXPORTS
+export {getWorkerURL} from './lib/worker-api/get-worker-url';
+export {validateWorkerVersion} from './lib/worker-api/validate-worker-version';
+export {getTransferList, getTransferListForWriter} from './lib/worker-utils/get-transfer-list';
+
+// LIBRARY UTILS
+export {
+  extractLoadLibraryOptions,
+  getLibraryUrl,
+  loadLibrary,
+  type LoadLibraryOptions
+} from './lib/library-utils/library-utils';
+
+// PARSER UTILS
+export {default as AsyncQueue} from './lib/async-queue/async-queue';
+
+// PROCESS UTILS
+export {default as ChildProcessProxy} from './lib/process-utils/child-process-proxy';
+
+// WORKER OBJECTS
+
+/** A null worker to test that worker processing is functional */
+export const NullWorker: WorkerObject = {
+  id: 'null',
+  name: 'null',
+  module: 'core',
+  workerFile: 'worker-utils/null-worker.js',
+  workerNode: 'worker-utils/null-worker-node.js',
+  version: VERSION,
+  options: {
+    null: {}
+  }
+};

package/src/worker-utils/lib/async-queue/async-queue.ts

@@ -0,0 +1,100 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license
+// http://2ality.com/2016/10/asynchronous-iteration.html
+
+/**
+ * Async Queue
+ * - AsyncIterable: An async iterator can be
+ * - Values can be pushed onto the queue
+ * @example
+ *   const asyncQueue = new AsyncQueue();
+ *   setTimeout(() => asyncQueue.enqueue('tick'), 1000);
+ *   setTimeout(() => asyncQueue.enqueue(new Error('done')), 10000);
+ *   for await (const value of asyncQueue) {
+ *     console.log(value); // tick
+ *   }
+ */
+export default class AsyncQueue<T> {
+  private _values: any[];
+  private _settlers: any[];
+  private _closed: boolean;
+
+  constructor() {
+    this._values = []; // enqueues > dequeues
+    this._settlers = []; // dequeues > enqueues
+    this._closed = false;
+  }
+
+  /** Return an async iterator for this queue */
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return this;
+  }
+
+  /** Push a new value - the async iterator will yield a promise resolved to this value */
+  push(value: T): void {
+    return this.enqueue(value);
+  }
+
+  /**
+   * Push a new value - the async iterator will yield a promise resolved to this value
+   * Add an error - the async iterator will yield a promise rejected with this value
+   */
+  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.shift();
+      if (value instanceof Error) {
+        settler.reject(value);
+      } else {
+        settler.resolve({value});
+      }
+    } else {
+      this._values.push(value);
+    }
+  }
+
+  /** Indicate that we not waiting for more values - The async iterator will be done */
+  close(): void {
+    while (this._settlers.length > 0) {
+      const settler = this._settlers.shift();
+      settler.resolve({done: true});
+    }
+    this._closed = true;
+  }
+
+  // ITERATOR IMPLEMENTATION
+
+  /** @returns a Promise for an IteratorResult */
+  next(): Promise<IteratorResult<T, any>> {
+    // If values in queue, yield the first value
+    if (this._values.length > 0) {
+      const value = this._values.shift();
+      if (value instanceof Error) {
+        return Promise.reject(value);
+      }
+      return Promise.resolve({done: false, value});
+    }
+
+    // If queue is closed, the iterator is done
+    if (this._closed) {
+      if (this._settlers.length > 0) {
+        throw new Error('Illegal internal state');
+      }
+      return Promise.resolve({done: true, value: undefined});
+    }
+
+    // Yield a promise that waits for new values to be enqueued
+    return new Promise((resolve, reject) => {
+      this._settlers.push({resolve, reject});
+    });
+  }
+}

package/src/worker-utils/lib/env-utils/assert.ts

@@ -0,0 +1,14 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// Replacement for the external assert method to reduce bundle size
+// Note: We don't use the second "message" argument in calling code,
+// so no need to support it here
+
+/** Throws an `Error` with the optional `message` if `condition` is falsy */
+export function assert(condition: any, message?: string): void {
+  if (!condition) {
+    throw new Error(message || 'loaders.gl assertion failed.');
+  }
+}

package/src/worker-utils/lib/env-utils/globals.ts

@@ -0,0 +1,40 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// Purpose: include this in your module to avoids adding dependencies on
+// micro modules like 'global' and 'is-browser';
+
+/* eslint-disable no-restricted-globals */
+const globals = {
+  self: typeof self !== 'undefined' && self,
+  window: typeof window !== 'undefined' && window,
+  global: typeof global !== 'undefined' && global,
+  document: typeof document !== 'undefined' && document
+};
+
+const self_: {[key: string]: any} = globals.self || globals.window || globals.global || {};
+const window_: {[key: string]: any} = globals.window || globals.self || globals.global || {};
+const global_: {[key: string]: any} = globals.global || globals.self || globals.window || {};
+const document_: {[key: string]: any} = globals.document || {};
+
+export {self_ as self, window_ as window, global_ as global, document_ as document};
+
+/** true if running in the browser, false if running in Node.js */
+export const isBrowser: boolean =
+  // @ts-ignore process.browser
+  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+
+/** true if running on a worker thread */
+export const isWorker: boolean = typeof importScripts === 'function';
+
+/** true if running on a mobile device */
+export const isMobile: boolean =
+  typeof window !== 'undefined' && typeof window.orientation !== 'undefined';
+
+// Extract node major version
+const matches =
+  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
+
+/** Version of Node.js if running under Node, otherwise 0 */
+export const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;

package/src/worker-utils/lib/env-utils/version.ts

@@ -0,0 +1,25 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {NPM_TAG} from '../npm-tag';
+
+// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
+declare let __VERSION__: string;
+
+/** Get the injected loaders.gl package version, or the npm tag used for unpublished builds. */
+function getVersion() {
+  if (!globalThis._loadersgl_?.version) {
+    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+    // __VERSION__ is injected by babel-plugin-version-inline
+    if (typeof __VERSION__ === 'undefined') {
+      globalThis._loadersgl_.version = NPM_TAG;
+    } else {
+      globalThis._loadersgl_.version = __VERSION__;
+    }
+  }
+
+  return globalThis._loadersgl_.version;
+}
+
+export const VERSION = getVersion();