web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/grpc-libp2p-client/dist/dc-http2/stream.esm.js

@@ -0,0 +1,248 @@
+import { pipe } from '../../../it-pipe/dist/src/index.js';
+import { pushable } from '../../../it-pushable/dist/src/index.js';
+
+const MaxChunkSize = 4 * 1024 - 5;
+class StreamWriter {
+  constructor(sink) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    this.sink = sink;
+    this.options = options;
+    //private p = pushable({ objectMode: false }) 
+    this.bytesWritten = 0;
+    this.abortController = new AbortController();
+    // 背压控制相关属性  
+    this.backpressureHistory = [];
+    this.isBackpressure = false;
+    this.writeQueue = [];
+    this.isProcessingQueue = false;
+    // 事件系统  
+    this.listeners = new Map();
+    if (options) {
+      this.options = {
+        chunkSize: options.chunkSize ?? MaxChunkSize,
+        bufferSize: options.bufferSize ?? 5 * 1024 * 1024,
+        retries: options.retries ?? 3
+      };
+    } else {
+      this.options = {
+        chunkSize: MaxChunkSize,
+        bufferSize: 5 * 1024 * 1024,
+        retries: 3
+      };
+    }
+    if (this.options.chunkSize && this.options.chunkSize > MaxChunkSize) {
+      this.options.chunkSize = MaxChunkSize;
+    }
+    const basePushable = pushable({
+      objectMode: false
+    });
+    // 保留原始方法引用  
+    basePushable._originalPush = basePushable.push.bind(basePushable);
+    basePushable._originalNext = basePushable.next.bind(basePushable);
+    basePushable._queueSize = 0;
+    // 重写 next 方法  
+    Object.defineProperty(basePushable, 'next', {
+      value: async () => {
+        const result = await basePushable._originalNext();
+        if (!result.done && result.value) {
+          basePushable._queueSize -= result.value.byteLength;
+        }
+        return result;
+      },
+      writable: false,
+      configurable: false
+    });
+    // 安全重写 push 方法  
+    Object.defineProperty(basePushable, 'push', {
+      value: chunk => {
+        basePushable._queueSize += chunk.byteLength;
+        return basePushable._originalPush(chunk);
+      },
+      writable: false,
+      configurable: false
+    });
+    this.p = basePushable;
+    this.startPipeline();
+  }
+  get queueSize() {
+    return this.p._queueSize;
+  }
+  // 在 next() 操作时更新队列大小  
+  async safeNext() {
+    const result = await this.p.next();
+    if (!result.done) {
+      this.p._queueSize -= result.value.byteLength;
+    }
+    return result;
+  }
+  handleError(err) {
+    this.dispatchEvent(new CustomEvent('error', {
+      detail: err
+    }));
+    this.abort(err.message);
+  }
+  startPipeline() {
+    pipe(this.p, this.createTransform(), this.sink).catch(err => this.handleError(err)); // 正确绑定this  
+  }
+  createTransform() {
+    return async function* (source) {
+      for await (const chunk of source) {
+        yield chunk;
+      }
+    };
+  }
+  async write(data) {
+    if (this.abortController.signal.aborted) return;
+    return new Promise((resolve, reject) => {
+      const task = async () => {
+        try {
+          const buffer = await this.convertToBuffer(data);
+          await this.writeChunks(buffer);
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      };
+      this.writeQueue.push(task);
+      this.processQueue();
+    });
+  }
+  async convertToBuffer(data) {
+    if (data instanceof Blob) return data.arrayBuffer();
+    if (typeof data === 'string') return new TextEncoder().encode(data).buffer;
+    return data;
+  }
+  async writeChunks(buffer) {
+    for (let offset = 0; offset < buffer.byteLength; offset += this.options.chunkSize) {
+      const end = Math.min(offset + this.options.chunkSize, buffer.byteLength);
+      const chunk = new Uint8Array(end - offset);
+      chunk.set(new Uint8Array(buffer.slice(offset, end)));
+      await this.retryableWrite(chunk);
+      this.updateProgress(chunk.byteLength);
+    }
+  }
+  async retryableWrite(chunk) {
+    let attempt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    try {
+      await this.monitorBackpressure();
+      await new Promise((resolve, reject) => {
+        try {
+          this.p.push(chunk);
+        } catch (err) {
+          reject(err);
+        }
+        resolve();
+      });
+    } catch (err) {
+      if (attempt < this.options.retries) {
+        const delay = this.calculateRetryDelay(attempt);
+        await new Promise(r => setTimeout(r, delay));
+        return this.retryableWrite(chunk, attempt + 1);
+      }
+      throw err;
+    }
+  }
+  async monitorBackpressure() {
+    const checkInterval = 50;
+    const historySize = 10;
+    while (true) {
+      const currentSize = this.queueSize; // 空值合并运算符  
+      if (currentSize > 0) {
+        this.backpressureHistory.push(currentSize);
+      }
+      if (this.backpressureHistory.length > historySize) {
+        this.backpressureHistory.shift();
+      }
+      const avg = this.backpressureHistory.reduce((a, b) => a + b, 0) / historySize;
+      const dynamicThreshold = Math.min(this.options.bufferSize * 0.8, avg * 1.5);
+      if (currentSize < dynamicThreshold || currentSize === 0) {
+        if (this.isBackpressure) {
+          this.isBackpressure = false;
+          this.dispatchEvent(new CustomEvent('backpressure', {
+            detail: {
+              currentSize,
+              averageSize: avg,
+              threshold: dynamicThreshold,
+              waitingTime: 0
+            }
+          }));
+        }
+        return;
+      }
+      if (!this.isBackpressure) {
+        this.isBackpressure = true;
+        this.dispatchEvent(new CustomEvent('backpressure', {
+          detail: {
+            currentSize,
+            averageSize: avg,
+            threshold: dynamicThreshold,
+            waitingTime: 0
+          }
+        }));
+      }
+      const waitTime = Math.min(10, checkInterval * Math.pow(2, currentSize / dynamicThreshold));
+      await new Promise(r => setTimeout(r, waitTime));
+      if (this.abortController.signal.aborted) break;
+    }
+  }
+  calculateRetryDelay(attempt) {
+    const baseDelay = 10;
+    const maxDelay = 100;
+    return Math.min(baseDelay * Math.pow(2, attempt) + Math.random() * 100, maxDelay);
+  }
+  async processQueue() {
+    if (this.isProcessingQueue || this.abortController.signal.aborted) return;
+    this.isProcessingQueue = true;
+    while (this.writeQueue.length > 0) {
+      if (this.abortController.signal.aborted) break;
+      await this.monitorBackpressure();
+      const task = this.writeQueue.shift();
+      await task();
+    }
+    this.isProcessingQueue = false;
+  }
+  updateProgress(bytes) {
+    this.bytesWritten += bytes;
+    this.dispatchEvent(new CustomEvent('progress', {
+      detail: {
+        loaded: this.bytesWritten
+      }
+    }));
+  }
+  async end() {
+    this.p.end();
+    await this.sink.return?.();
+    this.cleanup();
+  }
+  abort() {
+    let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'User aborted';
+    this.abortController.abort(reason);
+    this.cleanup();
+    this.dispatchEvent(new CustomEvent('abort', {
+      detail: reason
+    }));
+  }
+  cleanup() {
+    this.p.end();
+    this.abortController.abort();
+    this.writeQueue = [];
+  }
+  addEventListener(type, callback) {
+    const handlers = this.listeners.get(type) || [];
+    handlers.push(callback);
+    this.listeners.set(type, handlers);
+  }
+  // 修复后的代码片段  
+  dispatchEvent(event) {
+    const handlers = this.listeners.get(event.type) || [];
+    handlers.forEach(handler => handler(event));
+  }
+  // 明确指定事件类型  
+  dispatchBackpressureEvent(detail) {
+    this.dispatchEvent(new CustomEvent('backpressure', {
+      detail
+    }));
+  }
+}
+
+export { StreamWriter };

package/dist/esm/node_modules/has-property-descriptors/index.js

@@ -0,0 +1,30 @@
+import { __require as requireEsDefineProperty } from '../es-define-property/index.js';
+
+var hasPropertyDescriptors_1;
+var hasRequiredHasPropertyDescriptors;
+function requireHasPropertyDescriptors() {
+  if (hasRequiredHasPropertyDescriptors) return hasPropertyDescriptors_1;
+  hasRequiredHasPropertyDescriptors = 1;
+  var $defineProperty = /*@__PURE__*/requireEsDefineProperty();
+  var hasPropertyDescriptors = function hasPropertyDescriptors() {
+    return !!$defineProperty;
+  };
+  hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+    // node v0.6 has a bug where array lengths can be Set but not Defined
+    if (!$defineProperty) {
+      return null;
+    }
+    try {
+      return $defineProperty([], 'length', {
+        value: 1
+      }).length !== 1;
+    } catch (e) {
+      // In Firefox 4-22, defining length on an array throws an exception.
+      return true;
+    }
+  };
+  hasPropertyDescriptors_1 = hasPropertyDescriptors;
+  return hasPropertyDescriptors_1;
+}
+
+export { requireHasPropertyDescriptors as __require };

package/dist/esm/node_modules/has-symbols/index.js

@@ -0,0 +1,30 @@
+import { __require as requireShams } from './shams.js';
+
+var hasSymbols;
+var hasRequiredHasSymbols;
+function requireHasSymbols() {
+  if (hasRequiredHasSymbols) return hasSymbols;
+  hasRequiredHasSymbols = 1;
+  var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+  var hasSymbolSham = requireShams();
+
+  /** @type {import('.')} */
+  hasSymbols = function hasNativeSymbols() {
+    if (typeof origSymbol !== 'function') {
+      return false;
+    }
+    if (typeof Symbol !== 'function') {
+      return false;
+    }
+    if (typeof origSymbol('foo') !== 'symbol') {
+      return false;
+    }
+    if (typeof Symbol('bar') !== 'symbol') {
+      return false;
+    }
+    return hasSymbolSham();
+  };
+  return hasSymbols;
+}
+
+export { requireHasSymbols as __require };

package/dist/esm/node_modules/has-symbols/shams.js

@@ -0,0 +1,69 @@
+var shams;
+var hasRequiredShams;
+function requireShams() {
+  if (hasRequiredShams) return shams;
+  hasRequiredShams = 1;
+
+  /** @type {import('./shams')} */
+  /* eslint complexity: [2, 18], max-statements: [2, 33] */
+  shams = function hasSymbols() {
+    if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') {
+      return false;
+    }
+    if (typeof Symbol.iterator === 'symbol') {
+      return true;
+    }
+
+    /** @type {{ [k in symbol]?: unknown }} */
+    var obj = {};
+    var sym = Symbol('test');
+    var symObj = Object(sym);
+    if (typeof sym === 'string') {
+      return false;
+    }
+    if (Object.prototype.toString.call(sym) !== '[object Symbol]') {
+      return false;
+    }
+    if (Object.prototype.toString.call(symObj) !== '[object Symbol]') {
+      return false;
+    }
+
+    // temp disabled per https://github.com/ljharb/object.assign/issues/17
+    // if (sym instanceof Symbol) { return false; }
+    // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+    // if (!(symObj instanceof Symbol)) { return false; }
+
+    // if (typeof Symbol.prototype.toString !== 'function') { return false; }
+    // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+    var symVal = 42;
+    obj[sym] = symVal;
+    for (var _ in obj) {
+      return false;
+    } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+    if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) {
+      return false;
+    }
+    if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) {
+      return false;
+    }
+    var syms = Object.getOwnPropertySymbols(obj);
+    if (syms.length !== 1 || syms[0] !== sym) {
+      return false;
+    }
+    if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+      return false;
+    }
+    if (typeof Object.getOwnPropertyDescriptor === 'function') {
+      // eslint-disable-next-line no-extra-parens
+      var descriptor = /** @type {PropertyDescriptor} */Object.getOwnPropertyDescriptor(obj, sym);
+      if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+        return false;
+      }
+    }
+    return true;
+  };
+  return shams;
+}
+
+export { requireShams as __require };

package/dist/esm/node_modules/has-tostringtag/shams.js

@@ -0,0 +1,17 @@
+import { __require as requireShams$1 } from '../has-symbols/shams.js';
+
+var shams;
+var hasRequiredShams;
+function requireShams() {
+  if (hasRequiredShams) return shams;
+  hasRequiredShams = 1;
+  var hasSymbols = requireShams$1();
+
+  /** @type {import('.')} */
+  shams = function hasToStringTagShams() {
+    return hasSymbols() && !!Symbol.toStringTag;
+  };
+  return shams;
+}
+
+export { requireShams as __require };

package/dist/esm/node_modules/hasown/index.js

@@ -0,0 +1,17 @@
+import { __require as requireFunctionBind } from '../function-bind/index.js';
+
+var hasown;
+var hasRequiredHasown;
+function requireHasown() {
+  if (hasRequiredHasown) return hasown;
+  hasRequiredHasown = 1;
+  var call = Function.prototype.call;
+  var $hasOwn = Object.prototype.hasOwnProperty;
+  var bind = requireFunctionBind();
+
+  /** @type {import('.')} */
+  hasown = bind.call(call, $hasOwn);
+  return hasown;
+}
+
+export { requireHasown as __require };

package/dist/esm/node_modules/ieee754/index.js

@@ -0,0 +1,84 @@
+import { __exports as ieee754 } from '../../_virtual/index7.js';
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+var hasRequiredIeee754;
+function requireIeee754() {
+  if (hasRequiredIeee754) return ieee754;
+  hasRequiredIeee754 = 1;
+  ieee754.read = function (buffer, offset, isLE, mLen, nBytes) {
+    var e, m;
+    var eLen = nBytes * 8 - mLen - 1;
+    var eMax = (1 << eLen) - 1;
+    var eBias = eMax >> 1;
+    var nBits = -7;
+    var i = isLE ? nBytes - 1 : 0;
+    var d = isLE ? -1 : 1;
+    var s = buffer[offset + i];
+    i += d;
+    e = s & (1 << -nBits) - 1;
+    s >>= -nBits;
+    nBits += eLen;
+    for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+    m = e & (1 << -nBits) - 1;
+    e >>= -nBits;
+    nBits += mLen;
+    for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+    if (e === 0) {
+      e = 1 - eBias;
+    } else if (e === eMax) {
+      return m ? NaN : (s ? -1 : 1) * Infinity;
+    } else {
+      m = m + Math.pow(2, mLen);
+      e = e - eBias;
+    }
+    return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+  };
+  ieee754.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+    var e, m, c;
+    var eLen = nBytes * 8 - mLen - 1;
+    var eMax = (1 << eLen) - 1;
+    var eBias = eMax >> 1;
+    var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+    var i = isLE ? 0 : nBytes - 1;
+    var d = isLE ? 1 : -1;
+    var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+    value = Math.abs(value);
+    if (isNaN(value) || value === Infinity) {
+      m = isNaN(value) ? 1 : 0;
+      e = eMax;
+    } else {
+      e = Math.floor(Math.log(value) / Math.LN2);
+      if (value * (c = Math.pow(2, -e)) < 1) {
+        e--;
+        c *= 2;
+      }
+      if (e + eBias >= 1) {
+        value += rt / c;
+      } else {
+        value += rt * Math.pow(2, 1 - eBias);
+      }
+      if (value * c >= 2) {
+        e++;
+        c /= 2;
+      }
+      if (e + eBias >= eMax) {
+        m = 0;
+        e = eMax;
+      } else if (e + eBias >= 1) {
+        m = (value * c - 1) * Math.pow(2, mLen);
+        e = e + eBias;
+      } else {
+        m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+        e = 0;
+      }
+    }
+    for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+    e = e << mLen | m;
+    eLen += mLen;
+    for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+    buffer[offset + i - d] |= s * 128;
+  };
+  return ieee754;
+}
+
+export { requireIeee754 as __require };

package/dist/esm/node_modules/inherits/inherits_browser.js

@@ -0,0 +1,37 @@
+import { __module as inherits_browser } from '../../_virtual/inherits_browser.js';
+
+var hasRequiredInherits_browser;
+function requireInherits_browser() {
+  if (hasRequiredInherits_browser) return inherits_browser.exports;
+  hasRequiredInherits_browser = 1;
+  if (typeof Object.create === 'function') {
+    // implementation from standard node.js 'util' module
+    inherits_browser.exports = function inherits(ctor, superCtor) {
+      if (superCtor) {
+        ctor.super_ = superCtor;
+        ctor.prototype = Object.create(superCtor.prototype, {
+          constructor: {
+            value: ctor,
+            enumerable: false,
+            writable: true,
+            configurable: true
+          }
+        });
+      }
+    };
+  } else {
+    // old school shim for old browsers
+    inherits_browser.exports = function inherits(ctor, superCtor) {
+      if (superCtor) {
+        ctor.super_ = superCtor;
+        var TempCtor = function () {};
+        TempCtor.prototype = superCtor.prototype;
+        ctor.prototype = new TempCtor();
+        ctor.prototype.constructor = ctor;
+      }
+    };
+  }
+  return inherits_browser.exports;
+}
+
+export { requireInherits_browser as __require };