@loaders.gl/scan 5.0.0-alpha.3 → 5.0.0-alpha.5

package/dist/dist.min.js

@@ -15938,6 +15938,12 @@ return true;`);
           type: "list",
           children: [serializeArrowField(listField)]
         };
+      case LargeList2:
+        const largeListType = arrowType;
+        return {
+          type: "large-list",
+          children: [serializeArrowField(largeListType.valueField)]
+        };
       case FixedSizeList2:
         const fixedSizeList = arrowType;
         return {
@@ -15951,6 +15957,15 @@ return true;`);
           type: "struct",
           children: structType.children.map((arrowField) => serializeArrowField(arrowField))
         };
+      case SparseUnion:
+      case DenseUnion:
+        const unionType = arrowType;
+        return {
+          type: unionType instanceof DenseUnion ? "dense-union" : "sparse-union",
+          typeIds: unionType.typeIds,
+          children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+          typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+        };
       case Dictionary:
         const dictionaryType = arrowType;
         return {
@@ -15979,6 +15994,10 @@ return true;`);
           const field = deserializeArrowField(dataType.children[0], options);
           return new List2(field);
         }
+        case "large-list": {
+          const field = deserializeArrowField(dataType.children[0], options);
+          return new LargeList2(field);
+        }
         case "fixed-size-list": {
           const child = deserializeArrowField(dataType.children[0], options);
           return new FixedSizeList2(dataType.listSize, child);
@@ -15991,6 +16010,13 @@ return true;`);
           );
           return new Struct(children);
         }
+        case "sparse-union":
+        case "dense-union": {
+          const children = dataType.children.map(
+            (arrowField) => deserializeArrowField(arrowField, options)
+          );
+          return dataType.type === "dense-union" ? new DenseUnion(dataType.typeIds, children) : new SparseUnion(dataType.typeIds, children);
+        }
         case "dictionary": {
           return new Dictionary(
             deserializeArrowType(dataType.dictionary, options),
@@ -17176,6 +17202,9 @@ return true;`);
     if (left instanceof Date && right instanceof Date) {
       return compareNumbers2(left.getTime(), right.getTime());
     }
+    if (typeof left === "number" && right instanceof Date) {
+      return compareNumbers2(left, right.getTime());
+    }
     if (left instanceof Uint8Array && right instanceof Uint8Array) {
       return compareBinary(left, right);
     }
@@ -17574,29 +17603,29 @@ return true;`);
   }
 
   // src/scan-engine.ts
-  var scanBackendLoaders = /* @__PURE__ */ new Map();
+  var scanBackends = /* @__PURE__ */ new Map();
   var arrowScanBackend = Object.freeze({
     name: "arrow",
     query: queryArrowTable,
-    queryAsync: async (sourceTable, options) => queryArrowTable(sourceTable, options),
+    queryAsync: (sourceTable, options) => Promise.resolve().then(queryArrowTable.bind(null, sourceTable, options)),
     explain: explainArrowTableQuery
   });
-  scanBackendLoaders.set("arrow", () => arrowScanBackend);
+  scanBackends.set("arrow", arrowScanBackend);
   function registerScanBackend(name, loader) {
     if (!name || !loader) {
       throw new Error("A scan backend name and loader are required");
     }
-    scanBackendLoaders.set(name, loader);
+    scanBackends.set(name, loader);
   }
   async function createScanEngine(options = {}) {
     const backendName = options.backend || "arrow";
-    const loader = scanBackendLoaders.get(backendName);
-    if (!loader) {
+    const registeredBackend = scanBackends.get(backendName);
+    if (!registeredBackend) {
       throw new Error(
         `Scan backend "${backendName}" is not registered. The built-in backend is "arrow".`
       );
     }
-    const backend = await loader();
+    const backend = typeof registeredBackend === "function" ? await registeredBackend() : registeredBackend;
     if (backend.name !== backendName) {
       throw new Error(
         `Scan backend loader returned "${backend.name}" while "${backendName}" was requested.`