dicom-curate 0.4.0 → 0.5.0

package/dist/esm/collectMappings.js

@@ -99,6 +99,7 @@ export default function collectMappings(inputFilePath, inputFileIndex, dicomData
             dicomPS315EOptions: finalSpec.dicomPS315EOptions,
             dateOffset: mappingOptions.dateOffset,
             mapResults,
+            originalDicomDict: dicomData.dict,
         });
     }
     // Moving this after collectMappingsInData as this should take precedence.

package/dist/esm/config/dicom/tagConversion.js

@@ -0,0 +1,44 @@
+import * as dcmjs from 'dcmjs';
+/**
+ * Check if a tag identifier is a private tag
+ */
+export function isPrivateTag(tagId) {
+    // Check if it's already a tag ID format (8 hex digits)
+    if (/^[0-9A-Fa-f]{8}$/.test(tagId)) {
+        const group = parseInt(tagId.substring(0, 4), 16);
+        return group % 2 === 1;
+    }
+    // If it's a keyword, it's not a private tag
+    return false;
+}
+/**
+ * Convert a DICOM keyword to its corresponding tag ID
+ */
+export function convertKeywordToTagId(keyword) {
+    var _a;
+    // Use dcmjs built-in conversion for standard DICOM keywords
+    // For private tags (which don't have keywords), keep as-is
+    const tagId = isPrivateTag(keyword) ? keyword :
+        ((_a = dcmjs.data.DicomMetaDictionary.nameMap[keyword]) === null || _a === void 0 ? void 0 : _a.tag) || keyword;
+    // Remove parentheses and commas, convert to the format used in dictionary keys
+    return tagId.replace(/[(),]/g, '').toLowerCase();
+}
+/**
+ * Convert a keyword path to tag ID path for nested DICOM elements
+ */
+export function convertKeywordPathToTagIdPath(keywordPath) {
+    // Handle nested paths like "GeneralMatchingSequence[0].00510014"
+    const parts = keywordPath.split('.');
+    const convertedParts = parts.map(part => {
+        const arrayMatch = part.match(/^(.+)\[(\d+)\]$/);
+        if (arrayMatch) {
+            const [, keyword, index] = arrayMatch;
+            const tagId = convertKeywordToTagId(keyword);
+            return `${tagId}[${index}]`;
+        }
+        else {
+            return convertKeywordToTagId(part);
+        }
+    });
+    return convertedParts.join('.');
+}

package/dist/esm/curateDict.js

@@ -1,6 +1,7 @@
 import * as dcmjs from 'dcmjs';
 import collectMappings from './collectMappings.js';
 import mapMetaheader from './mapMetaheader.js';
+import { convertKeywordPathToTagIdPath } from './config/dicom/tagConversion.js';
 import { set as _set, unset as _unset, cloneDeep as _cloneDeep } from 'lodash';
 export default function curateDict(inputFilePath, inputFileIndex, dicomData, mappingOptions) {
     //
@@ -27,5 +28,69 @@ export default function curateDict(inputFilePath, inputFileIndex, dicomData, map
     mapMetaheader(dicomData.meta, naturalData.SOPInstanceUID));
     mappedDicomData.dict =
         dcmjs.data.DicomMetaDictionary.denaturalizeDataset(naturalData);
+    // Restore quarantined private tags directly to the final DICOM dict
+    // This must be done after denaturalization since private tags aren't in the dictionary
+    for (let tagPath in mapResults.quarantine) {
+        const quarantinedElement = mapResults.quarantine[tagPath];
+        if (!quarantinedElement)
+            continue;
+        // Convert keyword paths to tag ID paths for restoration
+        const tagIdPath = convertKeywordPathToTagIdPath(tagPath);
+        // If the quarantined element has DICOM structure (vr and Value), restore it directly
+        if (quarantinedElement && typeof quarantinedElement === 'object' && 'Value' in quarantinedElement) {
+            // Handle nested paths like "00080413[0].00510014"
+            const pathParts = tagIdPath.split('.');
+            if (pathParts.length === 2 && pathParts[0].includes('[')) {
+                // This is a nested path, handle it specially
+                const [sequenceWithIndex, privateTagId] = pathParts;
+                const arrayMatch = sequenceWithIndex.match(/^(.+)\[(\d+)\]$/);
+                if (arrayMatch) {
+                    const [, sequenceTagId, index] = arrayMatch;
+                    let sequence = mappedDicomData.dict[sequenceTagId];
+                    // If the sequence doesn't exist, we need to create it
+                    if (!sequence) {
+                        // Create the sequence with the private tag already included
+                        const sequenceItemWithPrivateTag = { [privateTagId]: quarantinedElement };
+                        sequence = {
+                            vr: 'SQ',
+                            Value: [sequenceItemWithPrivateTag]
+                        };
+                        mappedDicomData.dict[sequenceTagId] = sequence;
+                    }
+                    else {
+                        // Ensure the sequence has a Value array
+                        if (!sequence.Value) {
+                            sequence.Value = [];
+                        }
+                        // Ensure we have enough items in the sequence
+                        while (sequence.Value.length <= parseInt(index)) {
+                            sequence.Value.push({});
+                        }
+                        if (sequence && sequence.Value && sequence.Value[parseInt(index)]) {
+                            // Ensure the sequence item is properly structured
+                            const sequenceItem = sequence.Value[parseInt(index)];
+                            if (typeof sequenceItem === 'object' && sequenceItem !== null) {
+                                // Create a new object with the private tag included
+                                const newSequenceItem = Object.assign(Object.assign({}, sequenceItem), { [privateTagId]: quarantinedElement });
+                                sequence.Value[parseInt(index)] = newSequenceItem;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                // Top-level private tag
+                _set(mappedDicomData.dict, tagIdPath, quarantinedElement);
+            }
+        }
+        else {
+            // For raw values, we need to create a proper DICOM element structure
+            // This is a fallback - ideally all quarantined elements should have proper structure
+            _set(mappedDicomData.dict, tagIdPath, {
+                vr: 'UN', // Unknown VR for private tags
+                Value: Array.isArray(quarantinedElement) ? quarantinedElement : [quarantinedElement]
+            });
+        }
+    }
     return { dicomData: mappedDicomData, mapResults: _cloneDeep(mapResults) };
 }

package/dist/esm/curateOne.js

@@ -31,8 +31,20 @@ export function curateOne(_a) {
             dicomData = dcmjs.data.DicomMessage.readFile(fileArrayBuffer);
         }
         catch (error) {
+            console.warn(`[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`, error);
+            // Create a more informative error result
             const mapResults = {
-                anomalies: [`Could not parse ${fileInfo.name} as dicom data`],
+                anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
+                errors: [`File ${fileInfo.name} is not a valid DICOM file or is corrupted`],
+                sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                outputFilePath: `${fileInfo.path}/${fileInfo.name}`,
+                // Add metadata about the failed file
+                fileInfo: {
+                    name: fileInfo.name,
+                    size: fileInfo.size,
+                    path: fileInfo.path,
+                    parseError: error instanceof Error ? error.message : String(error)
+                }
             };
             return mapResults;
         }

package/dist/esm/deidentifyPS315E.js

@@ -15,6 +15,7 @@ import hashUid from './hashUid.js';
 import replaceUid from './replaceUid.js';
 import { elementNamesToAlwaysKeep } from './config/dicom/elementNamesToAlwaysKeep.js';
 import { ps315EElements as rawPs315EElements } from './config/dicom/ps315EElements.js';
+import { convertKeywordToTagId } from './config/dicom/tagConversion.js';
 import { offsetDateTime } from './offsetDateTime.js';
 import { retainAdditionalIds } from './config/dicom/retainAdditionalIds.js';
 import { uidRegistryPS3_06_A1 } from './config/dicom/uidRegistryPS3_06_A1.js';
@@ -55,7 +56,44 @@ const ps315EElements = rawPs315EElements.map((elm) => {
             return elm;
     }
 });
-export default function deidentifyPS315E({ naturalData, dicomPS315EOptions, dateOffset, mapResults, }) {
+export default function deidentifyPS315E({ naturalData, dicomPS315EOptions, dateOffset, mapResults, originalDicomDict, }) {
+    // Helper function to get original DICOM element from nested path
+    function getOriginalDicomElement(path, tagName) {
+        if (!originalDicomDict)
+            return null;
+        if (!path) {
+            // Top-level element
+            return originalDicomDict[tagName];
+        }
+        // Parse nested path like "GeneralMatchingSequence[0]."
+        const pathParts = path.split('.');
+        let current = originalDicomDict;
+        for (const part of pathParts) {
+            if (!part)
+                continue; // Skip empty parts from trailing dots
+            const arrayMatch = part.match(/^(.+)\[(\d+)\]$/);
+            if (arrayMatch) {
+                const [, sequenceName, index] = arrayMatch;
+                const tagId = convertKeywordToTagId(sequenceName);
+                if (current[tagId] && current[tagId].Value && current[tagId].Value[parseInt(index)]) {
+                    current = current[tagId].Value[parseInt(index)];
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                const tagId = convertKeywordToTagId(part);
+                if (current[tagId]) {
+                    current = current[tagId];
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        return current[tagName] || null;
+    }
     const { cleanDescriptorsOption, cleanDescriptorsExceptions, retainLongitudinalTemporalInformationOptions, retainPatientCharacteristicsOption, retainDeviceIdentityOption, retainUIDsOption, retainSafePrivateOption, retainInstitutionIdentityOption, } = dicomPS315EOptions;
     const taggedps315EEls = ps315EElements.reduce((acc, item) => {
         acc.push(item);
@@ -327,7 +365,17 @@ export default function deidentifyPS315E({ naturalData, dicomPS315EOptions, date
                     }
                     else {
                         // We keep the private tag but register its value for checking.
-                        mapResults.quarantine[attrPath] = data[name];
+                        // Store the full DICOM element structure, not just the value
+                        // For private tags, we need to preserve the original structure
+                        const originalElement = getOriginalDicomElement(path, name);
+                        if (originalElement) {
+                            // Store the original DICOM element structure (with vr and Value)
+                            mapResults.quarantine[attrPath] = originalElement;
+                        }
+                        else {
+                            // Fallback to the naturalized value if original not available
+                            mapResults.quarantine[attrPath] = data[name];
+                        }
                     }
                 }
                 else {

package/dist/esm/index.js

@@ -27,8 +27,11 @@ export { specVersion } from './config/specVersion.js';
 export { sample2PassCurationSpecification as sampleSpecification } from './config/sample2PassCurationSpecification.js';
 export { csvTextToRows } from './csvMapping.js';
 const mappingWorkerCount = navigator.hardwareConcurrency;
+// Update the type to include scan anomalies
 let filesToProcess = [];
 let directoryScanFinished = false;
+// Track scan anomalies separately since they don't go through the processing pipeline
+let scanAnomalies = [];
 function requiresDateOffset(deIdOpts) {
     return (deIdOpts !== 'Off' &&
         deIdOpts.retainLongitudinalTemporalInformationOptions === 'Offset');
@@ -47,24 +50,34 @@ function requiresDateOffset(deIdOpts) {
 function initializeFileListWorker() {
     filesToProcess = [];
     directoryScanFinished = false;
+    scanAnomalies = [];
     const fileListWorker = new Worker(new URL('./scanDirectoryWorker.js', import.meta.url), { type: 'module' });
     fileListWorker.addEventListener('message', (event) => {
         switch (event.data.response) {
             case 'file':
                 const { fileIndex, fileInfo } = event.data;
-                filesToProcess.push({ fileIndex, fileInfo });
+                filesToProcess.push({
+                    fileIndex,
+                    fileInfo,
+                    scanAnomalies: [], // Files sent to processing have no scan anomalies
+                });
                 // Could do some throttling:
                 // if (filesToProcess.length > 10) {
                 //   fileListWorker.postMessage({ request: 'stop' })
                 // }
                 dispatchMappingJobs();
                 break;
+            case 'scanAnomalies':
+                // Handle scan anomalies separately - they don't go to processing
+                const { fileInfo: anomalyFileInfo, anomalies } = event.data;
+                scanAnomalies.push({ fileInfo: anomalyFileInfo, anomalies });
+                break;
             case 'done':
                 console.log('directoryScanFinished');
                 directoryScanFinished = true;
                 break;
             default:
-                // @ts-expect-error: response is string here, not never
+                // @ts-expect-error: response is string here, not never
                 console.error(`Unknown response from worker ${event.data.response}`);
         }
         dispatchMappingJobs();
@@ -143,6 +156,22 @@ function dispatchMappingJobs() {
         clearCaches();
         console.log(`Finished mapping ${mapResultsList.length} files`);
         console.log('job is finished');
+        // Create individual mapResults entries for each scan anomaly
+        // Only do this during actual processing (not first pass)
+        if (!mappingWorkerOptions.skipWrite) {
+            scanAnomalies.forEach(({ fileInfo, anomalies }) => {
+                const scanAnomalyResult = {
+                    sourceInstanceUID: `scan_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, '_')}`,
+                    outputFilePath: `${fileInfo.path}/${fileInfo.name}`, // Use the actual file path
+                    mappings: {},
+                    anomalies: anomalies, // Keep the original anomalies array
+                    errors: [],
+                    quarantine: {},
+                };
+                // Add each scan anomaly result to the final results
+                mapResultsList.push(scanAnomalyResult);
+            });
+        }
         progressCallback({
             response: 'done',
             mapResultsList: mapResultsList,
@@ -197,9 +226,14 @@ function queueFilesForMapping(organizeOptions) {
             kind: 'blob',
             blob: inputFile,
         };
-        filesToProcess.push({ fileInfo, fileIndex });
-        dispatchMappingJobs();
+        filesToProcess.push({
+            fileInfo,
+            fileIndex,
+            scanAnomalies: [],
+        });
     });
+    // Dispatch jobs once after all files are queued to prevent race conditions
+    dispatchMappingJobs();
 }
 let progressCallback;
 function curateMany(organizeOptions, onProgress) {
@@ -225,9 +259,12 @@ function curateMany(organizeOptions, onProgress) {
                 //
                 if (organizeOptions.inputType === 'directory') {
                     const fileListWorker = initializeFileListWorker();
+                    const curationSpec = organizeOptions.curationSpec();
+                    const specExcludedFiletypes = curationSpec.excludedFiletypes;
                     fileListWorker.postMessage({
                         request: 'scan',
                         directoryHandle: organizeOptions.inputDirectory,
+                        excludedFiletypes: specExcludedFiletypes,
                     });
                 }
                 else if (organizeOptions.inputType === 'files') {

package/dist/esm/offsetDateTime.js

@@ -197,7 +197,9 @@ function getDurationFractionMicroseconds(iso8601Duration) {
  * @returns The offset DICOM string, formatted like the original.
  */
 export function offsetDateTime(dicomValue, iso8601Duration) {
-    // Step 0: Detect and handle a leading minus sign.
+    // Step 0: Trim leading/trailing spaces from the DICOM value
+    const trimmedDicomValue = dicomValue.trim();
+    // Step 0.5: Detect and handle a leading minus sign.
     let sign = 1;
     let durationStr = iso8601Duration;
     if (iso8601Duration.startsWith('-')) {
@@ -205,7 +207,7 @@ export function offsetDateTime(dicomValue, iso8601Duration) {
         durationStr = iso8601Duration.slice(1);
     }
     // Step 1: Convert the original DICOM string to a canonical DT string.
-    const canonical = dicomToCanonicalDT(dicomValue); // Format: "YYYYMMDDHHMMSS.FFFFFF"
+    const canonical = dicomToCanonicalDT(trimmedDicomValue); // Format: "YYYYMMDDHHMMSS.FFFFFF"
     // Step 2: Split the canonical DT string.
     const base = canonical.slice(0, 14); // 14-digit base: YYYYMMDDHHMMSS
     const fractionStr = canonical.slice(15, 21); // 6-digit fractional part: FFFFFF
@@ -238,5 +240,5 @@ export function offsetDateTime(dicomValue, iso8601Duration) {
     const newFractionStr = newFractionMicro.toString().padStart(6, '0');
     const newCanonical = newBase + '.' + newFractionStr;
     // Step 9: Convert the canonical DT back to the original DICOM format.
-    return canonicalDTToDicom(newCanonical, dicomValue);
+    return canonicalDTToDicom(newCanonical, trimmedDicomValue);
 }

package/dist/esm/scanDirectoryWorker.js

@@ -14,11 +14,59 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
+// Case-insensitive filetypes to ALWAYS exclude from processing
+const DEFAULT_EXCLUDED_FILETYPES = ['dicomdir', 'dicomdir.dir', 'dicomdir.dat', 'dicomdir.bak', 'thumbs.db', '.ds_store'];
 let keepScanning = true;
+let excludedFiletypes = [];
+/**
+ * Check if a file should be processed based on filtering rules
+ * @param file - The file to check
+ * @param fileAnomalies - Array to collect anomalies for this specific file e.g. excluded files
+ * @returns Promise<boolean> - True if the file should be processed
+ */
+function shouldProcessFile(file, fileAnomalies) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allExcludedFiletypes = [
+            ...DEFAULT_EXCLUDED_FILETYPES,
+            ...excludedFiletypes
+        ];
+        try {
+            // Check if the file is in the list of excluded files
+            if (allExcludedFiletypes.some(excluded => file.name.toLowerCase() === excluded.toLowerCase())) {
+                fileAnomalies.push(`Skipped excluded file: ${file.name}`);
+                return false;
+            }
+            // Check filesize - (valid) DICOM files are at least 132 bytes (128-byte preamble + 4-byte signature)
+            if (file.size < 132) {
+                fileAnomalies.push(`Skipped very small file: ${file.name} (${file.size} bytes)`);
+                return false;
+            }
+            // Check for DICOM signature "DICM" at offset 128
+            const headerBytes = yield file.slice(128, 132).arrayBuffer();
+            const headerView = new Uint8Array(headerBytes);
+            const dicomSignature = String.fromCharCode(headerView[0], headerView[1], headerView[2], headerView[3]);
+            if (dicomSignature === 'DICM') {
+                return true;
+            }
+            // Don't parse file without DICOM signature
+            fileAnomalies.push(`Skipped file without DICOM signature: ${file.name}`);
+            return false;
+        }
+        catch (error) {
+            fileAnomalies.push(`Unable to determine file validity - processing anyway: ${file.name} - ${error}`);
+            // If vetting process fails, let the parser decide
+            return true;
+        }
+    });
+}
 self.addEventListener('message', (event) => {
     switch (event.data.request) {
         case 'scan':
             console.log(`Starting directory scan of ${event.data.directoryHandle.name}`);
+            // Update excluded filetypes if provided
+            if (event.data.excludedFiletypes) {
+                excludedFiletypes = event.data.excludedFiletypes;
+            }
             keepScanning = true;
             scanDirectory(event.data.directoryHandle);
             break;
@@ -57,17 +105,36 @@ function scanDirectory(dir) {
                 for (const entry of entries) {
                     if (entry.kind === 'file' && keepScanning) {
                         const file = yield entry.getFile();
-                        self.postMessage({
-                            response: 'file',
-                            fileIndex: fileIndex++,
-                            fileInfo: {
-                                path: prefix,
-                                name: entry.name,
-                                size: file.size,
-                                kind: 'handle',
-                                fileHandle: entry,
-                            },
-                        });
+                        const fileAnomalies = [];
+                        if (yield shouldProcessFile(file, fileAnomalies)) {
+                            // Send file to processing pipeline
+                            self.postMessage({
+                                response: 'file',
+                                fileIndex: fileIndex++,
+                                fileInfo: {
+                                    path: prefix,
+                                    name: entry.name,
+                                    size: file.size,
+                                    kind: 'handle',
+                                    fileHandle: entry,
+                                },
+                            });
+                        }
+                        else if (fileAnomalies.length > 0) {
+                            // Send scan anomalies as separate messsage so they are not sent to processing (curate)
+                            self.postMessage({
+                                response: 'scanAnomalies',
+                                fileIndex: fileIndex++,
+                                fileInfo: {
+                                    path: prefix,
+                                    name: entry.name,
+                                    size: file.size,
+                                    kind: 'handle',
+                                    fileHandle: entry,
+                                },
+                                anomalies: fileAnomalies,
+                            });
+                        }
                     }
                     else if (entry.kind === 'directory' && keepScanning) {
                         yield traverse(entry, prefix + '/' + entry.name);

package/dist/types/config/dicom/tagConversion.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Check if a tag identifier is a private tag
+ */
+export declare function isPrivateTag(tagId: string): boolean;
+/**
+ * Convert a DICOM keyword to its corresponding tag ID
+ */
+export declare function convertKeywordToTagId(keyword: string): string;
+/**
+ * Convert a keyword path to tag ID path for nested DICOM elements
+ */
+export declare function convertKeywordPathToTagIdPath(keywordPath: string): string;

package/dist/types/deidentifyPS315E.d.ts

@@ -1,10 +1,11 @@
 import type { TNaturalData } from 'dcmjs';
 import type { Iso8601Duration, TPs315Options, TMapResults } from './types';
 export declare function protectUid(uid: string, retainUIDsOption: string): string;
-export default function deidentifyPS315E({ naturalData, dicomPS315EOptions, dateOffset, mapResults, }: {
+export default function deidentifyPS315E({ naturalData, dicomPS315EOptions, dateOffset, mapResults, originalDicomDict, }: {
     naturalData: TNaturalData;
     dicomPS315EOptions: TPs315Options;
     dateOffset?: Iso8601Duration;
     mapResults: TMapResults;
+    originalDicomDict?: Record<string, any>;
 }): void;
 export declare const defaultPs315Options: TPs315Options;

package/dist/types/scanDirectoryWorker.d.ts

@@ -4,6 +4,11 @@ export type FileScanMsg = {
     response: 'file';
     fileIndex: number;
     fileInfo: TFileInfo;
+} | {
+    response: 'scanAnomalies';
+    fileIndex: number;
+    fileInfo: TFileInfo;
+    anomalies: string[];
 } | {
     response: 'done';
 };

package/dist/types/types.d.ts

@@ -137,6 +137,7 @@ export type TCurationSpecification = {
     additionalData?: {
         mapping: TMappedValues;
     } & (TMappingInputDirect | TMappingInputTwoPass);
+    excludedFiletypes?: string[];
 };
 type TProgressMessageBase = {
     totalFiles?: number;