dicom-curate 0.2.0 → 0.4.0

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

@@ -19938,173 +19938,6 @@
         memoized.clear();
     }
 
-    function UniqueNumbers(padding = 5) {
-        // Internal state to hold counters for each grouping ID
-        let groupCounters = {};
-        // Provide uniqueness within group
-        function getUniqueNumberInGroup(groupingId) {
-            groupCounters[groupingId] = groupCounters[groupingId]
-                ? groupCounters[groupingId] + 1
-                : 1;
-            return groupCounters[groupingId].toString().padStart(padding, '0');
-        }
-        function clearUniqueNumberCache() {
-            groupCounters = {};
-        }
-        return { getUniqueNumberInGroup, clearUniqueNumberCache };
-    }
-
-    const FILEBASENAME = Symbol('fileBasename');
-    const FILENAME = Symbol('filename');
-    const { getUniqueNumberInGroup, clearUniqueNumberCache } = UniqueNumbers(6);
-    const { isUniqueInGroup, clearUniqueInGroupCache } = (function () {
-        let cache = new Set();
-        let lastGroupId = '';
-        return {
-            isUniqueInGroup(value, groupId) {
-                if (groupId !== lastGroupId) {
-                    cache = new Set();
-                    lastGroupId = groupId;
-                }
-                if (cache.has(value)) {
-                    return false;
-                }
-                cache.add(value);
-                return true;
-            },
-            clearUniqueInGroupCache() {
-                cache = new Set();
-            },
-        };
-    })();
-    function getParser(inputPathPattern, inputFilePath, naturalData, columnMappings, additionalData) {
-        function getDicom(attrName) {
-            if (attrName in data$1.DicomMetaDictionary.dictionary) {
-                // if in hex like "(0008,0100)", convert to text key
-                attrName = data$1.DicomMetaDictionary.dictionary[attrName].name;
-            }
-            return naturalData[attrName];
-        }
-        function getFilePathComp(component) {
-            var _a;
-            const patternParts = inputPathPattern.split('/');
-            const fileParts = inputFilePath.split('/');
-            let idx;
-            if (typeof component === 'number') {
-                // numeric indexing (supports negatives)
-                idx =
-                    component < 0
-                        ? fileParts.length + component // -1 → last, -2 → second-to-last, etc.
-                        : component;
-            }
-            else if (typeof component === 'symbol') {
-                // force last‐segment lookup on FILENAME or FILEBASENAME
-                idx = fileParts.length - 1;
-            }
-            else {
-                // string lookup against pattern
-                idx = patternParts.indexOf(component);
-            }
-            // return the segment if in range, else empty string
-            const segment = (_a = fileParts[idx]) !== null && _a !== void 0 ? _a : '';
-            // Return last component without a suffix
-            if (component === FILEBASENAME) {
-                return segment.replace(/\.[^/.]+$/, '');
-            }
-            return segment;
-        }
-        function getFrom(source, identifier) {
-            return source === 'dicom'
-                ? getDicom(identifier)
-                : getFilePathComp(identifier);
-        }
-        const getMapping = !additionalData || !columnMappings
-            ? undefined
-            : // key: one of the keys defined in the `mapping` object
-                function getMapping(key) {
-                    const { mapping } = additionalData;
-                    const { value: valueFn } = mapping[key];
-                    const value = valueFn({ getDicom, getFilePathComp, getFrom });
-                    return getCsvMapping(columnMappings, mapping, key, value);
-                };
-        function missingDicom(attrName) {
-            const value = getDicom(attrName);
-            return typeof value === 'undefined' || value === '';
-        }
-        return {
-            // This function enables errors like:
-            // [
-            //   'Duplicate Instance Number(s)',
-            //   !parser.isUniqueInGroup(instanceNumber, seriesUid),
-            // ],
-            isUniqueInGroup,
-            getUniqueNumberInGroup,
-            getFrom,
-            getFilePathComp,
-            getMapping,
-            getDicom,
-            missingDicom,
-            // TODO: Phase this out in favor of ISO8601 duration handling.
-            // Example of this logic:
-            // ContentDate:
-            //   parser.addDays(parser.getDicom('StudyDate'), parser.getMapping(
-            //     parser.getDicom('PatientID'), 'CURR_ID', 'DATE_OFFSET')),
-            addDays: (dicomDateString, offsetDays) => {
-                const year = Number(dicomDateString.slice(0, 4));
-                const monthIndex = Number(dicomDateString.slice(4, 6)) - 1;
-                const day = Number(dicomDateString.slice(6, 8));
-                const date = new Date(year, monthIndex, day);
-                let time = date.getTime();
-                const millisecondsPerDay = 1000 * 60 * 60 * 24;
-                time += offsetDays * millisecondsPerDay;
-                date.setTime(time);
-                const yearString = date.getFullYear();
-                const monthString = (date.getMonth() + 1).toString().padStart(2, '0');
-                const dayString = date.getDate().toString().padStart(2, '0');
-                return yearString + monthString + dayString;
-            },
-            FILENAME,
-            FILEBASENAME,
-        };
-    }
-
-    function clearCaches() {
-        clearReplaceUidCache();
-        clearUniqueNumberCache();
-        clearUniqueInGroupCache();
-    }
-
-    function createNestedDirectories(topLevelDirectoryHandle, path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pathSegments = path.split('/').filter((segment) => segment !== '');
-            let currentDirectoryHandle = topLevelDirectoryHandle;
-            for (const segment of pathSegments) {
-                try {
-                    // Attempt to get the directory handle without creating it
-                    const entry = yield currentDirectoryHandle.getDirectoryHandle(segment, {
-                        create: false,
-                    });
-                    currentDirectoryHandle = entry;
-                }
-                catch (error) {
-                    // If the error is specifically about the directory not existing, create it
-                    if (error.name === 'NotFoundError') {
-                        const entry = yield currentDirectoryHandle.getDirectoryHandle(segment, {
-                            create: true,
-                        });
-                        currentDirectoryHandle = entry;
-                    }
-                    else {
-                        // Handle other potential errors (e.g., name conflicts)
-                        return false; // Indicate failure
-                    }
-                }
-            }
-            // Return the last directory handle
-            return currentDirectoryHandle;
-        });
-    }
-
     const dummyValues = {
         AE: 'INVALID_AE',
         CS: 'REDACTED',
@@ -49094,6 +48927,9 @@
     function removeRetiredPrefix(name) {
         return name.startsWith('RETIRED_') ? name.slice(8) : name;
     }
+    function protectUid(uid, retainUIDsOption) {
+        return retainUIDsOption === 'Hashed' ? hashUid(uid) : memoized(uid);
+    }
     const elementNamesToAlwaysKeepSet = new Set(elementNamesToAlwaysKeep);
     // Special conditions for some PS3.15 E1.1 elements.
     const ps315EElements = ps315EElements$1.map((elm) => {
@@ -49296,7 +49132,7 @@
                             // UID is not a known class UID.
                             !(uid in uidRegistryPS3_06_A1)) {
                             // UIDs that need to be mapped
-                            const mappedUID = retainUIDsOption === 'Hashed' ? hashUid(uid) : memoized(uid);
+                            const mappedUID = protectUid(uid, retainUIDsOption);
                             mapResults.mappings[attrPath] = [
                                 uid,
                                 'replace',
@@ -49424,9 +49260,185 @@
         retainInstitutionIdentityOption: false,
     };
 
+    function UniqueNumbers(padding = 5) {
+        // Internal state to hold counters for each grouping ID
+        let groupCounters = {};
+        // Provide uniqueness within group
+        function getUniqueNumberInGroup(groupingId) {
+            groupCounters[groupingId] = groupCounters[groupingId]
+                ? groupCounters[groupingId] + 1
+                : 1;
+            return groupCounters[groupingId].toString().padStart(padding, '0');
+        }
+        function clearUniqueNumberCache() {
+            groupCounters = {};
+        }
+        return { getUniqueNumberInGroup, clearUniqueNumberCache };
+    }
+
+    const FILEBASENAME = Symbol('fileBasename');
+    const FILENAME = Symbol('filename');
+    const { getUniqueNumberInGroup, clearUniqueNumberCache } = UniqueNumbers(6);
+    const { isUniqueInGroup, clearUniqueInGroupCache } = (function () {
+        let cache = new Set();
+        let lastGroupId = '';
+        return {
+            isUniqueInGroup(value, groupId) {
+                if (groupId !== lastGroupId) {
+                    cache = new Set();
+                    lastGroupId = groupId;
+                }
+                if (cache.has(value)) {
+                    return false;
+                }
+                cache.add(value);
+                return true;
+            },
+            clearUniqueInGroupCache() {
+                cache = new Set();
+            },
+        };
+    })();
+    function getParser(inputPathPattern, inputFilePath, naturalData, dicomPS315EOptions, columnMappings, additionalData) {
+        function protectUid$1(uid) {
+            let protectedUid = uid;
+            if (dicomPS315EOptions !== 'Off') {
+                const { retainUIDsOption } = dicomPS315EOptions;
+                protectedUid = protectUid(uid, retainUIDsOption);
+            }
+            return protectedUid;
+        }
+        function getDicom(attrName) {
+            if (attrName in data$1.DicomMetaDictionary.dictionary) {
+                // if in hex like "(0008,0100)", convert to text key
+                attrName = data$1.DicomMetaDictionary.dictionary[attrName].name;
+            }
+            return naturalData[attrName];
+        }
+        function getFilePathComp(component) {
+            var _a;
+            const patternParts = inputPathPattern.split('/');
+            const fileParts = inputFilePath.split('/');
+            let idx;
+            if (typeof component === 'number') {
+                // numeric indexing (supports negatives)
+                idx =
+                    component < 0
+                        ? fileParts.length + component // -1 → last, -2 → second-to-last, etc.
+                        : component;
+            }
+            else if (typeof component === 'symbol') {
+                // force last‐segment lookup on FILENAME or FILEBASENAME
+                idx = fileParts.length - 1;
+            }
+            else {
+                // string lookup against pattern
+                idx = patternParts.indexOf(component);
+            }
+            // return the segment if in range, else empty string
+            const segment = (_a = fileParts[idx]) !== null && _a !== void 0 ? _a : '';
+            // Return last component without a suffix
+            if (component === FILEBASENAME) {
+                return segment.replace(/\.[^/.]+$/, '');
+            }
+            return segment;
+        }
+        function getFrom(source, identifier) {
+            return source === 'dicom'
+                ? getDicom(identifier)
+                : getFilePathComp(identifier);
+        }
+        const getMapping = !additionalData || !columnMappings
+            ? undefined
+            : // key: one of the keys defined in the `mapping` object
+                function getMapping(key) {
+                    const { mapping } = additionalData;
+                    const { value: valueFn } = mapping[key];
+                    const value = valueFn({ getDicom, getFilePathComp, getFrom });
+                    return getCsvMapping(columnMappings, mapping, key, value);
+                };
+        function missingDicom(attrName) {
+            const value = getDicom(attrName);
+            return typeof value === 'undefined' || value === '';
+        }
+        return {
+            // This function enables errors like:
+            // [
+            //   'Duplicate Instance Number(s)',
+            //   !parser.isUniqueInGroup(instanceNumber, seriesUid),
+            // ],
+            isUniqueInGroup,
+            getUniqueNumberInGroup,
+            getFrom,
+            getFilePathComp,
+            getMapping,
+            getDicom,
+            missingDicom,
+            protectUid: protectUid$1,
+            // TODO: Phase this out in favor of ISO8601 duration handling.
+            // Example of this logic:
+            // ContentDate:
+            //   parser.addDays(parser.getDicom('StudyDate'), parser.getMapping(
+            //     parser.getDicom('PatientID'), 'CURR_ID', 'DATE_OFFSET')),
+            addDays: (dicomDateString, offsetDays) => {
+                const year = Number(dicomDateString.slice(0, 4));
+                const monthIndex = Number(dicomDateString.slice(4, 6)) - 1;
+                const day = Number(dicomDateString.slice(6, 8));
+                const date = new Date(year, monthIndex, day);
+                let time = date.getTime();
+                const millisecondsPerDay = 1000 * 60 * 60 * 24;
+                time += offsetDays * millisecondsPerDay;
+                date.setTime(time);
+                const yearString = date.getFullYear();
+                const monthString = (date.getMonth() + 1).toString().padStart(2, '0');
+                const dayString = date.getDate().toString().padStart(2, '0');
+                return yearString + monthString + dayString;
+            },
+            FILENAME,
+            FILEBASENAME,
+        };
+    }
+
+    function clearCaches() {
+        clearReplaceUidCache();
+        clearUniqueNumberCache();
+        clearUniqueInGroupCache();
+    }
+
+    function createNestedDirectories(topLevelDirectoryHandle, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathSegments = path.split('/').filter((segment) => segment !== '');
+            let currentDirectoryHandle = topLevelDirectoryHandle;
+            for (const segment of pathSegments) {
+                try {
+                    // Attempt to get the directory handle without creating it
+                    const entry = yield currentDirectoryHandle.getDirectoryHandle(segment, {
+                        create: false,
+                    });
+                    currentDirectoryHandle = entry;
+                }
+                catch (error) {
+                    // If the error is specifically about the directory not existing, create it
+                    if (error.name === 'NotFoundError') {
+                        const entry = yield currentDirectoryHandle.getDirectoryHandle(segment, {
+                            create: true,
+                        });
+                        currentDirectoryHandle = entry;
+                    }
+                    else {
+                        // Handle other potential errors (e.g., name conflicts)
+                        return false; // Indicate failure
+                    }
+                }
+            }
+            // Return the last directory handle
+            return currentDirectoryHandle;
+        });
+    }
+
     const specVersion = '2.0';
 
-    function collectMappings(inputFilePath, dicomData, mappingOptions) {
+    function collectMappings(inputFilePath, inputFileIndex, dicomData, mappingOptions) {
         var _a;
         const mapResults = {
             // original UID for this dicomData
@@ -49445,13 +49457,15 @@
         let finalSpec = {
             dicomPS315EOptions: defaultPs315Options,
             inputPathPattern: '',
-            modifications: () => ({
-                dicomHeader: {},
-                outputFilePathComponents: [
-                    parser.getDicom('SeriesInstanceUID'),
-                    parser.getFilePathComp(parser.FILENAME),
-                ],
-            }),
+            modifications(parser) {
+                return {
+                    dicomHeader: {},
+                    outputFilePathComponents: [
+                        parser.protectUid(parser.getDicom('SeriesInstanceUID')),
+                        parser.getFilePathComp(parser.FILENAME),
+                    ],
+                };
+            },
             validation: () => ({ errors: [] }),
         };
         const _b = mappingOptions.curationSpec(), { modifications, validation } = _b, restSpec = __rest(_b, ["modifications", "validation"]);
@@ -49466,8 +49480,13 @@
         if (!mappingOptions.skipValidation) {
             finalSpec.validation = validation;
         }
+        // protect filename if we de-identify
+        const finalFilePath = finalSpec.dicomPS315EOptions === 'Off'
+            ? inputFilePath
+            : inputFilePath.slice(0, inputFilePath.lastIndexOf('/') + 1) +
+                `${String(inputFileIndex + 1).padStart(5, '0')}.dcm`;
         // create a parser object to be used in the eval'ed mappingFunctions
-        const parser = getParser(finalSpec.inputPathPattern, inputFilePath, naturalData, mappingOptions.columnMappings, finalSpec.additionalData);
+        const parser = getParser(finalSpec.inputPathPattern, finalFilePath, naturalData, finalSpec.dicomPS315EOptions, mappingOptions.columnMappings, finalSpec.additionalData);
         let modificationMap = finalSpec.modifications(parser);
         // List all validation errors
         mapResults.errors = finalSpec
@@ -49548,11 +49567,11 @@
         return mappedMetaheader;
     }
 
-    function curateDict(inputFilePath, dicomData, mappingOptions) {
+    function curateDict(inputFilePath, inputFileIndex, dicomData, mappingOptions) {
         //
         // Collect the mappings and apply them to the data
         //
-        const [naturalData, mapResults] = collectMappings(inputFilePath, dicomData, mappingOptions);
+        const [naturalData, mapResults] = collectMappings(inputFilePath, inputFileIndex, dicomData, mappingOptions);
         for (let tagPath in mapResults.mappings) {
             const [, operation, , mappedValue] = mapResults.mappings[tagPath];
             switch (operation) {
@@ -49576,8 +49595,8 @@
         return { dicomData: mappedDicomData, mapResults: lodashExports.cloneDeep(mapResults) };
     }
 
-    function curateOne(fileInfo, outputDirectory, mappingOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
+    function curateOne(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ fileInfo, fileIndex = 0, outputDirectory, mappingOptions, }) {
             //
             // First, read the dicom instance data from the file handle or blob
             //
@@ -49602,7 +49621,7 @@
                 };
                 return mapResults;
             }
-            const { dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(`${fileInfo.path}/${fileInfo.name}`, dicomData, mappingOptions);
+            const { dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(`${fileInfo.path}/${fileInfo.name}`, fileIndex, dicomData, mappingOptions);
             if (!mappingOptions.skipWrite) {
                 // Finally, write the results
                 const dirPath = clonedMapResults.outputFilePath
@@ -62883,7 +62902,8 @@
         fileListWorker.addEventListener('message', (event) => {
             switch (event.data.response) {
                 case 'file':
-                    filesToProcess.push(event.data.fileInfo);
+                    const { fileIndex, fileInfo } = event.data;
+                    filesToProcess.push({ fileIndex, fileInfo });
                     // Could do some throttling:
                     // if (filesToProcess.length > 10) {
                     //   fileListWorker.postMessage({ request: 'stop' })
@@ -62895,6 +62915,7 @@
                     directoryScanFinished = true;
                     break;
                 default:
+                    // @ts-expect-error: response is string here, not never
                     console.error(`Unknown response from worker ${event.data.response}`);
             }
             dispatchMappingJobs();
@@ -62928,14 +62949,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`);
@@ -62951,7 +62970,7 @@
     }
     function dispatchMappingJobs() {
         while (filesToProcess.length > 0 && availableMappingWorkers.length > 0) {
-            const fileInfo = filesToProcess.pop();
+            const { fileInfo, fileIndex } = filesToProcess.pop();
             const mappingWorker = availableMappingWorkers.pop();
             const _a = 
             // Not partial anymore.
@@ -62959,6 +62978,7 @@
             mappingWorker.postMessage({
                 request: 'apply',
                 fileInfo,
+                fileIndex,
                 outputDirectory,
                 serializedMappingOptions: serializeMappingOptions(mappingOptions),
             });
@@ -62974,6 +62994,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) {
@@ -63014,7 +63040,7 @@
         });
     }
     function queueFilesForMapping(organizeOptions) {
-        organizeOptions.inputFiles.forEach((inputFile) => {
+        organizeOptions.inputFiles.forEach((inputFile, fileIndex) => {
             const fileInfo = {
                 path: '',
                 name: inputFile.name,
@@ -63022,38 +63048,51 @@
                 kind: 'blob',
                 blob: inputFile,
             };
-            filesToProcess.push(fileInfo);
+            filesToProcess.push({ fileInfo, fileIndex });
             dispatchMappingJobs();
         });
     }
     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);
+                }
+            }));
         });
     }