@loaders.gl/draco 4.3.4 → 4.4.0-alpha.10

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

@@ -2,7 +2,7 @@
 // https://github.com/mrdoob/three.js/blob/398c4f39ebdb8b23eefd4a7a5ec49ec0c96c7462/examples/jsm/loaders/DRACOLoader.js
 // by Don McCurdy / https://www.donmccurdy.com / MIT license
 
-import {loadLibrary} from '@loaders.gl/worker-utils';
+import {isBrowser, loadLibrary, type LoadLibraryOptions} from '@loaders.gl/worker-utils';
 
 const DRACO_DECODER_VERSION = '1.5.6';
 const DRACO_ENCODER_VERSION = '1.4.1';
@@ -30,7 +30,10 @@ export const DRACO_EXTERNAL_LIBRARY_URLS = {
 let loadDecoderPromise;
 let loadEncoderPromise;
 
-export async function loadDracoDecoderModule(options) {
+export async function loadDracoDecoderModule(
+  options: LoadLibraryOptions = {},
+  type: 'wasm' | 'js'
+) {
   const modules = options.modules || {};
 
   // Check if a bundled draco3d library has been supplied by application
@@ -40,12 +43,12 @@ export async function loadDracoDecoderModule(options) {
     });
   } else {
     // If not, dynamically load the WASM script from our CDN
-    loadDecoderPromise ||= loadDracoDecoder(options);
+    loadDecoderPromise ||= loadDracoDecoder(options, type);
   }
   return await loadDecoderPromise;
 }
 
-export async function loadDracoEncoderModule(options) {
+export async function loadDracoEncoderModule(options: LoadLibraryOptions) {
   const modules = options.modules || {};
 
   // Check if a bundled draco3d library has been supplied by application
@@ -60,12 +63,24 @@ export async function loadDracoEncoderModule(options) {
   return await loadEncoderPromise;
 }
 
-// DRACO DECODER LOADING
+function getLibraryExport(library: any, exportName: string): any {
+  if (library && typeof library === 'object') {
+    if (library.default) {
+      return library.default;
+    }
+    if (library[exportName]) {
+      return library[exportName];
+    }
+  }
+  return library;
+}
 
-async function loadDracoDecoder(options) {
+// DRACO DECODER LOADING
+/** @todo - type the options, they are inconsistent */
+async function loadDracoDecoder(options: LoadLibraryOptions, type: 'wasm' | 'js') {
   let DracoDecoderModule;
   let wasmBinary;
-  switch (options.draco && options.draco.decoderType) {
+  switch (type) {
     case 'js':
       DracoDecoderModule = await loadLibrary(
         DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
@@ -77,28 +92,59 @@ async function loadDracoDecoder(options) {
 
     case 'wasm':
     default:
-      [DracoDecoderModule, wasmBinary] = await Promise.all([
-        await loadLibrary(
-          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
-          'draco',
-          options,
-          DRACO_EXTERNAL_LIBRARIES.DECODER
-        ),
-        await loadLibrary(
-          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
-          'draco',
-          options,
-          DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
-        )
-      ]);
+      try {
+        [DracoDecoderModule, wasmBinary] = await Promise.all([
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+            'draco',
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER
+          ),
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+            'draco',
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+          )
+        ]);
+      } catch {
+        DracoDecoderModule = null;
+        wasmBinary = null;
+      }
   }
-  // Depends on how import happened...
+  DracoDecoderModule = getLibraryExport(DracoDecoderModule, 'DracoDecoderModule');
   // @ts-ignore
   DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+
+  // In Node environments without network access, fall back to local copies in the repo.
+  if (!DracoDecoderModule && !isBrowser) {
+    [DracoDecoderModule, wasmBinary] = await Promise.all([
+      await loadLibrary(
+        DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+        'draco',
+        {...options, useLocalLibraries: true},
+        DRACO_EXTERNAL_LIBRARIES.DECODER
+      ),
+      await loadLibrary(
+        DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+        'draco',
+        {...options, useLocalLibraries: true},
+        DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+      )
+    ]);
+    DracoDecoderModule = getLibraryExport(DracoDecoderModule, 'DracoDecoderModule');
+    // @ts-ignore
+    DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+  }
+
   return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
 }
 
 function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
+  if (typeof DracoDecoderModule !== 'function') {
+    throw new Error('DracoDecoderModule could not be loaded');
+  }
+
   const options: {wasmBinary?: any} = {};
   if (wasmBinary) {
     options.wasmBinary = wasmBinary;
@@ -114,16 +160,34 @@ function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
 
 // ENCODER
 
-async function loadDracoEncoder(options) {
+async function loadDracoEncoder(options: LoadLibraryOptions) {
   let DracoEncoderModule = await loadLibrary(
     DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.ENCODER],
     'draco',
     options,
     DRACO_EXTERNAL_LIBRARIES.ENCODER
   );
+  DracoEncoderModule = getLibraryExport(DracoEncoderModule, 'DracoEncoderModule');
   // @ts-ignore
   DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;
 
+  // In Node environments without network access, fall back to local copies in the repo.
+  if (!DracoEncoderModule && !isBrowser) {
+    DracoEncoderModule = await loadLibrary(
+      DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.ENCODER],
+      'draco',
+      {...options, useLocalLibraries: true},
+      DRACO_EXTERNAL_LIBRARIES.ENCODER
+    );
+    DracoEncoderModule = getLibraryExport(DracoEncoderModule, 'DracoEncoderModule');
+    // @ts-ignore
+    DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;
+  }
+
+  if (typeof DracoEncoderModule !== 'function') {
+    throw new Error('DracoEncoderModule could not be loaded');
+  }
+
   return new Promise((resolve) => {
     DracoEncoderModule({
       onModuleLoaded: (draco) => resolve({draco}) // Module is Promise-like. Wrap in object to avoid loop.

package/src/lib/draco-parser.ts

@@ -25,7 +25,7 @@ import type {
   DracoOctahedronTransform
 } from './draco-types';
 
-import {getMeshBoundingBox} from '@loaders.gl/schema';
+import {getMeshBoundingBox} from '@loaders.gl/schema-utils';
 import {getDracoSchema} from './utils/get-draco-schema';
 
 /** Options to control draco parsing */
@@ -257,6 +257,7 @@ export default class DracoParser {
         case 'triangle-strip':
           return {
             topology: 'triangle-strip',
+            // TODO - mode is wrong?
             mode: 4, // GL.TRIANGLES
             attributes,
             indices: {
@@ -268,6 +269,7 @@ export default class DracoParser {
         default:
           return {
             topology: 'triangle-list',
+            // TODO - mode is wrong?
             mode: 5, // GL.TRIANGLE_STRIP
             attributes,
             indices: {

package/src/lib/utils/get-draco-schema.ts

@@ -1,4 +1,5 @@
-import {deduceMeshField, MeshAttribute, Schema, Field} from '@loaders.gl/schema';
+import {MeshAttribute, Schema, Field} from '@loaders.gl/schema';
+import {deduceMeshField} from '@loaders.gl/schema-utils';
 import type {DracoAttribute, DracoLoaderData, DracoMetadataEntry} from '../draco-types';
 
 /** Extract an arrow-like schema from a Draco mesh */

package/src/workers/draco-writer-worker-node.cjs

@@ -0,0 +1,18 @@
+// `@loaders.gl/draco` is an ESM package, so Node.js treats `.js` files as ES modules when executed directly.
+// The prebuilt Node worker bundle is emitted as CommonJS, so we load it by compiling it as CommonJS.
+/* @ts-expect-error TS doesn't like require in an ESM context */
+const fs = require('node:fs');
+/* @ts-expect-error TS doesn't like require in an ESM context */
+const path = require('node:path');
+/* @ts-expect-error TS doesn't like require in an ESM context */
+const Module = require('node:module');
+
+const filename = path.join(__dirname, '../../dist/draco-writer-worker-node.js');
+const code = fs.readFileSync(filename, 'utf8');
+
+const workerModule = new Module(filename);
+workerModule.filename = filename;
+// eslint-disable-next-line no-underscore-dangle
+workerModule.paths = Module._nodeModulePaths(path.dirname(filename));
+// eslint-disable-next-line no-underscore-dangle
+workerModule._compile(code, filename);