@loaders.gl/i3s 3.1.0-alpha.5 → 3.1.0-beta.7

package/dist/i3s-loader.d.ts

@@ -3,3 +3,4 @@ import type { LoaderWithParser } from '@loaders.gl/loader-utils';
  * Loader for I3S - Indexed 3D Scene Layer
  */
 export declare const I3SLoader: LoaderWithParser;
+//# sourceMappingURL=i3s-loader.d.ts.map

package/dist/i3s-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-loader.d.ts","sourceRoot":"","sources":["../src/i3s-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAc/D;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAsBvB,CAAC"}

package/dist/i3s-loader.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I3SLoader = void 0;
+const core_1 = require("@loaders.gl/core");
+const i3s_content_loader_1 = require("./i3s-content-loader");
+const parse_i3s_1 = require("./lib/parsers/parse-i3s");
+const constants_1 = require("./lib/parsers/constants");
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+const TILESET_REGEX = /layers\/[0-9]+$/;
+const TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
+const SLPK_HEX = '504b0304';
+/**
+ * Loader for I3S - Indexed 3D Scene Layer
+ */
+exports.I3SLoader = {
+    name: 'I3S (Indexed Scene Layers)',
+    id: 'i3s',
+    module: 'i3s',
+    version: VERSION,
+    mimeTypes: ['application/octet-stream'],
+    parse: parseI3S,
+    extensions: ['bin'],
+    options: {
+        i3s: {
+            loadContent: true,
+            token: null,
+            isTileset: 'auto',
+            isTileHeader: 'auto',
+            tile: null,
+            tileset: null,
+            useDracoGeometry: true,
+            useCompressedTextures: true,
+            decodeTextures: true,
+            coordinateSystem: constants_1.COORDINATE_SYSTEM.METER_OFFSETS
+        }
+    }
+};
+async function parseI3S(data, options, context) {
+    const url = context.url;
+    options.i3s = options.i3s || {};
+    const magicNumber = getMagicNumber(data);
+    // check if file is slpk
+    if (magicNumber === SLPK_HEX) {
+        throw new Error('Files with .slpk extention currently are not supported by I3SLoader');
+    }
+    // auto detect file type based on url
+    let isTileset;
+    if (options.i3s.isTileset === 'auto') {
+        isTileset = TILESET_REGEX.test(url);
+    }
+    else {
+        isTileset = options.i3s.isTileset;
+    }
+    let isTileHeader;
+    if (options.isTileHeader === 'auto') {
+        isTileHeader = TILE_HEADER_REGEX.test(url);
+    }
+    else {
+        isTileHeader = options.i3s.isTileHeader;
+    }
+    if (isTileset) {
+        data = await parseTileset(data, options, context);
+    }
+    else if (isTileHeader) {
+        data = await parseTile(data, options, context);
+        if (options.i3s.loadContent) {
+            options.i3s.tile = data;
+            await (0, core_1.load)(data.contentUrl, exports.I3SLoader, options);
+        }
+    }
+    else {
+        data = await parseTileContent(data, options);
+    }
+    return data;
+}
+async function parseTileContent(arrayBuffer, options) {
+    return await (0, core_1.parse)(arrayBuffer, i3s_content_loader_1.I3SContentLoader, options);
+}
+async function parseTileset(data, options, context) {
+    const tilesetJson = JSON.parse(new TextDecoder().decode(data));
+    // eslint-disable-next-line no-use-before-define
+    tilesetJson.loader = exports.I3SLoader;
+    await (0, parse_i3s_1.normalizeTilesetData)(tilesetJson, options, context);
+    return tilesetJson;
+}
+async function parseTile(data, options, context) {
+    data = JSON.parse(new TextDecoder().decode(data));
+    return (0, parse_i3s_1.normalizeTileData)(data, options, context);
+}
+function getMagicNumber(data) {
+    if (data instanceof ArrayBuffer) {
+        // slice binary data (4 bytes from the beginning) and transform it to hexadecimal numeral system
+        return [...new Uint8Array(data, 0, 4)]
+            .map((value) => value.toString(16).padStart(2, '0'))
+            .join('');
+    }
+    return null;
+}

package/dist/i3s-node-page-loader.d.ts

@@ -3,3 +3,4 @@ import type { LoaderWithParser } from '@loaders.gl/loader-utils';
  * Loader for I3S node pages
  */
 export declare const I3SNodePageLoader: LoaderWithParser;
+//# sourceMappingURL=i3s-node-page-loader.d.ts.map

package/dist/i3s-node-page-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-node-page-loader.d.ts","sourceRoot":"","sources":["../src/i3s-node-page-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAU/D;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,gBAS/B,CAAC"}

package/dist/i3s-node-page-loader.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I3SNodePageLoader = void 0;
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+async function parseNodePage(data) {
+    return JSON.parse(new TextDecoder().decode(data));
+}
+/**
+ * Loader for I3S node pages
+ */
+exports.I3SNodePageLoader = {
+    name: 'I3S Node Page',
+    id: 'i3s-node-page',
+    module: 'i3s',
+    version: VERSION,
+    mimeTypes: ['application/json'],
+    parse,
+    extensions: ['json'],
+    options: {}
+};
+async function parse(data) {
+    data = parseNodePage(data);
+    return data;
+}

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export { I3SAttributeLoader, loadFeatureAttributes } from './i3s-attribute-loade
 export { I3SBuildingSceneLayerLoader } from './i3s-building-scene-layer-loader';
 export type { BoundingVolumes, Mbs, Obb, SceneLayer3D, AttributeStorageInfo, Field, ESRIField, PopupInfo, Node3DIndexDocument, LodSelection, NodeReference, Resource, I3SGeometry, MaxScreenThresholdSQ, NodeInPage, SharedResources, TextureImage, Attribute, Extent, FeatureAttribute } from './types';
 export { COORDINATE_SYSTEM } from './lib/parsers/constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAC,kBAAkB,EAAE,qBAAqB,EAAC,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAC,2BAA2B,EAAC,MAAM,mCAAmC,CAAC;AAC9E,YAAY,EACV,eAAe,EACf,GAAG,EACH,GAAG,EACH,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,SAAS,EACT,SAAS,EACT,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,WAAW,EACX,oBAAoB,EACpB,UAAU,EACV,eAAe,EACf,YAAY,EACZ,SAAS,EACT,MAAM,EACN,gBAAgB,EACjB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COORDINATE_SYSTEM = exports.I3SBuildingSceneLayerLoader = exports.loadFeatureAttributes = exports.I3SAttributeLoader = exports.I3SContentLoader = exports.I3SLoader = void 0;
+var i3s_loader_1 = require("./i3s-loader");
+Object.defineProperty(exports, "I3SLoader", { enumerable: true, get: function () { return i3s_loader_1.I3SLoader; } });
+var i3s_content_loader_1 = require("./i3s-content-loader");
+Object.defineProperty(exports, "I3SContentLoader", { enumerable: true, get: function () { return i3s_content_loader_1.I3SContentLoader; } });
+var i3s_attribute_loader_1 = require("./i3s-attribute-loader");
+Object.defineProperty(exports, "I3SAttributeLoader", { enumerable: true, get: function () { return i3s_attribute_loader_1.I3SAttributeLoader; } });
+Object.defineProperty(exports, "loadFeatureAttributes", { enumerable: true, get: function () { return i3s_attribute_loader_1.loadFeatureAttributes; } });
+var i3s_building_scene_layer_loader_1 = require("./i3s-building-scene-layer-loader");
+Object.defineProperty(exports, "I3SBuildingSceneLayerLoader", { enumerable: true, get: function () { return i3s_building_scene_layer_loader_1.I3SBuildingSceneLayerLoader; } });
+var constants_1 = require("./lib/parsers/constants");
+Object.defineProperty(exports, "COORDINATE_SYSTEM", { enumerable: true, get: function () { return constants_1.COORDINATE_SYSTEM; } });

package/dist/lib/helpers/i3s-nodepages-tiles.d.ts

@@ -70,3 +70,4 @@ export default class I3SNodePagesTiles {
      */
     private getSupportedTextureFormats;
 }
+//# sourceMappingURL=i3s-nodepages-tiles.d.ts.map

package/dist/lib/helpers/i3s-nodepages-tiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-nodepages-tiles.d.ts","sourceRoot":"","sources":["../../../src/lib/helpers/i3s-nodepages-tiles.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,OAAO,EAAE,QAAQ,EAAC,MAAM,aAAa,CAAC;AAK9C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,QAAQ,EAAE,CAAM;IAC3B,gBAAgB,EAAE;QAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAA;KAAC,EAAE,CAAM;IAClF,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IAC9B,sBAAsB,EAAE,GAAG,CAAC;IAC5B,iCAAiC,EAAE,GAAG,EAAE,CAAM;IAC9C,OAAO,CAAC,oBAAoB,CAA4B;IAExD;;;;;OAKG;gBACS,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM;IAS7C;;;OAGG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM;IAqB5B;;;OAGG;IAEG,qBAAqB,CAAC,EAAE,EAAE,MAAM;IAwDtC;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IA4BrB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAevB;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IAmBlC;;;;OAIG;IACH,OAAO,CAAC,wCAAwC;IA2BhD;;;OAGG;IACH,OAAO,CAAC,0BAA0B;CAuBnC"}

package/dist/lib/helpers/i3s-nodepages-tiles.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@loaders.gl/core");
+const textures_1 = require("@loaders.gl/textures");
+const i3s_node_page_loader_1 = require("../../i3s-node-page-loader");
+const parse_i3s_1 = require("../parsers/parse-i3s");
+const url_utils_1 = require("../utils/url-utils");
+/**
+ * class I3SNodePagesTiles - loads nodePages and form i3s tiles from them
+ */
+class I3SNodePagesTiles {
+    /**
+     * @constructs
+     * Create a I3SNodePagesTiles instance.
+     * @param tileset - i3s tileset header ('layers/0')
+     * @param options - i3s loader options
+     */
+    constructor(tileset, options) {
+        this.nodePages = [];
+        this.pendingNodePages = [];
+        this.textureDefinitionsSelectedFormats = [];
+        this.textureLoaderOptions = {};
+        this.tileset = { ...tileset }; // spread the tileset to avoid circular reference
+        this.nodesPerPage = tileset.nodePages.nodesPerPage;
+        this.lodSelectionMetricType = tileset.nodePages.lodSelectionMetricType;
+        this.options = options;
+        this.initSelectedFormatsForTextureDefinitions(tileset);
+    }
+    /**
+     * Loads some nodePage and return a particular node from it
+     * @param id - id of node through all node pages
+     */
+    async getNodeById(id) {
+        const pageIndex = Math.floor(id / this.nodesPerPage);
+        if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
+            const nodePageUrl = (0, url_utils_1.getUrlWithToken)(`${this.tileset.url}/nodepages/${pageIndex}`, this.options.i3s?.token);
+            this.pendingNodePages[pageIndex] = {
+                status: 'Pending',
+                promise: (0, core_1.load)(nodePageUrl, i3s_node_page_loader_1.I3SNodePageLoader, this.options)
+            };
+            this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
+            this.pendingNodePages[pageIndex].status = 'Done';
+        }
+        if (this.pendingNodePages[pageIndex].status === 'Pending') {
+            this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
+        }
+        const nodeIndex = id % this.nodesPerPage;
+        return this.nodePages[pageIndex].nodes[nodeIndex];
+    }
+    /**
+     * Forms tile header using node and tileset data
+     * @param id - id of node through all node pages
+     */
+    // eslint-disable-next-line complexity
+    async formTileFromNodePages(id) {
+        const node = await this.getNodeById(id);
+        const children = [];
+        for (const child of node.children || []) {
+            const childNode = await this.getNodeById(child);
+            children.push({
+                id: child,
+                obb: childNode.obb
+            });
+        }
+        let contentUrl = null;
+        let textureUrl = null;
+        let materialDefinition = null;
+        let textureFormat = 'jpeg';
+        let attributeUrls = [];
+        let isDracoGeometry = false;
+        if (node && node.mesh) {
+            // Get geometry resource URL and type (compressed / non-compressed)
+            const { url, isDracoGeometry: isDracoGeometryResult } = (node.mesh.geometry &&
+                this.getContentUrl(node.mesh.geometry)) || { url: null, isDracoGeometry: null };
+            contentUrl = url;
+            isDracoGeometry = isDracoGeometryResult;
+            const [textureData, nodeMaterialDefinition] = this.getInformationFromMaterial(node.mesh.material);
+            materialDefinition = nodeMaterialDefinition;
+            textureFormat = textureData.format || textureFormat;
+            if (textureData.name) {
+                textureUrl = `${this.tileset.url}/nodes/${node.mesh.material.resource}/textures/${textureData.name}`;
+            }
+            if (this.tileset.attributeStorageInfo) {
+                attributeUrls = (0, url_utils_1.generateTilesetAttributeUrls)(this.tileset, node.mesh.attribute.resource);
+            }
+        }
+        const lodSelection = this.getLodSelection(node);
+        return (0, parse_i3s_1.normalizeTileNonUrlData)({
+            id,
+            lodSelection,
+            obb: node.obb,
+            contentUrl,
+            textureUrl,
+            attributeUrls,
+            materialDefinition,
+            textureFormat,
+            textureLoaderOptions: this.textureLoaderOptions,
+            children,
+            isDracoGeometry
+        });
+    }
+    /**
+     * Forms url and type of geometry resource by nodepage's data and `geometryDefinitions` in the tileset
+     * @param {Object} meshGeometryData - data about the node's mesh from the nodepage
+     * @returns {Object} -
+     *   {string} url - url to the geometry resource
+     *   {boolean} isDracoGeometry - whether the geometry resource contain DRACO compressed geometry
+     */
+    getContentUrl(meshGeometryData) {
+        let result = {};
+        const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
+        let geometryIndex = -1;
+        // Try to find DRACO geometryDefinition of `useDracoGeometry` option is set
+        if (this.options.i3s && this.options.i3s.useDracoGeometry) {
+            geometryIndex = geometryDefinition.geometryBuffers.findIndex((buffer) => buffer.compressedAttributes && buffer.compressedAttributes.encoding === 'draco');
+        }
+        // If DRACO geometry is not applicable try to select non-compressed geometry
+        if (geometryIndex === -1) {
+            geometryIndex = geometryDefinition.geometryBuffers.findIndex((buffer) => !buffer.compressedAttributes);
+        }
+        if (geometryIndex !== -1) {
+            const isDracoGeometry = Boolean(geometryDefinition.geometryBuffers[geometryIndex].compressedAttributes);
+            result = {
+                url: `${this.tileset.url}/nodes/${meshGeometryData.resource}/geometries/${geometryIndex}`,
+                isDracoGeometry
+            };
+        }
+        return result;
+    }
+    /**
+     * Forms 1.6 compatible LOD selection object from a nodepage's node data
+     * @param {Object} node - a node from nodepage
+     * @returns {Object[]} - Array of object of following properties:
+     *   {string} metricType - the label of the LOD metric
+     *   {number} maxError - the value of the metric
+     */
+    getLodSelection(node) {
+        const lodSelection = [];
+        if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
+            lodSelection.push({
+                metricType: 'maxScreenThreshold',
+                maxError: Math.sqrt(node.lodThreshold / (Math.PI * 0.25))
+            });
+        }
+        lodSelection.push({
+            metricType: this.lodSelectionMetricType,
+            maxError: node.lodThreshold
+        });
+        return lodSelection;
+    }
+    /**
+     * Returns information about texture and material from `materialDefinitions`
+     * @param {Object} material - material data from nodepage
+     * @returns {Object[]} - Couple [textureData, materialDefinition]
+     * {string} textureData.name - path name of the texture
+     * {string} textureData.format - format of the texture
+     * materialDefinition - PBR-like material definition from `materialDefinitions`
+     */
+    getInformationFromMaterial(material) {
+        const textureDataDefault = { name: null, format: null };
+        if (material) {
+            const materialDefinition = this.tileset.materialDefinitions[material.definition];
+            const textureSetDefinitionIndex = materialDefinition &&
+                materialDefinition.pbrMetallicRoughness &&
+                materialDefinition.pbrMetallicRoughness.baseColorTexture &&
+                materialDefinition.pbrMetallicRoughness.baseColorTexture.textureSetDefinitionId;
+            if (textureSetDefinitionIndex || textureSetDefinitionIndex === 0) {
+                const textureData = this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] || textureDataDefault;
+                return [textureData, materialDefinition];
+            }
+            return [textureDataDefault, materialDefinition];
+        }
+        return [textureDataDefault, null];
+    }
+    /**
+     * Sets preferable and supported format for each textureDefinition of the tileset
+     * @param {Object} tileset - I3S layer data
+     * @returns {void}
+     */
+    initSelectedFormatsForTextureDefinitions(tileset) {
+        this.textureDefinitionsSelectedFormats = [];
+        const possibleI3sFormats = this.getSupportedTextureFormats();
+        const textureSetDefinitions = tileset.textureSetDefinitions || [];
+        for (const textureSetDefinition of textureSetDefinitions) {
+            const formats = (textureSetDefinition && textureSetDefinition.formats) || [];
+            let selectedFormat = null;
+            for (const i3sFormat of possibleI3sFormats) {
+                const format = formats.find((value) => value.format === i3sFormat);
+                if (format) {
+                    selectedFormat = format;
+                    break;
+                }
+            }
+            // For I3S 1.8 need to define basis target format to decode
+            if (selectedFormat && selectedFormat.format === 'ktx2') {
+                this.textureLoaderOptions.basis = {
+                    format: (0, textures_1.selectSupportedBasisFormat)(),
+                    containerFormat: 'ktx2',
+                    module: 'encoder'
+                };
+            }
+            this.textureDefinitionsSelectedFormats.push(selectedFormat);
+        }
+    }
+    /**
+     * Returns the array of supported texture format
+     * @returns list of format strings
+     */
+    getSupportedTextureFormats() {
+        const formats = [];
+        if (!this.options.i3s || this.options.i3s.useCompressedTextures) {
+            // I3S 1.7 selection
+            const supportedCompressedFormats = (0, textures_1.getSupportedGPUTextureFormats)();
+            // List of possible in i3s formats:
+            // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/textureSetDefinitionFormat.cmn.md
+            if (supportedCompressedFormats.has('etc2')) {
+                formats.push('ktx-etc2');
+            }
+            if (supportedCompressedFormats.has('dxt')) {
+                formats.push('dds');
+            }
+            // I3S 1.8 selection
+            // ktx2 wraps basis texture which at the edge case can be decoded as uncompressed image
+            formats.push('ktx2');
+        }
+        formats.push('jpg');
+        formats.push('png');
+        return formats;
+    }
+}
+exports.default = I3SNodePagesTiles;

package/dist/lib/parsers/constants.d.ts

@@ -1,16 +1,6 @@
-export declare const TYPE_ARRAY_MAP: {
-    UInt8: Uint8ArrayConstructor;
-    UInt16: Uint16ArrayConstructor;
-    UInt32: Uint32ArrayConstructor;
-    Float32: Float32ArrayConstructor;
-    UInt64: Float64ArrayConstructor;
-};
+export declare function getConstructorForDataFormat(dataType: string): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | null;
 export declare const GL_TYPE_MAP: {
-    UInt8: number;
-    UInt16: number;
-    Float32: number;
-    UInt32: number;
-    UInt64: number;
+    [key: string]: number;
 };
 export declare const I3S_NAMED_VERTEX_ATTRIBUTES: {
     position: string;
@@ -25,25 +15,42 @@ export declare const I3S_NAMED_GEOMETRY_ATTRIBUTES: {
     featureAttributes: string;
 };
 export declare const I3S_NAMED_HEADER_ATTRIBUTES: {
-    header: string;
     vertexCount: string;
     featureCount: string;
 };
-export declare const SIZEOF: {
-    UInt8: number;
-    UInt16: number;
-    UInt32: number;
-    Float32: number;
-    UInt64: number;
-};
+/**
+ * Returns how many bytes a type occupies
+ * @param dataType
+ * @returns
+ */
+export declare function sizeOf(dataType: string): number;
 export declare const STRING_ATTRIBUTE_TYPE = "String";
 export declare const OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
 export declare const FLOAT_64_TYPE = "Float64";
 export declare const INT_16_ATTRIBUTE_TYPE = "Int16";
-export declare const COORDINATE_SYSTEM: {
-    DEFAULT: number;
-    LNGLAT: number;
-    METER_OFFSETS: number;
-    LNGLAT_OFFSETS: number;
-    CARTESIAN: number;
-};
+export declare enum COORDINATE_SYSTEM {
+    /**
+     * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
+     */
+    DEFAULT = -1,
+    /**
+     * Positions are interpreted as [lng, lat, elevation]
+     * lng lat are degrees, elevation is meters. distances as meters.
+     */
+    LNGLAT = 1,
+    /**
+     * Positions are interpreted as meter offsets, distances as meters
+     */
+    METER_OFFSETS = 2,
+    /**
+     * Positions are interpreted as lng lat offsets: [deltaLng, deltaLat, elevation]
+     * deltaLng, deltaLat are delta degrees, elevation is meters.
+     * distances as meters.
+     */
+    LNGLAT_OFFSETS = 3,
+    /**
+     * Non-geospatial
+     */
+    CARTESIAN = 0
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/lib/parsers/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/constants.ts"],"names":[],"mappings":"AAGA,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,sIAe3D;AAED,eAAO,MAAM,WAAW,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAM/C,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;CAMvC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;CAIzC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;CAIvC,CAAC;AACF;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAkB/C;AAED,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAC9C,eAAO,MAAM,wBAAwB,UAAU,CAAC;AAChD,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAI7C,oBAAY,iBAAiB;IAC3B;;OAEG;IACH,OAAO,KAAK;IACZ;;;OAGG;IACH,MAAM,IAAI;IACV;;OAEG;IACH,aAAa,IAAI;IACjB;;;;OAIG;IACH,cAAc,IAAI;IAClB;;OAEG;IACH,SAAS,IAAI;CACd"}

package/dist/lib/parsers/constants.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COORDINATE_SYSTEM = exports.INT_16_ATTRIBUTE_TYPE = exports.FLOAT_64_TYPE = exports.OBJECT_ID_ATTRIBUTE_TYPE = exports.STRING_ATTRIBUTE_TYPE = exports.sizeOf = exports.I3S_NAMED_HEADER_ATTRIBUTES = exports.I3S_NAMED_GEOMETRY_ATTRIBUTES = exports.I3S_NAMED_VERTEX_ATTRIBUTES = exports.GL_TYPE_MAP = exports.getConstructorForDataFormat = void 0;
+const constants_1 = __importDefault(require("@luma.gl/constants"));
+const types_1 = require("../../types");
+function getConstructorForDataFormat(dataType) {
+    switch (dataType) {
+        case types_1.DATA_TYPE.UInt8:
+            return Uint8Array;
+        case types_1.DATA_TYPE.UInt16:
+            return Uint16Array;
+        case types_1.DATA_TYPE.UInt32:
+            return Uint32Array;
+        case types_1.DATA_TYPE.Float32:
+            return Float32Array;
+        case types_1.DATA_TYPE.UInt64:
+            return Float64Array;
+        default:
+            return null;
+    }
+}
+exports.getConstructorForDataFormat = getConstructorForDataFormat;
+exports.GL_TYPE_MAP = {
+    UInt8: constants_1.default.UNSIGNED_BYTE,
+    UInt16: constants_1.default.UNSIGNED_INT,
+    Float32: constants_1.default.FLOAT,
+    UInt32: constants_1.default.UNSIGNED_INT,
+    UInt64: constants_1.default.DOUBLE
+};
+exports.I3S_NAMED_VERTEX_ATTRIBUTES = {
+    position: 'position',
+    normal: 'normal',
+    uv0: 'uv0',
+    color: 'color',
+    region: 'region'
+};
+exports.I3S_NAMED_GEOMETRY_ATTRIBUTES = {
+    vertexAttributes: 'vertexAttributes',
+    featureAttributeOrder: 'featureAttributeOrder',
+    featureAttributes: 'featureAttributes'
+};
+// TODO Remove Named Attributes and replase with Typescipt types
+exports.I3S_NAMED_HEADER_ATTRIBUTES = {
+    // header: 'header',
+    vertexCount: 'vertexCount',
+    featureCount: 'featureCount'
+};
+/**
+ * Returns how many bytes a type occupies
+ * @param dataType
+ * @returns
+ */
+function sizeOf(dataType) {
+    switch (dataType) {
+        case types_1.DATA_TYPE.UInt8:
+            return 1;
+        case types_1.DATA_TYPE.UInt16:
+        case types_1.DATA_TYPE.Int16:
+            return 2;
+        case types_1.DATA_TYPE.UInt32:
+        case types_1.DATA_TYPE.Int32:
+        case types_1.DATA_TYPE.Float32:
+            return 4;
+        case types_1.DATA_TYPE.UInt64:
+        case types_1.DATA_TYPE.Int64:
+        case types_1.DATA_TYPE.Float64:
+            return 8;
+        default:
+            return NaN;
+    }
+}
+exports.sizeOf = sizeOf;
+exports.STRING_ATTRIBUTE_TYPE = 'String';
+exports.OBJECT_ID_ATTRIBUTE_TYPE = 'Oid32';
+exports.FLOAT_64_TYPE = 'Float64';
+exports.INT_16_ATTRIBUTE_TYPE = 'Int16';
+// https://github.com/visgl/deck.gl/blob/9548f43cba2234a1f4877b6b17f6c88eb35b2e08/modules/core/src/lib/constants.js#L27
+// Describes the format of positions
+var COORDINATE_SYSTEM;
+(function (COORDINATE_SYSTEM) {
+    /**
+     * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["DEFAULT"] = -1] = "DEFAULT";
+    /**
+     * Positions are interpreted as [lng, lat, elevation]
+     * lng lat are degrees, elevation is meters. distances as meters.
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT"] = 1] = "LNGLAT";
+    /**
+     * Positions are interpreted as meter offsets, distances as meters
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["METER_OFFSETS"] = 2] = "METER_OFFSETS";
+    /**
+     * Positions are interpreted as lng lat offsets: [deltaLng, deltaLat, elevation]
+     * deltaLng, deltaLat are delta degrees, elevation is meters.
+     * distances as meters.
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
+    /**
+     * Non-geospatial
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["CARTESIAN"] = 0] = "CARTESIAN";
+})(COORDINATE_SYSTEM = exports.COORDINATE_SYSTEM || (exports.COORDINATE_SYSTEM = {}));

package/dist/lib/parsers/parse-i3s-attribute.d.ts

@@ -5,5 +5,6 @@
  * @returns {Promise<object>}
  */
 export declare function parseI3STileAttribute(arrayBuffer: any, options: any): Promise<{
-    [x: number]: string[] | Uint32Array | Int16Array | Float64Array | null;
+    [x: number]: Int16Array | Uint32Array | Float64Array | string[] | null;
 }>;
+//# sourceMappingURL=parse-i3s-attribute.d.ts.map

package/dist/lib/parsers/parse-i3s-attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-i3s-attribute.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s-attribute.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,WAAW,KAAA,EAAE,OAAO,KAAA;;GAS/D"}