@loaders.gl/schema-utils 4.4.0-alpha.1

package/dist/lib/schema/data-type.js

@@ -0,0 +1,88 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Deduce column types from values */
+export function getDataTypeFromValue(value, defaultNumberType = 'float32') {
+    if (value instanceof Date) {
+        return 'date-millisecond';
+    }
+    if (value instanceof Number) {
+        return defaultNumberType;
+    }
+    if (typeof value === 'string') {
+        return 'utf8';
+    }
+    if (value === null || value === 'undefined') {
+        return 'null';
+    }
+    return 'null';
+}
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+export function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== 'null') {
+        return { type, nullable: false };
+    }
+    if (array.length > 0) {
+        type = getDataTypeFromValue(array[0]);
+        return { type, nullable: true };
+    }
+    return { type: 'null', nullable: true };
+}
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+export function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+        case Int8Array:
+            return 'int8';
+        case Uint8Array:
+        case Uint8ClampedArray:
+            return 'uint8';
+        case Int16Array:
+            return 'int16';
+        case Uint16Array:
+            return 'uint16';
+        case Int32Array:
+            return 'int32';
+        case Uint32Array:
+            return 'uint32';
+        case Float32Array:
+            return 'float32';
+        case Float64Array:
+            return 'float64';
+        default:
+            return 'null';
+    }
+}
+export function getArrayTypeFromDataType(type, nullable) {
+    if (!nullable) {
+        switch (type) {
+            case 'int8':
+                return Int8Array;
+            case 'uint8':
+                return Uint8Array;
+            case 'int16':
+                return Int16Array;
+            case 'uint16':
+                return Uint16Array;
+            case 'int32':
+                return Int32Array;
+            case 'uint32':
+                return Uint32Array;
+            case 'float32':
+                return Float32Array;
+            case 'float64':
+                return Float64Array;
+            default:
+                break;
+        }
+    }
+    // if (typeof BigInt64Array !== 'undefined') {
+    //   TYPED_ARRAY_TO_TYPE.BigInt64Array = new Int64();
+    //   TYPED_ARRAY_TO_TYPE.BigUint64Array = new Uint64();
+    // }
+    return Array;
+}

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

@@ -0,0 +1,14 @@
+import type { Schema, Table } from '@loaders.gl/schema';
+/**
+ * SCHEMA SUPPORT - AUTODEDUCTION
+ * @param {*} table
+ * @param {*} schema
+ * @returns
+ */
+export declare function deduceTableSchema(table: Table): Schema;
+export declare function deduceSchema(data: unknown[][] | {
+    [key: string]: unknown;
+}[] | {
+    [key: string]: unknown[];
+}): Schema;
+//# sourceMappingURL=deduce-table-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deduce-table-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/deduce-table-schema.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,MAAM,EAAoB,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAGxE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAgBtD;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,EAAE,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;CAAC,GAC1E,MAAM,CAER"}

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

@@ -0,0 +1,100 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getDataTypeFromArray, getDataTypeFromValue } from "./data-type.js";
+/**
+ * SCHEMA SUPPORT - AUTODEDUCTION
+ * @param {*} table
+ * @param {*} schema
+ * @returns
+ */
+export function deduceTableSchema(table) {
+    switch (table.shape) {
+        case 'array-row-table':
+        case 'object-row-table':
+            return deduceSchemaFromRows(table.data);
+        case 'geojson-table':
+            return deduceSchemaFromGeoJSON(table.features);
+        case 'columnar-table':
+            return deduceSchemaFromColumns(table.data);
+        case 'arrow-table':
+        default:
+            throw new Error('Deduce schema');
+    }
+}
+export function deduceSchema(data) {
+    return Array.isArray(data) ? deduceSchemaFromRows(data) : deduceSchemaFromColumns(data);
+}
+/** Given an object with columnar arrays, try to deduce a schema */
+function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+        const field = deduceFieldFromColumn(column, columnName);
+        fields.push(field);
+    }
+    return { fields, metadata: {} };
+}
+/** Given an array of rows, try to deduce a schema */
+function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+        throw new Error('deduce from empty table');
+    }
+    const fields = [];
+    const row0 = rowTable[0];
+    // TODO - fields can be nullable, false detection...
+    // Could look at additional rows if nulls in first row
+    // TODO - if array, column names will be numbers
+    for (const [columnName, value] of Object.entries(row0)) {
+        fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+}
+/** Given a GeoJSON, try to deduce a schema */
+function deduceSchemaFromGeoJSON(features) {
+    if (!features.length) {
+        throw new Error('deduce from empty table');
+    }
+    const fields = [];
+    const row0 = features[0].properties || {};
+    // TODO - fields can be nullable, false detection...
+    // Could look at additional rows if nulls in first row
+    // TODO - if array, column names will be numbers
+    for (const [columnName, value] of Object.entries(row0)) {
+        fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+}
+/** Given a column (i.e. array), attempt to deduce an appropriate `Field` */
+function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+        const type = getDataTypeFromArray(column);
+        return {
+            name,
+            type: type.type || 'null',
+            nullable: type.nullable
+            // metadata: {}
+        };
+    }
+    if (Array.isArray(column) && column.length > 0) {
+        const value = column[0];
+        const type = getDataTypeFromValue(value);
+        // TODO - support nested schemas?
+        return {
+            name,
+            type,
+            nullable: true
+            // metadata: {},
+        };
+    }
+    throw new Error('empty table');
+}
+/** Given a value, attempt to deduce an appropriate `Field` */
+function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
+    return {
+        name,
+        type,
+        nullable: true
+        // metadata: {}
+    };
+}

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,36 @@
+// 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

@@ -0,0 +1,43 @@
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-like-interface.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow-api/arrow-like-interface.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAC,6BAA0B;AAE3C;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAS9B,MAAM,IAAI,MAAM,CAAC;IAEjB,KAAK,IAAI,KAAK,CAAC;IAEf,SAAS,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC;IAEhC,QAAQ,QAAG;CACZ;AAED,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAQ9B,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAElC,MAAM,CAAC,GAAG,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAEzC,QAAQ,CAAC,GAAG,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAE7C,MAAM,CAAC,cAAc,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC;CAClD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IAInB,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,MAAM,CAAC;IAIf,IAAI,EAAE,GAAG,CAAC;IAEV,OAAO,EAAE,MAAM,CAAC;IAEhB,MAAM,IAAI,MAAM,CAAC;IAEjB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAAC;CAK/C"}

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

@@ -0,0 +1,4 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export {};

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

@@ -0,0 +1,12 @@
+import type { SchemaMetadata, Field } from '@loaders.gl/schema';
+import { ArrowLikeField } from "./arrow-like-field.js";
+export declare class ArrowLikeSchema {
+    fields: ArrowLikeField[];
+    metadata: Map<string, string>;
+    constructor(fields: ArrowLikeField[] | Field[], metadata?: SchemaMetadata | Map<string, string>);
+    compareTo(other: ArrowLikeSchema): boolean;
+    select(...columnNames: string[]): ArrowLikeSchema;
+    selectAt(...columnIndices: number[]): ArrowLikeSchema;
+    assign(schemaOrFields: ArrowLikeSchema | ArrowLikeField[]): ArrowLikeSchema;
+}
+//# sourceMappingURL=arrow-like-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-like-schema.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow-api/arrow-like-schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,cAAc,EAAE,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAC,cAAc,EAAC,8BAA2B;AAElD,qBAAa,eAAe;IAC1B,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAG5B,MAAM,EAAE,cAAc,EAAE,GAAG,KAAK,EAAE,EAClC,QAAQ,GAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAA6B;IAY5E,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAe1C,MAAM,CAAC,GAAG,WAAW,EAAE,MAAM,EAAE,GAAG,eAAe;IAUjD,QAAQ,CAAC,GAAG,aAAa,EAAE,MAAM,EAAE,GAAG,eAAe;IAMrD,MAAM,CAAC,cAAc,EAAE,eAAe,GAAG,cAAc,EAAE,GAAG,eAAe;CA2B5E"}

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

@@ -0,0 +1,81 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { ArrowLikeField } from "./arrow-like-field.js";
+export class ArrowLikeSchema {
+    fields;
+    metadata;
+    constructor(fields, metadata = new Map()) {
+        // checkNames(fields);
+        // For kepler fields, create arrow compatible `Fields` that have kepler fields as `metadata`
+        this.fields = fields.map((field) => new ArrowLikeField(field.name, field.type, field.nullable, field.metadata));
+        this.metadata =
+            metadata instanceof Map ? metadata : new Map(Object.entries(metadata));
+    }
+    // TODO - arrow only seems to compare fields, not metadata
+    compareTo(other) {
+        if (this.metadata !== other.metadata) {
+            return false;
+        }
+        if (this.fields.length !== other.fields.length) {
+            return false;
+        }
+        for (let i = 0; i < this.fields.length; ++i) {
+            if (!this.fields[i].compareTo(other.fields[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    select(...columnNames) {
+        // Ensure column names reference valid fields
+        const nameMap = Object.create(null);
+        for (const name of columnNames) {
+            nameMap[name] = true;
+        }
+        const selectedFields = this.fields.filter((field) => nameMap[field.name]);
+        return new ArrowLikeSchema(selectedFields, this.metadata);
+    }
+    selectAt(...columnIndices) {
+        // Ensure column indices reference valid fields
+        const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);
+        return new ArrowLikeSchema(selectedFields, this.metadata);
+    }
+    assign(schemaOrFields) {
+        let fields;
+        let metadata = this.metadata;
+        if (schemaOrFields instanceof ArrowLikeSchema) {
+            const otherArrowLikeSchema = schemaOrFields;
+            fields = otherArrowLikeSchema.fields;
+            metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherArrowLikeSchema.metadata);
+        }
+        else {
+            fields = schemaOrFields;
+        }
+        // Create a merged list of fields, overwrite fields in place, new fields at end
+        const fieldMap = Object.create(null);
+        for (const field of this.fields) {
+            fieldMap[field.name] = field;
+        }
+        for (const field of fields) {
+            fieldMap[field.name] = field;
+        }
+        const mergedFields = Object.values(fieldMap);
+        return new ArrowLikeSchema(mergedFields, metadata);
+    }
+}
+// Warn if any duplicated field names
+// function checkNames(fields: Field[]): void {
+//   const usedNames: Record<string, boolean> = {};
+//   for (const field of fields) {
+//     if (usedNames[field.name]) {
+//       // eslint-disable-next-line
+//       console.warn('ArrowLikeSchema: duplicated field name', field.name, field);
+//     }
+//     usedNames[field.name] = true;
+//   }
+// }
+function mergeMaps(m1, m2) {
+    // @ts-ignore
+    return new Map([...(m1 || new Map()), ...(m2 || new Map())]);
+}

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

@@ -0,0 +1,28 @@
+import type { Table } from '@loaders.gl/schema';
+import { ArrowLikeSchema } from "./arrow-like-schema.js";
+declare class ArrowLikeVector {
+    table: Table;
+    columnName: string;
+    constructor(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 declare class ArrowLikeTable {
+    schema: ArrowLikeSchema;
+    table: Table;
+    constructor(table: Table);
+    get data(): any[][] | {
+        [columnName: string]: any;
+    }[] | import("geojson").Feature<import("geojson").Geometry, import("geojson").GeoJsonProperties>[] | {
+        [columnName: string]: ArrayLike<unknown>;
+    } | import("apache-arrow").Table<any>;
+    get numCols(): number;
+    get length(): number;
+    getChild(columnName: string): ArrowLikeVector;
+}
+export {};
+//# sourceMappingURL=arrow-like-table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-like-table.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow-api/arrow-like-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAE9C,OAAO,EAAC,eAAe,EAAC,+BAA4B;AAepD,cAAM,eAAe;IACnB,KAAK,EAAE,KAAK,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;gBAEP,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM;IAK5C,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI9B,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC;CAW9B;AAED;;;GAGG;AACH,qBAAa,cAAc;IACzB,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;gBAED,KAAK,EAAE,KAAK;IAUxB,IAAI,IAAI;;;;0CAEP;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe;CAO9C"}

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

@@ -0,0 +1,63 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { ArrowLikeSchema } from "./arrow-like-schema.js";
+import { deduceTableSchema } from "../../schema/deduce-table-schema.js";
+import { getTableCell, getTableLength, getTableNumCols
+// getTableCell,
+// getTableRowShape,
+// getTableColumnIndex,
+// getTableColumnName,
+// getTableRowAsObject,
+// getTableRowAsArray
+ } from "../tables/table-accessors.js";
+class ArrowLikeVector {
+    table;
+    columnName;
+    constructor(table, columnName) {
+        this.table = table;
+        this.columnName = columnName;
+    }
+    get(rowIndex) {
+        return getTableCell(this.table, rowIndex, this.columnName);
+    }
+    toArray() {
+        switch (this.table.shape) {
+            case 'arrow-table':
+                const arrowTable = this.table.data;
+                return arrowTable.getChild(this.columnName)?.toArray();
+            case 'columnar-table':
+                return this.table.data[this.columnName];
+            default:
+                throw new Error(this.table.shape);
+        }
+    }
+}
+/**
+ * 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 class ArrowLikeTable {
+    schema;
+    table;
+    constructor(table) {
+        const schema = table.schema || deduceTableSchema(table);
+        this.schema = new ArrowLikeSchema(schema.fields, schema.metadata);
+        this.table = { ...table, schema };
+    }
+    // get schema() {
+    //   return this.table.schema;
+    // }
+    get data() {
+        return this.table.shape === 'geojson-table' ? this.table.features : this.table.data;
+    }
+    get numCols() {
+        return getTableNumCols(this.table);
+    }
+    get length() {
+        return getTableLength(this.table);
+    }
+    getChild(columnName) {
+        return new ArrowLikeVector(this.table, columnName);
+    }
+}