chore(arrow): triangulateOnWorker plumbing

modules/arrow/package.json

@@ -39,10 +39,11 @@
     "fs": false
   },
   "scripts": {
-    "pre-build": "npm run build-worker && npm run build-bundle && npm run build-bundle -- --env=dev",
+    "pre-build": "npm run build-worker && npm run build-bundle && npm run build-bundle -- --env=dev && npm run build-triangulation-worker",
     "build-bundle": "ocular-bundle ./src/index.ts",
-    "build-worker": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js  --platform=browser --external:{stream} --define:__VERSION__=\\\"$npm_package_version\\\"",
+    "build-triangulation-worker": "esbuild src/workers/triangulation-worker.ts --bundle --outfile=dist/triangulation-worker.js  --platform=browser --external:{stream} --define:__VERSION__=\\\"$npm_package_version\\\"",
     "pre-build2": "cp fixed-package.json ../../node_modules/apache-arrow/package.json && npm run build-bundle && npm run build-worker",
+    "build-worker": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js  --platform=browser --external:{stream} --define:__VERSION__=\\\"$npm_package_version\\\"",
     "build-worker2": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js --platform=browser --external:{stream}"
   },
   "dependencies": {

modules/arrow/src/index.ts

@@ -78,3 +78,7 @@ export {
 export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson';
 
 export {updateBoundsFromGeoArrowSamples} from './geoarrow/get-arrow-bounds';
+
+// EXPERIMENTAL
+
+export {TriangulationWorker, triangulateOnWorker} from './triangulate-on-worker';

modules/arrow/src/triangulate-on-worker.ts

@@ -0,0 +1,47 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {WorkerOptions} from '@loaders.gl/worker-utils';
+import {processOnWorker} from '@loaders.gl/worker-utils';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+export type TriangulationWorkerInput = TriangulateInput | {operation: 'test'; data: any};
+export type TriangulationWorkerOutput = TriangulateResult | {operation: 'test'; data: any};
+
+/** Input data for operation: 'triangulate' */
+export type TriangulateInput = {
+  operation: 'triangulate';
+  polygonIndices: Uint16Array;
+  primitivePolygonIndices: Int32Array;
+  flatCoordinateArray: Float64Array;
+  nDim: number;
+};
+
+/** Result type for operation: 'triangulate' */
+export type TriangulateResult = TriangulateInput & {
+  triangleIndices: Uint32Array;
+};
+
+/**
+ * Worker for tessellating geometries. Normally called through triangulateOnWorker
+ */
+export const TriangulationWorker = {
+  id: 'triangulation',
+  name: 'Triangulate',
+  module: 'arrow',
+  version: VERSION,
+  options: {}
+};
+
+/**
+ * Provide type safety
+ */
+export function triangulateOnWorker(
+  data: TriangulationWorkerInput,
+  options: WorkerOptions = {}
+): Promise<TriangulationWorkerOutput> {
+  return processOnWorker(TriangulationWorker, data, options);
+}

modules/arrow/src/workers/triangulation-worker-node.ts

@@ -0,0 +1,4 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import './triangulation-worker';

modules/arrow/src/workers/triangulation-worker.ts

@@ -0,0 +1,39 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import {createWorker} from '@loaders.gl/worker-utils';
+import {getTriangleIndices} from '../geoarrow/convert-geoarrow-to-binary-geometry';
+import type {
+  TriangulationWorkerInput,
+  TriangulateInput,
+  TriangulateResult
+} from '../triangulate-on-worker';
+
+createWorker(async (data, options = {}) => {
+  const input = data as TriangulationWorkerInput;
+  const operation = input?.operation;
+  switch (operation) {
+    case 'test':
+      return input;
+    case 'triangulate':
+      return triangulateBatch(data);
+    default:
+      throw new Error(
+        `TriangulationWorker: Unsupported operation ${operation}. Expected 'triangulate'`
+      );
+  }
+});
+
+function triangulateBatch(data: TriangulateInput): TriangulateResult {
+  // Parse any WKT/WKB geometries
+  // Build binary geometries
+  // Call earcut and triangulate
+  console.error('TriangulationWorker: tessellating batch', data);
+  const triangleIndices = getTriangleIndices(
+    data.polygonIndices,
+    data.primitivePolygonIndices,
+    data.flatCoordinateArray,
+    data.nDim
+  );
+  return {...data, triangleIndices};
+}

modules/arrow/test/geoarrow/convert-geoarrow-to-binary-geometry.spec.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 import test, {Test} from 'tape-promise/tape';
 
 import {getGeometryColumnsFromSchema} from '@loaders.gl/gis';

modules/arrow/test/geoarrow/convert-geoarrow-to-geojson.spec.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 import test, {Test} from 'tape-promise/tape';
 
 import {fetchFile, parse} from '@loaders.gl/core';

modules/arrow/test/geoarrow/get-arrow-bounds.spec.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 import test from 'tape-promise/tape';
 
 import {updateBoundsFromGeoArrowSamples} from '@loaders.gl/arrow';

modules/arrow/test/index.ts

@@ -7,3 +7,5 @@ import './arrow-writer.spec';
 import './geoarrow/convert-geoarrow-to-binary-geometry.spec';
 import './geoarrow/convert-geoarrow-to-geojson.spec';
 import './geoarrow/get-arrow-bounds.spec';
+
+import './triangulate-on-worker.spec';

modules/arrow/test/triangulate-on-worker.spec.ts

@@ -0,0 +1,68 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import test from 'tape-promise/tape';
+import {triangulateOnWorker, TriangulationWorker} from '@loaders.gl/arrow';
+import {processOnWorker, isBrowser, WorkerFarm} from '@loaders.gl/worker-utils';
+
+// WORKER TESTS
+test('TriangulationWorker#plumbing', async (t) => {
+  const sourceData = {
+    operation: 'test',
+    data: new ArrayBuffer(100)
+  };
+
+  const triangulatedData = await processOnWorker(TriangulationWorker, sourceData, {
+    _workerType: 'test'
+  });
+
+  t.ok(triangulatedData, 'Triangulation worker echoed input data');
+
+  t.rejects(
+    () =>
+      processOnWorker(
+        TriangulationWorker,
+        {operation: 'error'},
+        {
+          _workerType: 'test'
+        }
+      ),
+    'Triangulation worker throws on incorrect operation'
+  );
+
+  if (!isBrowser) {
+    const workerFarm = WorkerFarm.getWorkerFarm({});
+    workerFarm.destroy();
+  }
+
+  t.end();
+});
+
+test('triangulateOnWorker#plumbing', async (t) => {
+  const triangulatedData = await triangulateOnWorker(
+    {
+      operation: 'test',
+      data: new ArrayBuffer(100)
+    },
+    {
+      _workerType: 'test'
+    }
+  );
+
+  t.equal(triangulatedData.operation, 'test', 'Triangulation worker got correct return type');
+  if (triangulatedData.operation === 'test') {
+    t.equal(triangulatedData.data?.byteLength, 100, 'Triangulation worker echoed input data');
+  }
+
+  // t.rejec(() => await processOnWorker(TriangulationWorker, sourceData, {
+  //   operation: 'error',
+  //   _workerType: 'test'
+  // }), 'Triangulation worker throws on incorrect operation');
+
+  if (!isBrowser) {
+    const workerFarm = WorkerFarm.getWorkerFarm({});
+    workerFarm.destroy();
+  }
+
+  t.end();
+});

modules/worker-utils/src/index.ts

@@ -28,6 +28,8 @@ 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 {processOnWorker, canProcessOnWorker} from './lib/worker-api/process-on-worker';
 export {createWorker} from './lib/worker-api/create-worker';
 

modules/worker-utils/src/lib/worker-api/process-on-worker.ts

@@ -13,7 +13,8 @@ import WorkerFarm from '../worker-farm/worker-farm';
 import {getWorkerURL, getWorkerName} from './get-worker-url';
 import {getTransferListForWriter} from '../worker-utils/get-transfer-list';
 
-type ProcessOnWorkerOptions = WorkerOptions & {
+/** Options for worker processing */
+export type ProcessOnWorkerOptions = WorkerOptions & {
   jobName?: string;
   [key: string]: any;
 };