@loaders.gl/schema 3.1.0-alpha.4 → 3.1.0-alpha.5

package/dist/bundle.d.ts

@@ -0,0 +1 @@
+declare const moduleExports: any;

package/dist/category/common.d.ts

@@ -0,0 +1,18 @@
+import type { RecordBatch } from 'apache-arrow';
+export declare type Field = any;
+export declare type Schema = {
+    [key: string]: Field;
+};
+export declare type Batch = {
+    batchType: 'data' | 'metadata' | 'partial-result' | 'final-result';
+    mimeType?: string;
+    shape: string;
+    data: any;
+    recordBatch?: RecordBatch;
+    length: number;
+    schema?: Schema;
+    bytesUsed?: number;
+    count?: number;
+    cursor?: number;
+    [key: string]: any;
+};

package/dist/category/gis.d.ts

@@ -0,0 +1,50 @@
+import type { TypedArray } from '../types';
+export type { GeoJSON, Feature, Geometry, Position, GeoJsonProperties } from 'geojson';
+export type { Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon } from 'geojson';
+export declare type BinaryAttribute = {
+    value: TypedArray;
+    size: number;
+};
+export declare type BinaryGeometryType = 'Point' | 'LineString' | 'Polygon';
+declare type NumericProps = {
+    [key: string]: BinaryAttribute;
+};
+declare type Properties = object[];
+/**
+ * Represent a single Geometry, similar to a GeoJSON Geometry
+ */
+export declare type BinaryGeometry = BinaryPointGeometry | BinaryLineGeometry | BinaryPolygonGeometry;
+export declare type BinaryPointGeometry = {
+    type: 'Point';
+    positions: BinaryAttribute;
+};
+export declare type BinaryLineGeometry = {
+    type: 'LineString';
+    positions: BinaryAttribute;
+    pathIndices: BinaryAttribute;
+};
+export declare type BinaryPolygonGeometry = {
+    type: 'Polygon';
+    positions: BinaryAttribute;
+    polygonIndices: BinaryAttribute;
+    primitivePolygonIndices: BinaryAttribute;
+};
+export declare type BinaryProperties = {
+    featureIds: BinaryAttribute;
+    globalFeatureIds: BinaryAttribute;
+    numericProps: NumericProps;
+    properties: Properties;
+    fields?: Properties;
+};
+export declare type BinaryPointFeatures = BinaryPointGeometry & BinaryProperties;
+export declare type BinaryLineFeatures = BinaryLineGeometry & BinaryProperties;
+export declare type BinaryPolygonFeatures = BinaryPolygonGeometry & BinaryProperties;
+/**
+ * Represent a collection of Features, similar to a GeoJSON FeatureCollection
+ */
+export declare type BinaryFeatures = {
+    type?: BinaryGeometryType;
+    points?: BinaryPointFeatures;
+    lines?: BinaryLineFeatures;
+    polygons?: BinaryPolygonFeatures;
+};

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

@@ -0,0 +1,14 @@
+import type { Mesh } from './mesh-types';
+import type { ColumnarTable, ArrowTable } from '../table/table-types';
+declare 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 {};

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

@@ -0,0 +1,23 @@
+import { MeshAttribute, MeshAttributes } from './mesh-types';
+import { Schema, Field } from '../../lib/schema';
+/**
+ * Create a schema for mesh attributes data
+ * @param attributes
+ * @param metadata
+ * @returns
+ */
+export declare function deduceMeshSchema(attributes: MeshAttributes, metadata?: Map<string, string>): Schema;
+/**
+ * Create arrow-like schema field for mesh attribute
+ * @param attributeName
+ * @param attribute
+ * @param optionalMetadata
+ * @returns
+ */
+export declare function deduceMeshField(attributeName: string, attribute: MeshAttribute, optionalMetadata?: Map<string, string>): Field;
+/**
+ * Make metadata by mesh attribute properties
+ * @param attribute
+ * @returns
+ */
+export declare function makeMeshAttributeMetadata(attribute: MeshAttribute): Map<string, string>;

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

@@ -0,0 +1,10 @@
+import { Table } from 'apache-arrow/Arrow.dom';
+import type { Mesh } from './mesh-types';
+/**
+ * * Convert a loaders.gl Mesh to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ */
+export declare function convertMeshToArrowTable(mesh: Mesh, batchSize?: number): Table;

package/dist/category/mesh/mesh-types.d.ts

@@ -0,0 +1,49 @@
+import type { Schema } from '../../lib/schema';
+import type { TypedArray } from '../../types';
+import type { ColumnarTable, ArrowTable } from '../table/table-types';
+/** Mesh as columnar table */
+export interface MeshTable extends ColumnarTable {
+    topology: 'point-list' | 'triangle-list' | 'triangle-strip';
+    indices?: MeshAttribute;
+}
+/** Mesh as arrow table */
+export interface MeshArrowTable extends ArrowTable {
+    topology: 'point-list' | 'triangle-list' | 'triangle-strip';
+    indices?: MeshAttribute;
+}
+/** Geometry part of a Mesh (compatible with a standard luma.gl "mesh") */
+export declare type MeshGeometry = {
+    attributes: {
+        [attributeName: string]: MeshAttribute;
+    };
+    indices?: MeshAttribute;
+    topology: 'point-list' | 'triangle-list' | 'triangle-strip';
+    mode: number;
+};
+/** Geometry and metadata for a Mesh (compatible with a standard luma.gl "mesh") */
+export declare type Mesh = MeshGeometry & {
+    loader?: string;
+    loaderData?: {
+        [key: string]: any;
+    };
+    header?: {
+        vertexCount: number;
+        boundingBox?: [number[], number[]];
+    };
+    schema: Schema;
+};
+/**
+ * luma.gl compatible attribute descriptors
+ * Can be mapped to any WebGL framework
+ */
+export declare type MeshAttribute = {
+    value: TypedArray;
+    size: number;
+    byteOffset?: number;
+    byteStride?: number;
+    normalized?: boolean;
+};
+/** A map of mesh attributes keyed by attribute names */
+export declare type MeshAttributes = {
+    [attributeName: string]: MeshAttribute;
+};

package/dist/category/mesh/mesh-utils.d.ts

@@ -0,0 +1,22 @@
+import { TypedArray } from '../../types';
+import { MeshAttributes } from './mesh-types';
+declare type TypedArrays = {
+    [key: string]: TypedArray;
+};
+/**
+ * Holds an axis aligned bounding box
+ * TODO - make sure AxisAlignedBoundingBox in math.gl/culling understands this format (or change this format)
+ */
+declare type BoundingBox = [[number, number, number], [number, number, number]];
+/**
+ * Get number of vertices in mesh
+ * @param attributes
+ */
+export declare function getMeshSize(attributes: TypedArrays): number;
+/**
+ * Get the (axis aligned) bounding box of a mesh
+ * @param attributes
+ * @returns array of two vectors representing the axis aligned bounding box
+ */
+export declare function getMeshBoundingBox(attributes: MeshAttributes): BoundingBox;
+export {};

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

@@ -0,0 +1,8 @@
+import { Schema } from '../../lib/schema';
+/**
+ * SCHEMA SUPPORT - AUTODEDUCTION
+ * @param {*} table
+ * @param {*} schema
+ * @returns
+ */
+export declare function deduceTableSchema(table: any, schema?: Schema): Schema;

package/dist/category/table/table-types.d.ts

@@ -0,0 +1,75 @@
+import type { Schema } from '../../lib/schema';
+import type { Table as ApacheArrowTable, RecordBatch } from 'apache-arrow/Arrow.dom';
+import type { AnyArray } from '../../types';
+import type { Batch } from '../common';
+/** A general table */
+export interface Table {
+    shape: 'row-table' | 'array-row-table' | 'object-row-table' | 'columnar-table' | 'arrow-table';
+    schema?: Schema;
+    schemaType?: 'explicit' | 'deduced';
+}
+/** A table organized as an array of rows */
+export interface RowTable extends Table {
+    shape: 'row-table' | 'array-row-table' | 'object-row-table';
+    data: any[];
+}
+/** A table organized as an array of rows, each row is an array of values */
+export interface ArrayRowTable extends RowTable {
+    shape: 'array-row-table';
+    data: any[][];
+}
+/** A table organized as an array of rows, each row is an object mapping columns to values */
+export interface ObjectRowTable extends RowTable {
+    shape: 'object-row-table';
+    data: {
+        [columnName: string]: any;
+    }[];
+}
+/** A table organized as a map of columns, each column is an array of value */
+export interface ColumnarTable extends Table {
+    shape: 'columnar-table';
+    data: {
+        [columnName: string]: AnyArray;
+    };
+}
+/** A table organized as an Apache Arrow table */
+export interface ArrowTable extends Table {
+    shape: 'arrow-table';
+    data: ApacheArrowTable;
+}
+/** Batch for a general table */
+export declare type TableBatch = Batch & {
+    data: any;
+    length: number;
+    schema?: Schema;
+    schemaType?: 'explicit' | 'deduced';
+};
+/** Batch for a table organized as an array of rows */
+export declare type RowTableBatch = TableBatch & {
+    shape: 'row-table';
+    data: any[];
+};
+/** Batch for a table organized as an array of rows, each row is an array of values */
+export declare type RowArrayTableBatch = RowTableBatch & {
+    shape: 'array-row-table';
+    data: any[][];
+};
+/** Batch for a table organized as an array of rows, each row is an object mapping columns to values */
+export declare type RowObjectTableBatch = RowTableBatch & {
+    shape: 'object-row-table';
+    data: {
+        [columnName: string]: any;
+    }[];
+};
+/** Batch for a table organized as a map of columns, each column is an array of value */
+export declare type ColumnarTableBatch = TableBatch & {
+    shape: 'columnar-table';
+    data: {
+        [columnName: string]: AnyArray;
+    };
+};
+/** Batch for a table organized as an Apache Arrow table */
+export declare type ArrowTableBatch = TableBatch & {
+    shape: 'arrow-table';
+    data: RecordBatch;
+};