dicom-curate 0.3.0 → 0.4.1

package/README.md

@@ -77,11 +77,11 @@ const columnMappings = extractColumnMappings([
   { subjectID: 'SubjectID2', blindedID: 'BlindedID2' },
 ])
 
-curateOne(
+curateOne({
   fileInfo, // path, name, size, kind, blob
-  undefined,
-  { curationSpec, columnMappings },
-)
+  mappingOptions: { curationSpec, columnMappings },
+})
+
 
 // Cache clean-up responsibility, e.g. for consistent UID mapping in `retainUIDsOption: 'Off'` is with caller
 clearCaches()

package/dist/esm/applyMappingsWorker.js

@@ -6,7 +6,12 @@ self.addEventListener('message', (event) => {
             const { serializedMappingOptions } = event.data;
             const mappingOptions = deserializeMappingOptions(serializedMappingOptions);
             try {
-                curateOne(event.data.fileInfo, event.data.outputDirectory, mappingOptions).then((mapResults) => {
+                curateOne({
+                    fileInfo: event.data.fileInfo,
+                    fileIndex: event.data.fileIndex,
+                    outputDirectory: event.data.outputDirectory,
+                    mappingOptions,
+                }).then((mapResults) => {
                     // Send finished message for completion
                     self.postMessage({
                         response: 'finished',

package/dist/esm/collectMappings.js

@@ -14,7 +14,7 @@ import deidentifyPS315E, { defaultPs315Options } from './deidentifyPS315E.js';
 import getParser from './getParser.js';
 import { specVersion } from './config/specVersion.js';
 import { get as _get } from 'lodash';
-export default function collectMappings(inputFilePath, dicomData, mappingOptions) {
+export default function collectMappings(inputFilePath, inputFileIndex, dicomData, mappingOptions) {
     var _a;
     const mapResults = {
         // original UID for this dicomData
@@ -33,13 +33,15 @@ export default function collectMappings(inputFilePath, dicomData, mappingOptions
     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"]);
@@ -54,8 +56,13 @@ export default function collectMappings(inputFilePath, dicomData, mappingOptions
     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
@@ -92,6 +99,7 @@ export default function collectMappings(inputFilePath, dicomData, mappingOptions
             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,12 +1,13 @@
 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, dicomData, mappingOptions) {
+export default 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) {
@@ -27,5 +28,69 @@ export default function curateDict(inputFilePath, dicomData, mappingOptions) {
     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

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import * as dcmjs from 'dcmjs';
 import createNestedDirectories from './createNestedDirectories.js';
 import curateDict from './curateDict.js';
-export function curateOne(fileInfo, outputDirectory, mappingOptions) {
-    return __awaiter(this, void 0, void 0, function* () {
+export 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
         //
@@ -36,7 +36,7 @@ export function curateOne(fileInfo, outputDirectory, mappingOptions) {
             };
             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

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';
@@ -33,6 +34,9 @@ function temporalVr(vr) {
 function removeRetiredPrefix(name) {
     return name.startsWith('RETIRED_') ? name.slice(8) : name;
 }
+export function protectUid(uid, retainUIDsOption) {
+    return retainUIDsOption === 'Hashed' ? hashUid(uid) : replaceUid(uid);
+}
 const elementNamesToAlwaysKeepSet = new Set(elementNamesToAlwaysKeep);
 // Special conditions for some PS3.15 E1.1 elements.
 const ps315EElements = rawPs315EElements.map((elm) => {
@@ -52,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);
@@ -235,7 +276,7 @@ export default function deidentifyPS315E({ naturalData, dicomPS315EOptions, date
                         // UID is not a known class UID.
                         !(uid in uidRegistryPS3_06_A1)) {
                         // UIDs that need to be mapped
-                        const mappedUID = retainUIDsOption === 'Hashed' ? hashUid(uid) : replaceUid(uid);
+                        const mappedUID = protectUid(uid, retainUIDsOption);
                         mapResults.mappings[attrPath] = [
                             uid,
                             'replace',
@@ -324,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/getParser.js

@@ -1,4 +1,5 @@
 import * as dcmjs from 'dcmjs';
+import { protectUid as rawProtectUid } from './deidentifyPS315E.js';
 import { getCsvMapping } from './csvMapping.js';
 import { UniqueNumbers } from './UniqueNumbers.js';
 export const FILEBASENAME = Symbol('fileBasename');
@@ -25,7 +26,15 @@ const { isUniqueInGroup, clearUniqueInGroupCache } = (function () {
     };
 })();
 export { clearUniqueNumberCache, clearUniqueInGroupCache };
-export default function getParser(inputPathPattern, inputFilePath, naturalData, columnMappings, additionalData) {
+export default function getParser(inputPathPattern, inputFilePath, naturalData, dicomPS315EOptions, columnMappings, additionalData) {
+    function protectUid(uid) {
+        let protectedUid = uid;
+        if (dicomPS315EOptions !== 'Off') {
+            const { retainUIDsOption } = dicomPS315EOptions;
+            protectedUid = rawProtectUid(uid, retainUIDsOption);
+        }
+        return protectedUid;
+    }
     function getDicom(attrName) {
         if (attrName in dcmjs.data.DicomMetaDictionary.dictionary) {
             // if in hex like "(0008,0100)", convert to text key
@@ -92,6 +101,7 @@ export default function getParser(inputPathPattern, inputFilePath, naturalData,
         getMapping,
         getDicom,
         missingDicom,
+        protectUid,
         // TODO: Phase this out in favor of ISO8601 duration handling.
         // Example of this logic:
         // ContentDate:

package/dist/esm/index.js

@@ -51,7 +51,8 @@ function initializeFileListWorker() {
     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' })
@@ -63,6 +64,7 @@ function initializeFileListWorker() {
                 directoryScanFinished = true;
                 break;
             default:
+                // @ts-expect-error: response is string here, not never
                 console.error(`Unknown response from worker ${event.data.response}`);
         }
         dispatchMappingJobs();
@@ -117,7 +119,7 @@ function initializeMappingWorkers() {
 }
 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.
@@ -125,6 +127,7 @@ function dispatchMappingJobs() {
         mappingWorker.postMessage({
             request: 'apply',
             fileInfo,
+            fileIndex,
             outputDirectory,
             serializedMappingOptions: serializeMappingOptions(mappingOptions),
         });
@@ -186,7 +189,7 @@ function collectMappingOptions(organizeOptions) {
     });
 }
 function queueFilesForMapping(organizeOptions) {
-    organizeOptions.inputFiles.forEach((inputFile) => {
+    organizeOptions.inputFiles.forEach((inputFile, fileIndex) => {
         const fileInfo = {
             path: '',
             name: inputFile.name,
@@ -194,7 +197,7 @@ function queueFilesForMapping(organizeOptions) {
             kind: 'blob',
             blob: inputFile,
         };
-        filesToProcess.push(fileInfo);
+        filesToProcess.push({ fileInfo, fileIndex });
         dispatchMappingJobs();
     });
 }

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

@@ -34,27 +34,14 @@ function scanDirectory(dir) {
         function traverse(dir, prefix) {
             return __awaiter(this, void 0, void 0, function* () {
                 var _a, e_1, _b, _c;
+                // First, collect sorted dir entries
+                const entries = [];
                 try {
                     for (var _d = true, _e = __asyncValues(dir.values()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
                         _c = _f.value;
                         _d = false;
                         const entry = _c;
-                        if (entry.kind === 'file' && keepScanning) {
-                            const file = yield entry.getFile();
-                            self.postMessage({
-                                response: 'file',
-                                fileInfo: {
-                                    path: prefix,
-                                    name: entry.name,
-                                    size: file.size,
-                                    kind: 'handle',
-                                    fileHandle: entry,
-                                },
-                            });
-                        }
-                        else if (entry.kind === 'directory' && keepScanning) {
-                            yield traverse(entry, prefix + '/' + entry.name);
-                        }
+                        entries.push(entry);
                     }
                 }
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -64,6 +51,28 @@ function scanDirectory(dir) {
                     }
                     finally { if (e_1) throw e_1.error; }
                 }
+                entries.sort((a, b) => a.name.localeCompare(b.name));
+                // Assign sorted index to files
+                let fileIndex = 0;
+                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,
+                            },
+                        });
+                    }
+                    else if (entry.kind === 'directory' && keepScanning) {
+                        yield traverse(entry, prefix + '/' + entry.name);
+                    }
+                }
             });
         }
         yield traverse(dir, dir.name);

package/dist/types/applyMappingsWorker.d.ts

@@ -1 +1,8 @@
-export {};
+import type { TFileInfo, TSerializedMappingOptions } from './types';
+export type MappingRequest = {
+    request: 'apply';
+    fileInfo: TFileInfo;
+    fileIndex: number;
+    outputDirectory?: FileSystemDirectoryHandle;
+    serializedMappingOptions: TSerializedMappingOptions;
+};

package/dist/types/collectMappings.d.ts

@@ -1,3 +1,3 @@
 import type { TMappingOptions, TMapResults } from './types';
 import type { TDicomData, TNaturalData } from 'dcmjs';
-export default function collectMappings(inputFilePath: string, dicomData: TDicomData, mappingOptions: TMappingOptions): [TNaturalData, TMapResults];
+export default function collectMappings(inputFilePath: string, inputFileIndex: number, dicomData: TDicomData, mappingOptions: TMappingOptions): [TNaturalData, TMapResults];

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/curateDict.d.ts

@@ -1,7 +1,7 @@
 import * as dcmjs from 'dcmjs';
 import type { TDicomData } from 'dcmjs';
 import type { TMappingOptions } from './types';
-export default function curateDict(inputFilePath: string, dicomData: TDicomData, mappingOptions: TMappingOptions): {
+export default function curateDict(inputFilePath: string, inputFileIndex: number, dicomData: TDicomData, mappingOptions: TMappingOptions): {
     dicomData: dcmjs.data.DicomDict;
     mapResults: import("./types").TMapResults;
 };

package/dist/types/curateOne.d.ts

@@ -1,4 +1,10 @@
 import type { TFileInfo, TMappingOptions, TMapResults } from './types';
-export declare function curateOne(fileInfo: TFileInfo, outputDirectory: FileSystemDirectoryHandle | undefined, mappingOptions: TMappingOptions): Promise<Omit<Partial<TMapResults>, 'anomalies'> & {
+export type TCurateOneArgs = {
+    fileInfo: TFileInfo;
+    fileIndex?: number;
+    outputDirectory: FileSystemDirectoryHandle | undefined;
+    mappingOptions: TMappingOptions;
+};
+export declare function curateOne({ fileInfo, fileIndex, outputDirectory, mappingOptions, }: TCurateOneArgs): Promise<Omit<Partial<TMapResults>, 'anomalies'> & {
     anomalies: TMapResults['anomalies'];
 }>;

package/dist/types/deidentifyPS315E.d.ts

@@ -1,9 +1,11 @@
 import type { TNaturalData } from 'dcmjs';
 import type { Iso8601Duration, TPs315Options, TMapResults } from './types';
-export default function deidentifyPS315E({ naturalData, dicomPS315EOptions, dateOffset, mapResults, }: {
+export declare function protectUid(uid: string, retainUIDsOption: string): string;
+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/getParser.d.ts

@@ -6,4 +6,4 @@ export declare const FILENAME: symbol;
 declare const clearUniqueNumberCache: () => void;
 declare const clearUniqueInGroupCache: () => void;
 export { clearUniqueNumberCache, clearUniqueInGroupCache };
-export default function getParser(inputPathPattern: string, inputFilePath: string, naturalData: TNaturalData, columnMappings?: TColumnMappings, additionalData?: TCurationSpecification['additionalData']): TParser;
+export default function getParser(inputPathPattern: string, inputFilePath: string, naturalData: TNaturalData, dicomPS315EOptions: TCurationSpecification['dicomPS315EOptions'], columnMappings?: TColumnMappings, additionalData?: TCurationSpecification['additionalData']): TParser;

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ import { curateOne } from './curateOne';
 import type { OrganizeOptions, TProgressMessage, TProgressMessageDone } from './types';
 export type ProgressCallback = (message: TProgressMessage) => void;
 export type { TPs315Options, TMapResults, TProgressMessage, OrganizeOptions, TCurationSpecification, } from './types';
+export { TCurateOneArgs } from './curateOne';
 export { specVersion } from './config/specVersion';
 export { sample2PassCurationSpecification as sampleSpecification } from './config/sample2PassCurationSpecification';
 export { csvTextToRows } from './csvMapping';

package/dist/types/scanDirectoryWorker.d.ts

@@ -1 +1,9 @@
+import type { TFileInfo } from './types';
 export {};
+export type FileScanMsg = {
+    response: 'file';
+    fileIndex: number;
+    fileInfo: TFileInfo;
+} | {
+    response: 'done';
+};

package/dist/types/serializeMappingOptions.d.ts

@@ -1,7 +1,3 @@
-import { TMappingOptions } from './types';
-type TSerializedMappingOptions = Omit<TMappingOptions, 'curationSpec'> & {
-    curationSpecStr: string;
-};
+import { TMappingOptions, TSerializedMappingOptions } from './types';
 export declare function serializeMappingOptions(mappingOptions: TMappingOptions): TSerializedMappingOptions;
 export declare function deserializeMappingOptions(serializedMappingOptions: TSerializedMappingOptions): TMappingOptions;
-export {};

package/dist/types/types.d.ts

@@ -34,6 +34,9 @@ export type TMappingOptions = {
     skipValidation?: boolean;
     dateOffset?: Iso8601Duration;
 };
+export type TSerializedMappingOptions = Omit<TMappingOptions, 'curationSpec'> & {
+    curationSpecStr: string;
+};
 export type TFileInfo = {
     path: string;
     name: string;
@@ -92,6 +95,7 @@ export type TParser = {
     getMapping: ((value: string) => string | number) | undefined;
     getDicom: (attrName: string) => any;
     missingDicom: (attrName: string) => boolean;
+    protectUid: (uid: string) => string;
     addDays: (dicomDateString: string, offsetDays: number) => string;
     FILENAME: symbol;
     FILEBASENAME: symbol;