@loaders.gl/arrow 4.1.0-alpha.1 → 4.1.0-alpha.2

package/dist/workers/hard-clone.d.ts

@@ -0,0 +1,23 @@
+import * as arrow from 'apache-arrow';
+/**
+ * Clone an Arrow JS Data or Vector, detaching from an existing ArrayBuffer if
+ * it is shared with other.
+ *
+ * The purpose of this function is to enable transferring a `Data` instance,
+ * e.g. to a web worker, without neutering any other data.
+ *
+ * Any internal buffers that are a slice of a larger `ArrayBuffer` (i.e. where
+ * the typed array's `byteOffset` is not `0` and where its `byteLength` does not
+ * match its `array.buffer.byteLength`) are copied into new `ArrayBuffers`.
+ *
+ * If `force` is `true`, always clone internal buffers, even if not shared. If
+ * the default, `false`, any internal buffers that are **not** a slice of a
+ * larger `ArrayBuffer` will not be copied.
+ */
+export declare function hardClone<T extends arrow.DataType>(input: arrow.Data<T>, force?: boolean): arrow.Data<T>;
+export declare function hardClone<T extends arrow.DataType>(input: arrow.Vector<T>, force?: boolean): arrow.Vector<T>;
+/**
+ * Test whether an arrow.Data instance is a slice of a larger `ArrayBuffer`.
+ */
+export declare function isShared<T extends arrow.DataType>(data: arrow.Data<T> | arrow.Vector<T>): boolean;
+//# sourceMappingURL=hard-clone.d.ts.map

package/dist/workers/hard-clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hard-clone.d.ts","sourceRoot":"","sources":["../../src/workers/hard-clone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AActC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,KAAK,CAAC,QAAQ,EAChD,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EACpB,KAAK,CAAC,EAAE,OAAO,GACd,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,wBAAgB,SAAS,CAAC,CAAC,SAAS,KAAK,CAAC,QAAQ,EAChD,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EACtB,KAAK,CAAC,EAAE,OAAO,GACd,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAuDnB;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,CAiCjG"}

package/dist/workers/hard-clone.js

@@ -0,0 +1,57 @@
+import * as arrow from 'apache-arrow';
+export function hardClone(data) {
+  let force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if ('data' in data) {
+    return new arrow.Vector(data.data.map(data => hardClone(data, force)));
+  }
+  const clonedChildren = [];
+  for (const childData of data.children) {
+    clonedChildren.push(hardClone(childData, force));
+  }
+  let clonedDictionary;
+  if (data.dictionary !== undefined) {
+    clonedDictionary = hardClone(data.dictionary, force);
+  }
+  const clonedBuffers = {
+    [arrow.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow.BufferType.OFFSET], force),
+    [arrow.BufferType.DATA]: cloneBuffer(data.buffers[arrow.BufferType.DATA], force),
+    [arrow.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow.BufferType.VALIDITY], force),
+    [arrow.BufferType.TYPE]: cloneBuffer(data.buffers[arrow.BufferType.TYPE], force)
+  };
+  return new arrow.Data(data.type, data.offset, data.length, data._nullCount, clonedBuffers, clonedChildren, clonedDictionary);
+}
+export function isShared(data) {
+  if ('data' in data) {
+    return data.data.some(data => isShared(data));
+  }
+  for (const childData of data.children) {
+    if (isShared(childData)) {
+      return true;
+    }
+  }
+  if (data.dictionary !== undefined) {
+    if (isShared(data.dictionary)) {
+      return true;
+    }
+  }
+  const bufferTypes = [arrow.BufferType.OFFSET, arrow.BufferType.DATA, arrow.BufferType.VALIDITY, arrow.BufferType.TYPE];
+  for (const bufferType of bufferTypes) {
+    if (data.buffers[bufferType] !== undefined && isTypedArraySliced(data.buffers[bufferType])) {
+      return true;
+    }
+  }
+  return false;
+}
+function isTypedArraySliced(arr) {
+  return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);
+}
+function cloneBuffer(arr, force) {
+  if (arr === undefined) {
+    return arr;
+  }
+  if (!force && !isTypedArraySliced(arr)) {
+    return arr;
+  }
+  return arr.slice();
+}
+//# sourceMappingURL=hard-clone.js.map

package/dist/workers/hard-clone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hard-clone.js","names":["arrow","hardClone","data","force","arguments","length","undefined","Vector","map","clonedChildren","childData","children","push","clonedDictionary","dictionary","clonedBuffers","BufferType","OFFSET","cloneBuffer","buffers","DATA","VALIDITY","TYPE","Data","type","offset","_nullCount","isShared","some","bufferTypes","bufferType","isTypedArraySliced","arr","byteOffset","byteLength","buffer","slice"],"sources":["../../src/workers/hard-clone.ts"],"sourcesContent":["import * as arrow from 'apache-arrow';\nimport type {Buffers} from 'apache-arrow/data';\n\ntype TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | Float32Array\n  | Float64Array;\n\n/**\n * Clone an Arrow JS Data or Vector, detaching from an existing ArrayBuffer if\n * it is shared with other.\n *\n * The purpose of this function is to enable transferring a `Data` instance,\n * e.g. to a web worker, without neutering any other data.\n *\n * Any internal buffers that are a slice of a larger `ArrayBuffer` (i.e. where\n * the typed array's `byteOffset` is not `0` and where its `byteLength` does not\n * match its `array.buffer.byteLength`) are copied into new `ArrayBuffers`.\n *\n * If `force` is `true`, always clone internal buffers, even if not shared. If\n * the default, `false`, any internal buffers that are **not** a slice of a\n * larger `ArrayBuffer` will not be copied.\n */\nexport function hardClone<T extends arrow.DataType>(\n  input: arrow.Data<T>,\n  force?: boolean\n): arrow.Data<T>;\nexport function hardClone<T extends arrow.DataType>(\n  input: arrow.Vector<T>,\n  force?: boolean\n): arrow.Vector<T>;\n\nexport function hardClone<T extends arrow.DataType>(\n  data: arrow.Data<T> | arrow.Vector<T>,\n  force: boolean = false\n): arrow.Data<T> | arrow.Vector<T> {\n  // Check if `data` is an arrow.Vector\n  if ('data' in data) {\n    return new arrow.Vector(data.data.map((data) => hardClone(data, force)));\n  }\n\n  // Clone each of the children, recursively\n  const clonedChildren: arrow.Data[] = [];\n  for (const childData of data.children) {\n    clonedChildren.push(hardClone(childData, force));\n  }\n\n  // Clone the dictionary if there is one\n  let clonedDictionary: arrow.Vector | undefined;\n  if (data.dictionary !== undefined) {\n    clonedDictionary = hardClone(data.dictionary, force);\n  }\n\n  // Buffers can have up to four entries. Each of these can be `undefined` for\n  // one or more array types.\n  //\n  // - OFFSET: value offsets for variable size list types\n  // - DATA: the underlying data\n  // - VALIDITY: the null buffer. This may be empty or undefined if all elements\n  //   are non-null/valid.\n  // - TYPE: type ids for a union type.\n  const clonedBuffers: Buffers<T> = {\n    [arrow.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow.BufferType.OFFSET], force),\n    [arrow.BufferType.DATA]: cloneBuffer(data.buffers[arrow.BufferType.DATA], force),\n    [arrow.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow.BufferType.VALIDITY], force),\n    [arrow.BufferType.TYPE]: cloneBuffer(data.buffers[arrow.BufferType.TYPE], force)\n  };\n\n  // Note: the data.offset is passed on so that a sliced Data instance will not\n  // be \"un-sliced\". However keep in mind that this means we're cloning the\n  // _original backing buffer_, not only the portion of the Data that was\n  // sliced.\n  return new arrow.Data(\n    data.type,\n    data.offset,\n    data.length,\n    // @ts-expect-error _nullCount is protected. We're using it here to mimic\n    // `Data.clone`\n    data._nullCount,\n    clonedBuffers,\n    clonedChildren,\n    clonedDictionary\n  );\n}\n\n/**\n * Test whether an arrow.Data instance is a slice of a larger `ArrayBuffer`.\n */\nexport function isShared<T extends arrow.DataType>(data: arrow.Data<T> | arrow.Vector<T>): boolean {\n  // Loop over arrow.Vector\n  if ('data' in data) {\n    return data.data.some((data) => isShared(data));\n  }\n\n  // Check child data\n  for (const childData of data.children) {\n    if (isShared(childData)) {\n      return true;\n    }\n  }\n\n  // Check dictionary\n  if (data.dictionary !== undefined) {\n    if (isShared(data.dictionary)) {\n      return true;\n    }\n  }\n\n  const bufferTypes = [\n    arrow.BufferType.OFFSET,\n    arrow.BufferType.DATA,\n    arrow.BufferType.VALIDITY,\n    arrow.BufferType.TYPE\n  ];\n  for (const bufferType of bufferTypes) {\n    if (data.buffers[bufferType] !== undefined && isTypedArraySliced(data.buffers[bufferType])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the current typed array is a partial slice on a larger\n * ArrayBuffer\n */\nfunction isTypedArraySliced(arr: TypedArray): boolean {\n  return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);\n}\n\n/**\n * If a slice of a larger ArrayBuffer, clone to a fresh `ArrayBuffer`.\n *\n * If `force` is `true`, always clone the array, even if not shared.\n */\nfunction cloneBuffer<A extends TypedArray | undefined>(arr: A, force: boolean): A {\n  // Not all buffer types are defined for every type of Arrow array. E.g.\n  // `arrow.BufferType.TYPE` is only defined for the Union type.\n  if (arr === undefined) {\n    return arr;\n  }\n\n  // The current array is not a part of a larger ArrayBuffer, don't clone it\n  if (!force && !isTypedArraySliced(arr)) {\n    return arr;\n  }\n\n  // Note: TypedArray.slice() **copies** into a new ArrayBuffer\n\n  // @ts-expect-error 'Uint8Array' is assignable to the constraint of type 'A',\n  // but 'A' could be instantiated with a different subtype of constraint\n  // 'TypedArray'\n  // We know from arr.slice that it will always return the same\n  return arr.slice();\n}\n"],"mappings":"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"}

package/dist/workers/triangulation-worker.js

@@ -1,5 +1,6 @@
+import * as arrow from 'apache-arrow';
 import { createWorker } from '@loaders.gl/worker-utils';
-import { getTriangleIndices } from "../geoarrow/convert-geoarrow-to-binary-geometry.js";
+import { getTriangleIndices, getBinaryGeometriesFromArrow } from "../geoarrow/convert-geoarrow-to-binary-geometry.js";
 createWorker(async function (data) {
   let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   const input = data;
@@ -9,6 +10,8 @@ createWorker(async function (data) {
       return input;
     case 'triangulate':
       return triangulateBatch(data);
+    case 'parse-geoarrow':
+      return parseGeoArrowBatch(data);
     default:
       throw new Error(`TriangulationWorker: Unsupported operation ${operation}. Expected 'triangulate'`);
   }
@@ -23,4 +26,34 @@ function triangulateBatch(data) {
     } : {})
   };
 }
+function parseGeoArrowBatch(data) {
+  let binaryDataFromGeoArrow = null;
+  const {
+    chunkData,
+    chunkIndex,
+    chunkOffset,
+    geometryEncoding,
+    calculateMeanCenters,
+    triangle
+  } = data;
+  const arrowData = new arrow.Data(chunkData.type, chunkData.offset, chunkData.length, chunkData.nullCount, chunkData.buffers, chunkData.children, chunkData.dictionary);
+  const geometryColumn = arrow.makeVector(arrowData);
+  if (geometryColumn) {
+    const options = {
+      calculateMeanCenters,
+      triangle,
+      chunkIndex: 0,
+      chunkOffset
+    };
+    binaryDataFromGeoArrow = getBinaryGeometriesFromArrow(geometryColumn, geometryEncoding, options);
+    return {
+      binaryDataFromGeoArrow,
+      chunkIndex
+    };
+  }
+  return {
+    binaryDataFromGeoArrow,
+    chunkIndex
+  };
+}
 //# sourceMappingURL=triangulation-worker.js.map

package/dist/workers/triangulation-worker.js.map

@@ -1 +1 @@
-{"version":3,"file":"triangulation-worker.js","names":["createWorker","getTriangleIndices","data","options","arguments","length","undefined","input","operation","triangulateBatch","Error","console","error","triangleIndices","polygonIndices","primitivePolygonIndices","flatCoordinateArray","nDim"],"sources":["../../src/workers/triangulation-worker.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {createWorker} from '@loaders.gl/worker-utils';\nimport {getTriangleIndices} from '../geoarrow/convert-geoarrow-to-binary-geometry';\nimport type {\n  TriangulationWorkerInput,\n  TriangulateInput,\n  TriangulateResult\n} from '../triangulate-on-worker';\n\ncreateWorker(async (data, options = {}) => {\n  const input = data as TriangulationWorkerInput;\n  const operation = input?.operation;\n  switch (operation) {\n    case 'test':\n      return input;\n    case 'triangulate':\n      return triangulateBatch(data);\n    default:\n      throw new Error(\n        `TriangulationWorker: Unsupported operation ${operation}. Expected 'triangulate'`\n      );\n  }\n});\n\nfunction triangulateBatch(data: TriangulateInput): TriangulateResult {\n  // Parse any WKT/WKB geometries\n  // Build binary geometries\n  // Call earcut and triangulate\n  console.error('TriangulationWorker: tessellating batch', data);\n  const triangleIndices = getTriangleIndices(\n    data.polygonIndices,\n    data.primitivePolygonIndices,\n    data.flatCoordinateArray,\n    data.nDim\n  );\n  return {...data, ...(triangleIndices ? {triangleIndices} : {})};\n}\n"],"mappings":"AAGA,SAAQA,YAAY,QAAO,0BAA0B;AAAC,SAC9CC,kBAAkB;AAO1BD,YAAY,CAAC,gBAAOE,IAAI,EAAmB;EAAA,IAAjBC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EACpC,MAAMG,KAAK,GAAGL,IAAgC;EAC9C,MAAMM,SAAS,GAAGD,KAAK,aAALA,KAAK,uBAALA,KAAK,CAAEC,SAAS;EAClC,QAAQA,SAAS;IACf,KAAK,MAAM;MACT,OAAOD,KAAK;IACd,KAAK,aAAa;MAChB,OAAOE,gBAAgB,CAACP,IAAI,CAAC;IAC/B;MACE,MAAM,IAAIQ,KAAK,CACZ,8CAA6CF,SAAU,0BAC1D,CAAC;EACL;AACF,CAAC,CAAC;AAEF,SAASC,gBAAgBA,CAACP,IAAsB,EAAqB;EAInES,OAAO,CAACC,KAAK,CAAC,yCAAyC,EAAEV,IAAI,CAAC;EAC9D,MAAMW,eAAe,GAAGZ,kBAAkB,CACxCC,IAAI,CAACY,cAAc,EACnBZ,IAAI,CAACa,uBAAuB,EAC5Bb,IAAI,CAACc,mBAAmB,EACxBd,IAAI,CAACe,IACP,CAAC;EACD,OAAO;IAAC,GAAGf,IAAI;IAAE,IAAIW,eAAe,GAAG;MAACA;IAAe,CAAC,GAAG,CAAC,CAAC;EAAC,CAAC;AACjE"}
+{"version":3,"file":"triangulation-worker.js","names":["arrow","createWorker","getTriangleIndices","getBinaryGeometriesFromArrow","data","options","arguments","length","undefined","input","operation","triangulateBatch","parseGeoArrowBatch","Error","console","error","triangleIndices","polygonIndices","primitivePolygonIndices","flatCoordinateArray","nDim","binaryDataFromGeoArrow","chunkData","chunkIndex","chunkOffset","geometryEncoding","calculateMeanCenters","triangle","arrowData","Data","type","offset","nullCount","buffers","children","dictionary","geometryColumn","makeVector"],"sources":["../../src/workers/triangulation-worker.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport * as arrow from 'apache-arrow';\nimport {createWorker} from '@loaders.gl/worker-utils';\nimport {\n  getTriangleIndices,\n  getBinaryGeometriesFromArrow,\n  BinaryDataFromGeoArrow\n} from '../geoarrow/convert-geoarrow-to-binary-geometry';\nimport type {\n  TriangulationWorkerInput,\n  TriangulateInput,\n  TriangulateResult,\n  ParseGeoArrowInput,\n  ParseGeoArrowResult\n} from '../triangulate-on-worker';\n\ncreateWorker(async (data, options = {}) => {\n  const input = data as TriangulationWorkerInput;\n  const operation = input?.operation;\n  switch (operation) {\n    case 'test':\n      return input;\n    case 'triangulate':\n      return triangulateBatch(data);\n    case 'parse-geoarrow':\n      return parseGeoArrowBatch(data);\n    default:\n      throw new Error(\n        `TriangulationWorker: Unsupported operation ${operation}. Expected 'triangulate'`\n      );\n  }\n});\n\nfunction triangulateBatch(data: TriangulateInput): TriangulateResult {\n  // Parse any WKT/WKB geometries\n  // Build binary geometries\n  // Call earcut and triangulate\n  console.error('TriangulationWorker: tessellating batch', data);\n  const triangleIndices = getTriangleIndices(\n    data.polygonIndices,\n    data.primitivePolygonIndices,\n    data.flatCoordinateArray,\n    data.nDim\n  );\n  return {...data, ...(triangleIndices ? {triangleIndices} : {})};\n}\n\n/**\n * Reading the arrow file into memory is very fast. Parsing the geoarrow column is slow, and blocking the main thread.\n * To address this issue, we can move the parsing job from main thread to parallel web workers.\n * Each web worker will parse one chunk/batch of geoarrow column, and return binary geometries to main thread.\n * The app on the main thread will render the binary geometries and the parsing will not block the main thread.\n *\n * @param data\n * @returns\n */\nfunction parseGeoArrowBatch(data: ParseGeoArrowInput): ParseGeoArrowResult {\n  let binaryDataFromGeoArrow: BinaryDataFromGeoArrow | null = null;\n  const {chunkData, chunkIndex, chunkOffset, geometryEncoding, calculateMeanCenters, triangle} =\n    data;\n  // rebuild chunkData that is only for geoarrow column\n  const arrowData = new arrow.Data(\n    chunkData.type,\n    chunkData.offset,\n    chunkData.length,\n    chunkData.nullCount,\n    chunkData.buffers,\n    chunkData.children,\n    chunkData.dictionary\n  );\n  // rebuild geometry column with chunkData\n  const geometryColumn = arrow.makeVector(arrowData);\n  if (geometryColumn) {\n    // NOTE: for a rebuild arrow.Vector, there is only one chunk, so chunkIndex is always 0\n    const options = {calculateMeanCenters, triangle, chunkIndex: 0, chunkOffset};\n    binaryDataFromGeoArrow = getBinaryGeometriesFromArrow(\n      geometryColumn,\n      geometryEncoding,\n      options\n    );\n    // NOTE: here binaryGeometry will be copied to main thread\n    return {\n      binaryDataFromGeoArrow,\n      chunkIndex\n    };\n  }\n  return {\n    binaryDataFromGeoArrow,\n    chunkIndex\n  };\n}\n"],"mappings":"AAGA,OAAO,KAAKA,KAAK,MAAM,cAAc;AACrC,SAAQC,YAAY,QAAO,0BAA0B;AAAC,SAEpDC,kBAAkB,EAClBC,4BAA4B;AAW9BF,YAAY,CAAC,gBAAOG,IAAI,EAAmB;EAAA,IAAjBC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EACpC,MAAMG,KAAK,GAAGL,IAAgC;EAC9C,MAAMM,SAAS,GAAGD,KAAK,aAALA,KAAK,uBAALA,KAAK,CAAEC,SAAS;EAClC,QAAQA,SAAS;IACf,KAAK,MAAM;MACT,OAAOD,KAAK;IACd,KAAK,aAAa;MAChB,OAAOE,gBAAgB,CAACP,IAAI,CAAC;IAC/B,KAAK,gBAAgB;MACnB,OAAOQ,kBAAkB,CAACR,IAAI,CAAC;IACjC;MACE,MAAM,IAAIS,KAAK,CACZ,8CAA6CH,SAAU,0BAC1D,CAAC;EACL;AACF,CAAC,CAAC;AAEF,SAASC,gBAAgBA,CAACP,IAAsB,EAAqB;EAInEU,OAAO,CAACC,KAAK,CAAC,yCAAyC,EAAEX,IAAI,CAAC;EAC9D,MAAMY,eAAe,GAAGd,kBAAkB,CACxCE,IAAI,CAACa,cAAc,EACnBb,IAAI,CAACc,uBAAuB,EAC5Bd,IAAI,CAACe,mBAAmB,EACxBf,IAAI,CAACgB,IACP,CAAC;EACD,OAAO;IAAC,GAAGhB,IAAI;IAAE,IAAIY,eAAe,GAAG;MAACA;IAAe,CAAC,GAAG,CAAC,CAAC;EAAC,CAAC;AACjE;AAWA,SAASJ,kBAAkBA,CAACR,IAAwB,EAAuB;EACzE,IAAIiB,sBAAqD,GAAG,IAAI;EAChE,MAAM;IAACC,SAAS;IAAEC,UAAU;IAAEC,WAAW;IAAEC,gBAAgB;IAAEC,oBAAoB;IAAEC;EAAQ,CAAC,GAC1FvB,IAAI;EAEN,MAAMwB,SAAS,GAAG,IAAI5B,KAAK,CAAC6B,IAAI,CAC9BP,SAAS,CAACQ,IAAI,EACdR,SAAS,CAACS,MAAM,EAChBT,SAAS,CAACf,MAAM,EAChBe,SAAS,CAACU,SAAS,EACnBV,SAAS,CAACW,OAAO,EACjBX,SAAS,CAACY,QAAQ,EAClBZ,SAAS,CAACa,UACZ,CAAC;EAED,MAAMC,cAAc,GAAGpC,KAAK,CAACqC,UAAU,CAACT,SAAS,CAAC;EAClD,IAAIQ,cAAc,EAAE;IAElB,MAAM/B,OAAO,GAAG;MAACqB,oBAAoB;MAAEC,QAAQ;MAAEJ,UAAU,EAAE,CAAC;MAAEC;IAAW,CAAC;IAC5EH,sBAAsB,GAAGlB,4BAA4B,CACnDiC,cAAc,EACdX,gBAAgB,EAChBpB,OACF,CAAC;IAED,OAAO;MACLgB,sBAAsB;MACtBE;IACF,CAAC;EACH;EACA,OAAO;IACLF,sBAAsB;IACtBE;EACF,CAAC;AACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/arrow",
-  "version": "4.1.0-alpha.1",
+  "version": "4.1.0-alpha.2",
   "description": "Simple columnar table loader for the Apache Arrow format",
   "license": "MIT",
   "type": "module",
@@ -52,12 +52,12 @@
     "build-worker2": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js --platform=browser --external:{stream}"
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.1.0-alpha.1",
-    "@loaders.gl/loader-utils": "4.1.0-alpha.1",
-    "@loaders.gl/schema": "4.1.0-alpha.1",
-    "@loaders.gl/wkt": "4.1.0-alpha.1",
+    "@loaders.gl/gis": "4.1.0-alpha.2",
+    "@loaders.gl/loader-utils": "4.1.0-alpha.2",
+    "@loaders.gl/schema": "4.1.0-alpha.2",
+    "@loaders.gl/wkt": "4.1.0-alpha.2",
     "@math.gl/polygon": "4.0.0",
     "apache-arrow": "^13.0.0"
   },
-  "gitHead": "6a4d3da93d45115ad99861474a43c3f4a0b280a7"
+  "gitHead": "a248382edd20e846c1ccb23c15d089fb9b368dbc"
 }

package/src/geoarrow/convert-geoarrow-to-binary-geometry.ts

@@ -45,7 +45,7 @@ type BinaryGeometryContent = {
   geomOffset: Int32Array;
   /** Array of geometry indicies: the start index of each geometry */
   geometryIndicies: Uint16Array;
-  /** (Optional) indices of triangels returned from polygon tessellation (Polygon only) */
+  /** (Optional) indices of triangels returned from polygon triangulation (Polygon only) */
   triangles?: Uint32Array;
   /** (Optional) array of mean center of each geometry */
   meanCenters?: Float64Array;
@@ -54,17 +54,21 @@ type BinaryGeometryContent = {
 /**
  * binary geometry template, see deck.gl BinaryGeometry
  */
-export const BINARY_GEOMETRY_TEMPLATE = {
-  globalFeatureIds: {value: new Uint32Array(0), size: 1},
-  positions: {value: new Float32Array(0), size: 2},
-  properties: [],
-  numericProps: {},
-  featureIds: {value: new Uint32Array(0), size: 1}
-};
+export function getBinaryGeometryTemplate() {
+  return {
+    globalFeatureIds: {value: new Uint32Array(0), size: 1},
+    positions: {value: new Float32Array(0), size: 2},
+    properties: [],
+    numericProps: {},
+    featureIds: {value: new Uint32Array(0), size: 1}
+  };
+}
 
 export type BinaryGeometriesFromArrowOptions = {
   /** option to specify which chunk to get binary geometries from, for progressive rendering */
   chunkIndex?: number;
+  /** The offset (beginning index of rows) of input chunk. Used for reconstructing globalFeatureIds in web workers */
+  chunkOffset?: number;
   /** option to get mean centers from geometries, for polygon filtering */
   calculateMeanCenters?: boolean;
   /** option to compute the triangle indices by tesselating polygons */
@@ -90,9 +94,12 @@ export function getBinaryGeometriesFromArrow(
     line: geoEncoding === 'geoarrow.multilinestring' || geoEncoding === 'geoarrow.linestring'
   };
 
-  const chunks = options?.chunkIndex ? [geoColumn.data[options?.chunkIndex]] : geoColumn.data;
+  const chunks =
+    options?.chunkIndex !== undefined && options?.chunkIndex >= 0
+      ? [geoColumn.data[options?.chunkIndex]]
+      : geoColumn.data;
   let bounds: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];
-  let globalFeatureIdOffset = 0;
+  let globalFeatureIdOffset = options?.chunkOffset || 0;
   const binaryGeometries: BinaryFeatures[] = [];
 
   chunks.forEach((chunk) => {
@@ -111,6 +118,7 @@ export function getBinaryGeometriesFromArrow(
         size: nDim
       },
       featureIds: {value: featureIds, size: 1},
+      // eslint-disable-next-line no-loop-func
       properties: [...Array(chunk.length).keys()].map((i) => ({
         index: i + globalFeatureIdOffset
       }))
@@ -123,18 +131,18 @@ export function getBinaryGeometriesFromArrow(
       shape: 'binary-feature-collection',
       points: {
         type: 'Point',
-        ...BINARY_GEOMETRY_TEMPLATE,
+        ...getBinaryGeometryTemplate(),
         ...(featureTypes.point ? binaryContent : {})
       },
       lines: {
         type: 'LineString',
-        ...BINARY_GEOMETRY_TEMPLATE,
+        ...getBinaryGeometryTemplate(),
         ...(featureTypes.line ? binaryContent : {}),
         pathIndices: {value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1}
       },
       polygons: {
         type: 'Polygon',
-        ...BINARY_GEOMETRY_TEMPLATE,
+        ...getBinaryGeometryTemplate(),
         ...(featureTypes.polygon ? binaryContent : {}),
         polygonIndices: {
           // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
@@ -281,7 +289,7 @@ function getBinaryGeometriesFromChunk(
  * @param primitivePolygonIndices Indices within positions of the start of each primitive Polygon/ring
  * @param flatCoordinateArray Array of x, y or x, y, z positions
  * @param nDim - number of dimensions per position
- * @returns
+ * @returns triangle indices or null if invalid polygon and earcut fails
  */
 export function getTriangleIndices(
   polygonIndices: Uint16Array,
@@ -306,13 +314,14 @@ export function getTriangleIndices(
         }
         primitiveIndex++;
       }
+      // TODO check if each ring is closed
       const triangleIndices = earcut(
         slicedFlatCoords,
         holeIndices.length > 0 ? holeIndices : undefined,
         nDim
       );
       if (triangleIndices.length === 0) {
-        throw Error('can not tesselate invalid polygon');
+        throw Error('earcut failed e.g. invalid polygon');
       }
       for (let j = 0; j < triangleIndices.length; j++) {
         triangles.push(triangleIndices[j] + startIdx);
@@ -325,9 +334,7 @@ export function getTriangleIndices(
     }
     return trianglesUint32;
   } catch (error) {
-    // TODO - add logging
-    // there is an expection when tesselating invalid polygon, e.g. polygon with self-intersection
-    // return null to skip tesselating
+    // if earcut fails, return null
     return null;
   }
 }
@@ -379,8 +386,8 @@ function getBinaryPolygonsFromChunk(
 
   return {
     featureIds,
-    flatCoordinateArray,
     nDim,
+    flatCoordinateArray,
     geomOffset,
     geometryIndicies,
     ...(options?.triangulate && triangles ? {triangles} : {})

package/src/index.ts

@@ -52,7 +52,7 @@ export type {
   BinaryGeometriesFromArrowOptions
 } from './geoarrow/convert-geoarrow-to-binary-geometry';
 export {
-  BINARY_GEOMETRY_TEMPLATE,
+  getBinaryGeometryTemplate,
   getBinaryGeometriesFromArrow,
   getTriangleIndices,
   getMeanCentersFromBinaryGeometries
@@ -65,5 +65,11 @@ export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson-geo
 export {convertArrowToGeoJSONTable} from './tables/convert-arrow-to-geojson-table';
 
 // EXPERIMENTAL WORKER
+export {hardClone} from './workers/hard-clone';
 
-export {TriangulationWorker, triangulateOnWorker} from './triangulate-on-worker';
+export type {ParseGeoArrowInput, ParseGeoArrowResult} from './triangulate-on-worker';
+export {
+  TriangulationWorker,
+  triangulateOnWorker,
+  parseGeoArrowOnWorker
+} from './triangulate-on-worker';

package/src/triangulate-on-worker.ts

@@ -1,19 +1,52 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
+import * as arrow from 'apache-arrow';
 import type {WorkerOptions} from '@loaders.gl/worker-utils';
 import {processOnWorker} from '@loaders.gl/worker-utils';
+import {BinaryDataFromGeoArrow, GeoArrowEncoding} from '@loaders.gl/arrow';
 
 // __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};
+export type TriangulationWorkerInput =
+  | ({operation: 'triangulate'} & TriangulateInput)
+  | ParseGeoArrowInput
+  | {operation: 'test'; data: any};
+
+export type TriangulationWorkerOutput =
+  | ({operation: 'triangulate'} & TriangulateResult)
+  | ({operation: 'parse-geoarrow'} & ParseGeoArrowResult)
+  | {operation: 'test'; data: any};
+
+type GeoArrowChunkData = {
+  type: arrow.DataType;
+  offset: number;
+  length: number;
+  nullCount: number;
+  buffers: any;
+  children: arrow.Data[];
+  dictionary?: arrow.Vector;
+};
+
+export type ParseGeoArrowInput = {
+  operation: 'parse-geoarrow';
+  chunkData: GeoArrowChunkData;
+  chunkIndex: number;
+  chunkOffset: number;
+  geometryEncoding: GeoArrowEncoding;
+  calculateMeanCenters: boolean;
+  triangle: boolean;
+};
+
+export type ParseGeoArrowResult = {
+  chunkIndex: number;
+  binaryDataFromGeoArrow: BinaryDataFromGeoArrow | null;
+};
 
 /** Input data for operation: 'triangulate' */
 export type TriangulateInput = {
-  operation: 'triangulate';
   polygonIndices: Uint16Array;
   primitivePolygonIndices: Int32Array;
   flatCoordinateArray: Float64Array;
@@ -37,11 +70,21 @@ export const TriangulationWorker = {
 };
 
 /**
- * Provide type safety
+ * Triangulate a set of polygons on worker, type safe API
  */
 export function triangulateOnWorker(
-  data: TriangulationWorkerInput,
+  data: TriangulateInput,
+  options: WorkerOptions = {}
+): Promise<TriangulateResult> {
+  return processOnWorker(TriangulationWorker, {...data, operation: 'triangulate'}, options);
+}
+
+/**
+ * Parse GeoArrow geometry colum on worker, type safe API
+ */
+export function parseGeoArrowOnWorker(
+  data: ParseGeoArrowInput,
   options: WorkerOptions = {}
-): Promise<TriangulationWorkerOutput> {
-  return processOnWorker(TriangulationWorker, data, options);
+): Promise<ParseGeoArrowResult> {
+  return processOnWorker(TriangulationWorker, {...data, operation: 'parse-geoarrow'}, options);
 }

package/src/workers/hard-clone.ts

@@ -0,0 +1,162 @@
+import * as arrow from 'apache-arrow';
+import type {Buffers} from 'apache-arrow/data';
+
+type TypedArray =
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Float32Array
+  | Float64Array;
+
+/**
+ * Clone an Arrow JS Data or Vector, detaching from an existing ArrayBuffer if
+ * it is shared with other.
+ *
+ * The purpose of this function is to enable transferring a `Data` instance,
+ * e.g. to a web worker, without neutering any other data.
+ *
+ * Any internal buffers that are a slice of a larger `ArrayBuffer` (i.e. where
+ * the typed array's `byteOffset` is not `0` and where its `byteLength` does not
+ * match its `array.buffer.byteLength`) are copied into new `ArrayBuffers`.
+ *
+ * If `force` is `true`, always clone internal buffers, even if not shared. If
+ * the default, `false`, any internal buffers that are **not** a slice of a
+ * larger `ArrayBuffer` will not be copied.
+ */
+export function hardClone<T extends arrow.DataType>(
+  input: arrow.Data<T>,
+  force?: boolean
+): arrow.Data<T>;
+export function hardClone<T extends arrow.DataType>(
+  input: arrow.Vector<T>,
+  force?: boolean
+): arrow.Vector<T>;
+
+export function hardClone<T extends arrow.DataType>(
+  data: arrow.Data<T> | arrow.Vector<T>,
+  force: boolean = false
+): arrow.Data<T> | arrow.Vector<T> {
+  // Check if `data` is an arrow.Vector
+  if ('data' in data) {
+    return new arrow.Vector(data.data.map((data) => hardClone(data, force)));
+  }
+
+  // Clone each of the children, recursively
+  const clonedChildren: arrow.Data[] = [];
+  for (const childData of data.children) {
+    clonedChildren.push(hardClone(childData, force));
+  }
+
+  // Clone the dictionary if there is one
+  let clonedDictionary: arrow.Vector | undefined;
+  if (data.dictionary !== undefined) {
+    clonedDictionary = hardClone(data.dictionary, force);
+  }
+
+  // Buffers can have up to four entries. Each of these can be `undefined` for
+  // one or more array types.
+  //
+  // - OFFSET: value offsets for variable size list types
+  // - DATA: the underlying data
+  // - VALIDITY: the null buffer. This may be empty or undefined if all elements
+  //   are non-null/valid.
+  // - TYPE: type ids for a union type.
+  const clonedBuffers: Buffers<T> = {
+    [arrow.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow.BufferType.OFFSET], force),
+    [arrow.BufferType.DATA]: cloneBuffer(data.buffers[arrow.BufferType.DATA], force),
+    [arrow.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow.BufferType.VALIDITY], force),
+    [arrow.BufferType.TYPE]: cloneBuffer(data.buffers[arrow.BufferType.TYPE], force)
+  };
+
+  // Note: the data.offset is passed on so that a sliced Data instance will not
+  // be "un-sliced". However keep in mind that this means we're cloning the
+  // _original backing buffer_, not only the portion of the Data that was
+  // sliced.
+  return new arrow.Data(
+    data.type,
+    data.offset,
+    data.length,
+    // @ts-expect-error _nullCount is protected. We're using it here to mimic
+    // `Data.clone`
+    data._nullCount,
+    clonedBuffers,
+    clonedChildren,
+    clonedDictionary
+  );
+}
+
+/**
+ * Test whether an arrow.Data instance is a slice of a larger `ArrayBuffer`.
+ */
+export function isShared<T extends arrow.DataType>(data: arrow.Data<T> | arrow.Vector<T>): boolean {
+  // Loop over arrow.Vector
+  if ('data' in data) {
+    return data.data.some((data) => isShared(data));
+  }
+
+  // Check child data
+  for (const childData of data.children) {
+    if (isShared(childData)) {
+      return true;
+    }
+  }
+
+  // Check dictionary
+  if (data.dictionary !== undefined) {
+    if (isShared(data.dictionary)) {
+      return true;
+    }
+  }
+
+  const bufferTypes = [
+    arrow.BufferType.OFFSET,
+    arrow.BufferType.DATA,
+    arrow.BufferType.VALIDITY,
+    arrow.BufferType.TYPE
+  ];
+  for (const bufferType of bufferTypes) {
+    if (data.buffers[bufferType] !== undefined && isTypedArraySliced(data.buffers[bufferType])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Returns true if the current typed array is a partial slice on a larger
+ * ArrayBuffer
+ */
+function isTypedArraySliced(arr: TypedArray): boolean {
+  return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);
+}
+
+/**
+ * If a slice of a larger ArrayBuffer, clone to a fresh `ArrayBuffer`.
+ *
+ * If `force` is `true`, always clone the array, even if not shared.
+ */
+function cloneBuffer<A extends TypedArray | undefined>(arr: A, force: boolean): A {
+  // Not all buffer types are defined for every type of Arrow array. E.g.
+  // `arrow.BufferType.TYPE` is only defined for the Union type.
+  if (arr === undefined) {
+    return arr;
+  }
+
+  // The current array is not a part of a larger ArrayBuffer, don't clone it
+  if (!force && !isTypedArraySliced(arr)) {
+    return arr;
+  }
+
+  // Note: TypedArray.slice() **copies** into a new ArrayBuffer
+
+  // @ts-expect-error 'Uint8Array' is assignable to the constraint of type 'A',
+  // but 'A' could be instantiated with a different subtype of constraint
+  // 'TypedArray'
+  // We know from arr.slice that it will always return the same
+  return arr.slice();
+}