dicom-curate 0.2.0 → 0.3.0

package/dist/esm/index.js

@@ -96,14 +96,12 @@ function initializeMappingWorkers() {
                     mapResultsList.push(event.data.mapResults);
                     workersActive -= 1;
                     // Report progress
-                    if (progressCallback) {
-                        progressCallback({
-                            response: 'progress',
-                            mapResults: event.data.mapResults,
-                            processedFiles: mapResultsList.length,
-                            totalFiles: filesToProcess.length + mapResultsList.length + workersActive,
-                        });
-                    }
+                    progressCallback({
+                        response: 'progress',
+                        mapResults: event.data.mapResults,
+                        processedFiles: mapResultsList.length,
+                        totalFiles: filesToProcess.length + mapResultsList.length + workersActive,
+                    });
                     dispatchMappingJobs();
                     if (mapResultsList.length % 100 === 0) {
                         console.log(`Finished mapping ${mapResultsList.length} files`);
@@ -142,6 +140,12 @@ function dispatchMappingJobs() {
         clearCaches();
         console.log(`Finished mapping ${mapResultsList.length} files`);
         console.log('job is finished');
+        progressCallback({
+            response: 'done',
+            mapResultsList: mapResultsList,
+            processedFiles: mapResultsList.length,
+            totalFiles: mapResultsList.length,
+        });
     }
 }
 function collectMappingOptions(organizeOptions) {
@@ -197,31 +201,44 @@ function queueFilesForMapping(organizeOptions) {
 let progressCallback;
 function curateMany(organizeOptions, onProgress) {
     return __awaiter(this, void 0, void 0, function* () {
-        progressCallback = onProgress;
-        // create the mapping workers
-        initializeMappingWorkers();
-        // Set global mappingWorkerOptions
-        mappingWorkerOptions = (yield collectMappingOptions(organizeOptions));
-        //
-        // If the request provides a directory, then use the worker
-        // to recursively convert to fileSystemHandles.
-        // If the request provides a list of File objects,
-        // send them to the mapping workers directly.
-        //
-        if (organizeOptions.inputType === 'directory') {
-            const fileListWorker = initializeFileListWorker();
-            fileListWorker.postMessage({
-                request: 'scan',
-                directoryHandle: organizeOptions.inputDirectory,
-            });
-        }
-        else if (organizeOptions.inputType === 'files') {
-            queueFilesForMapping(organizeOptions);
-        }
-        else {
-            console.error('`inputType` should be "directory" or "files"');
-        }
-        dispatchMappingJobs();
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            // Resolve promise if progressCallback gets called with 'done'
+            progressCallback = (msg) => {
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress(msg);
+                if (msg.response === 'done') {
+                    resolve(msg);
+                }
+            };
+            try {
+                // create the mapping workers
+                initializeMappingWorkers();
+                // Set global mappingWorkerOptions
+                mappingWorkerOptions = (yield collectMappingOptions(organizeOptions));
+                //
+                // If the request provides a directory, then use the worker
+                // to recursively convert to fileSystemHandles.
+                // If the request provides a list of File objects,
+                // send them to the mapping workers directly.
+                //
+                if (organizeOptions.inputType === 'directory') {
+                    const fileListWorker = initializeFileListWorker();
+                    fileListWorker.postMessage({
+                        request: 'scan',
+                        directoryHandle: organizeOptions.inputDirectory,
+                    });
+                }
+                else if (organizeOptions.inputType === 'files') {
+                    queueFilesForMapping(organizeOptions);
+                }
+                else {
+                    console.error('`inputType` should be "directory" or "files"');
+                }
+                dispatchMappingJobs();
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
     });
 }
 export { curateMany, curateOne, extractColumnMappings, clearCaches };

package/dist/types/index.d.ts

@@ -1,12 +1,12 @@
 import { extractColumnMappings } from './csvMapping';
 import { clearCaches } from './clearCaches';
 import { curateOne } from './curateOne';
-import type { OrganizeOptions, TProgressMessage } from './types';
+import type { OrganizeOptions, TProgressMessage, TProgressMessageDone } from './types';
 export type ProgressCallback = (message: TProgressMessage) => void;
 export type { TPs315Options, TMapResults, TProgressMessage, OrganizeOptions, TCurationSpecification, } from './types';
 export { specVersion } from './config/specVersion';
 export { sample2PassCurationSpecification as sampleSpecification } from './config/sample2PassCurationSpecification';
 export { csvTextToRows } from './csvMapping';
 export type { Row } from './csvMapping';
-declare function curateMany(organizeOptions: OrganizeOptions, onProgress?: ProgressCallback): Promise<void>;
+declare function curateMany(organizeOptions: OrganizeOptions, onProgress?: ProgressCallback): Promise<TProgressMessageDone>;
 export { curateMany, curateOne, extractColumnMappings, clearCaches };

package/dist/types/types.d.ts

@@ -134,11 +134,18 @@ export type TCurationSpecification = {
         mapping: TMappedValues;
     } & (TMappingInputDirect | TMappingInputTwoPass);
 };
-export type TProgressMessage = {
-    response: 'start' | 'progress' | 'finished' | 'error';
+type TProgressMessageBase = {
     totalFiles?: number;
     processedFiles?: number;
+};
+type TProgressMessageProgress = TProgressMessageBase & {
+    response: 'progress';
     mapResults?: TMapResults;
     error?: Error;
 };
+export type TProgressMessageDone = TProgressMessageBase & {
+    response: 'done';
+    mapResultsList: TMapResults[];
+};
+export type TProgressMessage = TProgressMessageProgress | TProgressMessageDone;
 export {};

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

@@ -62928,14 +62928,12 @@
                         mapResultsList.push(event.data.mapResults);
                         workersActive -= 1;
                         // Report progress
-                        if (progressCallback) {
-                            progressCallback({
-                                response: 'progress',
-                                mapResults: event.data.mapResults,
-                                processedFiles: mapResultsList.length,
-                                totalFiles: filesToProcess.length + mapResultsList.length + workersActive,
-                            });
-                        }
+                        progressCallback({
+                            response: 'progress',
+                            mapResults: event.data.mapResults,
+                            processedFiles: mapResultsList.length,
+                            totalFiles: filesToProcess.length + mapResultsList.length + workersActive,
+                        });
                         dispatchMappingJobs();
                         if (mapResultsList.length % 100 === 0) {
                             console.log(`Finished mapping ${mapResultsList.length} files`);
@@ -62974,6 +62972,12 @@
             clearCaches();
             console.log(`Finished mapping ${mapResultsList.length} files`);
             console.log('job is finished');
+            progressCallback({
+                response: 'done',
+                mapResultsList: mapResultsList,
+                processedFiles: mapResultsList.length,
+                totalFiles: mapResultsList.length,
+            });
         }
     }
     function collectMappingOptions(organizeOptions) {
@@ -63029,31 +63033,44 @@
     let progressCallback;
     function curateMany(organizeOptions, onProgress) {
         return __awaiter(this, void 0, void 0, function* () {
-            progressCallback = onProgress;
-            // create the mapping workers
-            initializeMappingWorkers();
-            // Set global mappingWorkerOptions
-            mappingWorkerOptions = (yield collectMappingOptions(organizeOptions));
-            //
-            // If the request provides a directory, then use the worker
-            // to recursively convert to fileSystemHandles.
-            // If the request provides a list of File objects,
-            // send them to the mapping workers directly.
-            //
-            if (organizeOptions.inputType === 'directory') {
-                const fileListWorker = initializeFileListWorker();
-                fileListWorker.postMessage({
-                    request: 'scan',
-                    directoryHandle: organizeOptions.inputDirectory,
-                });
-            }
-            else if (organizeOptions.inputType === 'files') {
-                queueFilesForMapping(organizeOptions);
-            }
-            else {
-                console.error('`inputType` should be "directory" or "files"');
-            }
-            dispatchMappingJobs();
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                // Resolve promise if progressCallback gets called with 'done'
+                progressCallback = (msg) => {
+                    onProgress === null || onProgress === void 0 ? void 0 : onProgress(msg);
+                    if (msg.response === 'done') {
+                        resolve(msg);
+                    }
+                };
+                try {
+                    // create the mapping workers
+                    initializeMappingWorkers();
+                    // Set global mappingWorkerOptions
+                    mappingWorkerOptions = (yield collectMappingOptions(organizeOptions));
+                    //
+                    // If the request provides a directory, then use the worker
+                    // to recursively convert to fileSystemHandles.
+                    // If the request provides a list of File objects,
+                    // send them to the mapping workers directly.
+                    //
+                    if (organizeOptions.inputType === 'directory') {
+                        const fileListWorker = initializeFileListWorker();
+                        fileListWorker.postMessage({
+                            request: 'scan',
+                            directoryHandle: organizeOptions.inputDirectory,
+                        });
+                    }
+                    else if (organizeOptions.inputType === 'files') {
+                        queueFilesForMapping(organizeOptions);
+                    }
+                    else {
+                        console.error('`inputType` should be "directory" or "files"');
+                    }
+                    dispatchMappingJobs();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }));
         });
     }