@ubercode/dcmtk 0.8.1 → 0.9.0

package/dist/index.cjs

@@ -7,10 +7,11 @@ var child_process = require('child_process');
 var kill = require('tree-kill');
 var events = require('events');
 var stderrLib = require('stderr-lib');
-var fastXmlParser = require('fast-xml-parser');
 var fs = require('fs/promises');
-var net = require('net');
 var os = require('os');
+var fastXmlParser = require('fast-xml-parser');
+var net = require('net');
+var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -35,8 +36,8 @@ function _interopNamespace(e) {
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var kill__default = /*#__PURE__*/_interopDefault(kill);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var net__namespace = /*#__PURE__*/_interopNamespace(net);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var net__namespace = /*#__PURE__*/_interopNamespace(net);
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -31501,13 +31502,26 @@ async function tryDirectPath(inputPath, timeoutMs, signal, verbosity) {
   if (!jsonBinary.ok) {
     return err(jsonBinary.error);
   }
-  const directArgs = [...buildVerbosityArgs(verbosity), inputPath];
-  const result = await execCommand(jsonBinary.value, directArgs, { timeoutMs, signal });
+  const bulkDir = await createBulkTempDir();
+  const directArgs = [...buildVerbosityArgs(verbosity), "+b", "+bd", bulkDir, inputPath];
+  try {
+    const execOpts = signal !== void 0 ? { timeoutMs, signal } : { timeoutMs };
+    return await execAndParse(jsonBinary.value, directArgs, inputPath, execOpts);
+  } finally {
+    fs.rm(bulkDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function createBulkTempDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), "dcm2json-bulk-"));
+}
+async function execAndParse(binary, args, inputPath, execOpts) {
+  const result = await execCommand(binary, args, execOpts);
   if (!result.ok) {
     return err(result.error);
   }
   if (result.value.exitCode !== 0) {
-    return err(createToolError("dcm2json", directArgs, result.value.exitCode, result.value.stderr));
+    return err(createToolError("dcm2json", args, result.value.exitCode, result.value.stderr));
   }
   try {
     const repaired = repairJson(result.value.stdout);
@@ -36881,8 +36895,8 @@ async function moveFile(src, dest) {
 }
 async function statFileSafe(filePath) {
   try {
-    const stat3 = await fs__namespace.stat(filePath);
-    return stat3.size;
+    const stat4 = await fs__namespace.stat(filePath);
+    return stat4.size;
   } catch {
     return 0;
   }
@@ -38293,6 +38307,341 @@ async function batch(items, operation, options) {
   return { results: state.results, succeeded: state.succeeded, failed: state.failed };
 }
 
+// src/testing/types.ts
+var HammerPhase = {
+  /** File generation phase (copy + modify). */
+  GENERATE: "generate",
+  /** File sending phase (dcmsend). */
+  SEND: "send"
+};
+
+// src/testing/DicomHammer.ts
+var DEFAULT_FILE_COUNT = 100;
+var MAX_FILE_COUNT = 1e5;
+var DEFAULT_CONCURRENCY2 = 4;
+var MAX_CONCURRENCY2 = 64;
+var DEFAULT_CALLING_AE = "HAMMER";
+var DEFAULT_CALLED_AE = "ANY-SCP";
+var DICOM_UID_ROOT = "2.25.";
+var DicomHammerOptionsSchema = zod.z.object({
+  sourceFile: zod.z.string().min(1),
+  host: zod.z.string().min(1),
+  port: zod.z.number().int().min(1).max(65535),
+  callingAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  calledAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  fileCount: zod.z.number().int().min(1).max(MAX_FILE_COUNT).optional(),
+  concurrency: zod.z.number().int().min(1).max(MAX_CONCURRENCY2).optional(),
+  delayMs: zod.z.number().int().min(0).optional(),
+  institution: zod.z.string().min(1).optional(),
+  erasePrivateTags: zod.z.boolean().optional(),
+  modifications: zod.z.array(zod.z.object({ tag: zod.z.string().min(1), value: zod.z.string() })).optional(),
+  timeoutMs: zod.z.number().int().positive().optional(),
+  signal: zod.z.instanceof(AbortSignal).optional(),
+  outputDir: zod.z.string().min(1).optional(),
+  noHalt: zod.z.boolean().optional()
+}).strict();
+function resolveNetworkOptions(options) {
+  return {
+    host: options.host,
+    port: options.port,
+    callingAETitle: options.callingAETitle ?? DEFAULT_CALLING_AE,
+    calledAETitle: options.calledAETitle ?? DEFAULT_CALLED_AE,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    noHalt: options.noHalt ?? true
+  };
+}
+function resolveOptions(options) {
+  return {
+    sourceFile: options.sourceFile,
+    ...resolveNetworkOptions(options),
+    fileCount: options.fileCount ?? DEFAULT_FILE_COUNT,
+    concurrency: options.concurrency ?? DEFAULT_CONCURRENCY2,
+    delayMs: options.delayMs ?? 0,
+    institution: options.institution,
+    erasePrivateTags: options.erasePrivateTags ?? false,
+    modifications: options.modifications ?? [],
+    signal: options.signal,
+    outputDir: options.outputDir ?? os.tmpdir()
+  };
+}
+function generateUid() {
+  const hex = crypto.randomUUID().replace(/-/g, "");
+  const decimal = BigInt("0x" + hex).toString(10);
+  return DICOM_UID_ROOT + decimal;
+}
+function formatDate() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = String(d.getFullYear());
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return yyyy + mm + dd;
+}
+function buildModifications(index, opts) {
+  const mods = [
+    { tag: "(0020,000D)", value: generateUid() },
+    { tag: "(0020,000E)", value: generateUid() },
+    { tag: "(0008,0018)", value: generateUid() },
+    { tag: "(0008,0020)", value: formatDate() },
+    { tag: "(0008,0050)", value: `HAMMER-${String(index + 1).padStart(6, "0")}` }
+  ];
+  if (opts.institution !== void 0) {
+    mods.push({ tag: "(0008,0080)", value: opts.institution });
+  }
+  for (const mod of opts.modifications) {
+    mods.push({ tag: mod.tag, value: mod.value });
+  }
+  return mods;
+}
+function computeThroughput(succeeded, totalBytes, durationMs) {
+  const durationSec = durationMs / 1e3;
+  return {
+    filesPerSec: durationSec > 0 ? succeeded / durationSec : 0,
+    bytesPerSec: durationSec > 0 ? totalBytes / durationSec : 0
+  };
+}
+function delay3(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var DicomHammer = class _DicomHammer extends events.EventEmitter {
+  constructor(options) {
+    super();
+    __publicField(this, "opts");
+    __publicField(this, "generatedDir");
+    __publicField(this, "generatedFiles", []);
+    this.opts = options;
+    this.setMaxListeners(20);
+  }
+  // -----------------------------------------------------------------------
+  // Factory
+  // -----------------------------------------------------------------------
+  /**
+   * Creates a DicomHammer instance.
+   *
+   * @param options - Configuration for file generation and sending
+   * @returns A Result containing the DicomHammer or a validation error
+   */
+  static create(options) {
+    const validation = DicomHammerOptionsSchema.safeParse(options);
+    if (!validation.success) {
+      return err(createValidationError("DicomHammer", validation.error));
+    }
+    return ok(new _DicomHammer(resolveOptions(options)));
+  }
+  // -----------------------------------------------------------------------
+  // Generate phase
+  // -----------------------------------------------------------------------
+  /**
+   * Generates modified copies of the source DICOM file.
+   *
+   * Each copy receives unique Study/Series/SOP Instance UIDs, a unique
+   * accession number, and any custom modifications.
+   */
+  async generate() {
+    const start = Date.now();
+    const dir = path.join(this.opts.outputDir, `dcmtk-hammer-${Date.now()}`);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch {
+      return err(new Error(`Failed to create output directory: ${dir}`));
+    }
+    this.generatedDir = dir;
+    const indices = Array.from({ length: this.opts.fileCount }, (_, i) => i);
+    const total = this.opts.fileCount;
+    let completedCount = 0;
+    const result = await batch(
+      indices,
+      async (index) => {
+        return this.generateOneFile(index, dir);
+      },
+      {
+        concurrency: this.opts.concurrency,
+        signal: this.opts.signal,
+        onProgress: (_completed, _total, fileResult) => {
+          completedCount++;
+          if (fileResult.ok) {
+            this.emit("FILE_GENERATED", { index: completedCount - 1, total, filePath: fileResult.value });
+          }
+          this.emitProgress(HammerPhase.GENERATE, completedCount, total);
+        }
+      }
+    );
+    const files = result.results.filter((r) => r.ok).map((r) => r.value);
+    this.generatedFiles = files;
+    if (files.length === 0) {
+      return err(new Error(`All ${total} file generations failed`));
+    }
+    return ok({ files, durationMs: Date.now() - start, outputDir: dir });
+  }
+  /** Generates a single modified copy. Extracted for function size compliance. */
+  async generateOneFile(index, dir) {
+    const padded = String(index + 1).padStart(6, "0");
+    const dest = path.join(dir, `hammer_${padded}.dcm`);
+    const copyResult = await copyFileSafe(this.opts.sourceFile, dest);
+    if (!copyResult.ok) return err(copyResult.error);
+    const modResult = await dcmodify(dest, {
+      modifications: buildModifications(index, this.opts),
+      erasePrivateTags: this.opts.erasePrivateTags || void 0,
+      insertIfMissing: true,
+      noBackup: true,
+      timeoutMs: this.opts.timeoutMs,
+      signal: this.opts.signal
+    });
+    if (!modResult.ok) return err(modResult.error);
+    return ok(dest);
+  }
+  // -----------------------------------------------------------------------
+  // Send phase
+  // -----------------------------------------------------------------------
+  /**
+   * Sends files to the target SCP.
+   *
+   * @param files - Files to send. Defaults to previously generated files.
+   */
+  async send(files) {
+    const filesToSend = files ?? this.generatedFiles;
+    if (filesToSend.length === 0) {
+      return err(new Error("No files to send. Call generate() first or provide files."));
+    }
+    const fileSize = await this.getFileSize(filesToSend[0]);
+    const start = Date.now();
+    const total = filesToSend.length;
+    const tracker = { errors: [], completedCount: 0, succeeded: 0 };
+    await batch([...filesToSend], async (file) => this.sendOneFile(file), {
+      concurrency: this.opts.concurrency,
+      signal: this.opts.signal,
+      onProgress: (_c, _t, sendResult) => this.trackSendProgress(sendResult, filesToSend, total, tracker)
+    });
+    return ok(this.buildSendResult(tracker, total, fileSize, Date.now() - start));
+  }
+  /** Tracks a single send result for progress reporting. */
+  trackSendProgress(sendResult, files, total, tracker) {
+    tracker.completedCount++;
+    const file = files[tracker.completedCount - 1];
+    if (sendResult.ok) {
+      tracker.succeeded++;
+      this.emit("SEND_COMPLETE", { index: tracker.completedCount - 1, total, file, durationMs: 0 });
+    } else {
+      tracker.errors.push({ file, error: sendResult.error });
+      this.emit("SEND_FAILED", { index: tracker.completedCount - 1, total, file, error: sendResult.error });
+    }
+    this.emitProgress(HammerPhase.SEND, tracker.completedCount, total);
+  }
+  /** Assembles the final HammerSendResult. */
+  buildSendResult(tracker, total, fileSize, durationMs) {
+    const totalBytes = tracker.succeeded * fileSize;
+    const throughput = computeThroughput(tracker.succeeded, totalBytes, durationMs);
+    return {
+      succeeded: tracker.succeeded,
+      failed: tracker.errors.length,
+      totalFiles: total,
+      durationMs,
+      filesPerSec: throughput.filesPerSec,
+      bytesPerSec: throughput.bytesPerSec,
+      totalBytes,
+      errors: tracker.errors
+    };
+  }
+  /** Sends a single file, with optional delay. */
+  async sendOneFile(file) {
+    if (this.opts.delayMs > 0) {
+      await delay3(this.opts.delayMs);
+    }
+    const result = await dcmsend({
+      host: this.opts.host,
+      port: this.opts.port,
+      files: [file],
+      callingAETitle: this.opts.callingAETitle,
+      calledAETitle: this.opts.calledAETitle,
+      noHalt: this.opts.noHalt || void 0,
+      timeoutMs: this.opts.timeoutMs,
+      signal: this.opts.signal
+    });
+    if (!result.ok) return err(result.error);
+    return ok(void 0);
+  }
+  /** Gets the file size in bytes, returning 0 on error. */
+  async getFileSize(filePath) {
+    try {
+      const s = await fs.stat(filePath);
+      return s.size;
+    } catch {
+      return 0;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Combined run
+  // -----------------------------------------------------------------------
+  /**
+   * Generates files and sends them in one call.
+   *
+   * @returns Combined result with timing for both phases
+   */
+  async run() {
+    const genResult = await this.generate();
+    if (!genResult.ok) return err(genResult.error);
+    const sendResult = await this.send(genResult.value.files);
+    if (!sendResult.ok) return err(sendResult.error);
+    const result = {
+      succeeded: sendResult.value.succeeded,
+      failed: sendResult.value.failed,
+      totalFiles: sendResult.value.totalFiles,
+      durationMs: genResult.value.durationMs + sendResult.value.durationMs,
+      generateDurationMs: genResult.value.durationMs,
+      sendDurationMs: sendResult.value.durationMs,
+      filesPerSec: sendResult.value.filesPerSec,
+      bytesPerSec: sendResult.value.bytesPerSec,
+      totalBytes: sendResult.value.totalBytes,
+      errors: sendResult.value.errors
+    };
+    this.emit("RUN_COMPLETE", result);
+    return ok(result);
+  }
+  // -----------------------------------------------------------------------
+  // Cleanup
+  // -----------------------------------------------------------------------
+  /** Removes all generated files and the output directory. */
+  async cleanup() {
+    if (this.generatedDir === void 0) return ok(void 0);
+    try {
+      await fs.rm(this.generatedDir, { recursive: true, force: true });
+      this.generatedDir = void 0;
+      this.generatedFiles = [];
+      return ok(void 0);
+    } catch {
+      return err(new Error(`Failed to cleanup: ${this.generatedDir}`));
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Event helpers
+  // -----------------------------------------------------------------------
+  /** Emits a PROGRESS event. */
+  emitProgress(phase, completed, total) {
+    this.emit("PROGRESS", { phase, completed, total, percent: Math.round(completed / total * 100) });
+  }
+  /** Registers a listener for FILE_GENERATED events. */
+  onFileGenerated(listener) {
+    return this.on("FILE_GENERATED", listener);
+  }
+  /** Registers a listener for SEND_COMPLETE events. */
+  onSendComplete(listener) {
+    return this.on("SEND_COMPLETE", listener);
+  }
+  /** Registers a listener for SEND_FAILED events. */
+  onSendFailed(listener) {
+    return this.on("SEND_FAILED", listener);
+  }
+  /** Registers a listener for PROGRESS events. */
+  onProgress(listener) {
+    return this.on("PROGRESS", listener);
+  }
+  /** Registers a listener for RUN_COMPLETE events. */
+  onRunComplete(listener) {
+    return this.on("RUN_COMPLETE", listener);
+  }
+};
+
 // src/utils/retry.ts
 var DEFAULT_MAX_ATTEMPTS = 3;
 var DEFAULT_INITIAL_DELAY_MS = 1e3;
@@ -38399,6 +38748,7 @@ exports.Dcmrecv = Dcmrecv;
 exports.DcmrecvEvent = DcmrecvEvent;
 exports.DcmtkProcess = DcmtkProcess;
 exports.DicomDataset = DicomDataset;
+exports.DicomHammer = DicomHammer;
 exports.DicomInstance = DicomInstance;
 exports.DicomReceiver = DicomReceiver;
 exports.DicomSend = DicomSend;
@@ -38407,6 +38757,7 @@ exports.DicomTagPathSchema = DicomTagPathSchema;
 exports.DicomTagSchema = DicomTagSchema;
 exports.FilenameMode = FilenameMode;
 exports.GetQueryModel = GetQueryModel;
+exports.HammerPhase = HammerPhase;
 exports.Img2dcmInputFormat = Img2dcmInputFormat;
 exports.JplsColorConversion = JplsColorConversion;
 exports.LineParser = LineParser;