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

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

@@ -0,0 +1,350 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export function isTable(table) {
+    const shape = typeof table === 'object' && table?.shape;
+    switch (shape) {
+        case 'array-row-table':
+        case 'object-row-table':
+            return Array.isArray(table.data);
+        case 'geojson-table':
+            return Array.isArray(table.features);
+        case 'columnar-table':
+            return table.data && typeof table.data === 'object';
+        case 'arrow-table':
+            return Boolean(table?.data?.numRows !== undefined);
+        default:
+            return false;
+    }
+}
+/**
+ * Returns the length of the table (i.e. the number of rows)
+ */
+export function getTableLength(table) {
+    switch (table.shape) {
+        case 'array-row-table':
+        case 'object-row-table':
+            return table.data.length;
+        case 'geojson-table':
+            return table.features.length;
+        case 'arrow-table':
+            const arrowTable = table.data;
+            return arrowTable.numRows;
+        case 'columnar-table':
+            for (const column of Object.values(table.data)) {
+                return column.length || 0;
+            }
+            return 0;
+        default:
+            throw new Error('table');
+    }
+}
+/**
+ * Returns the number of columns in the table
+ * @throws Fails to deduce number of columns if the table has no schema and is empty
+ */
+export 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':
+            return Object.keys(table.data[0]).length;
+        case 'geojson-table':
+            return Object.keys(table.features[0]).length;
+        case 'columnar-table':
+            return Object.keys(table.data).length;
+        case 'arrow-table':
+            const arrowTable = table.data;
+            return arrowTable.numCols;
+        default:
+            throw new Error('table');
+    }
+}
+/** Get a table cell value at row index and column name */
+export 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':
+            return table.data[rowIndex][columnName];
+        case 'geojson-table':
+            return table.features[rowIndex][columnName];
+        case 'columnar-table':
+            const column = table.data[columnName];
+            return column[rowIndex];
+        case 'arrow-table':
+            const arrowTable = table.data;
+            const arrowColumnIndex = arrowTable.schema.fields.findIndex((field) => field.name === columnName);
+            return arrowTable.getChildAt(arrowColumnIndex)?.get(rowIndex);
+        default:
+            throw new Error('todo');
+    }
+}
+/** Get a table cell value at row index and column name */
+export function getTableCellAt(table, rowIndex, columnIndex) {
+    switch (table.shape) {
+        case 'array-row-table':
+            return table.data[rowIndex][columnIndex];
+        case 'object-row-table':
+            const columnName1 = getTableColumnName(table, columnIndex);
+            return table.data[rowIndex][columnName1];
+        case 'geojson-table':
+            const columnName2 = getTableColumnName(table, columnIndex);
+            return table.features[rowIndex][columnName2];
+        case 'columnar-table':
+            const columnName3 = getTableColumnName(table, columnIndex);
+            const column = table.data[columnName3];
+            return column[rowIndex];
+        case 'arrow-table':
+            const arrowTable = table.data;
+            return arrowTable.getChildAt(columnIndex)?.get(rowIndex);
+        default:
+            throw new Error('todo');
+    }
+}
+/** Deduce the table row shape */
+export function getTableRowShape(table) {
+    switch (table.shape) {
+        case 'array-row-table':
+        case 'object-row-table':
+            return table.shape;
+        case 'geojson-table':
+            // TODO - this is not correct, geojson-table is not a row table
+            return 'object-row-table';
+        case 'columnar-table':
+        default:
+            throw new Error('Not a row table');
+    }
+}
+/** Get the index of a named table column. Requires the table to have a schema */
+export function getTableColumnIndex(table, columnName) {
+    const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
+    if (columnIndex === undefined) {
+        throw new Error(columnName);
+    }
+    return columnIndex;
+}
+/** Get the name of a table column by index. Requires the table to have a schema */
+export function getTableColumnName(table, columnIndex) {
+    const columnName = table.schema?.fields[columnIndex]?.name;
+    if (!columnName) {
+        throw new Error(`${columnIndex}`);
+    }
+    return columnName;
+}
+/**
+ * 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
+export 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':
+            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 'geojson-table':
+            if (table.schema) {
+                const objectRow = target || {};
+                // TODO - should lift properties to top level
+                for (let i = 0; i < table.schema.fields.length; i++) {
+                    objectRow[table.schema.fields[i].name] = table.features[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 arrowTable = table.data;
+            const objectRow = target || {};
+            const row = arrowTable.get(rowIndex);
+            const schema = arrowTable.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');
+    }
+}
+/**
+ * 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
+export 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':
+            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 'geojson-table':
+            if (table.schema) {
+                const arrayRow = target || [];
+                // TODO - should lift properties to top level
+                for (let i = 0; i < table.schema.fields.length; i++) {
+                    arrayRow[i] = table.features[rowIndex][table.schema.fields[i].name];
+                }
+                return arrayRow;
+            }
+            // Warning: just slap on the values, this risks mismatches between rows
+            return Object.values(table.features[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 arrowTable = table.data;
+            const arrayRow = target || [];
+            const row = arrowTable.get(rowIndex);
+            const schema = arrowTable.schema;
+            for (let i = 0; i < schema.fields.length; i++) {
+                arrayRow[i] = row?.[schema.fields[i].name];
+            }
+            return arrayRow;
+        default:
+            throw new Error('shape');
+    }
+}
+/** Convert any table into array row format */
+export 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
+    };
+}
+/** Convert any table into object row format */
+export 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
+    };
+}
+/** Convert any table into object row format */
+export 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
+    };
+}
+// Row Iterators
+/**
+ * Iterate over table rows
+ * @param table
+ * @param shape
+ */
+export 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}`);
+    }
+}
+/**
+ * Streaming processing: Iterate over table, yielding array rows
+ * @param table
+ * @param shape
+ */
+export function* makeArrayRowIterator(table, target = []) {
+    const length = getTableLength(table);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        yield getTableRowAsArray(table, rowIndex, target);
+    }
+}
+/**
+ * Streaming processing: Iterate over table, yielding object rows
+ * @param table
+ * @param shape
+ */
+export function* makeObjectRowIterator(table, target = {}) {
+    const length = getTableLength(table);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        yield getTableRowAsObject(table, rowIndex, target);
+    }
+}

package/dist/lib/table/tables/table-column.d.ts

@@ -0,0 +1,7 @@
+import type { Field } from '@loaders.gl/schema';
+export interface ArrayType<T = unknown> {
+    readonly length: number;
+    [n: number]: T;
+}
+export declare function makeColumnFromField(field: Field, length: number): ArrayType;
+//# sourceMappingURL=table-column.d.ts.map

package/dist/lib/table/tables/table-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-column.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/tables/table-column.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAG9C,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;CAChB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAG3E"}

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

@@ -0,0 +1,39 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getArrayTypeFromDataType } from "../../schema/data-type.js";
+export function makeColumnFromField(field, length) {
+    const ArrayType = getArrayTypeFromDataType(field.type, field.nullable);
+    return new ArrayType(length);
+}
+/*
+// 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/tables/table-types.d.ts

@@ -0,0 +1,12 @@
+import type { Table, ObjectRowTable, ArrayRowTable, ColumnarTable, GeoJSONTable, ArrowTable } from '@loaders.gl/schema';
+/** Checks if a table is of array row layout */
+export declare function isArrayRowTable(table: Table): table is ArrayRowTable;
+/** Checks if a table is of array row layout */
+export declare function isObjectRowTable(table: Table): table is ObjectRowTable;
+/** Checks if a table is of columnar layout */
+export declare function isColumnarTable(table: Table): table is ColumnarTable;
+/** Checks if a table is of GeoJSON format */
+export declare function isGeoJSONTable(table: Table): table is GeoJSONTable;
+/** Checks if table wraps an Apache Arrow table */
+export declare function isArrowTable(table: Table): table is ArrowTable;
+//# sourceMappingURL=table-types.d.ts.map

package/dist/lib/table/tables/table-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-types.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/tables/table-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,KAAK,EACL,cAAc,EACd,aAAa,EACb,aAAa,EACb,YAAY,EACZ,UAAU,EACX,MAAM,oBAAoB,CAAC;AAE5B,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,aAAa,CAEpE;AAED,+CAA+C;AAC/C,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,cAAc,CAEtE;AAED,8CAA8C;AAC9C,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,aAAa,CAEpE;AAED,6CAA6C;AAC7C,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,YAAY,CAElE;AAED,kDAAkD;AAClD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,UAAU,CAE9D"}

package/dist/lib/table/tables/table-types.js

@@ -0,0 +1,23 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Checks if a table is of array row layout */
+export function isArrayRowTable(table) {
+    return table.shape === 'array-row-table';
+}
+/** Checks if a table is of array row layout */
+export function isObjectRowTable(table) {
+    return table.shape === 'object-row-table';
+}
+/** Checks if a table is of columnar layout */
+export function isColumnarTable(table) {
+    return table.shape === 'columnar-table';
+}
+/** Checks if a table is of GeoJSON format */
+export function isGeoJSONTable(table) {
+    return table.shape === 'geojson-table';
+}
+/** Checks if table wraps an Apache Arrow table */
+export function isArrowTable(table) {
+    return table.shape === 'arrow-table';
+}

package/dist/lib/utils/assert.d.ts

@@ -0,0 +1,2 @@
+export declare function assert(condition: boolean, message?: string): void;
+//# sourceMappingURL=assert.d.ts.map

package/dist/lib/utils/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/assert.ts"],"names":[],"mappings":"AAGA,wBAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,QAI1D"}

package/dist/lib/utils/assert.js

@@ -0,0 +1,8 @@
+// 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
+export function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'loader assertion failed.');
+    }
+}

package/dist/lib/utils/async-queue.d.ts

@@ -0,0 +1,18 @@
+export default class AsyncQueue<T> {
+    private _values;
+    private _settlers;
+    private _closed;
+    constructor();
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    enqueue(value: T | Error): void;
+    /**
+     * @returns a Promise for an IteratorResult
+     */
+    next(): Promise<any>;
+}
+/**
+ * @returns a Promise for an Array with the elements in `asyncIterable`
+ */
+export declare function takeAsync(asyncIterable: AsyncIterable<any>, count?: number): Promise<any[]>;
+//# sourceMappingURL=async-queue.d.ts.map

package/dist/lib/utils/async-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-queue.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/async-queue.ts"],"names":[],"mappings":"AAcA,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,CAAC;IAC/B,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,SAAS,CAA8E;IAC/F,OAAO,CAAC,OAAO,CAAU;;IAazB,KAAK,IAAI,IAAI;IAOb,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;IAI1C,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,KAAK,GAAG,IAAI;IAoB/B;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;CAoBrB;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,aAAa,EAAE,aAAa,CAAC,GAAG,CAAC,EACjC,KAAK,SAAW,GACf,OAAO,CAAC,GAAG,EAAE,CAAC,CAWhB"}

package/dist/lib/utils/async-queue.js

@@ -0,0 +1,90 @@
+// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license
+// http://2ality.com/2016/10/asynchronous-iteration.html
+class ArrayQueue extends Array {
+    enqueue(value) {
+        // Add at the end
+        return this.push(value);
+    }
+    dequeue() {
+        // Remove first element
+        return this.shift();
+    }
+}
+export default class AsyncQueue {
+    _values;
+    _settlers;
+    _closed;
+    constructor() {
+        // enqueues > dequeues
+        this._values = new ArrayQueue();
+        // dequeues > enqueues
+        this._settlers = new ArrayQueue();
+        this._closed = false;
+    }
+    close() {
+        while (this._settlers.length > 0) {
+            this._settlers.dequeue().resolve({ done: true });
+        }
+        this._closed = true;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    enqueue(value) {
+        if (this._closed) {
+            throw new Error('Closed');
+        }
+        if (this._settlers.length > 0) {
+            if (this._values.length > 0) {
+                throw new Error('Illegal internal state');
+            }
+            const settler = this._settlers.dequeue();
+            if (value instanceof Error) {
+                settler.reject(value);
+            }
+            else {
+                settler.resolve({ value });
+            }
+        }
+        else {
+            this._values.enqueue(value);
+        }
+    }
+    /**
+     * @returns a Promise for an IteratorResult
+     */
+    next() {
+        if (this._values.length > 0) {
+            const value = this._values.dequeue();
+            if (value instanceof Error) {
+                return Promise.reject(value);
+            }
+            return Promise.resolve({ value });
+        }
+        if (this._closed) {
+            if (this._settlers.length > 0) {
+                throw new Error('Illegal internal state');
+            }
+            return Promise.resolve({ done: true });
+        }
+        // Wait for new values to be enqueued
+        return new Promise((resolve, reject) => {
+            this._settlers.enqueue({ resolve, reject });
+        });
+    }
+}
+/**
+ * @returns a Promise for an Array with the elements in `asyncIterable`
+ */
+export async function takeAsync(asyncIterable, count = Infinity) {
+    const result = [];
+    const iterator = asyncIterable[Symbol.asyncIterator]();
+    while (result.length < count) {
+        const { value, done } = await iterator.next();
+        if (done) {
+            break;
+        }
+        result.push(value);
+    }
+    return result;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,15 @@
+/** Any typed array */
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
+export type BigTypedArray = TypedArray | BigInt64Array | BigUint64Array;
+export type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+export type BigTypedArrayConstructor = TypedArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor;
+/** Any numeric array: typed array or `number[]` */
+export type NumberArray = number[] | TypedArray;
+export type NumericArray = number[] | TypedArray;
+export interface ArrayType<T = unknown> {
+    readonly length: number;
+    [n: number]: T;
+}
+/** Any array: typed array or js array (`any[]`) */
+export type AnyArray = any[] | TypedArray;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":"AAIA,sBAAsB;AACtB,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,GACX,iBAAiB,GACjB,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,aAAa,GAAG,cAAc,CAAC;AAExE,MAAM,MAAM,qBAAqB,GAC7B,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B,MAAM,MAAM,wBAAwB,GAChC,qBAAqB,GACrB,wBAAwB,GACxB,yBAAyB,CAAC;AAE9B,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,MAAM,EAAE,GAAG,UAAU,CAAC;AAEhD,MAAM,MAAM,YAAY,GAAG,MAAM,EAAE,GAAG,UAAU,CAAC;AAEjD,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;CAChB;AAED,mDAAmD;AACnD,MAAM,MAAM,QAAQ,GAAG,GAAG,EAAE,GAAG,UAAU,CAAC"}

package/dist/types/types.js

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

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@loaders.gl/schema-utils",
+  "version": "4.4.0-alpha.1",
+  "description": "Schema-related utilities for loaders.gl...",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/visgl/loaders.gl"
+  },
+  "keywords": [
+    "webgl",
+    "loader",
+    "3d",
+    "mesh",
+    "point cloud",
+    "PLY"
+  ],
+  "types": "dist/index.d.ts",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "pre-build": "npm run build-bundle && npm run build-bundle-dev",
+    "build-bundle": "ocular-bundle ./bundle.ts --output=dist/dist.min.js",
+    "build-bundle-dev": "ocular-bundle ./bundle.ts --env=dev --output=dist/dist.dev.js"
+  },
+  "dependencies": {
+    "@loaders.gl/schema": "4.4.0-alpha.1",
+    "@types/geojson": "^7946.0.7",
+    "apache-arrow": ">= 15.0.0"
+  },
+  "peerDependencies": {
+    "@loaders.gl/core": "4.4.0-alpha.0"
+  },
+  "gitHead": "f1732de45907bd500bf4eedb4803beca8bf4bfb0"
+}