@loaders.gl/draco 4.2.0-alpha.5 → 4.2.0-beta.1

package/src/draco-loader.ts

@@ -9,10 +9,11 @@ import {VERSION} from './lib/utils/version';
 
 export type DracoLoaderOptions = LoaderOptions & {
   draco?: DracoParseOptions & {
+    /** @deprecated WASM decoding is faster but JS is more backwards compatible */
     decoderType?: 'wasm' | 'js';
+    /** @deprecated Specify where to load the Draco decoder library */
     libraryPath?: string;
-    extraAttributes?;
-    attributeNameEntry?: string;
+    /** Override the URL to the worker bundle (by default loads from unpkg.com) */
     workerUrl?: string;
   };
 };
@@ -20,7 +21,9 @@ export type DracoLoaderOptions = LoaderOptions & {
 /**
  * Worker loader for Draco3D compressed geometries
  */
-export const DracoLoader: Loader<DracoMesh, never, DracoLoaderOptions> = {
+export const DracoLoader = {
+  dataType: null as unknown as DracoMesh,
+  batchType: null as never,
   name: 'Draco',
   id: 'draco',
   module: 'draco',
@@ -39,4 +42,4 @@ export const DracoLoader: Loader<DracoMesh, never, DracoLoaderOptions> = {
       attributeNameEntry: undefined
     }
   }
-};
+} as const satisfies Loader<DracoMesh, never, DracoLoaderOptions>;

package/src/draco-writer.ts

@@ -29,7 +29,7 @@ const DEFAULT_DRACO_WRITER_OPTIONS = {
 /**
  * Exporter for Draco3D compressed geometries
  */
-export const DracoWriter: WriterWithEncoder<DracoMesh, unknown, DracoWriterOptions> = {
+export const DracoWriter = {
   name: 'DRACO',
   id: 'draco',
   module: 'draco',
@@ -39,7 +39,7 @@ export const DracoWriter: WriterWithEncoder<DracoMesh, unknown, DracoWriterOptio
     draco: DEFAULT_DRACO_WRITER_OPTIONS
   },
   encode
-};
+} as const satisfies WriterWithEncoder<DracoMesh, unknown, DracoWriterOptions>;
 
 async function encode(data: DracoMesh, options: DracoWriterOptions = {}): Promise<ArrayBuffer> {
   // Dynamically load draco

package/src/index.ts

@@ -45,10 +45,10 @@ export {DracoWorkerLoader};
 /**
  * Loader for Draco3D compressed geometries
  */
-export const DracoLoader: LoaderWithParser<DracoMesh, never, DracoLoaderOptions> = {
+export const DracoLoader = {
   ...DracoWorkerLoader,
   parse
-};
+} as const satisfies LoaderWithParser<DracoMesh, never, DracoLoaderOptions>;
 
 async function parse(arrayBuffer: ArrayBuffer, options?: DracoLoaderOptions): Promise<DracoMesh> {
   const {draco} = await loadDracoDecoderModule(options);

package/src/lib/draco-builder.ts

@@ -273,7 +273,7 @@ export default class DracoBuilder {
     attributeName: string,
     attribute: TypedArray,
     vertexCount: number
-  ) {
+  ): number {
     if (!ArrayBuffer.isView(attribute)) {
       return -1;
     }
@@ -317,8 +317,16 @@ export default class DracoBuilder {
         return builder.AddUInt32Attribute(mesh, type, vertexCount, size, new Uint32Array(buffer));
 
       case Float32Array:
-      default:
         return builder.AddFloatAttribute(mesh, type, vertexCount, size, new Float32Array(buffer));
+
+      // case Float64Array:
+      // Add attribute does not seem to be exposed
+      //   return builder.AddAttribute(mesh, type, vertexCount, size, new Float32Array(buffer));
+
+      default:
+        // eslint-disable-next-line no-console
+        console.warn('Unsupported attribute type', attribute);
+        return -1;
     }
   }
 

package/src/lib/draco-module-loader.ts

@@ -35,14 +35,12 @@ export async function loadDracoDecoderModule(options) {
 
   // Check if a bundled draco3d library has been supplied by application
   if (modules.draco3d) {
-    loadDecoderPromise =
-      loadDecoderPromise ||
-      modules.draco3d.createDecoderModule({}).then((draco) => {
-        return {draco};
-      });
+    loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
+      return {draco};
+    });
   } else {
     // If not, dynamically load the WASM script from our CDN
-    loadDecoderPromise = loadDecoderPromise || loadDracoDecoder(options);
+    loadDecoderPromise ||= loadDracoDecoder(options);
   }
   return await loadDecoderPromise;
 }
@@ -52,14 +50,12 @@ export async function loadDracoEncoderModule(options) {
 
   // Check if a bundled draco3d library has been supplied by application
   if (modules.draco3d) {
-    loadEncoderPromise =
-      loadEncoderPromise ||
-      modules.draco3d.createEncoderModule({}).then((draco) => {
-        return {draco};
-      });
+    loadEncoderPromise ||= modules.draco3d.createEncoderModule({}).then((draco) => {
+      return {draco};
+    });
   } else {
     // If not, dynamically load the WASM script from our CDN
-    loadEncoderPromise = loadEncoderPromise || loadDracoEncoder(options);
+    loadEncoderPromise ||= loadDracoEncoder(options);
   }
   return await loadEncoderPromise;
 }

package/src/lib/draco-parser.ts

@@ -28,18 +28,17 @@ import type {
 import {getMeshBoundingBox} from '@loaders.gl/schema';
 import {getDracoSchema} from './utils/get-draco-schema';
 
-/**
- * @param topology - How triangle indices should be generated (mesh only)
- * @param attributeNameEntry
- * @param extraAttributes
- * @param quantizedAttributes
- * @param octahedronAttributes
- */
+/** Options to control draco parsing */
 export type DracoParseOptions = {
+  /** How triangle indices should be generated (mesh only) */
   topology?: 'triangle-list' | 'triangle-strip';
+  /** Specify which attribute metadata entry stores the attribute name */
   attributeNameEntry?: string;
+  /** Names and ids of extra attributes to include in the output */
   extraAttributes?: {[uniqueId: string]: number};
+  /** Skip transforms specific quantized attributes */
   quantizedAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];
+  /** Skip transforms specific octahedron encoded  attributes */
   octahedronAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];
 };
 
@@ -65,7 +64,11 @@ const DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {
   4: Uint16Array,
   5: Int32Array,
   6: Uint32Array,
+  // 7: BigInt64Array,
+  // 8: BigUint64Array,
   9: Float32Array
+  // 10: Float64Array
+  // 11: BOOL - What array type do we use for this?
 };
 
 const INDEX_ITEM_SIZE = 4;
@@ -293,14 +296,17 @@ export default class DracoParser {
     for (const loaderAttribute of Object.values(loaderData.attributes)) {
       const attributeName = this._deduceAttributeName(loaderAttribute, options);
       loaderAttribute.name = attributeName;
-      const {value, size} = this._getAttributeValues(dracoGeometry, loaderAttribute);
-      attributes[attributeName] = {
-        value,
-        size,
-        byteOffset: loaderAttribute.byte_offset,
-        byteStride: loaderAttribute.byte_stride,
-        normalized: loaderAttribute.normalized
-      };
+      const values = this._getAttributeValues(dracoGeometry, loaderAttribute);
+      if (values) {
+        const {value, size} = values;
+        attributes[attributeName] = {
+          value,
+          size,
+          byteOffset: loaderAttribute.byte_offset,
+          byteStride: loaderAttribute.byte_stride,
+          normalized: loaderAttribute.normalized
+        };
+      }
     }
 
     return attributes;
@@ -350,8 +356,13 @@ export default class DracoParser {
   _getAttributeValues(
     dracoGeometry: Mesh | PointCloud,
     attribute: DracoAttribute
-  ): {value: TypedArray; size: number} {
+  ): {value: TypedArray; size: number} | null {
     const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
+    if (!TypedArrayCtor) {
+      // eslint-disable-next-line no-console
+      console.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`);
+      return null;
+    }
     const numComponents = attribute.num_components;
     const numPoints = dracoGeometry.num_points();
     const numValues = numPoints * numComponents;