@loaders.gl/i3s 3.1.0-beta.7 → 3.1.3

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"}

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

@@ -11,54 +11,59 @@ const tiles_1 = require("@loaders.gl/tiles");
 const i3s_nodepages_tiles_1 = __importDefault(require("../helpers/i3s-nodepages-tiles"));
 const url_utils_1 = require("../utils/url-utils");
 function normalizeTileData(tile, options, context) {
-    tile.url = context.url;
-    if (tile.featureData) {
-        tile.featureUrl = `${tile.url}/${tile.featureData[0].href}`;
-    }
+    const url = context.url || '';
+    let contentUrl;
     if (tile.geometryData) {
-        tile.contentUrl = `${tile.url}/${tile.geometryData[0].href}`;
+        contentUrl = `${url}/${tile.geometryData[0].href}`;
     }
+    let textureUrl;
     if (tile.textureData) {
-        tile.textureUrl = `${tile.url}/${tile.textureData[0].href}`;
+        textureUrl = `${url}/${tile.textureData[0].href}`;
     }
+    let attributeUrls;
     if (tile.attributeData) {
-        tile.attributeUrls = (0, url_utils_1.generateTileAttributeUrls)(tile);
+        attributeUrls = (0, url_utils_1.generateTileAttributeUrls)(url, tile);
     }
-    return normalizeTileNonUrlData(tile);
+    return normalizeTileNonUrlData({
+        ...tile,
+        url,
+        contentUrl,
+        textureUrl,
+        attributeUrls,
+        isDracoGeometry: false
+    });
 }
 exports.normalizeTileData = normalizeTileData;
 function normalizeTileNonUrlData(tile) {
-    const box = tile.obb
-        ? [
-            ...geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
-            ...tile.obb.halfSize,
-            ...tile.obb.quaternion // quaternion
-        ]
-        : undefined;
-    let sphere;
+    const boundingVolume = {};
+    let mbs = [0, 0, 0, 1];
     if (tile.mbs) {
-        sphere = [
+        mbs = tile.mbs;
+        boundingVolume.sphere = [
             ...geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
             tile.mbs[3] // radius of sphere
         ];
     }
-    else if (box) {
-        const obb = new culling_1.OrientedBoundingBox().fromCenterHalfSizeQuaternion(box.slice(0, 3), tile.obb.halfSize, tile.obb.quaternion);
+    else if (tile.obb) {
+        boundingVolume.box = [
+            ...geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
+            ...tile.obb.halfSize,
+            ...tile.obb.quaternion // quaternion
+        ];
+        const obb = new culling_1.OrientedBoundingBox().fromCenterHalfSizeQuaternion(boundingVolume.box.slice(0, 3), tile.obb.halfSize, tile.obb.quaternion);
         const boundingSphere = obb.getBoundingSphere();
-        sphere = [...boundingSphere.center, boundingSphere.radius];
-        tile.mbs = [...tile.obb.center, boundingSphere.radius];
+        boundingVolume.sphere = [...boundingSphere.center, boundingSphere.radius];
+        mbs = [...tile.obb.center, boundingSphere.radius];
     }
-    tile.boundingVolume = {
-        sphere,
-        box
-    };
-    tile.lodMetricType = tile.lodSelection[0].metricType;
-    tile.lodMetricValue = tile.lodSelection[0].maxError;
-    tile.transformMatrix = tile.transform;
-    tile.type = tiles_1.TILE_TYPE.MESH;
-    // TODO only support replacement for now
-    tile.refine = tiles_1.TILE_REFINEMENT.REPLACE;
-    return tile;
+    const lodMetricType = tile.lodSelection?.[0].metricType;
+    const lodMetricValue = tile.lodSelection?.[0].maxError;
+    const transformMatrix = tile.transform;
+    const type = tiles_1.TILE_TYPE.MESH;
+    /**
+     * I3S specification supports only REPLACE
+     */
+    const refine = tiles_1.TILE_REFINEMENT.REPLACE;
+    return { ...tile, mbs, boundingVolume, lodMetricType, lodMetricValue, transformMatrix, type, refine };
 }
 exports.normalizeTileNonUrlData = normalizeTileNonUrlData;
 async function normalizeTilesetData(tileset, options, context) {

package/dist/lib/utils/url-utils.d.ts

@@ -1,17 +1,17 @@
-import { Tile } from '../../types';
+import { Node3DIndexDocument } from '../../types';
 /**
  * Generates url with token if it is exists.
- * @param {String} url
- * @param {any} token
- * @returns {string}
+ * @param url
+ * @param token
+ * @returns
  */
-export declare function getUrlWithToken(url: string, token?: null): string;
+export declare function getUrlWithToken(url: string, token?: string | null): string;
 /**
  * Generates attribute urls for tile.
  * @param tile
  * @returns list of attribute urls
  */
-export declare function generateTileAttributeUrls(tile: Tile): string[];
+export declare function generateTileAttributeUrls(url: string, tile: Node3DIndexDocument): string[];
 /**
  * Generates attribute urls for tileset based on tileset and resource
  * @param {Object} tileset

package/dist/lib/utils/url-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/url-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,aAAa,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,OAAO,GAAG,MAAM,CAEjE;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAU9D;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,KAAA,EAAE,QAAQ,KAAA,YAU7D"}
+{"version":3,"file":"url-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/url-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAC,MAAM,aAAa,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,GAAG,IAAW,GAAG,MAAM,CAEhF;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAU1F;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,KAAA,EAAE,QAAQ,KAAA,YAU7D"}

package/dist/lib/utils/url-utils.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTilesetAttributeUrls = exports.generateTileAttributeUrls = exports.getUrlWithToken = void 0;
 /**
  * Generates url with token if it is exists.
- * @param {String} url
- * @param {any} token
- * @returns {string}
+ * @param url
+ * @param token
+ * @returns
  */
 function getUrlWithToken(url, token = null) {
     return token ? `${url}?token=${token}` : url;
@@ -16,8 +16,8 @@ exports.getUrlWithToken = getUrlWithToken;
  * @param tile
  * @returns list of attribute urls
  */
-function generateTileAttributeUrls(tile) {
-    const { url, attributeData } = tile;
+function generateTileAttributeUrls(url, tile) {
+    const { attributeData = [] } = tile;
     const attributeUrls = [];
     for (let index = 0; index < attributeData.length; index++) {
         const attributeUrl = attributeData[index].href.replace('./', '');