dcmjs 0.49.1 → 0.49.3

package/build/dcmjs.es.js

@@ -9194,12 +9194,7 @@ var SEQUENCE_DELIMITER_TAG = 0xfffee0dd;
 
 // Nearly all transfer syntaxes are encapsulated, so record those which are
 // unencapsulated as the exceptions.
-var unencapsulatedTransferSyntaxes = {
-  IMPLICIT_LITTLE_ENDIAN: true,
-  EXPLICIT_BIG_ENDIAN: true,
-  DEFLATED_EXPLICIT_LITTLE_ENDIAN: true,
-  EXPLICIT_LITTLE_ENDIAN: true
-};
+var unencapsulatedTransferSyntaxes = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, IMPLICIT_LITTLE_ENDIAN, true), EXPLICIT_BIG_ENDIAN, true), DEFLATED_EXPLICIT_LITTLE_ENDIAN, true), EXPLICIT_LITTLE_ENDIAN$1, true);
 
 /**
  * Video transfer syntax UIDs (MPEG2, H.264, H.265)
@@ -10011,7 +10006,7 @@ var BinaryRepresentation = /*#__PURE__*/function (_ValueRepresentation3) {
   }
   _createClass(BinaryRepresentation, [{
     key: "writeBytes",
-    value: function writeBytes(stream, value, syntax, isEncapsulated) {
+    value: function writeBytes(stream, value, _syntax, isEncapsulated) {
       var writeOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
       var i;
       var binaryStream;
@@ -11815,8 +11810,8 @@ var Tag = /*#__PURE__*/function () {
     value: function write(stream, vrType, values, syntax, writeOptions) {
       var vr = ValueRepresentation.createByTypeString(vrType);
       var useSyntax = DicomMessage$1._normalizeSyntax(syntax);
-      var implicit = useSyntax == IMPLICIT_LITTLE_ENDIAN ? true : false;
-      var isLittleEndian = useSyntax == IMPLICIT_LITTLE_ENDIAN || useSyntax == EXPLICIT_LITTLE_ENDIAN$1 ? true : false;
+      var implicit = useSyntax === IMPLICIT_LITTLE_ENDIAN;
+      var isLittleEndian = useSyntax === IMPLICIT_LITTLE_ENDIAN || useSyntax === EXPLICIT_LITTLE_ENDIAN$1;
       var isEncapsulated = this.isPixelDataTag() && DicomMessage$1.isEncapsulated(syntax);
       var oldEndian = stream.isLittleEndian;
       stream.setEndian(isLittleEndian);
@@ -12677,6 +12672,14 @@ var DicomMetadataListener = /*#__PURE__*/function () {
     _defineProperty(this, "dict", null);
     _defineProperty(this, "filters", []);
     _defineProperty(this, "information", null);
+    /**
+     * Optional backpressure (drain) function. When set, the reader will await
+     * the returned promise before emitting more fragment values, to avoid
+     * having too many open streams or overwhelming the consumer.
+     */
+    _defineProperty(this, "_drain", function () {
+      return Promise.resolve();
+    });
     // Handle legacy constructor format where first arg might be a filter
     if (typeof options.addTag === "function" || typeof options.startObject === "function" || typeof options.pop === "function" || typeof options.value === "function") {
       // Legacy format: all arguments are filters
@@ -12701,6 +12704,33 @@ var DicomMetadataListener = /*#__PURE__*/function () {
    * @returns {void}
    */
   _createClass(DicomMetadataListener, [{
+    key: "setDrain",
+    value:
+    /**
+     * Set the drain (pushback) function for backpressure. The function should
+     * return a Promise that resolves when it is safe to emit more data (e.g.
+     * when unsettled stream write count is below a limit). Node.js streams use
+     * the term "drain" for this (see Writable 'drain' event).
+     *
+     * @param {(() => Promise<void>) | null} fn - Function that returns a Promise, or null to clear
+     */
+    function setDrain(fn) {
+      this._drain = typeof fn === "function" ? fn : null;
+    }
+
+    /**
+     * Returns a Promise that resolves when the drain condition is met (or
+     * immediately if no drain is set). Call this before emitting values to
+     * apply backpressure.
+     *
+     * @returns {Promise<void>}
+     */
+  }, {
+    key: "awaitDrain",
+    value: function awaitDrain() {
+      return this._drain() || Promise.resolve();
+    }
+  }, {
     key: "init",
     value: function init() {
       var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
@@ -13369,29 +13399,33 @@ var AsyncDicomReader = /*#__PURE__*/function () {
     key: "_emitSplitValues",
     value: (function () {
       var _emitSplitValues2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(length) {
+        var _listener$awaitDrain;
         var stream, listener, maxFragmentSize, offset, chunkSize, buffer;
         return _regeneratorRuntime().wrap(function _callee7$(_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
               stream = this.stream, listener = this.listener;
+              _context7.next = 3;
+              return (_listener$awaitDrain = listener.awaitDrain) === null || _listener$awaitDrain === void 0 ? void 0 : _listener$awaitDrain.call(listener);
+            case 3:
               maxFragmentSize = this.maxFragmentSize;
               offset = 0;
-            case 3:
+            case 5:
               if (!(offset < length)) {
-                _context7.next = 13;
+                _context7.next = 15;
                 break;
               }
               chunkSize = Math.min(maxFragmentSize, length - offset);
-              _context7.next = 7;
+              _context7.next = 9;
               return stream.ensureAvailable(chunkSize);
-            case 7:
+            case 9:
               buffer = stream.readArrayBuffer(chunkSize);
               listener.value(buffer);
               offset += chunkSize;
               stream.consume();
-              _context7.next = 3;
+              _context7.next = 5;
               break;
-            case 13:
+            case 15:
             case "end":
               return _context7.stop();
           }