@kepler.gl/deckgl-arrow-layers 3.1.0-alpha.1 → 3.1.0-alpha.2

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/picking.d.ts

@@ -0,0 +1,16 @@
+import * as arrow from 'apache-arrow';
+import { GetPickingInfoParams } from '@deck.gl/core/typed';
+import { GeoArrowPickingInfo } from '../types';
+export interface GeoArrowExtraPickingProps {
+    recordBatchIdx: number;
+    tableOffsets: Uint32Array;
+    data: {
+        invertedGeomOffsets?: Uint8Array | Uint16Array | Uint32Array;
+    };
+}
+export declare function getPickingInfo({ info, sourceLayer }: GetPickingInfoParams & {
+    sourceLayer: {
+        props: GeoArrowExtraPickingProps;
+    };
+}, table: arrow.Table): GeoArrowPickingInfo;
+export declare function computeChunkOffsets<T extends arrow.DataType>(chunks: ReadonlyArray<arrow.Data<T>>): Uint32Array;

package/dist/utils/picking.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeChunkOffsets = computeChunkOffsets;
+exports.getPickingInfo = getPickingInfo;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+function getPickingInfo(_ref, table) {
+  var info = _ref.info,
+    sourceLayer = _ref.sourceLayer;
+  // Geometry index as rendered
+  var index = info.index;
+
+  // if a Multi- geometry dataset, map from the rendered index back to the
+  // feature index
+  if (sourceLayer.props.data.invertedGeomOffsets) {
+    index = sourceLayer.props.data.invertedGeomOffsets[index];
+  }
+  var recordBatchIdx = sourceLayer.props.recordBatchIdx;
+  var tableOffsets = sourceLayer.props.tableOffsets;
+  var batch = table.batches[recordBatchIdx];
+  var row = batch.get(index);
+  if (row === null) {
+    return info;
+  }
+  var currentBatchOffset = tableOffsets[recordBatchIdx];
+
+  // Update index to be _global_ index, not within the specific record batch
+  index += currentBatchOffset;
+  return _objectSpread(_objectSpread({}, info), {}, {
+    index: index,
+    object: row
+  });
+}
+
+// This is vendored from Arrow JS because it's a private API
+function computeChunkOffsets(chunks) {
+  return chunks.reduce(function (offsets, chunk, index) {
+    offsets[index + 1] = offsets[index] + chunk.length;
+    return offsets;
+  }, new Uint32Array(chunks.length + 1));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/utils.d.ts

@@ -0,0 +1,54 @@
+import * as arrow from 'apache-arrow';
+import * as ga from '@geoarrow/geoarrow-js';
+export declare type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array;
+export declare function findGeometryColumnIndex(schema: arrow.Schema, extensionName: string, geometryColumnName?: string | null): number | null;
+/**
+ * Returns `true` if the input is a reference to a column in the table
+ */
+export declare function isColumnReference(input: any): input is string;
+declare type AssignAccessorProps = {
+    /** The object on which to assign the resolved accesor */
+    props: Record<string, any>;
+    /** The name of the prop to set */
+    propName: string;
+    /** The user-supplied input to the layer. Must either be a scalar value or a reference to a column in the table. */
+    propInput: any;
+    /** Numeric index in the table */
+    chunkIdx: number;
+    /** a map from the geometry index to the coord offsets for that geometry. */
+    geomCoordOffsets?: Int32Array | null;
+    /** Absolute offset of the batch in the table/vector. Added to the sampling index. */
+    batchOffset?: number;
+};
+/**
+ * Resolve accessor and assign to props object
+ *
+ * This is useful as a helper function because a scalar prop is set at the top
+ * level while a vectorized prop is set inside data.attributes
+ *
+ */
+export declare function assignAccessor(args: AssignAccessorProps): void;
+/**
+ * Expand an array from "one element per geometry" to "one element per coordinate"
+ *
+ * @param input: the input array to expand
+ * @param size : the number of nested elements in the input array per geometry. So for example, for RGB data this would be 3, for RGBA this would be 4. For radius, this would be 1.
+ * @param geomOffsets : an offsets array mapping from the geometry to the coordinate indexes. So in the case of a LineStringArray, this is retrieved directly from the GeoArrow storage. In the case of a PolygonArray, this comes from the resolved indexes that need to be given to the SolidPolygonLayer anyways.
+ *
+ * @return  {TypedArray} values expanded to be per-coordinate
+ */
+export declare function expandArrayToCoords<T extends TypedArray>(input: T, size: number, geomOffsets: Int32Array): T;
+/**
+ * Get a geometry vector with the specified extension type name from the table.
+ */
+export declare function getGeometryVector(table: arrow.Table, geoarrowTypeName: string): arrow.Vector | null;
+export declare function getListNestingLevels(data: arrow.Data): number;
+export declare function getMultiLineStringResolvedOffsets(data: ga.data.MultiLineStringData): Int32Array;
+export declare function getPolygonResolvedOffsets(data: ga.data.PolygonData): Int32Array;
+export declare function getMultiPolygonResolvedOffsets(data: ga.data.MultiPolygonData): Int32Array;
+/**
+ * Invert offsets so that lookup can go in the opposite direction
+ */
+export declare function invertOffsets(offsets: Int32Array): Uint8Array | Uint16Array | Uint32Array;
+export declare function extractAccessorsFromProps(props: Record<string, any>, excludeKeys: string[]): [Record<string, any>, Record<string, any>];
+export {};

package/dist/utils/utils.js

@@ -0,0 +1,307 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignAccessor = assignAccessor;
+exports.expandArrayToCoords = expandArrayToCoords;
+exports.extractAccessorsFromProps = extractAccessorsFromProps;
+exports.findGeometryColumnIndex = findGeometryColumnIndex;
+exports.getGeometryVector = getGeometryVector;
+exports.getListNestingLevels = getListNestingLevels;
+exports.getMultiLineStringResolvedOffsets = getMultiLineStringResolvedOffsets;
+exports.getMultiPolygonResolvedOffsets = getMultiPolygonResolvedOffsets;
+exports.getPolygonResolvedOffsets = getPolygonResolvedOffsets;
+exports.invertOffsets = invertOffsets;
+exports.isColumnReference = isColumnReference;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typed = require("@deck.gl/core/typed");
+var arrow = _interopRequireWildcard(require("apache-arrow"));
+var ga = _interopRequireWildcard(require("@geoarrow/geoarrow-js"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+function findGeometryColumnIndex(schema, extensionName, geometryColumnName) {
+  var index = schema.fields.findIndex(function (field) {
+    return field.name === geometryColumnName || field.metadata.get('ARROW:extension:name') === extensionName;
+  });
+  return index !== -1 ? index : null;
+}
+
+/**
+ * Returns `true` if the input is a reference to a column in the table
+ */
+function isColumnReference(input) {
+  return typeof input === 'string';
+}
+function isDataInterleavedCoords(data) {
+  // TODO: also check 2 or 3d? Float64?
+  return data.type instanceof arrow.FixedSizeList;
+}
+function isDataSeparatedCoords(data) {
+  // TODO: also check child names? Float64?
+  return data.type instanceof arrow.Struct;
+}
+
+/**
+ * Convert geoarrow Struct coordinates to FixedSizeList coords
+ *
+ * The GeoArrow spec allows for either separated or interleaved coords, but at
+ * this time deck.gl only supports interleaved.
+ */
+// TODO: this hasn't been tested yet
+// @ts-expect-error
+function convertStructToFixedSizeList(coords) {
+  if (isDataInterleavedCoords(coords)) {
+    return coords;
+  } else if (isDataSeparatedCoords(coords)) {
+    // TODO: support 3d
+    var interleavedCoords = new Float64Array(coords.length * 2);
+    var _coords$children = (0, _slicedToArray2["default"])(coords.children, 2),
+      xChild = _coords$children[0],
+      yChild = _coords$children[1];
+    for (var i = 0; i < coords.length; i++) {
+      interleavedCoords[i * 2] = xChild.values[i];
+      interleavedCoords[i * 2 + 1] = yChild.values[i];
+    }
+    var childDataType = new arrow.Float64();
+    var dataType = new arrow.FixedSizeList(2, new arrow.Field('coords', childDataType));
+    var interleavedCoordsData = arrow.makeData({
+      type: childDataType,
+      length: interleavedCoords.length
+    });
+    var data = arrow.makeData({
+      type: dataType,
+      length: coords.length,
+      nullCount: coords.nullCount,
+      nullBitmap: coords.nullBitmap,
+      child: interleavedCoordsData
+    });
+    return data;
+  }
+  (0, _typed.assert)(false);
+}
+/**
+ * A wrapper around a user-provided accessor function
+ *
+ * For layers like Scatterplot, Path, and Polygon, we automatically handle
+ * "exploding" the table when multi-geometry input are provided. This means that
+ * the upstream `index` value passed to the user will be the correct row index
+ * _only_ for non-exploded data.
+ *
+ * With this function, we simplify the user usage by automatically converting
+ * back from "exploded" index back to the original row index.
+ */
+function wrapAccessorFunction(objectInfo, userAccessorFunction, batchOffset) {
+  var index = objectInfo.index,
+    data = objectInfo.data;
+  var newIndex = index + batchOffset;
+  if (data.invertedGeomOffsets !== undefined) {
+    newIndex = data.invertedGeomOffsets[index];
+  }
+  var newObjectData = {
+    data: data.data,
+    length: data.length,
+    attributes: data.attributes
+  };
+  var newObjectInfo = {
+    index: newIndex,
+    data: newObjectData,
+    target: objectInfo.target
+  };
+  return userAccessorFunction(newObjectInfo);
+}
+
+/**
+ * Resolve accessor and assign to props object
+ *
+ * This is useful as a helper function because a scalar prop is set at the top
+ * level while a vectorized prop is set inside data.attributes
+ *
+ */
+function assignAccessor(args) {
+  var props = args.props,
+    propName = args.propName,
+    propInput = args.propInput,
+    chunkIdx = args.chunkIdx,
+    geomCoordOffsets = args.geomCoordOffsets,
+    _args$batchOffset = args.batchOffset,
+    batchOffset = _args$batchOffset === void 0 ? 0 : _args$batchOffset;
+  if (propInput === undefined) {
+    return;
+  }
+  if (propInput instanceof arrow.Vector) {
+    var columnData = propInput.data[chunkIdx];
+    if (arrow.DataType.isFixedSizeList(columnData)) {
+      (0, _typed.assert)(columnData.children.length === 1);
+      var values = columnData.children[0].values;
+      if (geomCoordOffsets) {
+        values = expandArrayToCoords(values, columnData.type.listSize, geomCoordOffsets);
+      }
+      props.data.attributes[propName] = {
+        value: values,
+        size: columnData.type.listSize,
+        // Set to `true` to signify that colors are already 0-255, and deck/luma
+        // does not need to rescale
+        // https://github.com/visgl/deck.gl/blob/401d624c0529faaa62125714c376b3ba3b8f379f/docs/api-reference/core/attribute-manager.md?plain=1#L66
+        normalized: true
+      };
+    } else if (arrow.DataType.isFloat(columnData)) {
+      var _values = columnData.values;
+      if (geomCoordOffsets) {
+        _values = expandArrayToCoords(_values, 1, geomCoordOffsets);
+      }
+      props.data.attributes[propName] = {
+        value: _values,
+        size: 1
+      };
+    }
+  } else if (typeof propInput === 'function') {
+    props[propName] = function (object, objectInfo) {
+      // Special case that doesn't have the same parameters
+      if (propName === 'getPolygonOffset') {
+        return propInput(object, objectInfo);
+      }
+      return wrapAccessorFunction(objectInfo, propInput, batchOffset);
+    };
+  } else {
+    props[propName] = propInput;
+  }
+}
+
+/**
+ * Expand an array from "one element per geometry" to "one element per coordinate"
+ *
+ * @param input: the input array to expand
+ * @param size : the number of nested elements in the input array per geometry. So for example, for RGB data this would be 3, for RGBA this would be 4. For radius, this would be 1.
+ * @param geomOffsets : an offsets array mapping from the geometry to the coordinate indexes. So in the case of a LineStringArray, this is retrieved directly from the GeoArrow storage. In the case of a PolygonArray, this comes from the resolved indexes that need to be given to the SolidPolygonLayer anyways.
+ *
+ * @return  {TypedArray} values expanded to be per-coordinate
+ */
+function expandArrayToCoords(input, size, geomOffsets) {
+  var numCoords = geomOffsets[geomOffsets.length - 1];
+  // @ts-expect-error
+  var outputArray = new input.constructor(numCoords * size);
+
+  // geomIdx is an index into the geomOffsets array
+  // geomIdx is also the geometry/table index
+  for (var geomIdx = 0; geomIdx < geomOffsets.length - 1; geomIdx++) {
+    // geomOffsets maps from the geometry index to the coord index
+    // So here we get the range of coords that this geometry covers
+    var lastCoordIdx = geomOffsets[geomIdx];
+    var nextCoordIdx = geomOffsets[geomIdx + 1];
+
+    // Iterate over this range of coord indices
+    for (var coordIdx = lastCoordIdx; coordIdx < nextCoordIdx; coordIdx++) {
+      // Iterate over size
+      for (var i = 0; i < size; i++) {
+        // Copy from the geometry index in `input` to the coord index in
+        // `output`
+        outputArray[coordIdx * size + i] = input[geomIdx * size + i];
+      }
+    }
+  }
+  return outputArray;
+}
+
+/**
+ * Get a geometry vector with the specified extension type name from the table.
+ */
+function getGeometryVector(table, geoarrowTypeName) {
+  var geometryColumnIdx = findGeometryColumnIndex(table.schema, geoarrowTypeName);
+  if (geometryColumnIdx === null) {
+    return null;
+    // throw new Error(`No column found with extension type ${geoarrowTypeName}`);
+  }
+  return table.getChildAt(geometryColumnIdx);
+}
+function getListNestingLevels(data) {
+  var nestingLevels = 0;
+  if (arrow.DataType.isList(data.type)) {
+    nestingLevels += 1;
+    data = data.children[0];
+  }
+  return nestingLevels;
+}
+function getMultiLineStringResolvedOffsets(data) {
+  var geomOffsets = data.valueOffsets;
+  var lineStringData = ga.child.getMultiLineStringChild(data);
+  var ringOffsets = lineStringData.valueOffsets;
+  var resolvedRingOffsets = new Int32Array(geomOffsets.length);
+  for (var i = 0; i < resolvedRingOffsets.length; ++i) {
+    // Perform the lookup into the ringIndices array using the geomOffsets
+    // array
+    resolvedRingOffsets[i] = ringOffsets[geomOffsets[i]];
+  }
+  return resolvedRingOffsets;
+}
+function getPolygonResolvedOffsets(data) {
+  var geomOffsets = data.valueOffsets;
+  var ringData = ga.child.getPolygonChild(data);
+  var ringOffsets = ringData.valueOffsets;
+  var resolvedRingOffsets = new Int32Array(geomOffsets.length);
+  for (var i = 0; i < resolvedRingOffsets.length; ++i) {
+    // Perform the lookup into the ringIndices array using the geomOffsets
+    // array
+    resolvedRingOffsets[i] = ringOffsets[geomOffsets[i]];
+  }
+  return resolvedRingOffsets;
+}
+function getMultiPolygonResolvedOffsets(data) {
+  var polygonData = ga.child.getMultiPolygonChild(data);
+  var ringData = ga.child.getPolygonChild(polygonData);
+  var geomOffsets = data.valueOffsets;
+  var polygonOffsets = polygonData.valueOffsets;
+  var ringOffsets = ringData.valueOffsets;
+  var resolvedRingOffsets = new Int32Array(geomOffsets.length);
+  for (var i = 0; i < resolvedRingOffsets.length; ++i) {
+    resolvedRingOffsets[i] = ringOffsets[polygonOffsets[geomOffsets[i]]];
+  }
+  return resolvedRingOffsets;
+}
+
+/**
+ * Invert offsets so that lookup can go in the opposite direction
+ */
+function invertOffsets(offsets) {
+  var largestOffset = offsets[offsets.length - 1];
+  var arrayConstructor = offsets.length < Math.pow(2, 8) ? Uint8Array : offsets.length < Math.pow(2, 16) ? Uint16Array : Uint32Array;
+  var invertedOffsets = new arrayConstructor(largestOffset);
+  for (var arrayIdx = 0; arrayIdx < offsets.length - 1; arrayIdx++) {
+    var thisOffset = offsets[arrayIdx];
+    var nextOffset = offsets[arrayIdx + 1];
+    for (var offset = thisOffset; offset < nextOffset; offset++) {
+      invertedOffsets[offset] = arrayIdx;
+    }
+  }
+  return invertedOffsets;
+}
+
+// TODO: better typing
+function extractAccessorsFromProps(props, excludeKeys) {
+  var accessors = {};
+  var otherProps = {};
+  for (var _i = 0, _Object$entries = Object.entries(props); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (excludeKeys.includes(key)) {
+      continue;
+    }
+    if (key.startsWith('get')) {
+      accessors[key] = value;
+    } else {
+      otherProps[key] = value;
+    }
+  }
+  return [accessors, otherProps];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_typed","require","arrow","_interopRequireWildcard","ga","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","findGeometryColumnIndex","schema","extensionName","geometryColumnName","index","fields","findIndex","field","name","metadata","isColumnReference","input","isDataInterleavedCoords","data","type","FixedSizeList","isDataSeparatedCoords","Struct","convertStructToFixedSizeList","coords","interleavedCoords","Float64Array","length","_coords$children","_slicedToArray2","children","xChild","yChild","values","childDataType","Float64","dataType","Field","interleavedCoordsData","makeData","nullCount","nullBitmap","child","assert","wrapAccessorFunction","objectInfo","userAccessorFunction","batchOffset","newIndex","invertedGeomOffsets","undefined","newObjectData","attributes","newObjectInfo","target","assignAccessor","args","props","propName","propInput","chunkIdx","geomCoordOffsets","_args$batchOffset","Vector","columnData","DataType","isFixedSizeList","expandArrayToCoords","listSize","value","size","normalized","isFloat","object","geomOffsets","numCoords","outputArray","constructor","geomIdx","lastCoordIdx","nextCoordIdx","coordIdx","getGeometryVector","table","geoarrowTypeName","geometryColumnIdx","getChildAt","getListNestingLevels","nestingLevels","isList","getMultiLineStringResolvedOffsets","valueOffsets","lineStringData","getMultiLineStringChild","ringOffsets","resolvedRingOffsets","Int32Array","getPolygonResolvedOffsets","ringData","getPolygonChild","getMultiPolygonResolvedOffsets","polygonData","getMultiPolygonChild","polygonOffsets","invertOffsets","offsets","largestOffset","arrayConstructor","Math","pow","Uint8Array","Uint16Array","Uint32Array","invertedOffsets","arrayIdx","thisOffset","nextOffset","offset","extractAccessorsFromProps","excludeKeys","accessors","otherProps","_i","_Object$entries","entries","_Object$entries$_i","key","includes","startsWith"],"sources":["../../src/utils/utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// deck.gl-community\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {assert} from '@deck.gl/core/typed';\nimport * as arrow from 'apache-arrow';\nimport * as ga from '@geoarrow/geoarrow-js';\nimport {AccessorContext, AccessorFunction, _InternalAccessorContext} from '../types';\n\nexport type TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | Float32Array\n  | Float64Array;\n\nexport function findGeometryColumnIndex(\n  schema: arrow.Schema,\n  extensionName: string,\n  geometryColumnName?: string | null\n): number | null {\n  const index = schema.fields.findIndex(\n    field =>\n      field.name === geometryColumnName ||\n      field.metadata.get('ARROW:extension:name') === extensionName\n  );\n  return index !== -1 ? index : null;\n}\n\n/**\n * Returns `true` if the input is a reference to a column in the table\n */\nexport function isColumnReference(input: any): input is string {\n  return typeof input === 'string';\n}\n\nfunction isDataInterleavedCoords(\n  data: arrow.Data\n): data is arrow.Data<arrow.FixedSizeList<arrow.Float64>> {\n  // TODO: also check 2 or 3d? Float64?\n  return data.type instanceof arrow.FixedSizeList;\n}\n\nfunction isDataSeparatedCoords(\n  data: arrow.Data\n): data is arrow.Data<arrow.Struct<{x: arrow.Float64; y: arrow.Float64}>> {\n  // TODO: also check child names? Float64?\n  return data.type instanceof arrow.Struct;\n}\n\n/**\n * Convert geoarrow Struct coordinates to FixedSizeList coords\n *\n * The GeoArrow spec allows for either separated or interleaved coords, but at\n * this time deck.gl only supports interleaved.\n */\n// TODO: this hasn't been tested yet\n// @ts-expect-error\nfunction convertStructToFixedSizeList(\n  coords:\n    | arrow.Data<arrow.FixedSizeList<arrow.Float64>>\n    | arrow.Data<arrow.Struct<{x: arrow.Float64; y: arrow.Float64}>>\n): arrow.Data<arrow.FixedSizeList<arrow.Float64>> {\n  if (isDataInterleavedCoords(coords)) {\n    return coords;\n  } else if (isDataSeparatedCoords(coords)) {\n    // TODO: support 3d\n    const interleavedCoords = new Float64Array(coords.length * 2);\n    const [xChild, yChild] = coords.children;\n    for (let i = 0; i < coords.length; i++) {\n      interleavedCoords[i * 2] = xChild.values[i];\n      interleavedCoords[i * 2 + 1] = yChild.values[i];\n    }\n\n    const childDataType = new arrow.Float64();\n    const dataType = new arrow.FixedSizeList(2, new arrow.Field('coords', childDataType));\n\n    const interleavedCoordsData = arrow.makeData({\n      type: childDataType,\n      length: interleavedCoords.length\n    });\n\n    const data = arrow.makeData({\n      type: dataType,\n      length: coords.length,\n      nullCount: coords.nullCount,\n      nullBitmap: coords.nullBitmap,\n      child: interleavedCoordsData\n    });\n    return data;\n  }\n\n  assert(false);\n}\n\ntype AssignAccessorProps = {\n  /** The object on which to assign the resolved accesor */\n  props: Record<string, any>;\n  /** The name of the prop to set */\n  propName: string;\n  /** The user-supplied input to the layer. Must either be a scalar value or a reference to a column in the table. */\n  propInput: any;\n  /** Numeric index in the table */\n  chunkIdx: number;\n  /** a map from the geometry index to the coord offsets for that geometry. */\n  geomCoordOffsets?: Int32Array | null;\n  /** Absolute offset of the batch in the table/vector. Added to the sampling index. */\n  batchOffset?: number;\n};\n\n/**\n * A wrapper around a user-provided accessor function\n *\n * For layers like Scatterplot, Path, and Polygon, we automatically handle\n * \"exploding\" the table when multi-geometry input are provided. This means that\n * the upstream `index` value passed to the user will be the correct row index\n * _only_ for non-exploded data.\n *\n * With this function, we simplify the user usage by automatically converting\n * back from \"exploded\" index back to the original row index.\n */\nfunction wrapAccessorFunction<In, Out>(\n  objectInfo: _InternalAccessorContext<In>,\n  userAccessorFunction: AccessorFunction<In, Out>,\n  batchOffset: number\n): Out {\n  const {index, data} = objectInfo;\n  let newIndex = index + batchOffset;\n  if (data.invertedGeomOffsets !== undefined) {\n    newIndex = data.invertedGeomOffsets[index];\n  }\n  const newObjectData = {\n    data: data.data,\n    length: data.length,\n    attributes: data.attributes\n  };\n  const newObjectInfo = {\n    index: newIndex,\n    data: newObjectData,\n    target: objectInfo.target\n  };\n  return userAccessorFunction(newObjectInfo);\n}\n\n/**\n * Resolve accessor and assign to props object\n *\n * This is useful as a helper function because a scalar prop is set at the top\n * level while a vectorized prop is set inside data.attributes\n *\n */\nexport function assignAccessor(args: AssignAccessorProps) {\n  const {props, propName, propInput, chunkIdx, geomCoordOffsets, batchOffset = 0} = args;\n\n  if (propInput === undefined) {\n    return;\n  }\n\n  if (propInput instanceof arrow.Vector) {\n    const columnData = propInput.data[chunkIdx];\n\n    if (arrow.DataType.isFixedSizeList(columnData)) {\n      assert(columnData.children.length === 1);\n      let values = columnData.children[0].values;\n\n      if (geomCoordOffsets) {\n        values = expandArrayToCoords(values, columnData.type.listSize, geomCoordOffsets);\n      }\n\n      props.data.attributes[propName] = {\n        value: values,\n        size: columnData.type.listSize,\n        // Set to `true` to signify that colors are already 0-255, and deck/luma\n        // does not need to rescale\n        // https://github.com/visgl/deck.gl/blob/401d624c0529faaa62125714c376b3ba3b8f379f/docs/api-reference/core/attribute-manager.md?plain=1#L66\n        normalized: true\n      };\n    } else if (arrow.DataType.isFloat(columnData)) {\n      let values = columnData.values;\n\n      if (geomCoordOffsets) {\n        values = expandArrayToCoords(values, 1, geomCoordOffsets);\n      }\n\n      props.data.attributes[propName] = {\n        value: values,\n        size: 1\n      };\n    }\n  } else if (typeof propInput === 'function') {\n    props[propName] = <In>(object: any, objectInfo: AccessorContext<In>) => {\n      // Special case that doesn't have the same parameters\n      if (propName === 'getPolygonOffset') {\n        return propInput(object, objectInfo);\n      }\n\n      return wrapAccessorFunction(objectInfo, propInput, batchOffset);\n    };\n  } else {\n    props[propName] = propInput;\n  }\n}\n\n/**\n * Expand an array from \"one element per geometry\" to \"one element per coordinate\"\n *\n * @param input: the input array to expand\n * @param size : the number of nested elements in the input array per geometry. So for example, for RGB data this would be 3, for RGBA this would be 4. For radius, this would be 1.\n * @param geomOffsets : an offsets array mapping from the geometry to the coordinate indexes. So in the case of a LineStringArray, this is retrieved directly from the GeoArrow storage. In the case of a PolygonArray, this comes from the resolved indexes that need to be given to the SolidPolygonLayer anyways.\n *\n * @return  {TypedArray} values expanded to be per-coordinate\n */\nexport function expandArrayToCoords<T extends TypedArray>(\n  input: T,\n  size: number,\n  geomOffsets: Int32Array\n): T {\n  const numCoords = geomOffsets[geomOffsets.length - 1];\n  // @ts-expect-error\n  const outputArray: T = new input.constructor(numCoords * size);\n\n  // geomIdx is an index into the geomOffsets array\n  // geomIdx is also the geometry/table index\n  for (let geomIdx = 0; geomIdx < geomOffsets.length - 1; geomIdx++) {\n    // geomOffsets maps from the geometry index to the coord index\n    // So here we get the range of coords that this geometry covers\n    const lastCoordIdx = geomOffsets[geomIdx];\n    const nextCoordIdx = geomOffsets[geomIdx + 1];\n\n    // Iterate over this range of coord indices\n    for (let coordIdx = lastCoordIdx; coordIdx < nextCoordIdx; coordIdx++) {\n      // Iterate over size\n      for (let i = 0; i < size; i++) {\n        // Copy from the geometry index in `input` to the coord index in\n        // `output`\n        outputArray[coordIdx * size + i] = input[geomIdx * size + i];\n      }\n    }\n  }\n\n  return outputArray;\n}\n\n/**\n * Get a geometry vector with the specified extension type name from the table.\n */\nexport function getGeometryVector(\n  table: arrow.Table,\n  geoarrowTypeName: string\n): arrow.Vector | null {\n  const geometryColumnIdx = findGeometryColumnIndex(table.schema, geoarrowTypeName);\n\n  if (geometryColumnIdx === null) {\n    return null;\n    // throw new Error(`No column found with extension type ${geoarrowTypeName}`);\n  }\n\n  return table.getChildAt(geometryColumnIdx);\n}\n\nexport function getListNestingLevels(data: arrow.Data): number {\n  let nestingLevels = 0;\n  if (arrow.DataType.isList(data.type)) {\n    nestingLevels += 1;\n    data = data.children[0];\n  }\n  return nestingLevels;\n}\n\nexport function getMultiLineStringResolvedOffsets(data: ga.data.MultiLineStringData): Int32Array {\n  const geomOffsets = data.valueOffsets;\n  const lineStringData = ga.child.getMultiLineStringChild(data);\n  const ringOffsets = lineStringData.valueOffsets;\n\n  const resolvedRingOffsets = new Int32Array(geomOffsets.length);\n  for (let i = 0; i < resolvedRingOffsets.length; ++i) {\n    // Perform the lookup into the ringIndices array using the geomOffsets\n    // array\n    resolvedRingOffsets[i] = ringOffsets[geomOffsets[i]];\n  }\n\n  return resolvedRingOffsets;\n}\n\nexport function getPolygonResolvedOffsets(data: ga.data.PolygonData): Int32Array {\n  const geomOffsets = data.valueOffsets;\n  const ringData = ga.child.getPolygonChild(data);\n  const ringOffsets = ringData.valueOffsets;\n\n  const resolvedRingOffsets = new Int32Array(geomOffsets.length);\n  for (let i = 0; i < resolvedRingOffsets.length; ++i) {\n    // Perform the lookup into the ringIndices array using the geomOffsets\n    // array\n    resolvedRingOffsets[i] = ringOffsets[geomOffsets[i]];\n  }\n\n  return resolvedRingOffsets;\n}\n\nexport function getMultiPolygonResolvedOffsets(data: ga.data.MultiPolygonData): Int32Array {\n  const polygonData = ga.child.getMultiPolygonChild(data);\n  const ringData = ga.child.getPolygonChild(polygonData);\n\n  const geomOffsets = data.valueOffsets;\n  const polygonOffsets = polygonData.valueOffsets;\n  const ringOffsets = ringData.valueOffsets;\n\n  const resolvedRingOffsets = new Int32Array(geomOffsets.length);\n  for (let i = 0; i < resolvedRingOffsets.length; ++i) {\n    resolvedRingOffsets[i] = ringOffsets[polygonOffsets[geomOffsets[i]]];\n  }\n\n  return resolvedRingOffsets;\n}\n\n/**\n * Invert offsets so that lookup can go in the opposite direction\n */\nexport function invertOffsets(offsets: Int32Array): Uint8Array | Uint16Array | Uint32Array {\n  const largestOffset = offsets[offsets.length - 1];\n\n  const arrayConstructor =\n    offsets.length < Math.pow(2, 8)\n      ? Uint8Array\n      : offsets.length < Math.pow(2, 16)\n      ? Uint16Array\n      : Uint32Array;\n\n  const invertedOffsets = new arrayConstructor(largestOffset);\n  for (let arrayIdx = 0; arrayIdx < offsets.length - 1; arrayIdx++) {\n    const thisOffset = offsets[arrayIdx];\n    const nextOffset = offsets[arrayIdx + 1];\n    for (let offset = thisOffset; offset < nextOffset; offset++) {\n      invertedOffsets[offset] = arrayIdx;\n    }\n  }\n\n  return invertedOffsets;\n}\n\n// TODO: better typing\nexport function extractAccessorsFromProps(\n  props: Record<string, any>,\n  excludeKeys: string[]\n): [Record<string, any>, Record<string, any>] {\n  const accessors: Record<string, any> = {};\n  const otherProps: Record<string, any> = {};\n  for (const [key, value] of Object.entries(props)) {\n    if (excludeKeys.includes(key)) {\n      continue;\n    }\n\n    if (key.startsWith('get')) {\n      accessors[key] = value;\n    } else {\n      otherProps[key] = value;\n    }\n  }\n\n  return [accessors, otherProps];\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/utils/validate.d.ts

@@ -0,0 +1,12 @@
+import * as arrow from 'apache-arrow';
+export declare function validateAccessors(props: Record<string, any>, table: arrow.Table): void;
+/**
+ * Provide validation for accessors provided
+ *
+ * - Assert that all vectors have the same number of chunks as the main table
+ * - Assert that all chunks in each vector have the same number of rows as the
+ *   relevant batch in the main table.
+ *
+ */
+export declare function validateVectorAccessors(table: arrow.Table, vectorAccessors: arrow.Vector[]): void;
+export declare function validateColorVector(vector: arrow.Vector): void;