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

package/src/lib/table/simple-table/data-type.ts

@@ -1,104 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {DataType} from '../../../types/schema';
-import {TypedArray, TypedArrayConstructor, ArrayType} from '../../../types/types';
-
-/** Deduce column types from values */
-export function getDataTypeFromValue(
-  value: unknown,
-  defaultNumberType: 'float32' = 'float32'
-): DataType {
-  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: ArrayType): {type: DataType; nullable: boolean} {
-  let type = getDataTypeFromTypedArray(array as TypedArray);
-  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: TypedArray): DataType {
-  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: DataType,
-  nullable: boolean | undefined
-): TypedArrayConstructor | ArrayConstructor {
-  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/src/lib/table/simple-table/make-table-from-batches.ts

@@ -1,98 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {Schema} from '../../../types/schema';
-import type {TableBatch, Table, ObjectRowTable, ArrayRowTable} from '../../../types/category-table';
-import type {Feature} from '../../../types/category-gis';
-import {getTableLength} from './table-accessors';
-
-/**
- * Returns an iterator that yields a single table as a sequence of batches.
- * @note Currently only a single batch is yielded.
- * @note All batches will have the same shape and schema as the original table.
- * @returns
- */
-export function* makeBatchesFromTable(table: Table): IterableIterator<TableBatch> {
-  yield makeBatchFromTable(table);
-}
-
-/**
- * Returns a table packaged as a single table batch
- * @note The batch will have the same shape and schema as the original table.
- * @returns `null` if no batches are yielded by the async iterator
- */
-export function makeBatchFromTable(table: Table): TableBatch {
-  return {...table, length: getTableLength(table), batchType: 'data'};
-}
-
-/**
- * Assembles all batches from an async iterator into a single table.
- * @note All batches must have the same shape and schema
- * @param batchIterator
- * @returns `null` if no batches are yielded by the async iterator
- */
-// eslint-disable-next-line complexity
-export async function makeTableFromBatches(
-  batchIterator: AsyncIterable<TableBatch> | Iterable<TableBatch>
-): Promise<Table | null> {
-  let arrayRows: ArrayRowTable['data'];
-  let objectRows: ObjectRowTable['data'];
-  let features: Feature[];
-  let shape: Table['shape'] | null = null;
-  let schema: Schema | undefined;
-
-  for await (const batch of batchIterator) {
-    shape = shape || batch.shape;
-    schema = schema || batch.schema;
-
-    switch (batch.shape) {
-      case 'array-row-table':
-        arrayRows = arrayRows! || [];
-        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
-          const row = batch.data[rowIndex];
-          arrayRows.push(row);
-        }
-        break;
-
-      case 'object-row-table':
-        objectRows = objectRows! || [];
-        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
-          const row = batch.data[rowIndex];
-          objectRows.push(row);
-        }
-        break;
-
-      case 'geojson-table':
-        features = features! || [];
-        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
-          const row = batch.features[rowIndex];
-          features.push(row);
-        }
-        break;
-
-      case 'columnar-table':
-      case 'arrow-table':
-      default:
-        throw new Error('shape');
-    }
-  }
-
-  if (!shape) {
-    return null;
-  }
-
-  switch (shape) {
-    case 'array-row-table':
-      return {shape: 'array-row-table', data: arrayRows!, schema};
-
-    case 'object-row-table':
-      return {shape: 'object-row-table', data: objectRows!, schema};
-
-    case 'geojson-table':
-      return {shape: 'geojson-table', type: 'FeatureCollection', features: features!, schema};
-
-    default:
-      return null;
-  }
-}

package/src/lib/table/simple-table/make-table.ts

@@ -1,111 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {Table, ArrayRowTable, ObjectRowTable, ColumnarTable} from '../../../types/category-table';
-import {deduceTableSchema} from './table-schema';
-
-/**
- * Makes a typed table from data.
- * @throws Row tables must contain at least one row. Columnar tables must contain empty arrays
- */
-export function makeTableFromData(data: unknown[][]): ArrayRowTable;
-export function makeTableFromData(data: {[column: string]: unknown}[]): ObjectRowTable;
-export function makeTableFromData(data: {[column: string]: ArrayLike<unknown>}): ColumnarTable;
-export function makeTableFromData(data: unknown): Table {
-  let table: Table;
-  switch (getTableShapeFromData(data)) {
-    case 'array-row-table':
-      table = {shape: 'array-row-table', data: data as unknown[][]};
-      break;
-    case 'object-row-table':
-      table = {shape: 'object-row-table', data: data as {[key: string]: unknown}[]};
-      break;
-    case 'columnar-table':
-      table = {shape: 'columnar-table', data: data as {[column: string]: ArrayLike<unknown>}};
-      break;
-    default:
-      throw new Error('table');
-  }
-  const schema = deduceTableSchema(table);
-  return {...table, schema};
-}
-
-/** Helper function to get shape of data */
-function getTableShapeFromData(data) {
-  if (Array.isArray(data)) {
-    if (data.length === 0) {
-      throw new Error('cannot deduce type of empty table');
-    }
-
-    // Deduce the table shape from the first row
-    const firstRow = data[0];
-
-    if (Array.isArray(firstRow)) {
-      return 'array-row-table';
-    }
-
-    if (firstRow && typeof firstRow === 'object') {
-      return 'object-row-table';
-    }
-  }
-
-  if (data && typeof data === 'object') {
-    return 'columnar-table';
-  }
-
-  throw new Error('invalid table');
-}
-
-/** Convert any table into object row format *
-export function makeColumnarTable(table: Table): ColumnarTable {
-  if (table.shape === 'columnar-table') {
-    return table;
-  }
-  const length = getTableLength(table);
-  const data = new Array<{[key: string]: unknown}>(length);
-  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-    data[rowIndex] = getTableRowAsObject(table, rowIndex);
-  }
-  return {
-    shape: 'columnar-table',
-    schema: table.schema,
-    data
-  };
-}
-
-
-/** Convert any table into array row format *
-export function makeArrayRowTable(table: TableLike): ArrayRowTable {
-  if (table.shape === 'array-row-table') {
-    return table;
-  }
-  const length = getTableLength(table);
-  const data = new Array<unknown[]>(length);
-  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-    data[rowIndex] = getTableRowAsArray(table, rowIndex);
-  }
-  return {
-    shape: 'array-row-table',
-    schema: table.schema,
-    data
-  };
-}
-
-/** Convert any table into object row format *
-export function makeObjectRowTable(table: Table): ObjectRowTable {
-  if (table.shape === 'object-row-table') {
-    return table;
-  }
-  const length = getTableLength(table);
-  const data = new Array<{[key: string]: unknown}>(length);
-  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-    data[rowIndex] = getTableRowAsObject(table, rowIndex);
-  }
-  return {
-    shape: 'object-row-table',
-    schema: table.schema,
-    data
-  };
-}
-*/

package/src/lib/table/simple-table/row-utils.ts

@@ -1,59 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/** Convert an object row to an array row */
-export function convertToObjectRow(
-  arrayRow: unknown[],
-  headers: string[] | null
-): {[columnName: string]: unknown} {
-  if (!arrayRow) {
-    throw new Error('null row');
-  }
-  const objectRow: {[columnName: string]: unknown} = {};
-  if (headers) {
-    for (let i = 0; i < headers.length; i++) {
-      objectRow[headers[i]] = arrayRow[i];
-    }
-  } else {
-    for (let i = 0; i < arrayRow.length; i++) {
-      const columnName = `column-${i}`;
-      objectRow[columnName] = arrayRow[i];
-    }
-  }
-  return objectRow;
-}
-
-/** Convert an object row to an array row */
-export function convertToArrayRow(
-  objectRow: {[columnName: string]: unknown},
-  headers: string[] | null
-): unknown[] {
-  if (!objectRow) {
-    throw new Error('null row');
-  }
-
-  if (headers) {
-    const arrayRow = new Array(headers.length);
-    for (let i = 0; i < headers.length; i++) {
-      arrayRow[i] = objectRow[headers[i]];
-    }
-    return arrayRow;
-  }
-  return Object.values(objectRow);
-}
-
-/** Get headers from a sample array row */
-export function inferHeadersFromArrayRow(arrayRow: unknown[]) {
-  const headers: string[] = [];
-  for (let i = 0; i < arrayRow.length; i++) {
-    const columnName = `column-${i}`;
-    headers.push(columnName);
-  }
-  return headers;
-}
-
-/** Get headers from a smaple object row */
-export function inferHeadersFromObjectRow(row: {[columnName: string]: unknown}) {
-  return Object.keys(row);
-}