dcmjs 0.49.2 → 0.49.3

package/build/dcmjs.es.js

@@ -12672,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
@@ -12696,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;
@@ -13364,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();
           }