dicom-curate 0.28.0 → 0.28.1

package/dist/esm/applyMappingsWorker.js

@@ -80039,7 +80039,7 @@ async function curateOne({
       hashPartSize
     );
     fileArrayBuffer = null;
-    const previousPostMappedHash = previousMappedFileInfo ? previousMappedFileInfo(clonedMapResults.outputFilePath)?.postMappedHash : void 0;
+    const previousPostMappedHash = previousMappedFileInfo ? (await previousMappedFileInfo(clonedMapResults.outputFilePath))?.postMappedHash : void 0;
     if (previousPostMappedHash !== void 0 && previousPostMappedHash === postMappedHash) {
       return noMapResult(clonedMapResults.outputFilePath);
     }
@@ -85792,9 +85792,6 @@ function deserializeMappingOptions(serializedMappingOptions) {
   return { ...rest, curationSpec };
 }
 
-// src/types.ts
-var OUTPUT_FILE_PREFIX = "output#";
-
 // src/worker.ts
 var wt = null;
 async function initializeNodeWorker() {
@@ -85848,51 +85845,60 @@ function postErrorResponse(error2, fileInfo) {
     });
   }
 }
-var postMappedFileInfo;
+var pendingLookupResolve = null;
+function lookupMappedFileInfo(outputPath) {
+  return new Promise((resolve) => {
+    pendingLookupResolve = resolve;
+    globalThis.postMessage({
+      response: "lookup",
+      outputPath
+    });
+  });
+}
 fixupNodeWorkerEnvironment().then(() => {
   globalThis.addEventListener(
     "message",
     (event) => {
-      switch (event.data.request) {
-        case "fileInfoIndex": {
-          postMappedFileInfo = event.data.fileInfoIndex;
-          break;
-        }
-        case "apply": {
-          const { serializedMappingOptions } = event.data;
-          const mappingOptions = deserializeMappingOptions(
-            serializedMappingOptions
-          );
-          const fileInfo = event.data.fileInfo;
-          try {
-            curateOne({
-              fileInfo,
-              outputTarget: event.data.outputTarget ?? {},
-              hashMethod: event.data.hashMethod,
-              hashPartSize: event.data.hashPartSize,
-              mappingOptions,
-              previousSourceFileInfo: event.data.previousFileInfo,
-              previousMappedFileInfo: (targetName) => {
-                const hash2 = postMappedFileInfo?.[OUTPUT_FILE_PREFIX + targetName];
-                return hash2;
-              }
-            }).then((mapResults) => {
-              globalThis.postMessage({
-                response: "finished",
-                mapResults
-              });
-            }).catch((error2) => {
-              postErrorResponse(error2, fileInfo);
-            });
-          } catch (error2) {
-            postErrorResponse(error2, fileInfo);
-          }
-          break;
+      if ("response" in event.data && event.data.response === "lookupResult") {
+        const resolve = pendingLookupResolve;
+        pendingLookupResolve = null;
+        if (resolve) {
+          const hash2 = event.data.postMappedHash;
+          resolve(hash2 ? { postMappedHash: hash2 } : void 0);
         }
-        default:
-          console.error(
-            `Unknown request ${event.data.request}`
-          );
+        return;
+      }
+      const data10 = event.data;
+      if (data10.request !== "apply") {
+        console.error(
+          `Unknown request ${data10.request}`
+        );
+        return;
+      }
+      const { serializedMappingOptions } = data10;
+      const mappingOptions = deserializeMappingOptions(
+        serializedMappingOptions
+      );
+      const fileInfo = data10.fileInfo;
+      try {
+        curateOne({
+          fileInfo,
+          outputTarget: data10.outputTarget ?? {},
+          hashMethod: data10.hashMethod,
+          hashPartSize: data10.hashPartSize,
+          mappingOptions,
+          previousSourceFileInfo: data10.previousFileInfo,
+          previousMappedFileInfo: lookupMappedFileInfo
+        }).then((mapResults) => {
+          globalThis.postMessage({
+            response: "finished",
+            mapResults
+          });
+        }).catch((error2) => {
+          postErrorResponse(error2, fileInfo);
+        });
+      } catch (error2) {
+        postErrorResponse(error2, fileInfo);
       }
     }
   );

package/dist/esm/curateOne.js

@@ -73748,7 +73748,7 @@ async function curateOne({
       hashPartSize
     );
     fileArrayBuffer = null;
-    const previousPostMappedHash = previousMappedFileInfo ? previousMappedFileInfo(clonedMapResults.outputFilePath)?.postMappedHash : void 0;
+    const previousPostMappedHash = previousMappedFileInfo ? (await previousMappedFileInfo(clonedMapResults.outputFilePath))?.postMappedHash : void 0;
     if (previousPostMappedHash !== void 0 && previousPostMappedHash === postMappedHash) {
       return noMapResult(clonedMapResults.outputFilePath);
     }

package/dist/esm/index.js

@@ -81599,7 +81599,7 @@ async function curateOne({
       hashPartSize
     );
     fileArrayBuffer = null;
-    const previousPostMappedHash = previousMappedFileInfo ? previousMappedFileInfo(clonedMapResults.outputFilePath)?.postMappedHash : void 0;
+    const previousPostMappedHash = previousMappedFileInfo ? (await previousMappedFileInfo(clonedMapResults.outputFilePath))?.postMappedHash : void 0;
     if (previousPostMappedHash !== void 0 && previousPostMappedHash === postMappedHash) {
       return noMapResult(clonedMapResults.outputFilePath);
     }
@@ -87465,6 +87465,9 @@ async function getHttpOutputHeaders(outputTarget) {
   return outputTarget;
 }
 
+// src/types.ts
+var OUTPUT_FILE_PREFIX = "output#";
+
 // src/mappingWorkerPool.ts
 var mappingWorkerOptions = {};
 var availableMappingWorkers = [];
@@ -87512,10 +87515,7 @@ async function initializeMappingWorkers(skipCollectingMappings, fileInfoIndex, p
     progressCallback = progressCb;
   const effectiveWorkerCount = workerCount ?? Math.min(await getHardwareConcurrency(), 8);
   const workers = await Promise.all(
-    Array.from(
-      { length: effectiveWorkerCount },
-      () => createMappingWorker(fileInfoIndex)
-    )
+    Array.from({ length: effectiveWorkerCount }, () => createMappingWorker())
   );
   availableMappingWorkers.push(...workers);
 }
@@ -87615,7 +87615,7 @@ function recoverCrashedWorker(mappingWorker, errorMessage) {
   });
   dispatchMappingJobs();
   pendingReplacements += 1;
-  void createMappingWorker(currentFileInfoIndex).then((worker) => {
+  void createMappingWorker().then((worker) => {
     pendingReplacements -= 1;
     availableMappingWorkers.push(worker);
     dispatchMappingJobs();
@@ -87625,7 +87625,7 @@ function recoverCrashedWorker(mappingWorker, errorMessage) {
     dispatchMappingJobs();
   });
 }
-async function createMappingWorker(fileInfoIndex) {
+async function createMappingWorker() {
   const mappingWorker = await createWorker(
     new URL("./applyMappingsWorker.js", import.meta.url),
     { type: "module" }
@@ -87645,18 +87645,16 @@ async function createMappingWorker(fileInfoIndex) {
       }
     });
   }
-  if (fileInfoIndex !== void 0) {
-    const postMappedOnly = Object.fromEntries(
-      Object.entries(fileInfoIndex).filter(
-        ([_key, value]) => !!value.postMappedHash
-      )
-    );
-    mappingWorker.postMessage({
-      request: "fileInfoIndex",
-      fileInfoIndex: postMappedOnly
-    });
-  }
   mappingWorker.addEventListener("message", (event) => {
+    if (event.data.response === "lookup") {
+      const outputPath = event.data.outputPath;
+      const entry = currentFileInfoIndex?.[OUTPUT_FILE_PREFIX + outputPath];
+      mappingWorker.postMessage({
+        response: "lookupResult",
+        postMappedHash: entry?.postMappedHash
+      });
+      return;
+    }
     lastWorkerProgressTime = Date.now();
     workerCurrentFile.delete(mappingWorker);
     switch (event.data.response) {
@@ -87715,9 +87713,6 @@ function getLastWorkerProgressTime() {
   return lastWorkerProgressTime;
 }
 
-// src/types.ts
-var OUTPUT_FILE_PREFIX = "output#";
-
 // src/index.ts
 function requiresDateOffset(deIdOpts) {
   return deIdOpts !== "Off" && deIdOpts.retainLongitudinalTemporalInformationOptions === "Offset";

package/dist/esm/mappingWorkerPool.js

@@ -12043,6 +12043,9 @@ function dataURLToBlobURL(dataURL) {
   return URL.createObjectURL(blob);
 }
 
+// src/types.ts
+var OUTPUT_FILE_PREFIX = "output#";
+
 // src/mappingWorkerPool.ts
 var mappingWorkerOptions = {};
 var availableMappingWorkers = [];
@@ -12090,10 +12093,7 @@ async function initializeMappingWorkers(skipCollectingMappings, fileInfoIndex, p
     progressCallback = progressCb;
   const effectiveWorkerCount = workerCount ?? Math.min(await getHardwareConcurrency(), 8);
   const workers = await Promise.all(
-    Array.from(
-      { length: effectiveWorkerCount },
-      () => createMappingWorker(fileInfoIndex)
-    )
+    Array.from({ length: effectiveWorkerCount }, () => createMappingWorker())
   );
   availableMappingWorkers.push(...workers);
 }
@@ -12193,7 +12193,7 @@ function recoverCrashedWorker(mappingWorker, errorMessage) {
   });
   dispatchMappingJobs();
   pendingReplacements += 1;
-  void createMappingWorker(currentFileInfoIndex).then((worker) => {
+  void createMappingWorker().then((worker) => {
     pendingReplacements -= 1;
     availableMappingWorkers.push(worker);
     dispatchMappingJobs();
@@ -12203,7 +12203,7 @@ function recoverCrashedWorker(mappingWorker, errorMessage) {
     dispatchMappingJobs();
   });
 }
-async function createMappingWorker(fileInfoIndex) {
+async function createMappingWorker() {
   const mappingWorker = await createWorker(
     new URL("./applyMappingsWorker.js", import.meta.url),
     { type: "module" }
@@ -12223,18 +12223,16 @@ async function createMappingWorker(fileInfoIndex) {
       }
     });
   }
-  if (fileInfoIndex !== void 0) {
-    const postMappedOnly = Object.fromEntries(
-      Object.entries(fileInfoIndex).filter(
-        ([_key, value]) => !!value.postMappedHash
-      )
-    );
-    mappingWorker.postMessage({
-      request: "fileInfoIndex",
-      fileInfoIndex: postMappedOnly
-    });
-  }
   mappingWorker.addEventListener("message", (event) => {
+    if (event.data.response === "lookup") {
+      const outputPath = event.data.outputPath;
+      const entry = currentFileInfoIndex?.[OUTPUT_FILE_PREFIX + outputPath];
+      mappingWorker.postMessage({
+        response: "lookupResult",
+        postMappedHash: entry?.postMappedHash
+      });
+      return;
+    }
     lastWorkerProgressTime = Date.now();
     workerCurrentFile.delete(mappingWorker);
     switch (event.data.response) {

package/dist/types/applyMappingsWorker.d.ts

@@ -1,4 +1,4 @@
-import { type TFileInfo, type TFileInfoIndex, type THashMethod, type TOutputTarget, type TSerializedMappingOptions } from './types';
+import { type TFileInfo, type THashMethod, type TOutputTarget, type TSerializedMappingOptions } from './types';
 export type MappingRequest = {
     request: 'apply';
     fileInfo: TFileInfo;
@@ -11,7 +11,9 @@ export type MappingRequest = {
     hashMethod?: THashMethod;
     hashPartSize?: number;
     serializedMappingOptions: TSerializedMappingOptions;
-} | {
-    request: 'fileInfoIndex';
-    fileInfoIndex?: TFileInfoIndex;
+};
+/** Response sent back from the main thread for a fileInfoIndex lookup. */
+export type LookupResponse = {
+    response: 'lookupResult';
+    postMappedHash?: string;
 };

package/dist/types/curateOne.d.ts

@@ -10,9 +10,9 @@ export type TCurateOneArgs = {
         mtime?: string;
         preMappedHash?: string;
     };
-    previousMappedFileInfo?: (mappedFileName: string) => {
+    previousMappedFileInfo?: (mappedFileName: string) => Promise<{
         postMappedHash?: string;
-    } | undefined;
+    } | undefined>;
 };
 export declare function curateOne({ fileInfo, outputTarget, mappingOptions, hashMethod, hashPartSize, previousSourceFileInfo, previousMappedFileInfo, }: TCurateOneArgs): Promise<Omit<Partial<TMapResults>, 'anomalies'> & {
     anomalies: TMapResults['anomalies'];

package/dist/umd/dicom-curate.umd.js

@@ -49170,7 +49170,8 @@
               // allocation that can now be GC'd.
               fileArrayBuffer = null;
               const previousPostMappedHash = previousMappedFileInfo
-                  ? previousMappedFileInfo(clonedMapResults.outputFilePath)?.postMappedHash
+                  ? (await previousMappedFileInfo(clonedMapResults.outputFilePath))
+                      ?.postMappedHash
                   : undefined;
               if (previousPostMappedHash !== undefined &&
                   previousPostMappedHash === postMappedHash) {
@@ -62473,9 +62474,6 @@
           return { ...rest, curationSpec };
       }
 
-      // Kept here, because it is also imported from the worker
-      const OUTPUT_FILE_PREFIX = 'output#';
-
       let wt = null;
       // Lazy initialization for Node.js worker_threads
       async function initializeNodeWorker() {
@@ -62544,52 +62542,72 @@
               });
           }
       }
-      let postMappedFileInfo;
+      /**
+       * Pending lookup resolve function. At most one lookup is in flight at a time
+       * because each worker processes one file at a time sequentially.
+       */
+      let pendingLookupResolve = null;
+      /**
+       * Request a postMappedHash lookup from the main thread.
+       * Returns a Promise that resolves when the main thread replies with
+       * a 'lookupResult' message.
+       */
+      function lookupMappedFileInfo(outputPath) {
+          return new Promise((resolve) => {
+              pendingLookupResolve = resolve;
+              globalThis.postMessage({
+                  response: 'lookup',
+                  outputPath,
+              });
+          });
+      }
       fixupNodeWorkerEnvironment()
           .then(() => {
           globalThis.addEventListener('message', (event) => {
-              switch (event.data.request) {
-                  case 'fileInfoIndex': {
-                      postMappedFileInfo = event.data.fileInfoIndex;
-                      break;
-                  }
-                  case 'apply': {
-                      const { serializedMappingOptions } = event.data;
-                      const mappingOptions = deserializeMappingOptions(serializedMappingOptions);
-                      const fileInfo = event.data.fileInfo;
-                      try {
-                          curateOne({
-                              fileInfo,
-                              outputTarget: event.data.outputTarget ?? {},
-                              hashMethod: event.data.hashMethod,
-                              hashPartSize: event.data.hashPartSize,
-                              mappingOptions,
-                              previousSourceFileInfo: event.data.previousFileInfo,
-                              previousMappedFileInfo: (targetName) => {
-                                  const hash = postMappedFileInfo?.[OUTPUT_FILE_PREFIX + targetName];
-                                  return hash;
-                              },
-                          })
-                              .then((mapResults) => {
-                              // Send finished message for completion
-                              globalThis.postMessage({
-                                  response: 'finished',
-                                  mapResults: mapResults,
-                              });
-                          })
-                              .catch((error) => {
-                              // also catch promise rejections
-                              postErrorResponse(error, fileInfo);
-                          });
-                      }
-                      catch (error) {
-                          postErrorResponse(error, fileInfo);
-                          // no need to throw here, it would terminate the worker
-                      }
-                      break;
+              // Handle lookup response from main thread
+              if ('response' in event.data &&
+                  event.data.response === 'lookupResult') {
+                  const resolve = pendingLookupResolve;
+                  pendingLookupResolve = null;
+                  if (resolve) {
+                      const hash = event.data.postMappedHash;
+                      resolve(hash ? { postMappedHash: hash } : undefined);
                   }
-                  default:
-                      console.error(`Unknown request ${event.data.request}`);
+                  return;
+              }
+              const data = event.data;
+              if (data.request !== 'apply') {
+                  console.error(`Unknown request ${data.request}`);
+                  return;
+              }
+              const { serializedMappingOptions } = data;
+              const mappingOptions = deserializeMappingOptions(serializedMappingOptions);
+              const fileInfo = data.fileInfo;
+              try {
+                  curateOne({
+                      fileInfo,
+                      outputTarget: data.outputTarget ?? {},
+                      hashMethod: data.hashMethod,
+                      hashPartSize: data.hashPartSize,
+                      mappingOptions,
+                      previousSourceFileInfo: data.previousFileInfo,
+                      previousMappedFileInfo: lookupMappedFileInfo,
+                  })
+                      .then((mapResults) => {
+                      // Send finished message for completion
+                      globalThis.postMessage({
+                          response: 'finished',
+                          mapResults: mapResults,
+                      });
+                  })
+                      .catch((error) => {
+                      // also catch promise rejections
+                      postErrorResponse(error, fileInfo);
+                  });
+              }
+              catch (error) {
+                  postErrorResponse(error, fileInfo);
+                  // no need to throw here, it would terminate the worker
               }
           });
       })
@@ -111283,7 +111301,8 @@
             // allocation that can now be GC'd.
             fileArrayBuffer = null;
             const previousPostMappedHash = previousMappedFileInfo
-                ? previousMappedFileInfo(clonedMapResults.outputFilePath)?.postMappedHash
+                ? (await previousMappedFileInfo(clonedMapResults.outputFilePath))
+                    ?.postMappedHash
                 : undefined;
             if (previousPostMappedHash !== undefined &&
                 previousPostMappedHash === postMappedHash) {
@@ -126881,6 +126900,9 @@
         return outputTarget;
     }
 
+    // Kept here, because it is also imported from the worker
+    const OUTPUT_FILE_PREFIX = 'output#';
+
     /**
      * Mapping worker pool management.
      *
@@ -126906,8 +126928,8 @@
     // The termination condition in dispatchMappingJobs() waits for this to reach 0
     // before finishing, to avoid orphaning in-flight replacements.
     let pendingReplacements = 0;
-    // Stored fileInfoIndex from initializeMappingWorkers, needed when spawning
-    // replacement workers after a crash.
+    // Stored fileInfoIndex from initializeMappingWorkers, used for lookup
+    // responses when workers query for previousMappedFileInfo.
     let currentFileInfoIndex;
     // Shared state accessed by both scan worker (in index.ts) and dispatch (here).
     // Exported so index.ts can push items and set the scan-finished flag.
@@ -126968,7 +126990,7 @@
         if (progressCb)
             progressCallback = progressCb;
         const effectiveWorkerCount = workerCount ?? Math.min(await getHardwareConcurrency(), 8);
-        const workers = await Promise.all(Array.from({ length: effectiveWorkerCount }, () => createMappingWorker(fileInfoIndex)));
+        const workers = await Promise.all(Array.from({ length: effectiveWorkerCount }, () => createMappingWorker()));
         availableMappingWorkers.push(...workers);
     }
     /**
@@ -127100,7 +127122,7 @@
         // Spawn a replacement worker so the pool doesn't shrink permanently.
         // A directory with many problematic files could otherwise kill all workers.
         pendingReplacements += 1;
-        void createMappingWorker(currentFileInfoIndex)
+        void createMappingWorker()
             .then((worker) => {
             pendingReplacements -= 1;
             availableMappingWorkers.push(worker);
@@ -127117,7 +127139,7 @@
      * Used by both initializeMappingWorkers (initial pool) and recoverCrashedWorker
      * (replacement after crash).
      */
-    async function createMappingWorker(fileInfoIndex) {
+    async function createMappingWorker() {
         const mappingWorker = await createWorker(new URL('./applyMappingsWorker.js', (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('dicom-curate.umd.js', document.baseURI).href))), { type: 'module' });
         // Handle worker-level errors (uncaught exceptions, DataCloneError, etc.).
         // The previous `onerror = console.error` only logged and did not recover
@@ -127139,14 +127161,20 @@
                 }
             });
         }
-        if (fileInfoIndex !== undefined) {
-            const postMappedOnly = Object.fromEntries(Object.entries(fileInfoIndex).filter(([_key, value]) => !!value.postMappedHash));
-            mappingWorker.postMessage({
-                request: 'fileInfoIndex',
-                fileInfoIndex: postMappedOnly,
-            });
-        }
         mappingWorker.addEventListener('message', (event) => {
+            // Handle lookup requests from the worker. The worker sends these when
+            // curateOne needs to check if a mapped file was already uploaded
+            // (previousMappedFileInfo). The index is kept on the main thread to
+            // avoid copying 200k+ entries to every worker.
+            if (event.data.response === 'lookup') {
+                const outputPath = event.data.outputPath;
+                const entry = currentFileInfoIndex?.[OUTPUT_FILE_PREFIX + outputPath];
+                mappingWorker.postMessage({
+                    response: 'lookupResult',
+                    postMappedHash: entry?.postMappedHash,
+                });
+                return;
+            }
             // Any message from a worker means progress is being made.
             lastWorkerProgressTime = Date.now();
             workerCurrentFile.delete(mappingWorker);
@@ -127218,9 +127246,6 @@
         return lastWorkerProgressTime;
     }
 
-    // Kept here, because it is also imported from the worker
-    const OUTPUT_FILE_PREFIX = 'output#';
-
     function requiresDateOffset(deIdOpts) {
         return (deIdOpts !== 'Off' &&
             deIdOpts.retainLongitudinalTemporalInformationOptions === 'Offset');