replace class with proxy creator; use in loader

Author: frasercl

src/loaders/OmeZarrLoader.ts

@@ -44,6 +44,7 @@ import type {
   NumericZarrArray,
 } from "./zarr_utils/types.js";
 import { VolumeLoadError, VolumeLoadErrorType, wrapVolumeLoadError } from "./VolumeLoadError.js";
+import cachingArray from "./zarr_utils/CachingArray.js";
 import { validateOMEZarrMetadata } from "./zarr_utils/validation.js";
 
 const CHUNK_REQUEST_CANCEL_REASON = "chunk request cancelled";
@@ -169,7 +170,7 @@ class OMEZarrLoader extends ThreadableVolumeLoader {
 
     // Create one `ZarrSource` per URL
     const sourceProms = urlsArr.map(async (url, i) => {
-      const store = new WrappedStore<RequestInit>(new FetchStore(url), cache, queue);
+      const store = new WrappedStore<RequestInit>(new FetchStore(url), queue);
       const root = zarr.root(store);
 
       const group = await zarr
@@ -191,6 +192,7 @@ class OMEZarrLoader extends ThreadableVolumeLoader {
       const lvlProms = multiscaleMetadata.datasets.map(({ path }) =>
         zarr
           .open(root.resolve(path), { kind: "array" })
+          .then((array) => (cache ? cachingArray(array, cache) : array))
           .catch(
             wrapVolumeLoadError(
               `Failed to open scale level ${path} of OME-Zarr data at ${url}`,

src/loaders/zarr_utils/CachingArray.ts

@@ -1,31 +1,32 @@
-import { Array, ArrayMetadata, Chunk, DataType } from "@zarrita/core";
+import { Array as ZarrArray, Chunk, DataType } from "@zarrita/core";
 import VolumeCache, { CacheData } from "../../VolumeCache";
-import { AbsolutePath, Readable } from "@zarrita/storage";
+import { Readable } from "@zarrita/storage";
 import { pathIsToMetadata } from "./utils";
 
-const ZARR_EXTS = [".zarray", ".zgroup", ".zattrs", "zarr.json"];
-
 const isChunk = (data: CacheData): data is Chunk<DataType> => (data as Chunk<DataType>).data !== undefined;
 
-export default class CachingArray<T extends DataType, Store extends Readable = Readable> extends Array<T, Store> {
-  constructor(store: Store, path: AbsolutePath, metadata: ArrayMetadata<T>, private cache?: VolumeCache) {
-    super(store, path, metadata);
-  }
-
-  async getChunk(coords: number[], opts?: Parameters<Store["get"]>[1]): Promise<Chunk<T>> {
-    if (!this.cache || pathIsToMetadata(this.path)) {
-      return super.getChunk(coords, opts);
+export default function cachingArray<T extends DataType, Store extends Readable = Readable>(
+  array: ZarrArray<T, Store>,
+  cache: VolumeCache
+): ZarrArray<T, Store> {
+  const getChunk = async (coords: number[], opts?: Parameters<Store["get"]>[1]): Promise<Chunk<T>> => {
+    if (pathIsToMetadata(array.path)) {
+      return array.getChunk(coords, opts);
     }
 
-    const trailingSlash = this.path.endsWith("/") ? "" : "/";
-    const fullKey = this.path + trailingSlash + coords.join(",");
-    const cacheResult = this.cache.get(fullKey);
+    const trailingSlash = array.path.endsWith("/") ? "" : "/";
+    const fullKey = array.path + trailingSlash + coords.join(",");
+    const cacheResult = cache.get(fullKey);
     if (cacheResult && isChunk(cacheResult)) {
       return cacheResult;
     }
 
-    const result = await super.getChunk(coords, opts);
-    this.cache.insert(fullKey, result);
+    const result = await array.getChunk(coords, opts);
+    cache.insert(fullKey, result);
     return result;
-  }
+  };
+
+  return new Proxy(array, {
+    get: (target, prop, reciever) => (prop === "getChunk" ? getChunk : Reflect.get(target, prop, reciever)),
+  });
 }