@loaders.gl/schema 4.3.2 → 4.4.0-alpha.1

package/src/geometry/binary-features.ts

@@ -0,0 +1,43 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// GIS
+import type {TypedArray} from '../types/types';
+import type {
+  BinaryPointGeometry,
+  BinaryLineGeometry,
+  BinaryPolygonGeometry
+} from './binary-geometries';
+
+export type BinaryAttribute = {
+  value: TypedArray;
+  size: number;
+};
+
+/**
+ * Represent a collection of Features, similar to a GeoJSON FeatureCollection
+ * But in columnar format, with binary columns when possible
+ */
+export type BinaryFeatureCollection = {
+  shape: 'binary-feature-collection';
+  points?: BinaryPointFeature;
+  lines?: BinaryLineFeature;
+  polygons?: BinaryPolygonFeature;
+};
+
+/** Binary feature + binary attributes */
+export type BinaryFeature = BinaryPointFeature | BinaryLineFeature | BinaryPolygonFeature;
+
+export type BinaryPointFeature = BinaryPointGeometry & BinaryProperties;
+export type BinaryLineFeature = BinaryLineGeometry & BinaryProperties;
+export type BinaryPolygonFeature = BinaryPolygonGeometry & BinaryProperties;
+
+/** Common properties for binary geometries */
+export type BinaryProperties = {
+  featureIds: BinaryAttribute;
+  globalFeatureIds: BinaryAttribute;
+  numericProps: Record<string, BinaryAttribute>;
+  properties: Record<string, any>[];
+  fields?: Record<string, any>[];
+};

package/src/geometry/binary-geometries.ts

@@ -0,0 +1,45 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// GIS
+import type {TypedArray} from '../types/types';
+
+// BINARY FORMAT GEOMETRY
+
+export type BinaryGeometryType = 'Point' | 'LineString' | 'Polygon';
+
+/**
+ * Similar to an apache arrow FixedSizeList,
+ * contains the contiguous array and the number of values in each element  */
+export type BinaryFixedSizeList = {
+  value: TypedArray;
+  size: number;
+};
+
+/**
+ * Represent a single Geometry, similar to a GeoJSON Geometry
+ */
+export type BinaryGeometry = BinaryPointGeometry | BinaryLineGeometry | BinaryPolygonGeometry;
+
+/** Binary point geometry: an array of positions */
+export type BinaryPointGeometry = {
+  type: 'Point';
+  positions: BinaryFixedSizeList;
+};
+
+/** Binary line geometry, array of positions and indices to the start of each line */
+export type BinaryLineGeometry = {
+  type: 'LineString';
+  positions: BinaryFixedSizeList;
+  pathIndices: BinaryFixedSizeList;
+};
+
+/** Binary polygon geometry, an array of positions to each primitite polygon and polygon */
+export type BinaryPolygonGeometry = {
+  type: 'Polygon';
+  positions: BinaryFixedSizeList;
+  polygonIndices: BinaryFixedSizeList;
+  primitivePolygonIndices: BinaryFixedSizeList;
+  triangles?: BinaryFixedSizeList;
+};

package/src/{types → geometry}/flat-geometries.ts

@@ -3,37 +3,67 @@
 // Copyright (c) vis.gl contributors
 
 // FLAT GEOJSON FORMAT GEOMETRY
-import type {Feature, Geometry, Point, LineString, Polygon} from 'geojson';
+import type {Feature, Geometry} from 'geojson';
+
+/**
+ * Generic flat geometry data storage type
+ * (an intermediate "Flat GeoJSON"
+ * data format, which maps closely to the binary data buffers.
+ * It is similar to GeoJSON, but rather than storing the coordinates
+ * in multidimensional arrays, we have a 1D `data` with all the
+ * coordinates, and then index into this using the `indices`
+ * parameter
+ *
+ * Thus the indices member lets us look up the relevant range
+ * from the data array.
+ * The Multi* versions of the above types share the same data
+ * structure, just with multiple elements in the indices array
+ *
+ * @example
+ *
+ * geometry: {
+ *   type: 'Point', data: [1,2], indices: [0]
+ * }
+ * geometry: {
+ *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+ * }
+ * geometry: {
+ *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+ * }
+ */
+export type FlatIndexedGeometry = {
+  data: number[];
+  indices: number[];
+};
 
 /** Flat geometry type */
 export type FlatGeometryType = 'Point' | 'LineString' | 'Polygon';
 
-type RemoveCoordinatesField<Type> = {
-  [Property in keyof Type as Exclude<Property, 'coordinates'>]: Type[Property];
-};
+/** GeoJSON geometry with coordinate data flattened into `data` array and indexed by 2D `indices` */
+export type FlatGeometry = FlatPoint | FlatLineString | FlatPolygon;
 
-/** Generic flat geometry data storage type */
-export type FlatIndexedGeometry = {
+/** GeoJSON (Multi)Point geometry with coordinate data flattened into `data` array and indexed by `indices` */
+export type FlatPoint = {
+  type: 'Point';
   data: number[];
   indices: number[];
 };
 
-/** GeoJSON (Multi)Point geometry with coordinate data flattened into `data` array and indexed by `indices` */
-export type FlatPoint = RemoveCoordinatesField<Point> & FlatIndexedGeometry;
-
 /** GeoJSON (Multi)LineString geometry with coordinate data flattened into `data` array and indexed by `indices` */
-export type FlatLineString = RemoveCoordinatesField<LineString> & FlatIndexedGeometry;
+export type FlatLineString = {
+  type: 'LineString';
+  data: number[];
+  indices: number[];
+};
 
 /** GeoJSON (Multi)Polygon geometry with coordinate data flattened into `data` array and indexed by 2D `indices` */
-export type FlatPolygon = RemoveCoordinatesField<Polygon> & {
+export type FlatPolygon = {
+  type: 'Polygon';
   data: number[];
   indices: number[][];
   areas: number[][];
 };
 
-/** GeoJSON geometry with coordinate data flattened into `data` array and indexed by 2D `indices` */
-export type FlatGeometry = FlatPoint | FlatLineString | FlatPolygon;
-
 type FlattenGeometry<Type> = {
   [Property in keyof Type]: Type[Property] extends Geometry ? FlatGeometry : Type[Property];
 };

package/src/index.ts

@@ -18,8 +18,6 @@ export type {
 export type {Schema, Field, DataType, SchemaMetadata, FieldMetadata} from './types/schema';
 export type {Batch} from './types/batch';
 
-export {getArrayTypeFromDataType} from './lib/table/simple-table/data-type';
-
 // TABLE CATEGORY TYPES
 export type {
   Table,
@@ -30,7 +28,7 @@ export type {
   ColumnarTable,
   ArrowTable,
   Tables
-} from './types/category-table';
+} from './categories/category-table';
 export type {
   TableBatch,
   ArrayRowTableBatch,
@@ -38,41 +36,7 @@ export type {
   GeoJSONTableBatch,
   ColumnarTableBatch,
   ArrowTableBatch
-} from './types/category-table';
-
-// TABLE CATEGORY UTILS
-export {TableBatchBuilder} from './lib/table/batches/table-batch-builder';
-export type {TableBatchAggregator} from './lib/table/batches/table-batch-aggregator';
-export {RowTableBatchAggregator} from './lib/table/batches/row-table-batch-aggregator';
-export {ColumnarTableBatchAggregator} from './lib/table/batches/columnar-table-batch-aggregator';
-
-export {
-  isTable,
-  getTableLength,
-  getTableNumCols,
-  getTableCell,
-  getTableCellAt,
-  getTableRowShape,
-  getTableColumnIndex,
-  getTableColumnName,
-  getTableRowAsObject,
-  getTableRowAsArray,
-  makeRowIterator,
-  makeArrayRowIterator,
-  makeObjectRowIterator
-} from './lib/table/simple-table/table-accessors';
-
-export {ArrowLikeTable} from './lib/table/arrow-api/arrow-like-table';
-
-export {makeTableFromData} from './lib/table/simple-table/make-table';
-export {
-  makeTableFromBatches,
-  makeBatchFromTable
-} from './lib/table/simple-table/make-table-from-batches';
-export {convertTable} from './lib/table/simple-table/convert-table';
-export {deduceTableSchema} from './lib/table/simple-table/table-schema';
-export {convertToObjectRow, convertToArrayRow} from './lib/table/simple-table/row-utils';
-export {getDataTypeFromArray} from './lib/table/simple-table/data-type';
+} from './categories/category-table';
 
 // MESH CATEGORY
 export type {
@@ -82,24 +46,17 @@ export type {
   MeshGeometry,
   MeshAttribute,
   MeshAttributes
-} from './types/category-mesh';
-
-export {getMeshSize, getMeshBoundingBox} from './lib/mesh/mesh-utils';
-// Commented out due to https://github.com/visgl/deck.gl/issues/6906 and https://github.com/visgl/loaders.gl/issues/2177
-// export {convertMesh} from './category/mesh/convert-mesh';
-export {
-  deduceMeshSchema,
-  deduceMeshField,
-  makeMeshAttributeMetadata
-} from './lib/mesh/deduce-mesh-schema';
+} from './categories/category-mesh';
 
 // TEXTURES
-export type {TextureLevel, GPUTextureFormat} from './types/category-texture';
+export type {TextureLevel, GPUTextureFormat} from './categories/category-texture';
 
 // IMAGES
-export type {ImageDataType, ImageType, ImageTypeEnum} from './types/category-image';
+export type {ImageDataType, ImageType, ImageTypeEnum} from './categories/category-image';
+
+// GIS CATEGORY - GEOARROW
+// export type {GeoArrowMetadata, GeoArrowEncoding} from './geometry/geoarrow-metadata';
 
-// TYPES
 // GIS CATEGORY - GEOJSON
 export type {
   GeoJSON,
@@ -115,9 +72,7 @@ export type {
   Polygon,
   MultiPolygon,
   GeometryCollection
-} from './types/category-gis';
-
-export type {GeojsonGeometryInfo} from './types/category-gis';
+} from './categories/category-gis';
 
 // GIS CATEGORY - FLAT GEOJSON
 export type {
@@ -128,7 +83,7 @@ export type {
   FlatPoint,
   FlatLineString,
   FlatPolygon
-} from './types/category-gis';
+} from './categories/category-gis';
 
 // GIS CATEGORY - BINARY
 export type {
@@ -138,58 +93,17 @@ export type {
   BinaryLineGeometry,
   BinaryPolygonGeometry,
   BinaryAttribute
-} from './types/category-gis';
+} from './categories/category-gis';
 export type {
   BinaryFeatureCollection,
   BinaryFeature,
   BinaryPointFeature,
   BinaryLineFeature,
   BinaryPolygonFeature
-} from './types/category-gis';
+} from './categories/category-gis';
 
-// SCHEMA
-export {
-  Schema as ArrowLikeSchema,
-  Field as ArrowLikeField,
-  DataType as ArrowLikeDataType,
-  Null,
-  Binary,
-  Bool,
-  Int,
-  Int8,
-  Int16,
-  Int32,
-  Int64,
-  Uint8,
-  Uint16,
-  Uint32,
-  Uint64,
-  Float,
-  Float16,
-  Float32,
-  Float64,
-  Utf8,
-  Date,
-  DateDay,
-  DateMillisecond,
-  Time,
-  TimeMillisecond,
-  TimeSecond,
-  Timestamp,
-  TimestampSecond,
-  TimestampMillisecond,
-  TimestampMicrosecond,
-  TimestampNanosecond,
-  Interval,
-  IntervalDayTime,
-  IntervalYearMonth,
-  FixedSizeList,
-  Struct
-} from './lib/table/arrow-api/index';
+// DEPRECATED
 
-// EXPERIMENTAL APIs
-
-// SCHEMA UTILS
-export {getTypeInfo} from './lib/table/arrow-api/get-type-info';
+// MESH CATEGORY
 
-export {default as AsyncQueue} from './lib/utils/async-queue';
+export {getMeshSize, getMeshBoundingBox} from './deprecated/mesh-utils';

package/src/types/batch.ts

@@ -12,9 +12,11 @@ type ApacheRecordBatch = unknown;
  * @see parseInBatches()
  * @see loadInBatches()
  */
-export type Batch = {
+export type Batch<MetadataT = unknown> = {
   /** A batch can contain metadata, data, or in case of unstructured data (JSON) */
   batchType: 'data' | 'metadata' | 'partial-result' | 'final-result';
+  /** Metadata for this batch if batchType === 'metadata' */
+  metadata?: MetadataT;
   /** A string identifying the shape of data in this batch (table, etc) */
   shape: string;
   /** Schema of the data in this batch */

package/dist/lib/mesh/convert-mesh.d.ts

@@ -1,15 +0,0 @@
-import type { Mesh } from "../../types/category-mesh.js";
-import type { ColumnarTable, ArrowTable } from "../../types/category-table.js";
-type TargetShape = 'mesh' | 'columnar-table' | 'arrow-table';
-/**
- * Convert a mesh to a specific shape
- */
-export declare function convertMesh(mesh: Mesh, shape: TargetShape, options?: any): Mesh | ColumnarTable | ArrowTable;
-/**
- * Convert a loaders.gl Mesh to a Columnar Table
- * @param mesh
- * @returns
- */
-export declare function convertMeshToColumnarTable(mesh: Mesh): ColumnarTable;
-export {};
-//# sourceMappingURL=convert-mesh.d.ts.map

package/dist/lib/mesh/convert-mesh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-mesh.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/convert-mesh.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAC,qCAAkC;AACpD,OAAO,KAAK,EAAC,aAAa,EAAE,UAAU,EAAC,sCAAmC;AAG1E,KAAK,WAAW,GAAG,MAAM,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAE7D;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,GAAG,GACZ,IAAI,GAAG,aAAa,GAAG,UAAU,CAcnC;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,CAYpE"}

package/dist/lib/mesh/convert-mesh.js

@@ -1,37 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/**
- * Convert a mesh to a specific shape
- */
-export function convertMesh(mesh, shape, options) {
-    switch (shape || 'mesh') {
-        case 'mesh':
-            return mesh;
-        case 'columnar-table':
-            return convertMeshToColumnarTable(mesh);
-        // case 'arrow-table':
-        //   return {
-        //     shape: 'arrow-table',
-        //     data: convertMeshToArrowTable(mesh)
-        //   };
-        default:
-            throw new Error(`Unsupported shape ${options?.shape}`);
-    }
-}
-/**
- * Convert a loaders.gl Mesh to a Columnar Table
- * @param mesh
- * @returns
- */
-export function convertMeshToColumnarTable(mesh) {
-    const columns = {};
-    for (const [columnName, attribute] of Object.entries(mesh.attributes)) {
-        columns[columnName] = attribute.value;
-    }
-    return {
-        shape: 'columnar-table',
-        schema: mesh.schema,
-        data: columns
-    };
-}

package/dist/lib/mesh/deduce-mesh-schema.d.ts

@@ -1,24 +0,0 @@
-import { MeshAttribute, MeshAttributes } from "../../types/category-mesh.js";
-import { Schema, Field } from "../../types/schema.js";
-/**
- * Create a schema for mesh attributes data
- * @param attributes
- * @param metadata
- * @returns
- */
-export declare function deduceMeshSchema(attributes: MeshAttributes, metadata?: Record<string, string>): Schema;
-/**
- * Create arrow-like schema field for mesh attribute
- * @param attributeName
- * @param attribute
- * @param optionalMetadata
- * @returns
- */
-export declare function deduceMeshField(name: string, attribute: MeshAttribute, optionalMetadata?: Record<string, string>): Field;
-/**
- * Make metadata by mesh attribute properties
- * @param attribute
- * @returns
- */
-export declare function makeMeshAttributeMetadata(attribute: MeshAttribute): Record<string, string>;
-//# sourceMappingURL=deduce-mesh-schema.d.ts.map

package/dist/lib/mesh/deduce-mesh-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deduce-mesh-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/deduce-mesh-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,aAAa,EAAE,cAAc,EAAC,qCAAkC;AACxE,OAAO,EAAC,MAAM,EAAE,KAAK,EAAC,8BAA2B;AAGjD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,cAAc,EAC1B,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACpC,MAAM,CAGR;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,aAAa,EACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACxC,KAAK,CASP;AAgBD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAY1F"}

package/dist/lib/mesh/deduce-mesh-schema.js

@@ -1,62 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { getDataTypeFromTypedArray } from "../table/simple-table/data-type.js";
-/**
- * Create a schema for mesh attributes data
- * @param attributes
- * @param metadata
- * @returns
- */
-export function deduceMeshSchema(attributes, metadata = {}) {
-    const fields = deduceMeshFields(attributes);
-    return { fields, metadata };
-}
-/**
- * Create arrow-like schema field for mesh attribute
- * @param attributeName
- * @param attribute
- * @param optionalMetadata
- * @returns
- */
-export function deduceMeshField(name, attribute, optionalMetadata) {
-    const type = getDataTypeFromTypedArray(attribute.value);
-    const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
-    return {
-        name,
-        type: { type: 'fixed-size-list', listSize: attribute.size, children: [{ name: 'value', type }] },
-        nullable: false,
-        metadata
-    };
-}
-/**
- * Create fields array for mesh attributes
- * @param attributes
- * @returns
- */
-function deduceMeshFields(attributes) {
-    const fields = [];
-    for (const attributeName in attributes) {
-        const attribute = attributes[attributeName];
-        fields.push(deduceMeshField(attributeName, attribute));
-    }
-    return fields;
-}
-/**
- * Make metadata by mesh attribute properties
- * @param attribute
- * @returns
- */
-export function makeMeshAttributeMetadata(attribute) {
-    const result = {};
-    if ('byteOffset' in attribute) {
-        result.byteOffset = attribute.byteOffset.toString(10);
-    }
-    if ('byteStride' in attribute) {
-        result.byteStride = attribute.byteStride.toString(10);
-    }
-    if ('normalized' in attribute) {
-        result.normalized = attribute.normalized.toString();
-    }
-    return result;
-}

package/dist/lib/mesh/mesh-to-arrow-table.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=mesh-to-arrow-table.d.ts.map

package/dist/lib/mesh/mesh-to-arrow-table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mesh-to-arrow-table.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/mesh-to-arrow-table.ts"],"names":[],"mappings":""}

package/dist/lib/mesh/mesh-to-arrow-table.js

@@ -1,47 +0,0 @@
-"use strict";
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/* Problem with arrow dependency...
-import {
-  Table,
-  Schema,
-  RecordBatch,
-  FixedSizeList,
-  Field,
-  Data,
-  FixedSizeListVector
-} from 'apache-arrow';
-import {AbstractVector} from 'apache-arrow/vector';
-import {getArrowType, getArrowVector} from '../table/arrow/arrow-type-utils';
-import type {Mesh} from './mesh-types';
-import {makeMeshAttributeMetadata} from './deduce-mesh-schema';
-
-/**
- * * Convert a loaders.gl Mesh to an Apache Arrow Table
- * @param mesh
- * @param metadata
- * @param batchSize
- * @returns
- *
-export function convertMeshToArrowTable(mesh: Mesh, batchSize?: number): Table {
-  const vectors: AbstractVector[] = [];
-  const fields: Field[] = [];
-  for (const attributeKey in mesh.attributes) {
-    const attribute = mesh.attributes[attributeKey];
-    const {value, size = 1} = attribute;
-    const type = getArrowType(value);
-    const vector = getArrowVector(value);
-    const listType = new FixedSizeList(size, new Field('value', type));
-    const field = new Field(attributeKey, listType, false, makeMeshAttributeMetadata(attribute));
-    const data = new Data(listType, 0, value.length / size, 0, undefined, [vector]);
-    const listVector = new FixedSizeListVector(data);
-    vectors.push(listVector);
-    fields.push(field);
-  }
-  const schema = new Schema(fields, mesh?.schema?.metadata || new Map<string, string>());
-  const recordBatch = new RecordBatch(schema, vectors[0].length, vectors);
-  const table = new Table(schema, recordBatch);
-  return table;
-}
-*/

package/dist/lib/mesh/mesh-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mesh-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/mesh-utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,UAAU,EAAC,6BAA0B;AAC7C,OAAO,EAAC,cAAc,EAAC,qCAAkC;AAEzD,KAAK,WAAW,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAC,CAAC;AAE/C;;;GAGG;AACH,KAAK,WAAW,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAExE;;;GAGG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,WAAW,GAAG,MAAM,CAU3D;AAED;;;;GAIG;AAEH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,cAAc,GAAG,WAAW,CA4B1E"}

package/dist/lib/table/arrow-api/arrow-like-field.d.ts

@@ -1,19 +0,0 @@
-import { DataType } from "./arrow-like-type.js";
-/**
- * ArrowJS `Field` API-compatible class for row-based tables
- * https://loaders.gl/arrowjs/docs/api-reference/field
- * A field holds name, nullable, and metadata information about a table "column"
- * A Schema is essentially a list of fields
- */
-export declare class ArrowLikeField {
-    name: string;
-    type: DataType;
-    nullable: boolean;
-    metadata: Map<string, string>;
-    constructor(name: string, type: DataType, nullable?: boolean, metadata?: Map<string, string>);
-    get typeId(): number;
-    clone(): ArrowLikeField;
-    compareTo(other: this): boolean;
-    toString(): string;
-}
-//# sourceMappingURL=arrow-like-field.d.ts.map

package/dist/lib/table/arrow-api/arrow-like-field.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrow-like-field.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow-api/arrow-like-field.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAC,6BAA0B;AAE3C;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAG5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,EACd,QAAQ,UAAQ,EAChB,QAAQ,GAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAa;IAQ3C,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,KAAK,IAAI,cAAc;IAIvB,SAAS,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;IAS/B,QAAQ,IAAI,MAAM;CAKnB"}

package/dist/lib/table/arrow-api/arrow-like-field.js

@@ -1,36 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/**
- * ArrowJS `Field` API-compatible class for row-based tables
- * https://loaders.gl/arrowjs/docs/api-reference/field
- * A field holds name, nullable, and metadata information about a table "column"
- * A Schema is essentially a list of fields
- */
-export class ArrowLikeField {
-    name;
-    type;
-    nullable;
-    metadata;
-    constructor(name, type, nullable = false, metadata = new Map()) {
-        this.name = name;
-        this.type = type;
-        this.nullable = nullable;
-        this.metadata = metadata;
-    }
-    get typeId() {
-        return this.type && this.type.typeId;
-    }
-    clone() {
-        return new ArrowLikeField(this.name, this.type, this.nullable, this.metadata);
-    }
-    compareTo(other) {
-        return (this.name === other.name &&
-            this.type === other.type &&
-            this.nullable === other.nullable &&
-            this.metadata === other.metadata);
-    }
-    toString() {
-        return `${JSON.stringify(this.type)}${this.nullable ? ', nullable' : ''}${this.metadata ? `, metadata: ${JSON.stringify(this.metadata)}` : ''}`;
-    }
-}

package/dist/lib/table/arrow-api/arrow-like-interface.d.ts

@@ -1,43 +0,0 @@
-import { DataType } from "./arrow-like-type.js";
-/**
- * ArrowJS `Field` API-compatible class for row-based tables
- * https://loaders.gl/arrowjs/docs/api-reference/field
- * A field holds name, nullable, and metadata information about a table "column"
- * A Schema is essentially a list of fields
- */
-export interface Field {
-    name: string;
-    type: DataType;
-    nullable: boolean;
-    metadata: Map<string, string>;
-    typeId(): number;
-    clone(): Field;
-    compareTo(other: this): boolean;
-    toString(): any;
-}
-export interface Schema {
-    fields: Field[];
-    metadata: Map<string, string>;
-    compareTo(other: Schema): boolean;
-    select(...columnNames: string[]): Schema;
-    selectAt(...columnIndices: number[]): Schema;
-    assign(schemaOrFields: Schema | Field[]): Schema;
-}
-export interface ArrowLikeVector {
-    table: Table;
-    columnName: string;
-    get(rowIndex: number): unknown;
-    toArray(): ArrayLike<unknown>;
-}
-/**
- * Class that provides an API similar to Apache Arrow Table class
- * Forwards methods directly if the underlying table is Arrow, otherwise calls accessor functions
- */
-export interface Table {
-    schema: Schema;
-    data: any;
-    numCols: number;
-    length(): number;
-    getChild(columnName: string): ArrowLikeVector;
-}
-//# sourceMappingURL=arrow-like-interface.d.ts.map