@ubercode/dcmtk 0.12.1 → 0.13.1

package/dist/servers.cjs

@@ -2312,6 +2312,7 @@ var Dcm2jsonOptionsSchema = zod.z.object({
   signal: zod.z.instanceof(AbortSignal).optional(),
   directOnly: zod.z.boolean().optional(),
   charsetAssume: zod.z.string().min(1).optional(),
+  charsetFallback: zod.z.string().min(1).optional(),
   verbosity: zod.z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
 var VERBOSITY_FLAGS = { verbose: "-v", debug: "-d" };
@@ -2325,27 +2326,34 @@ function buildXmlOpts(options) {
   const result = {};
   if (options?.verbosity !== void 0) result["verbosity"] = options.verbosity;
   if (options?.charsetAssume !== void 0) result["charsetAssume"] = options.charsetAssume;
+  if (options?.charsetFallback !== void 0) result["charsetFallback"] = options.charsetFallback;
   return result;
 }
+function isCharsetError(stderrOutput) {
+  return stderrOutput.includes("convert character encoding") || stderrOutput.includes("Illegal byte sequence");
+}
+async function runXmlAndParse(binary, args, execOpts) {
+  const xmlResult = await execCommand(binary, args, execOpts);
+  if (!xmlResult.ok) return err(xmlResult.error);
+  if (xmlResult.value.exitCode !== 0) {
+    return err(createToolError("dcm2xml", args, xmlResult.value.exitCode, xmlResult.value.stderr));
+  }
+  const jsonResult = xmlToJson(xmlResult.value.stdout);
+  if (!jsonResult.ok) return err(jsonResult.error);
+  return ok({ data: jsonResult.value, source: "xml" });
+}
 async function tryXmlPath(inputPath, timeoutMs, signal, opts) {
   const xmlBinary = resolveBinary("dcm2xml");
-  if (!xmlBinary.ok) {
-    return err(xmlBinary.error);
-  }
+  if (!xmlBinary.ok) return err(xmlBinary.error);
   const charsetArgs = opts?.charsetAssume !== void 0 ? ["+Ca", opts.charsetAssume] : [];
   const xmlArgs = [...buildVerbosityArgs(opts?.verbosity), ...charsetArgs, "-nat", inputPath];
-  const xmlResult = await execCommand(xmlBinary.value, xmlArgs, { timeoutMs, signal });
-  if (!xmlResult.ok) {
-    return err(xmlResult.error);
+  const execOpts = signal !== void 0 ? { timeoutMs, signal } : { timeoutMs };
+  const result = await runXmlAndParse(xmlBinary.value, xmlArgs, execOpts);
+  if (!result.ok && opts?.charsetFallback !== void 0 && isCharsetError(result.error.message)) {
+    const fallbackArgs = [...buildVerbosityArgs(opts.verbosity), "+Ca", opts.charsetFallback, "-nat", inputPath];
+    return runXmlAndParse(xmlBinary.value, fallbackArgs, execOpts);
   }
-  if (xmlResult.value.exitCode !== 0) {
-    return err(createToolError("dcm2xml", xmlArgs, xmlResult.value.exitCode, xmlResult.value.stderr));
-  }
-  const jsonResult = xmlToJson(xmlResult.value.stdout);
-  if (!jsonResult.ok) {
-    return err(jsonResult.error);
-  }
-  return ok({ data: jsonResult.value, source: "xml" });
+  return result;
 }
 async function tryDirectPath(inputPath, timeoutMs, signal, verbosity) {
   const jsonBinary = resolveBinary("dcm2json");
@@ -2530,7 +2538,8 @@ var DicomInstance = class _DicomInstance {
     const jsonResult = await dcm2json(path2, {
       timeoutMs: options?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       signal: options?.signal,
-      charsetAssume: options?.charsetAssume
+      charsetAssume: options?.charsetAssume,
+      charsetFallback: options?.charsetFallback
     });
     if (!jsonResult.ok) return err(jsonResult.error);
     const datasetResult = DicomDataset.fromJson(jsonResult.value.data);
@@ -2848,6 +2857,13 @@ var DicomReceiverOptionsSchema = zod.z.object({
   filenameMode: zod.z.enum(["default", "unique", "short-unique", "system-time"]).optional(),
   filenameExtension: zod.z.string().min(1).optional(),
   storageMode: zod.z.enum(["normal", "bit-preserving", "ignore"]).optional(),
+  instanceOpenOptions: zod.z.object({
+    timeoutMs: zod.z.number().int().positive().optional(),
+    signal: zod.z.instanceof(AbortSignal).optional(),
+    charsetAssume: zod.z.string().min(1).optional(),
+    charsetFallback: zod.z.string().min(1).optional()
+  }).strict().optional(),
+  parseInstances: zod.z.boolean().optional(),
   signal: zod.z.instanceof(AbortSignal).optional()
 }).strict().refine((data) => (data.minPoolSize ?? DEFAULT_MIN_POOL_SIZE) <= (data.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE), {
   message: "minPoolSize must be <= maxPoolSize"
@@ -3017,6 +3033,8 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     __publicField(this, "minPoolSize");
     __publicField(this, "maxPoolSize");
     __publicField(this, "connectionTimeoutMs");
+    __publicField(this, "resolvedInstanceOpenOptions");
+    __publicField(this, "parseInstances");
     __publicField(this, "workers", /* @__PURE__ */ new Map());
     __publicField(this, "tcpServer");
     __publicField(this, "associationCounter", 0);
@@ -3028,6 +3046,8 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     this.minPoolSize = options.minPoolSize ?? DEFAULT_MIN_POOL_SIZE;
     this.maxPoolSize = options.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE;
     this.connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+    this.resolvedInstanceOpenOptions = { charsetFallback: "Latin1", ...options.instanceOpenOptions };
+    this.parseInstances = options.parseInstances ?? true;
   }
   // -----------------------------------------------------------------------
   // Public API
@@ -3480,21 +3500,23 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
       calledAE: data.calledAE,
       source: data.source
     });
-    const instanceCtx = {
-      filePath: finalPath,
-      fileSize,
-      associationId: ctx.associationId,
-      associationDir: ctx.associationDir,
-      callingAE: data.callingAE,
-      calledAE: data.calledAE,
-      source: data.source
-    };
-    worker.trackInstance(this.parseAndEmitInstance(worker, instanceCtx));
+    if (this.parseInstances) {
+      const instanceCtx = {
+        filePath: finalPath,
+        fileSize,
+        associationId: ctx.associationId,
+        associationDir: ctx.associationDir,
+        callingAE: data.callingAE,
+        calledAE: data.calledAE,
+        source: data.source
+      };
+      worker.trackInstance(this.parseAndEmitInstance(worker, instanceCtx));
+    }
   }
   /** Parses a DICOM file and emits INSTANCE_RECEIVED or INSTANCE_ERROR. */
   async parseAndEmitInstance(worker, ctx) {
     try {
-      const openResult = await DicomInstance.open(ctx.filePath);
+      const openResult = await DicomInstance.open(ctx.filePath, this.resolvedInstanceOpenOptions);
       if (!openResult.ok) {
         worker.recordInstanceError();
         this.emit("INSTANCE_ERROR", { error: openResult.error, thrown: false, ...ctx });