@loaders.gl/schema 4.0.0-alpha.23 → 4.0.0-alpha.24

package/dist/lib/table/simple-table/data-type.js

@@ -1,93 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getArrayTypeFromDataType = exports.getDataTypeFromTypedArray = exports.getDataTypeFromArray = exports.getDataTypeFromValue = void 0;
-/** Deduce column types from values */
-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';
-}
-exports.getDataTypeFromValue = getDataTypeFromValue;
-/**
- * Deduces a simple data type "descriptor from a typed array instance
- */
-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 };
-}
-exports.getDataTypeFromArray = getDataTypeFromArray;
-/**
- * Deduces a simple data type "descriptor from a typed array instance
- */
-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';
-    }
-}
-exports.getDataTypeFromTypedArray = getDataTypeFromTypedArray;
-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;
-}
-exports.getArrayTypeFromDataType = getArrayTypeFromDataType;

package/dist/lib/table/simple-table/make-table.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTableFromData = void 0;
-const table_schema_1 = require("./table-schema");
-function makeTableFromData(data) {
-    let table;
-    switch (getTableShapeFromData(data)) {
-        case 'array-row-table':
-            table = { shape: 'array-row-table', data: data };
-            break;
-        case 'object-row-table':
-            table = { shape: 'object-row-table', data: data };
-            break;
-        case 'columnar-table':
-            table = { shape: 'columnar-table', data: data };
-            break;
-        default:
-            throw new Error('table');
-    }
-    const schema = (0, table_schema_1.deduceTableSchema)(table);
-    return { ...table, schema };
-}
-exports.makeTableFromData = makeTableFromData;
-/** 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/dist/lib/table/simple-table/row-utils.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToArrayRow = exports.convertToObjectRow = void 0;
-/** Convert an object row to an array row */
-function convertToObjectRow(arrayRow, headers) {
-    if (!arrayRow) {
-        throw new Error('null row');
-    }
-    if (!headers) {
-        throw new Error('no headers');
-    }
-    const objectRow = {};
-    for (let i = 0; i < headers.length; i++) {
-        objectRow[headers[i]] = arrayRow[i];
-    }
-    return objectRow;
-}
-exports.convertToObjectRow = convertToObjectRow;
-/** Convert an object row to an array row */
-function convertToArrayRow(objectRow, headers) {
-    if (!objectRow) {
-        throw new Error('null row');
-    }
-    if (!headers) {
-        throw new Error('no headers');
-    }
-    const arrayRow = new Array(headers.length);
-    for (let i = 0; i < headers.length; i++) {
-        arrayRow[i] = objectRow[headers[i]];
-    }
-    return arrayRow;
-}
-exports.convertToArrayRow = convertToArrayRow;

package/dist/lib/table/simple-table/table-accessors.js

@@ -1,319 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeObjectRowIterator = exports.makeArrayRowIterator = exports.makeRowIterator = exports.makeColumnarTable = exports.makeObjectRowTable = exports.makeArrayRowTable = exports.getTableRowAsArray = exports.getTableRowAsObject = exports.getTableColumnName = exports.getTableColumnIndex = exports.getTableRowShape = exports.getTableCellAt = exports.getTableCell = exports.getTableNumCols = exports.getTableLength = void 0;
-/**
- * Returns the length of the table (i.e. the number of rows)
- */
-function getTableLength(table) {
-    switch (table.shape) {
-        case 'array-row-table':
-        case 'object-row-table':
-        case 'geojson-row-table':
-            return table.data.length;
-        case 'arrow-table':
-            return table.data.numRows;
-        case 'columnar-table':
-            for (const column of Object.values(table.data)) {
-                return column.length || 0;
-            }
-            return 0;
-        default:
-            throw new Error('table');
-    }
-}
-exports.getTableLength = getTableLength;
-/**
- * Returns the number of columns in the table
- * @throws Fails to deduce number of columns if the table has no schema and is empty
- */
-function getTableNumCols(table) {
-    if (table.schema) {
-        return table.schema.fields.length;
-    }
-    if (getTableLength(table) === 0) {
-        throw new Error('empty table');
-    }
-    switch (table.shape) {
-        case 'array-row-table':
-            return table.data[0].length;
-        case 'object-row-table':
-        case 'geojson-row-table':
-            return Object.keys(table.data[0]).length;
-        case 'columnar-table':
-            return Object.keys(table.data).length;
-        case 'arrow-table':
-            return table.data.numCols;
-        default:
-            throw new Error('table');
-    }
-}
-exports.getTableNumCols = getTableNumCols;
-/** Get a table cell value at row index and column name */
-function getTableCell(table, rowIndex, columnName) {
-    switch (table.shape) {
-        case 'array-row-table':
-            const columnIndex = getTableColumnIndex(table, columnName);
-            return table.data[rowIndex][columnIndex];
-        case 'object-row-table':
-        case 'geojson-row-table':
-            return table.data[rowIndex][columnName];
-        case 'columnar-table':
-            const column = table.data[columnName];
-            return column[rowIndex];
-        case 'arrow-table':
-            const arrowColumnIndex = table.data.schema.fields.findIndex((field) => field.name === columnName);
-            return table.data.getChildAt(arrowColumnIndex)?.get(rowIndex);
-        default:
-            throw new Error('todo');
-    }
-}
-exports.getTableCell = getTableCell;
-/** Get a table cell value at row index and column name */
-function getTableCellAt(table, rowIndex, columnIndex) {
-    switch (table.shape) {
-        case 'array-row-table':
-            return table.data[rowIndex][columnIndex];
-        case 'object-row-table':
-        case 'geojson-row-table':
-            let columnName = getTableColumnName(table, columnIndex);
-            return table.data[rowIndex][columnName];
-        case 'columnar-table':
-            columnName = getTableColumnName(table, columnIndex);
-            const column = table.data[columnName];
-            return column[rowIndex];
-        case 'arrow-table':
-            return table.data.getChildAt(columnIndex)?.get(rowIndex);
-        default:
-            throw new Error('todo');
-    }
-}
-exports.getTableCellAt = getTableCellAt;
-/** Deduce the table row shape */
-function getTableRowShape(table) {
-    switch (table.shape) {
-        case 'array-row-table':
-        case 'object-row-table':
-            return table.shape;
-        case 'geojson-row-table':
-            return 'object-row-table';
-        case 'columnar-table':
-        default:
-            throw new Error('Not a row table');
-    }
-}
-exports.getTableRowShape = getTableRowShape;
-/** Get the index of a named table column. Requires the table to have a schema */
-function getTableColumnIndex(table, columnName) {
-    const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
-    if (columnIndex === undefined) {
-        throw new Error(columnName);
-    }
-    return columnIndex;
-}
-exports.getTableColumnIndex = getTableColumnIndex;
-/** Get the name of a table column by index. Requires the table to have a schema */
-function getTableColumnName(table, columnIndex) {
-    const columnName = table.schema?.fields[columnIndex]?.name;
-    if (!columnName) {
-        throw new Error(`${columnIndex}`);
-    }
-    return columnName;
-}
-exports.getTableColumnName = getTableColumnName;
-/**
- * Returns one row of the table in object format.
- * @param target Optional parameter will be used if needed to store the row. Can be reused between calls to improve performance
- * @returns an array representing the row. May be the original array in the row, a new object, or the target parameter
- */
-// eslint-disable-next-line complexity
-function getTableRowAsObject(table, rowIndex, target, copy) {
-    switch (table.shape) {
-        case 'object-row-table':
-            return copy ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
-        case 'array-row-table':
-        case 'geojson-row-table':
-            if (table.schema) {
-                const objectRow = target || {};
-                for (let i = 0; i < table.schema.fields.length; i++) {
-                    objectRow[table.schema.fields[i].name] = table.data[rowIndex][i];
-                }
-                return objectRow;
-            }
-            throw new Error('no schema');
-        case 'columnar-table':
-            if (table.schema) {
-                const objectRow = target || {};
-                for (let i = 0; i < table.schema.fields.length; i++) {
-                    objectRow[table.schema.fields[i].name] =
-                        table.data[table.schema.fields[i].name][rowIndex];
-                }
-                return objectRow;
-            }
-            else {
-                // eslint-disable-line no-else-return
-                const objectRow = target || {};
-                for (const [name, column] of Object.entries(table.data)) {
-                    objectRow[name] = column[rowIndex];
-                }
-                return objectRow;
-            }
-        case 'arrow-table':
-            const objectRow = target || {};
-            const row = table.data.get(rowIndex);
-            const schema = table.data.schema;
-            for (let i = 0; i < schema.fields.length; i++) {
-                objectRow[schema.fields[i].name] = row?.[schema.fields[i].name];
-            }
-            return objectRow;
-        default:
-            throw new Error('shape');
-    }
-}
-exports.getTableRowAsObject = getTableRowAsObject;
-/**
- * Returns one row of the table in array format.
- * @param target Optional parameter will be used if needed to store the row. Can be reused between calls to improve performance.
- * @returns an array representing the row. May be the original array in the row, a new object, or the target parameter
- */
-// eslint-disable-next-line complexity
-function getTableRowAsArray(table, rowIndex, target, copy) {
-    switch (table.shape) {
-        case 'array-row-table':
-            return copy ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
-        case 'object-row-table':
-        case 'geojson-row-table':
-            if (table.schema) {
-                const arrayRow = target || [];
-                for (let i = 0; i < table.schema.fields.length; i++) {
-                    arrayRow[i] = table.data[rowIndex][table.schema.fields[i].name];
-                }
-                return arrayRow;
-            }
-            // Warning: just slap on the values, this risks mismatches between rows
-            return Object.values(table.data[rowIndex]);
-        case 'columnar-table':
-            if (table.schema) {
-                const arrayRow = target || [];
-                for (let i = 0; i < table.schema.fields.length; i++) {
-                    arrayRow[i] = table.data[table.schema.fields[i].name][rowIndex];
-                }
-                return arrayRow;
-            }
-            else {
-                // eslint-disable-line no-else-return
-                const arrayRow = target || [];
-                let i = 0;
-                for (const column of Object.values(table.data)) {
-                    arrayRow[i] = column[rowIndex];
-                    i++;
-                }
-                return arrayRow;
-            }
-        case 'arrow-table':
-            const arrayRow = target || [];
-            const row = table.data.get(rowIndex);
-            const schema = table.data.schema;
-            for (let i = 0; i < schema.fields.length; i++) {
-                arrayRow[i] = row?.[schema.fields[i].name];
-            }
-            return arrayRow;
-        default:
-            throw new Error('shape');
-    }
-}
-exports.getTableRowAsArray = getTableRowAsArray;
-/** Convert any table into array row format */
-function makeArrayRowTable(table) {
-    if (table.shape === 'array-row-table') {
-        return table;
-    }
-    const length = getTableLength(table);
-    const data = new Array(length);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-        data[rowIndex] = getTableRowAsArray(table, rowIndex);
-    }
-    return {
-        shape: 'array-row-table',
-        schema: table.schema,
-        data
-    };
-}
-exports.makeArrayRowTable = makeArrayRowTable;
-/** Convert any table into object row format */
-function makeObjectRowTable(table) {
-    if (table.shape === 'object-row-table') {
-        return table;
-    }
-    const length = getTableLength(table);
-    const data = new Array(length);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-        data[rowIndex] = getTableRowAsObject(table, rowIndex);
-    }
-    return {
-        shape: 'object-row-table',
-        schema: table.schema,
-        data
-    };
-}
-exports.makeObjectRowTable = makeObjectRowTable;
-/** Convert any table into object row format */
-function makeColumnarTable(table) {
-    if (table.shape === 'object-row-table') {
-        return table;
-    }
-    const length = getTableLength(table);
-    const data = new Array(length);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-        data[rowIndex] = getTableRowAsObject(table, rowIndex);
-    }
-    return {
-        shape: 'object-row-table',
-        schema: table.schema,
-        data
-    };
-}
-exports.makeColumnarTable = makeColumnarTable;
-// Row Iterators
-/**
- * Iterate over table rows
- * @param table
- * @param shape
- */
-function* makeRowIterator(table, shape) {
-    switch (shape) {
-        case 'array-row-table':
-            yield* makeArrayRowIterator(table);
-            break;
-        case 'object-row-table':
-            yield* makeObjectRowIterator(table);
-            break;
-        default:
-            throw new Error(`Unknown row type ${shape}`);
-    }
-}
-exports.makeRowIterator = makeRowIterator;
-/**
- * Streaming processing: Iterate over table, yielding array rows
- * @param table
- * @param shape
- */
-function* makeArrayRowIterator(table, target = []) {
-    const length = getTableLength(table);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-        yield getTableRowAsArray(table, rowIndex, target);
-    }
-}
-exports.makeArrayRowIterator = makeArrayRowIterator;
-/**
- * Streaming processing: Iterate over table, yielding object rows
- * @param table
- * @param shape
- */
-function* makeObjectRowIterator(table, target = {}) {
-    const length = getTableLength(table);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-        yield getTableRowAsObject(table, rowIndex, target);
-    }
-}
-exports.makeObjectRowIterator = makeObjectRowIterator;

package/dist/lib/table/simple-table/table-column.js

@@ -1,41 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeColumnFromField = void 0;
-const data_type_1 = require("./data-type");
-function makeColumnFromField(field, length) {
-    const ArrayType = (0, data_type_1.getArrayTypeFromDataType)(field.type, field.nullable);
-    return new ArrayType(length);
-}
-exports.makeColumnFromField = makeColumnFromField;
-/*
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function deduceSchema(rows) {
-  const row = rows[0];
-
-  const schema = {};
-  let i = 0;
-  for (const columnName in row) {
-    const value = row[columnName];
-    switch (typeof value) {
-      case 'number':
-      case 'boolean':
-        // TODO - booleans could be handled differently...
-        schema[columnName] = {name: String(columnName), index: i, type: Float32Array};
-        break;
-
-      case 'object':
-        schema[columnName] = {name: String(columnName), index: i, type: Array};
-        break;
-
-      case 'string':
-      default:
-        schema[columnName] = {name: String(columnName), index: i, type: Array};
-      // We currently only handle numeric rows
-      // TODO we could offer a function to map strings to numbers?
-    }
-    i++;
-  }
-  return schema;
-}
-*/

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

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deduceSchema = exports.deduceTableSchema = void 0;
-const data_type_1 = require("./data-type");
-/**
- * SCHEMA SUPPORT - AUTODEDUCTION
- * @param {*} table
- * @param {*} schema
- * @returns
- */
-function deduceTableSchema(table) {
-    switch (table.shape) {
-        case 'array-row-table':
-        case 'object-row-table':
-            return deduceSchemaFromRows(table.data);
-        case 'columnar-table':
-            return deduceSchemaFromColumns(table.data);
-        case 'arrow-table':
-        default:
-            throw new Error('Deduce schema');
-    }
-}
-exports.deduceTableSchema = deduceTableSchema;
-function deduceSchema(data) {
-    return Array.isArray(data) ? deduceSchemaFromRows(data) : deduceSchemaFromColumns(data);
-}
-exports.deduceSchema = deduceSchema;
-/** 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 column (i.e. array), attempt to deduce an appropriate `Field` */
-function deduceFieldFromColumn(column, name) {
-    if (ArrayBuffer.isView(column)) {
-        const type = (0, data_type_1.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 = (0, data_type_1.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 = (0, data_type_1.getDataTypeFromValue)(value);
-    return {
-        name,
-        type,
-        nullable: true
-        // metadata: {}
-    };
-}

package/dist/lib/utils/assert.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = void 0;
-// Replacement for the external assert method to reduce bundle size
-// Note: We don't use the second "message" argument in calling code,
-// so no need to support it here
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(message || 'loader assertion failed.');
-    }
-}
-exports.assert = assert;