@loaders.gl/i3s 3.1.0-beta.2 → 3.1.1

package/dist/index.d.ts

@@ -2,6 +2,6 @@ export { I3SLoader } from './i3s-loader';
 export { I3SContentLoader } from './i3s-content-loader';
 export { I3SAttributeLoader, loadFeatureAttributes } from './i3s-attribute-loader';
 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 type { BoundingVolumes, Mbs, Obb, SceneLayer3D, AttributeStorageInfo, Field, ESRIField, PopupInfo, Node3DIndexDocument, LodSelection, NodeReference, Resource, MaxScreenThresholdSQ, NodeInPage, SharedResources, Attribute, Extent, FeatureAttribute, FieldInfo, I3SMaterialDefinition } from './types';
 export { COORDINATE_SYSTEM } from './lib/parsers/constants';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +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"}
+{"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,oBAAoB,EACpB,UAAU,EACV,eAAe,EACf,SAAS,EACT,MAAM,EACN,gBAAgB,EAChB,SAAS,EACT,qBAAqB,EACtB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC"}

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

@@ -1,20 +1,22 @@
-import { Tileset, NodePage } from '../../types';
+import type { LoaderOptions } from '@loaders.gl/loader-utils';
+import { I3STilesetHeader, NodePage, NodeInPage, I3STextureFormat, I3STileHeader } from '../../types';
 /**
  * class I3SNodePagesTiles - loads nodePages and form i3s tiles from them
  */
 export default class I3SNodePagesTiles {
-    tileset: Tileset;
+    tileset: I3STilesetHeader;
     nodePages: NodePage[];
     pendingNodePages: {
         promise: Promise<NodePage>;
         status: 'Pending' | 'Done';
     }[];
     nodesPerPage: number;
-    options: {
-        [key: string]: any;
-    };
-    lodSelectionMetricType: any;
-    textureDefinitionsSelectedFormats: any[];
+    options: LoaderOptions;
+    lodSelectionMetricType?: string;
+    textureDefinitionsSelectedFormats: ({
+        format: I3STextureFormat;
+        name: string;
+    } | null)[];
     private textureLoaderOptions;
     /**
      * @constructs
@@ -22,37 +24,35 @@ export default class I3SNodePagesTiles {
      * @param tileset - i3s tileset header ('layers/0')
      * @param options - i3s loader options
      */
-    constructor(tileset: Tileset, options: object);
+    constructor(tileset: I3STilesetHeader, options: LoaderOptions);
     /**
      * Loads some nodePage and return a particular node from it
      * @param id - id of node through all node pages
      */
-    getNodeById(id: number): Promise<any>;
+    getNodeById(id: number): Promise<NodeInPage>;
     /**
      * Forms tile header using node and tileset data
      * @param id - id of node through all node pages
      */
-    formTileFromNodePages(id: number): Promise<any>;
+    formTileFromNodePages(id: number): Promise<I3STileHeader>;
     /**
      * 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} -
+     * @param - data about the node's mesh from the nodepage
+     * @returns -
      *   {string} url - url to the geometry resource
      *   {boolean} isDracoGeometry - whether the geometry resource contain DRACO compressed geometry
      */
     private getContentUrl;
     /**
      * 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
+     * @param node - a node from nodepage
+     * @returns- Array of LodSelection
      */
     private getLodSelection;
     /**
      * Returns information about texture and material from `materialDefinitions`
-     * @param {Object} material - material data from nodepage
-     * @returns {Object[]} - Couple [textureData, materialDefinition]
+     * @param material - material data from nodepage
+     * @returns - 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`
@@ -60,8 +60,8 @@ export default class I3SNodePagesTiles {
     private getInformationFromMaterial;
     /**
      * Sets preferable and supported format for each textureDefinition of the tileset
-     * @param {Object} tileset - I3S layer data
-     * @returns {void}
+     * @param tileset - I3S layer data
+     * @returns
      */
     private initSelectedFormatsForTextureDefinitions;
     /**

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

@@ -1 +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"}
+{"version":3,"file":"i3s-nodepages-tiles.d.ts","sourceRoot":"","sources":["../../../src/lib/helpers/i3s-nodepages-tiles.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EACL,gBAAgB,EAEhB,QAAQ,EACR,UAAU,EAIV,gBAAgB,EAEhB,aAAa,EACd,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,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,aAAa,CAAC;IACvB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iCAAiC,EAAE,CAAC;QAAC,MAAM,EAAE,gBAAgB,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,EAAE,CAAM;IAC5F,OAAO,CAAC,oBAAoB,CAA4B;IAExD;;;;;OAKG;gBACS,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa;IAS7D;;;OAGG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBlD;;;OAGG;IAEG,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAuD/D;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IA6BrB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAiBvB;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IAuBlC;;;;OAIG;IACH,OAAO,CAAC,wCAAwC;IA2BhD;;;OAGG;IACH,OAAO,CAAC,0BAA0B;CAuBnC"}

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

@@ -21,8 +21,8 @@ class I3SNodePagesTiles {
         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.nodesPerPage = tileset.nodePages?.nodesPerPage || 64;
+        this.lodSelectionMetricType = tileset.nodePages?.lodSelectionMetricType;
         this.options = options;
         this.initSelectedFormatsForTextureDefinitions(tileset);
     }
@@ -58,23 +58,23 @@ class I3SNodePagesTiles {
         for (const child of node.children || []) {
             const childNode = await this.getNodeById(child);
             children.push({
-                id: child,
+                id: child.toString(),
                 obb: childNode.obb
             });
         }
-        let contentUrl = null;
-        let textureUrl = null;
-        let materialDefinition = null;
-        let textureFormat = 'jpeg';
+        let contentUrl;
+        let textureUrl;
+        let materialDefinition;
+        let textureFormat = 'jpg';
         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 };
+                this.getContentUrl(node.mesh.geometry)) || { isDracoGeometry: false };
             contentUrl = url;
             isDracoGeometry = isDracoGeometryResult;
-            const [textureData, nodeMaterialDefinition] = this.getInformationFromMaterial(node.mesh.material);
+            const { textureData, materialDefinition: nodeMaterialDefinition } = this.getInformationFromMaterial(node.mesh.material);
             materialDefinition = nodeMaterialDefinition;
             textureFormat = textureData.format || textureFormat;
             if (textureData.name) {
@@ -86,7 +86,7 @@ class I3SNodePagesTiles {
         }
         const lodSelection = this.getLodSelection(node);
         return (0, parse_i3s_1.normalizeTileNonUrlData)({
-            id,
+            id: id.toString(),
             lodSelection,
             obb: node.obb,
             contentUrl,
@@ -101,13 +101,14 @@ class I3SNodePagesTiles {
     }
     /**
      * 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} -
+     * @param - data about the node's mesh from the nodepage
+     * @returns -
      *   {string} url - url to the geometry resource
      *   {boolean} isDracoGeometry - whether the geometry resource contain DRACO compressed geometry
      */
     getContentUrl(meshGeometryData) {
-        let result = {};
+        let result = null;
+        // @ts-ignore
         const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
         let geometryIndex = -1;
         // Try to find DRACO geometryDefinition of `useDracoGeometry` option is set
@@ -129,53 +130,53 @@ class I3SNodePagesTiles {
     }
     /**
      * 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
+     * @param node - a node from nodepage
+     * @returns- Array of LodSelection
      */
     getLodSelection(node) {
         const lodSelection = [];
         if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
             lodSelection.push({
                 metricType: 'maxScreenThreshold',
+                // @ts-ignore
                 maxError: Math.sqrt(node.lodThreshold / (Math.PI * 0.25))
             });
         }
         lodSelection.push({
             metricType: this.lodSelectionMetricType,
+            // @ts-ignore
             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]
+     * @param material - material data from nodepage
+     * @returns - 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 };
+        const informationFromMaterial = { textureData: { name: 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];
+            const materialDefinition = this.tileset.materialDefinitions?.[material.definition];
+            if (materialDefinition) {
+                informationFromMaterial.materialDefinition = materialDefinition;
+                const textureSetDefinitionIndex = materialDefinition?.pbrMetallicRoughness?.baseColorTexture?.textureSetDefinitionId;
+                if (typeof textureSetDefinitionIndex === 'number') {
+                    informationFromMaterial.textureData =
+                        this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] ||
+                            informationFromMaterial.textureData;
+                }
             }
-            return [textureDataDefault, materialDefinition];
         }
-        return [textureDataDefault, null];
+        return informationFromMaterial;
     }
     /**
      * Sets preferable and supported format for each textureDefinition of the tileset
-     * @param {Object} tileset - I3S layer data
-     * @returns {void}
+     * @param tileset - I3S layer data
+     * @returns
      */
     initSelectedFormatsForTextureDefinitions(tileset) {
         this.textureDefinitionsSelectedFormats = [];

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

@@ -1,23 +1,7 @@
-export declare function getConstructorForDataFormat(dataType: string): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | null;
+export declare function getConstructorForDataFormat(dataType: string): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
 export declare const GL_TYPE_MAP: {
     [key: string]: number;
 };
-export declare const I3S_NAMED_VERTEX_ATTRIBUTES: {
-    position: string;
-    normal: string;
-    uv0: string;
-    color: string;
-    region: string;
-};
-export declare const I3S_NAMED_GEOMETRY_ATTRIBUTES: {
-    vertexAttributes: string;
-    featureAttributeOrder: string;
-    featureAttributes: string;
-};
-export declare const I3S_NAMED_HEADER_ATTRIBUTES: {
-    vertexCount: string;
-    featureCount: string;
-};
 /**
  * Returns how many bytes a type occupies
  * @param dataType

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

@@ -1 +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"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/constants.ts"],"names":[],"mappings":"AAGA,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,+HAe3D;AAED,eAAO,MAAM,WAAW,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAM/C,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

@@ -3,7 +3,7 @@ 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;
+exports.COORDINATE_SYSTEM = exports.INT_16_ATTRIBUTE_TYPE = exports.FLOAT_64_TYPE = exports.OBJECT_ID_ATTRIBUTE_TYPE = exports.STRING_ATTRIBUTE_TYPE = exports.sizeOf = exports.GL_TYPE_MAP = exports.getConstructorForDataFormat = void 0;
 const constants_1 = __importDefault(require("@luma.gl/constants"));
 const types_1 = require("../../types");
 function getConstructorForDataFormat(dataType) {
@@ -19,7 +19,7 @@ function getConstructorForDataFormat(dataType) {
         case types_1.DATA_TYPE.UInt64:
             return Float64Array;
         default:
-            return null;
+            throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
     }
 }
 exports.getConstructorForDataFormat = getConstructorForDataFormat;
@@ -30,24 +30,6 @@ exports.GL_TYPE_MAP = {
     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
@@ -69,7 +51,7 @@ function sizeOf(dataType) {
         case types_1.DATA_TYPE.Float64:
             return 8;
         default:
-            return NaN;
+            throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
     }
 }
 exports.sizeOf = sizeOf;

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

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

package/dist/lib/parsers/parse-i3s-tile-content.d.ts

@@ -1,4 +1,4 @@
 import type { LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
-import type { Tileset, Tile } from '../../types';
-export declare function parseI3STileContent(arrayBuffer: ArrayBuffer, tile: Tile, tileset: Tileset, options?: LoaderOptions, context?: LoaderContext): Promise<Tile>;
+import { I3STilesetHeader, I3STileHeader } from '../../types';
+export declare function parseI3STileContent(arrayBuffer: ArrayBuffer, tile: I3STileHeader, tileset: I3STilesetHeader, options?: LoaderOptions, context?: LoaderContext): Promise<I3STileHeader>;
 //# sourceMappingURL=parse-i3s-tile-content.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-i3s-tile-content.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s-tile-content.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAK3E,OAAO,KAAK,EACV,OAAO,EACP,IAAI,EAOL,MAAM,aAAa,CAAC;AAgCrB,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,iBAkDxB"}
+{"version":3,"file":"parse-i3s-tile-content.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s-tile-content.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAK3E,OAAO,EACL,gBAAgB,EAChB,aAAa,EAQd,MAAM,aAAa,CAAC;AAuBrB,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,0BA+CxB"}

package/dist/lib/parsers/parse-i3s-tile-content.js

@@ -7,34 +7,31 @@ const geospatial_1 = require("@math.gl/geospatial");
 const images_1 = require("@loaders.gl/images");
 const draco_1 = require("@loaders.gl/draco");
 const textures_1 = require("@loaders.gl/textures");
+const types_1 = require("../../types");
 const url_utils_1 = require("../utils/url-utils");
 const constants_1 = require("./constants");
 const scratchVector = new core_2.Vector3([0, 0, 0]);
 function getLoaderForTextureFormat(textureFormat) {
     switch (textureFormat) {
-        case 'jpeg':
-        case 'png':
-            return images_1.ImageLoader;
         case 'ktx-etc2':
         case 'dds':
             return textures_1.CompressedTextureLoader;
         case 'ktx2':
             return textures_1.BasisLoader;
+        case 'jpg':
+        case 'png':
         default:
-            return null;
+            return images_1.ImageLoader;
     }
 }
 const I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
 async function parseI3STileContent(arrayBuffer, tile, tileset, options, context) {
     tile.content = tile.content || {};
     tile.content.featureIds = tile.content.featureIds || null;
-    // construct featureData from defaultGeometrySchema;
-    tile.content.featureData = constructFeatureDataStruct(tileset);
     tile.content.attributes = {};
     if (tile.textureUrl) {
         const url = (0, url_utils_1.getUrlWithToken)(tile.textureUrl, options?.i3s?.token);
-        const loader = getLoaderForTextureFormat(tile.textureFormat) || images_1.ImageLoader;
-        // @ts-ignore context must be defined
+        const loader = getLoaderForTextureFormat(tile.textureFormat);
         const response = await fetch(url);
         const arrayBuffer = await response.arrayBuffer();
         if (options?.i3s.decodeTextures) {
@@ -71,11 +68,11 @@ async function parseI3STileContent(arrayBuffer, tile, tileset, options, context)
     if (tile.content.material) {
         tile.content.texture = null;
     }
-    return await parseI3SNodeGeometry(arrayBuffer, tile, options);
+    return await parseI3SNodeGeometry(arrayBuffer, tile, tileset, options);
 }
 exports.parseI3STileContent = parseI3STileContent;
 /* eslint-disable max-statements */
-async function parseI3SNodeGeometry(arrayBuffer, tile, options) {
+async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
     if (!tile.content) {
         return tile;
     }
@@ -84,14 +81,16 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, options) {
     let vertexCount;
     let byteOffset = 0;
     let featureCount = 0;
+    let indices;
     if (tile.isDracoGeometry) {
         const decompressedGeometry = await (0, core_1.parse)(arrayBuffer, draco_1.DracoLoader, {
             draco: {
                 attributeNameEntry: I3S_ATTRIBUTE_TYPE
             }
         });
+        // @ts-expect-error
         vertexCount = decompressedGeometry.header.vertexCount;
-        const indices = decompressedGeometry.indices.value;
+        indices = decompressedGeometry.indices?.value;
         const { POSITION, NORMAL, COLOR_0, TEXCOORD_0, ['feature-index']: featureIndex, ['uv-region']: uvRegion } = decompressedGeometry.attributes;
         attributes = {
             position: POSITION,
@@ -99,8 +98,7 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, options) {
             color: COLOR_0,
             uv0: TEXCOORD_0,
             uvRegion,
-            id: featureIndex,
-            indices
+            id: featureIndex
         };
         updateAttributesMetadata(attributes, decompressedGeometry);
         const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
@@ -109,16 +107,14 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, options) {
         }
     }
     else {
-        const { vertexAttributes, attributesOrder, featureAttributes, featureAttributeOrder } = content.featureData;
+        const { vertexAttributes, ordering: attributesOrder, featureAttributes, featureAttributeOrder } = tileset.store.defaultGeometrySchema;
         // First 8 bytes reserved for header (vertexCount and featureCount)
-        const headers = parseHeaders(content, arrayBuffer);
+        const headers = parseHeaders(tileset, arrayBuffer);
         byteOffset = headers.byteOffset;
         vertexCount = headers.vertexCount;
         featureCount = headers.featureCount;
         // Getting vertex attributes such as positions, normals, colors, etc...
-        const { attributes: normalizedVertexAttributes, byteOffset: offset } = normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, 
-        // @ts-expect-error
-        attributesOrder);
+        const { attributes: normalizedVertexAttributes, byteOffset: offset } = normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder);
         // Getting feature attributes such as featureIds and faceRange
         const { attributes: normalizedFeatureAttributes } = normalizeAttributes(arrayBuffer, offset, featureAttributes, featureCount, featureAttributeOrder);
         flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes);
@@ -141,7 +137,7 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, options) {
         texCoords: attributes.uv0,
         uvRegions: normalizeAttribute(attributes.uvRegion) // Normalize from UInt16
     };
-    content.indices = attributes.indices || null;
+    content.indices = indices || null;
     if (attributes.id && attributes.id.value) {
         tile.content.featureIds = attributes.id.value;
     }
@@ -197,46 +193,26 @@ function normalizeAttribute(attribute) {
     attribute.normalized = true;
     return attribute;
 }
-function constructFeatureDataStruct(tileset) {
-    // seed featureData from defaultGeometrySchema
-    const defaultGeometrySchema = tileset.store.defaultGeometrySchema;
-    const featureData = defaultGeometrySchema;
-    // populate the vertex attributes value types and values per element
-    for (const geometryAttribute in constants_1.I3S_NAMED_GEOMETRY_ATTRIBUTES) {
-        for (const namedAttribute in constants_1.I3S_NAMED_VERTEX_ATTRIBUTES) {
-            const attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
-            if (attribute) {
-                const { byteOffset = 0, count = 0, valueType, valuesPerElement } = attribute;
-                featureData[geometryAttribute][namedAttribute] = {
-                    valueType,
-                    valuesPerElement,
-                    byteOffset,
-                    count
-                };
-            }
-        }
-    }
-    featureData.attributesOrder = defaultGeometrySchema.ordering;
-    return featureData;
-}
-function parseHeaders(content, arrayBuffer) {
+function parseHeaders(tileset, arrayBuffer) {
     let byteOffset = 0;
     // First 8 bytes reserved for header (vertexCount and featurecount)
     let vertexCount = 0;
     let featureCount = 0;
-    content.featureData.header.forEach(({ property, type }) => {
+    for (const { property, type } of tileset.store.defaultGeometrySchema.header) {
         const TypedArrayTypeHeader = (0, constants_1.getConstructorForDataFormat)(type);
-        if (property === constants_1.I3S_NAMED_HEADER_ATTRIBUTES.vertexCount) {
-            // @ts-expect-error
-            vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
-            byteOffset += (0, constants_1.sizeOf)(type);
-        }
-        if (property === constants_1.I3S_NAMED_HEADER_ATTRIBUTES.featureCount) {
-            // @ts-expect-error
-            featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
-            byteOffset += (0, constants_1.sizeOf)(type);
+        switch (property) {
+            case types_1.HeaderAttributeProperty.vertexCount:
+                vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
+                byteOffset += (0, constants_1.sizeOf)(type);
+                break;
+            case types_1.HeaderAttributeProperty.featureCount:
+                featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
+                byteOffset += (0, constants_1.sizeOf)(type);
+                break;
+            default:
+                break;
         }
-    });
+    }
     return {
         vertexCount,
         featureCount,
@@ -262,13 +238,12 @@ function normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCo
                 break;
             }
             const buffer = arrayBuffer.slice(byteOffset);
-            let value = [];
+            let value;
             if (valueType === 'UInt64') {
                 value = parseUint64Values(buffer, count * valuesPerElement, (0, constants_1.sizeOf)(valueType));
             }
             else {
                 const TypedArrayType = (0, constants_1.getConstructorForDataFormat)(valueType);
-                // @ts-expect-error
                 value = new TypedArrayType(buffer, 0, count * valuesPerElement);
             }
             attributes[attribute] = {
@@ -310,7 +285,7 @@ function parseUint64Values(buffer, elementsCount, attributeSize) {
         values.push(value);
         offset += attributeSize;
     }
-    return values;
+    return new Uint32Array(values);
 }
 function parsePositions(attribute, tile) {
     const mbs = tile.mbs;
@@ -405,7 +380,9 @@ function makePbrMaterial(materialDefinition, texture) {
     if (pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorFactor) {
         pbrMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFormat(pbrMaterial.pbrMetallicRoughness.baseColorFactor);
     }
-    setMaterialTexture(pbrMaterial, texture);
+    if (texture) {
+        setMaterialTexture(pbrMaterial, texture);
+    }
     return pbrMaterial;
 }
 /**
@@ -501,8 +478,5 @@ function flattenFeatureIdsByFeatureIndices(attributes, featureIds) {
  * @returns
  */
 function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
-    return (featureIndex &&
-        featureIndex.metadata &&
-        featureIndex.metadata['i3s-feature-ids'] &&
-        featureIndex.metadata['i3s-feature-ids'].intArray);
+    return featureIndex?.metadata?.['i3s-feature-ids']?.intArray;
 }

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

@@ -1,4 +1,6 @@
-export declare function normalizeTileData(tile: any, options: any, context: any): any;
-export declare function normalizeTileNonUrlData(tile: any): any;
-export declare function normalizeTilesetData(tileset: any, options: any, context: any): Promise<void>;
+import { I3STilesetHeader, I3STileHeader, I3SMinimalNodeData, Node3DIndexDocument } from '../../types';
+import type { LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
+export declare function normalizeTileData(tile: Node3DIndexDocument, options: LoaderOptions, context: LoaderContext): I3STileHeader;
+export declare function normalizeTileNonUrlData(tile: I3SMinimalNodeData): I3STileHeader;
+export declare function normalizeTilesetData(tileset: I3STilesetHeader, options: LoaderOptions, context: LoaderContext): Promise<void>;
 //# sourceMappingURL=parse-i3s.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-i3s.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s.ts"],"names":[],"mappings":"AAOA,wBAAgB,iBAAiB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,OAoBvD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,OAqC3C;AAED,wBAAsB,oBAAoB,CAAC,OAAO,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,iBAqBnE"}
+{"version":3,"file":"parse-i3s.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,gBAAgB,EAChB,aAAa,EAEb,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAG,mBAAmB,EAAE,OAAO,EAAG,aAAa,EAAE,OAAO,EAAE,aAAa,GAAG,aAAa,CAyB5H;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAG,kBAAkB,GAAG,aAAa,CAmChF;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAG,gBAAgB,EAAE,OAAO,EAAG,aAAa,EAAE,OAAO,EAAE,aAAa,iBAqBrH"}