artplayer-plugin-p2p 1.0.0

package/dist/pure.d.mts

@@ -0,0 +1,48 @@
+export { B as BANDWIDTH_WINDOW_MS, D as DEFAULT_FATAL_RETRY_MAX, c as DEFAULT_TYPE, d as DownloadChannel, P as P2POptions, b as P2PPluginHandle, e as P2PSettingItemsOptions, f as P2PStats, a as P2PStatsEngine, g as P2PTrackerOptions, h as P2PUIOptions, i as P2P_EVENT_BRIDGE_MAP, S as STATS_POLLING_MS, j as StateChangeDetails, k as applyRuntimeToggle, m as mergeCoreConfig, r as resolveOptions } from './stats-CFbDXEsi.mjs';
+export { CoreConfig, DynamicCoreConfig } from 'p2p-media-loader-core';
+import 'p2p-media-loader-hlsjs';
+import 'hls.js';
+
+/**
+ * 滑动时间窗带宽计算器
+ *
+ * 纯逻辑实现：时间源可注入（timestampMs 参数），缺省取
+ * performance.now()（单调时钟，与 p2pml 官方带宽计算一致，
+ * 不受系统时钟跳变影响），测试可注入固定时间戳
+ *
+ * @module bandwidth
+ */
+/**
+ * 滑动时间窗带宽计算器
+ *
+ * 每笔字节记录为独立样本，读取速率时惰性清理窗口外样本；
+ * 样本量与窗口内的 chunk 频次成正比（直播场景上限约数百个），无需主动压缩
+ */
+declare class BandwidthCalculator {
+    #private;
+    /**
+     * @param windowMs - 滑动时间窗长度（毫秒），窗口越长速率越平滑
+     */
+    constructor(windowMs: number);
+    /**
+     * 记录一笔字节
+     *
+     * @param bytes - 字节数（非正值直接忽略，防御脏数据）
+     * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+     */
+    record(bytes: number, timestampMs?: number): void;
+    /**
+     * 计算窗口内平均速率
+     *
+     * 读取时惰性清理过期样本；速率按整个窗口长度折算而非
+     * 首尾样本间隔，保证窗口未填满时（刚启动）读数平滑趋近真实值
+     *
+     * @param nowMs - 当前时间戳；缺省取 performance.now()，测试可注入固定时间
+     * @returns 速率 B/s
+     */
+    getSpeed(nowMs?: number): number;
+    /** 清空全部样本 */
+    reset(): void;
+}
+
+export { BandwidthCalculator };

package/dist/pure.d.ts

@@ -0,0 +1,48 @@
+export { B as BANDWIDTH_WINDOW_MS, D as DEFAULT_FATAL_RETRY_MAX, c as DEFAULT_TYPE, d as DownloadChannel, P as P2POptions, b as P2PPluginHandle, e as P2PSettingItemsOptions, f as P2PStats, a as P2PStatsEngine, g as P2PTrackerOptions, h as P2PUIOptions, i as P2P_EVENT_BRIDGE_MAP, S as STATS_POLLING_MS, j as StateChangeDetails, k as applyRuntimeToggle, m as mergeCoreConfig, r as resolveOptions } from './stats-CFbDXEsi.js';
+export { CoreConfig, DynamicCoreConfig } from 'p2p-media-loader-core';
+import 'p2p-media-loader-hlsjs';
+import 'hls.js';
+
+/**
+ * 滑动时间窗带宽计算器
+ *
+ * 纯逻辑实现：时间源可注入（timestampMs 参数），缺省取
+ * performance.now()（单调时钟，与 p2pml 官方带宽计算一致，
+ * 不受系统时钟跳变影响），测试可注入固定时间戳
+ *
+ * @module bandwidth
+ */
+/**
+ * 滑动时间窗带宽计算器
+ *
+ * 每笔字节记录为独立样本，读取速率时惰性清理窗口外样本；
+ * 样本量与窗口内的 chunk 频次成正比（直播场景上限约数百个），无需主动压缩
+ */
+declare class BandwidthCalculator {
+    #private;
+    /**
+     * @param windowMs - 滑动时间窗长度（毫秒），窗口越长速率越平滑
+     */
+    constructor(windowMs: number);
+    /**
+     * 记录一笔字节
+     *
+     * @param bytes - 字节数（非正值直接忽略，防御脏数据）
+     * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+     */
+    record(bytes: number, timestampMs?: number): void;
+    /**
+     * 计算窗口内平均速率
+     *
+     * 读取时惰性清理过期样本；速率按整个窗口长度折算而非
+     * 首尾样本间隔，保证窗口未填满时（刚启动）读数平滑趋近真实值
+     *
+     * @param nowMs - 当前时间戳；缺省取 performance.now()，测试可注入固定时间
+     * @returns 速率 B/s
+     */
+    getSpeed(nowMs?: number): number;
+    /** 清空全部样本 */
+    reset(): void;
+}
+
+export { BandwidthCalculator };

package/dist/pure.js

@@ -0,0 +1,309 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/pure.ts
+var pure_exports = {};
+__export(pure_exports, {
+  BANDWIDTH_WINDOW_MS: () => BANDWIDTH_WINDOW_MS,
+  BandwidthCalculator: () => BandwidthCalculator,
+  DEFAULT_FATAL_RETRY_MAX: () => DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE: () => DEFAULT_TYPE,
+  P2PStatsEngine: () => P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP: () => P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS: () => STATS_POLLING_MS,
+  applyRuntimeToggle: () => applyRuntimeToggle,
+  mergeCoreConfig: () => mergeCoreConfig,
+  resolveOptions: () => resolveOptions
+});
+module.exports = __toCommonJS(pure_exports);
+
+// src/constants.ts
+var DEFAULT_TYPE = "m3u8";
+var DEFAULT_FATAL_RETRY_MAX = 2;
+var BANDWIDTH_WINDOW_MS = 1e4;
+var STATS_POLLING_MS = 1e3;
+var P2P_EVENT_BRIDGE_MAP = {
+  onStreamAdded: "p2p:streamAdded",
+  onStreamRegistrationError: "p2p:streamRegistrationError",
+  onSegmentLoaded: "p2p:segmentLoaded",
+  onSegmentError: "p2p:segmentError",
+  onSegmentAbort: "p2p:segmentAbort",
+  onSegmentStart: "p2p:segmentStart",
+  onPeerConnect: "p2p:peerConnect",
+  onPeerConnectError: "p2p:peerConnectError",
+  onPeerClose: "p2p:peerClose",
+  onPeerError: "p2p:peerError",
+  onPeerWarning: "p2p:peerWarning",
+  onChunkDownloaded: "p2p:chunkDownloaded",
+  onChunkUploaded: "p2p:chunkUploaded",
+  onTrackerError: "p2p:trackerError",
+  onTrackerWarning: "p2p:trackerWarning"
+};
+
+// src/config.ts
+function resolveUIOptions(ui) {
+  return ui.setting !== false;
+}
+function resolveSettingItems(setting) {
+  if (setting === void 0 || setting === true) {
+    return { p2pEnabled: true, uploadOnly: true, stats: true };
+  }
+  if (setting === false) {
+    return { p2pEnabled: false, uploadOnly: false, stats: false };
+  }
+  return {
+    p2pEnabled: setting.p2pEnabled ?? true,
+    uploadOnly: setting.uploadOnly ?? true,
+    stats: setting.stats ?? true
+  };
+}
+function resolveOptions(options) {
+  const uiEnabled = options.ui !== false;
+  let settingEnabled;
+  let settingItems;
+  if (typeof options.ui === "object" && options.ui !== null) {
+    settingEnabled = resolveUIOptions(options.ui);
+    settingItems = resolveSettingItems(options.ui.setting);
+  } else {
+    settingEnabled = uiEnabled;
+    settingItems = resolveSettingItems(uiEnabled ? void 0 : false);
+  }
+  return {
+    typeName: options.type ?? DEFAULT_TYPE,
+    fatalRetryMax: options.fatalRetryMax ?? DEFAULT_FATAL_RETRY_MAX,
+    p2pEnabled: options.enabled ?? true,
+    uploadEnabled: options.uploadEnabled ?? true,
+    uiEnabled,
+    statsEnabled: uiEnabled && options.stats !== false,
+    settingEnabled,
+    settingItems,
+    core: options.core,
+    tracker: options.tracker,
+    hls: options.hls
+  };
+}
+function mergeCoreConfig(options) {
+  return { ...options.core, ...options.tracker };
+}
+function applyRuntimeToggle(config, p2pEnabled, uploadEnabled) {
+  return {
+    ...config,
+    isP2PDisabled: !p2pEnabled,
+    isP2PUploadDisabled: !uploadEnabled
+  };
+}
+
+// src/bandwidth.ts
+var _windowMs, _samples, _BandwidthCalculator_instances, removeExpired_fn;
+var BandwidthCalculator = class {
+  /**
+   * @param windowMs - 滑动时间窗长度（毫秒），窗口越长速率越平滑
+   */
+  constructor(windowMs) {
+    __privateAdd(this, _BandwidthCalculator_instances);
+    __privateAdd(this, _windowMs);
+    __privateAdd(this, _samples, []);
+    __privateSet(this, _windowMs, windowMs);
+  }
+  /**
+   * 记录一笔字节
+   *
+   * @param bytes - 字节数（非正值直接忽略，防御脏数据）
+   * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  record(bytes, timestampMs = performance.now()) {
+    if (bytes <= 0) return;
+    __privateGet(this, _samples).push({ timestampMs, bytes });
+  }
+  /**
+   * 计算窗口内平均速率
+   *
+   * 读取时惰性清理过期样本；速率按整个窗口长度折算而非
+   * 首尾样本间隔，保证窗口未填满时（刚启动）读数平滑趋近真实值
+   *
+   * @param nowMs - 当前时间戳；缺省取 performance.now()，测试可注入固定时间
+   * @returns 速率 B/s
+   */
+  getSpeed(nowMs = performance.now()) {
+    __privateMethod(this, _BandwidthCalculator_instances, removeExpired_fn).call(this, nowMs);
+    let totalBytes = 0;
+    for (const sample of __privateGet(this, _samples)) {
+      totalBytes += sample.bytes;
+    }
+    return totalBytes / (__privateGet(this, _windowMs) / 1e3);
+  }
+  /** 清空全部样本 */
+  reset() {
+    __privateGet(this, _samples).length = 0;
+  }
+};
+_windowMs = new WeakMap();
+_samples = new WeakMap();
+_BandwidthCalculator_instances = new WeakSet();
+/**
+ * 移除窗口外的过期样本
+ *
+ * 样本时间戳单调递增（缺省时间源 performance.now 单调；
+ * 注入时间戳同样须单调），从头扫描至首个窗口内样本即可。
+ * 边界样本（age 恰等于窗口长）保留在窗口内，与 p2pml
+ * 官方带宽计算的过期判定语义保持一致
+ */
+removeExpired_fn = function(nowMs) {
+  const cutoff = nowMs - __privateGet(this, _windowMs);
+  let firstValid = __privateGet(this, _samples).length;
+  for (let i = 0; i < __privateGet(this, _samples).length; i++) {
+    if (__privateGet(this, _samples)[i].timestampMs >= cutoff) {
+      firstValid = i;
+      break;
+    }
+  }
+  __privateGet(this, _samples).splice(0, firstValid);
+};
+
+// src/stats.ts
+var _peers, _peakPeers, _p2pDownloadedBytes, _httpDownloadedBytes, _uploadedBytes, _downloadBandwidths, _uploadBandwidth;
+var P2PStatsEngine = class {
+  constructor() {
+    __privateAdd(this, _peers, 0);
+    __privateAdd(this, _peakPeers, 0);
+    __privateAdd(this, _p2pDownloadedBytes, 0);
+    __privateAdd(this, _httpDownloadedBytes, 0);
+    __privateAdd(this, _uploadedBytes, 0);
+    __privateAdd(this, _downloadBandwidths, {
+      p2p: new BandwidthCalculator(BANDWIDTH_WINDOW_MS),
+      http: new BandwidthCalculator(BANDWIDTH_WINDOW_MS)
+    });
+    __privateAdd(this, _uploadBandwidth, new BandwidthCalculator(BANDWIDTH_WINDOW_MS));
+  }
+  /** 记录一个 peer 连接建立（同时维护峰值） */
+  recordPeerConnect() {
+    __privateSet(this, _peers, __privateGet(this, _peers) + 1);
+    if (__privateGet(this, _peers) > __privateGet(this, _peakPeers)) {
+      __privateSet(this, _peakPeers, __privateGet(this, _peers));
+    }
+  }
+  /** 记录一个 peer 连接断开（计数不小于零） */
+  recordPeerClose() {
+    if (__privateGet(this, _peers) > 0) {
+      __privateSet(this, _peers, __privateGet(this, _peers) - 1);
+    }
+  }
+  /**
+   * 记录一笔下行字节
+   *
+   * @param bytes - 字节数
+   * @param channel - 下载通道（http / p2p）
+   * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  recordDownload(bytes, channel, timestampMs) {
+    if (bytes <= 0) return;
+    if (channel === "p2p") {
+      __privateSet(this, _p2pDownloadedBytes, __privateGet(this, _p2pDownloadedBytes) + bytes);
+    } else {
+      __privateSet(this, _httpDownloadedBytes, __privateGet(this, _httpDownloadedBytes) + bytes);
+    }
+    __privateGet(this, _downloadBandwidths)[channel].record(bytes, timestampMs);
+  }
+  /**
+   * 记录一笔 P2P 上行字节
+   *
+   * @param bytes - 字节数
+   * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  recordUpload(bytes, timestampMs) {
+    if (bytes <= 0) return;
+    __privateSet(this, _uploadedBytes, __privateGet(this, _uploadedBytes) + bytes);
+    __privateGet(this, _uploadBandwidth).record(bytes, timestampMs);
+  }
+  /**
+   * 输出当前统计快照（累计量 + 派生指标一次算清）
+   *
+   * 带宽基准时间只取一次、每通道只计算一次，
+   * 保证快照内部指标自洽（downloadSpeed 恒等于两通道之和）
+   *
+   * @param nowMs - 带宽计算基准时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  snapshot(nowMs) {
+    const totalDownloadedBytes = __privateGet(this, _p2pDownloadedBytes) + __privateGet(this, _httpDownloadedBytes);
+    const now = nowMs ?? performance.now();
+    const p2pDownloadSpeed = __privateGet(this, _downloadBandwidths).p2p.getSpeed(now);
+    const httpDownloadSpeed = __privateGet(this, _downloadBandwidths).http.getSpeed(now);
+    return {
+      peers: __privateGet(this, _peers),
+      peakPeers: __privateGet(this, _peakPeers),
+      p2pDownloadedBytes: __privateGet(this, _p2pDownloadedBytes),
+      httpDownloadedBytes: __privateGet(this, _httpDownloadedBytes),
+      uploadedBytes: __privateGet(this, _uploadedBytes),
+      totalDownloadedBytes,
+      p2pDownloadRatio: totalDownloadedBytes > 0 ? __privateGet(this, _p2pDownloadedBytes) / totalDownloadedBytes : 0,
+      downloadSpeed: p2pDownloadSpeed + httpDownloadSpeed,
+      p2pDownloadSpeed,
+      uploadSpeed: __privateGet(this, _uploadBandwidth).getSpeed(now)
+    };
+  }
+  /**
+   * 清零当前 peer 计数
+   *
+   * 动态关闭 P2P 或销毁播放实例后连接已全部断开（引擎销毁不保证
+   * 逐个发出 onPeerClose），主动清零防止残留计数污染下一次快照；
+   * 峰值与字节累计保留
+   */
+  resetPeers() {
+    __privateSet(this, _peers, 0);
+  }
+  /** 重置全部计数与样本（换源时调用） */
+  reset() {
+    __privateSet(this, _peers, 0);
+    __privateSet(this, _peakPeers, 0);
+    __privateSet(this, _p2pDownloadedBytes, 0);
+    __privateSet(this, _httpDownloadedBytes, 0);
+    __privateSet(this, _uploadedBytes, 0);
+    __privateGet(this, _downloadBandwidths).p2p.reset();
+    __privateGet(this, _downloadBandwidths).http.reset();
+    __privateGet(this, _uploadBandwidth).reset();
+  }
+};
+_peers = new WeakMap();
+_peakPeers = new WeakMap();
+_p2pDownloadedBytes = new WeakMap();
+_httpDownloadedBytes = new WeakMap();
+_uploadedBytes = new WeakMap();
+_downloadBandwidths = new WeakMap();
+_uploadBandwidth = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BANDWIDTH_WINDOW_MS,
+  BandwidthCalculator,
+  DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE,
+  P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS,
+  applyRuntimeToggle,
+  mergeCoreConfig,
+  resolveOptions
+});

package/dist/pure.mjs

@@ -0,0 +1,24 @@
+import {
+  BANDWIDTH_WINDOW_MS,
+  BandwidthCalculator,
+  DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE,
+  P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS,
+  applyRuntimeToggle,
+  mergeCoreConfig,
+  resolveOptions
+} from "./chunk-IX2RPNML.mjs";
+export {
+  BANDWIDTH_WINDOW_MS,
+  BandwidthCalculator,
+  DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE,
+  P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS,
+  applyRuntimeToggle,
+  mergeCoreConfig,
+  resolveOptions
+};