@minto-ai/tools 1.0.57 → 1.0.59

package/dist/browser/create-audio-permission.d.ts

@@ -1,45 +1,172 @@
+declare enum AudioPermissionErrorType {
+    NO_USER_INTERACTION_ERROR = "NoUserInteractionError",
+    AUTOPLAY_BLOCKED = "AutoplayBlocked",
+    AUTOPLAY_UNKNOWN_ERROR = "AutoplayUnknownError",
+    SECURE_CONTEXT_ERROR = "SecureContextError",
+    PERMISSION_DENIED_PERMANENTLY = "PermissionDeniedPermanently",
+    NOT_ALLOWED_ERROR = "NotAllowedError",
+    MEDIA_DEVICES_API_UNAVAILABLE = "MediaDevicesApiUnavailable",
+    NOT_FOUND_ERROR = "NotFoundError",
+    NOT_READABLE_ERROR = "NotReadableError",
+    OVERCONSTRAINED_ERROR = "OverconstrainedError",
+    SECURITY_ERROR = "SecurityError",
+    MICROPHONE_UNKNOWN_ERROR = "MicrophoneUnknownError"
+}
+declare class AudioPermissionError extends Error {
+    name: AudioPermissionErrorType;
+    private constructor();
+    static create(name: AudioPermissionErrorType, message?: string): AudioPermissionError;
+}
 /**
- * 音频权限管理类
+ * 音频播放权限管理类
  *
- * 用于处理浏览器中的音频播放和录音权限问题，解决自动播放限制。
+ * 根据MDN文档，音频播放权限需要满足以下条件之一：
+ * 1. 音频被静音或音量为0
+ * 2. 用户已与网站产生交互（点击、触摸、按键等）
+ * 3. 网站已被加入自动播放白名单
+ * 4. 通过Permissions Policy授权
  *
- * 平台差异处理：
- * - iOS平台：
- *      必须在用户交互后，通过 navigator.mediaDevices.getUserMedia({ audio: true }) 申请权限，这里会直接audioContext仍然suspended状态，需要 audioContext.resume() 改变状态
- *      当后续 audioPermissionGranted 为true 申请完权限之后，第二次调用申请权限时，仍然需要申请权限，使用 audioContext.resume() 改变AudioContext从suspended变为running
- * - Android平台：(注意点：虽然一开始检测AudioContext状态为running，但是navigator.mediaDevices.getUserMedia会报错，所有并不能一开始就检测AudioContext状态)
- *       必须在用户交互后，通过 navigator.mediaDevices.getUserMedia({ audio: true }) 申请权限，这里会直接audioContext变为为running状态，并不需要 audioContext.resume() 改变状态
- *       当后续 audioPermissionGranted 为true 申请完权限之后，第二次调用申请权限时，不需要再次申请权限，这时 audioContext 会变为running状态，直接返回成功
- * - PC平台：
- *      可以优先检测如果为running则表示权限已可用，就不需要申请权限，如果为suspended则表示权限未可用，需要申请权限
- *      当用户交互后，通过 navigator.mediaDevices.getUserMedia({ audio: true }) 申请权限，这里会直接audioContext变为为running状态，并不需要 audioContext.resume() 改变状态
- *      当后续 audioPermissionGranted 为true 申请完权限之后，第二次调用申请权限时，不需要再次申请权限，这时 audioContext 会变为running状态，直接返回成功
+ * 跨平台实现策略：
+ * - PC端：预检测AudioContext状态，如果suspended则监听用户交互
+ * - iOS Safari：必须在用户交互事件的调用栈中调用resume()，需要50ms延迟确保状态变更
+ * - Android：直接在用户交互后检测AudioContext状态
+ *
+ * 自动播放策略限制：
+ * - Chrome 66+：需要用户交互或MEI（Media Engagement Index）足够高
+ * - Safari：严格要求用户交互，AudioContext创建时默认为suspended状态
+ * - Firefox：相对宽松，但仍会阻止明显的自动播放行为
+ *
+ *
+ *
+ * 实现原理：
+ *    PC:
+ *      1.在PC端首先预检测AudioContext状态：
+ *        如果状态是 “running” 状态则可以播放音频，
+ *        如果状态不是 “running” 状态则需要监听用户交互事件，
+ *      2.用户交互事件触发后，再检测AudioContext状态：
+ *        如果状态是 “running” 状态则可以播放音频，
+ *        如果状态不是 “running” 状态则抛出异常。
+ *
+ *    IOS:
+ *      1.用户交互事件触发后，再检测AudioContext状态：
+ *        如果状态是 “suspended” 则需要调用 resume 方法，并且需要延迟 50ms，
+ *        如果状态不是 “suspended” 状态进行下一步判断，
+ *      2.获取AudioContext状态：
+ *        如果状态是 “running” 状态则可以播放音频，
+ *        如果状态不是 “running” 状态则抛出异常。
+ *
+ *    Android:
+ *      1.用户交互事件触发后，再检测AudioContext状态：
+ *        如果状态是 “running” 状态则可以播放音频，
+ *        如果状态不是 “running” 状态则抛出异常。
  */
-declare class AudioPermission {
+declare class AudioPlaybackPermission {
     private userInteracted;
-    private audioPermissionGranted;
     constructor();
     /**
-     * 初始化音频权限检测流程
-     * 根据不同平台采用相应的权限检测策略
+     * 初始化播放权限检测
      */
-    private initAudioPermission;
+    private initPlaybackPermission;
     /**
-     * 监听用户交互事件
-     * 监听多种交互事件类型，确保在各种设备上都能正确检测到用户操作
+     * 检测初始AudioContext状态（仅PC平台）
      */
-    private waitForUserInteraction;
+    private checkInitialAudioContextState;
     /**
-     * 请求音频权限（包含录音和播放权限）
-     *
-     * @returns Promise<boolean> 返回权限获取结果，true表示成功，false表示失败
+     * 设置用户交互监听器
      */
-    requestAudioPermission(): Promise<boolean>;
+    private setupUserInteractionListeners;
+    /**
+     * 请求播放权限
+     * 根据Web Audio API最佳实践实现
+     */
+    requestPlaybackPermission(): Promise<void>;
 }
 /**
- * 创建或获取音频权限管理实例
+ * 麦克风权限管理类
+ *
+ * 根据MDN文档，getUserMedia需要满足：
+ * 1. 安全上下文（HTTPS）
+ * 2. 用户明确授权
+ * 3. 顶级文档上下文或通过Permissions Policy授权的iframe
+ *
+ *
+ * 权限状态说明：
+ * - granted: 用户已授权，可直接访问麦克风
+ * - denied: 用户已拒绝，需要用户手动在浏览器设置中重新开启
+ * - prompt: 首次访问，会弹出授权对话框
+ *
+ *
+ * 平台差异：
+ * - 桌面端：通过浏览器原生授权对话框处理
+ * - iOS Safari：权限被拒绝后，需要用户在系统设置中重新开启
+ * - Android Chrome：权限处理与桌面端类似，但某些版本可能有缓存问题
+ *
+ *
+ * 注意事项：
+ * 1. 浏览器会永久缓存用户的权限决定
+ * 2. 在非HTTPS环境下（除localhost外）会直接失败
+ * 3. 某些浏览器在隐私模式下可能有不同行为
+ * 4. iframe中使用需要正确配置Permissions Policy
+ *
  *
- * @returns AudioPermission 音频权限管理实例
+ * 实现原理：
+ * - PC平台：
+ *     1. 通过授权弹框申请权限：
+ *          如果用户拒绝了权限，会抛出异常
+ *          如果用户点击了允许，会返回成功
+ *     2.第二次申请权限，会根据用户第一次申请权限的结果：
+ *          如果用户第一次申请权限失败，会抛出异常
+ *          如果用户第一次申请权限成功，会返回成功
+ * - 移动端：
+ *     1. 通过授权弹框申请权限：
+ *          如果用户拒绝了权限，会抛出异常
+ *          如果用户点击了允许，会返回成功
+ *      2.第二次申请权限，会根据用户第一次申请权限的结果：
+ *          如果用户第一次申请权限失败，会抛出异常
+ *          如果用户第一次申请权限成功，会返回成功
+ *
+ *  iOS平台：
+ *      1. 通过授权弹框申请权限：
+ *          如果用户拒绝了权限，会抛出异常
+ *          如果用户点击了允许，会返回成功
+ *      2.第二次申请权限，会根据用户第一次申请权限的结果：
+ *          如果用户第一次申请权限失败，会抛出异常
+ *          如果用户第一次申请权限成功，会返回成功
+ *
+ *
+ */
+declare class MicrophonePermission {
+    private microphonePermissionGranted;
+    private permissionDeniedPermanently;
+    /**
+     * 检查是否在安全上下文中
+     */
+    private isSecureContext;
+    /**
+     * 请求麦克风权限
+     * 根据MediaDevices.getUserMedia规范实现
+     */
+    requestMicrophonePermission(): Promise<void>;
+}
+/**
+ * 统一的音频权限管理类
+ */
+declare class AudioPermission {
+    private playbackPermission;
+    private microphonePermission;
+    constructor();
+    /**
+     * 请求音频播放权限
+     */
+    requestPlaybackPermission(): Promise<void>;
+    /**
+     * 请求麦克风权限
+     */
+    requestMicrophonePermission(): Promise<void>;
+}
+/**
+ * 创建或获取音频权限管理实例
  */
 declare function createAudioPermission(): AudioPermission;
 export default createAudioPermission;
+export { AudioPermission, AudioPermissionError, AudioPermissionErrorType, AudioPlaybackPermission, MicrophonePermission };

package/dist/index.js

@@ -46,6 +46,13 @@ function _callSuper(t, o, e) {
 function _classCallCheck(a, n) {
   if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
 }
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
 function _defineProperties(e, r) {
   for (var t = 0; t < r.length; t++) {
     var o = r[t];
@@ -53,7 +60,7 @@ function _defineProperties(e, r) {
   }
 }
 function _createClass(e, r, t) {
-  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
     writable: false
   }), e;
 }
@@ -128,6 +135,13 @@ function _inherits(t, e) {
     writable: false
   }), e && _setPrototypeOf(t, e);
 }
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
 function _isNativeReflectConstruct() {
   try {
     var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
@@ -488,6 +502,28 @@ function _unsupportedIterableToArray(r, a) {
     return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
   }
 }
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
+  return _wrapNativeSuper = function(t2) {
+    if (null === t2 || !_isNativeFunction(t2)) return t2;
+    if ("function" != typeof t2) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t2)) return r.get(t2);
+      r.set(t2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t2, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    }), _setPrototypeOf(Wrapper, t2);
+  }, _wrapNativeSuper(t);
+}
 var check = function check2(it) {
   return it && it.Math === Math && it;
 };
@@ -13238,157 +13274,361 @@ function copyText(text) {
     }
   });
 }
-function isAndroid() {
-  var userAgent2 = navigator.userAgent.toLowerCase();
-  return /android/.test(userAgent2);
-}
-function isIos() {
-  var userAgent2 = navigator.userAgent.toLowerCase();
-  return /iphone|ipad|ipod/.test(userAgent2);
-}
-var AudioPermission = /* @__PURE__ */ function() {
-  function AudioPermission2() {
-    _classCallCheck(this, AudioPermission2);
+var AudioPermissionError = /* @__PURE__ */ function(_Error) {
+  function AudioPermissionError2(name, message) {
+    var _this;
+    _classCallCheck(this, AudioPermissionError2);
+    _this = _callSuper(this, AudioPermissionError2, [message]);
+    _defineProperty(_this, "name", void 0);
+    _this.name = name;
+    return _this;
+  }
+  _inherits(AudioPermissionError2, _Error);
+  return _createClass(AudioPermissionError2, null, [{
+    key: "create",
+    value: function create4(name, message) {
+      var _codeMessageMap;
+      var codeMessageMap = (_codeMessageMap = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_codeMessageMap, "NoUserInteractionError", "需要用户交互才能播放音频"), "AutoplayBlocked", "自动播放被浏览器阻止"), "AutoplayUnknownError", "未知自动播放错误"), "SecureContextError", "麦克风权限需要在安全上下文（HTTPS）中使用"), "PermissionDeniedPermanently", "音频权限已被永久拒绝，需在浏览器设置中开启麦克风权限"), "MediaDevicesApiUnavailable", "MediaDevices API不可用"), "NotAllowedError", "麦克风权限被拒绝"), "NotReadableError", "音频设备被其他应用程序占用"), "NotFoundError", "未找到音频输入设备"), "SecurityError", "安全策略阻止访问麦克风"), _defineProperty(_defineProperty(_codeMessageMap, "OverconstrainedError", "音频设备不满足指定的约束条件"), "MicrophoneUnknownError", "未知麦克风权限错误"));
+      return new AudioPermissionError2(name, message || codeMessageMap[name]);
+    }
+  }]);
+}(/* @__PURE__ */ _wrapNativeSuper(Error));
+var AudioPlaybackPermission = /* @__PURE__ */ function() {
+  function AudioPlaybackPermission2() {
+    _classCallCheck(this, AudioPlaybackPermission2);
     _defineProperty(this, "userInteracted", false);
-    _defineProperty(this, "audioPermissionGranted", false);
-    this.initAudioPermission();
-  }
-  return _createClass(AudioPermission2, [{
-    key: "initAudioPermission",
+    this.initPlaybackPermission();
+  }
+  return _createClass(AudioPlaybackPermission2, [{
+    key: "initPlaybackPermission",
+    value: function initPlaybackPermission() {
+      var _this2 = this;
+      if (!isIos() && !isAndroid()) {
+        this.checkInitialAudioContextState()["catch"](function() {
+          _this2.setupUserInteractionListeners();
+        });
+      } else {
+        this.setupUserInteractionListeners();
+      }
+    }
+    /**
+     * 检测初始AudioContext状态（仅PC平台）
+     */
+  }, {
+    key: "checkInitialAudioContextState",
     value: function() {
-      var _initAudioPermission = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee() {
-        var audioContext;
+      var _checkInitialAudioContextState = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee() {
+        var testContext;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              if (isIos() || isAndroid()) {
-                this.waitForUserInteraction();
-              } else {
-                try {
-                  audioContext = new (window.AudioContext || window.webkitAudioContext)();
-                  if (audioContext.state === "running") {
-                    this.userInteracted = true;
-                    this.audioPermissionGranted = true;
-                    audioContext.close();
-                  } else {
-                    audioContext.close();
-                    this.waitForUserInteraction();
-                  }
-                } catch (error2) {
-                  console.warn("AudioContext创建失败，回退到用户交互模式:", error2);
-                  this.waitForUserInteraction();
-                }
+              testContext = new (window.AudioContext || window.webkitAudioContext)();
+              if (testContext.state === "running") {
+                this.userInteracted = true;
               }
-            case 1:
+              _context.next = 4;
+              return testContext.close();
+            case 4:
+              if (!this.userInteracted) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", Promise.resolve());
+            case 8:
+              return _context.abrupt("return", Promise.reject());
+            case 9:
             case "end":
               return _context.stop();
           }
         }, _callee, this);
       }));
-      function initAudioPermission() {
-        return _initAudioPermission.apply(this, arguments);
+      function checkInitialAudioContextState() {
+        return _checkInitialAudioContextState.apply(this, arguments);
       }
-      return initAudioPermission;
+      return checkInitialAudioContextState;
     }()
   }, {
-    key: "waitForUserInteraction",
-    value: function waitForUserInteraction() {
-      var _this = this;
+    key: "setupUserInteractionListeners",
+    value: function setupUserInteractionListeners() {
+      var _this3 = this;
       var interactionEvents = ["click", "touchstart", "touchend", "keydown", "mousedown", "pointerdown"];
       var _handleInteraction = function handleInteraction() {
-        _this.userInteracted = true;
+        _this3.userInteracted = true;
+        console.log(_this3.userInteracted);
         interactionEvents.forEach(function(eventType) {
           document.removeEventListener(eventType, _handleInteraction);
         });
       };
       interactionEvents.forEach(function(eventType) {
         document.addEventListener(eventType, _handleInteraction, {
-          passive: true
+          passive: true,
+          once: true
         });
       });
     }
     /**
-     * 请求音频权限（包含录音和播放权限）
-     *
-     * @returns Promise<boolean> 返回权限获取结果，true表示成功，false表示失败
+     * 请求播放权限
+     * 根据Web Audio API最佳实践实现
      */
   }, {
-    key: "requestAudioPermission",
+    key: "requestPlaybackPermission",
     value: function() {
-      var _requestAudioPermission = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee2() {
-        var stream, audioContext;
+      var _requestPlaybackPermission = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee2() {
+        var audioContext, unknownError;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
+              audioContext = null;
+              _context2.prev = 1;
               if (this.userInteracted) {
-                _context2.next = 3;
+                _context2.next = 4;
                 break;
               }
-              console.warn("用户尚未产生交互，无法获取音频权限");
-              return _context2.abrupt("return", false);
-            case 3:
-              if (!(this.audioPermissionGranted && !isIos())) {
-                _context2.next = 5;
+              throw AudioPermissionError.create(
+                "NoUserInteractionError"
+                /* NO_USER_INTERACTION_ERROR */
+              );
+            case 4:
+              audioContext = new (window.AudioContext || window.webkitAudioContext)();
+              if (!(isIos() && audioContext.state === "suspended")) {
+                _context2.next = 10;
                 break;
               }
-              return _context2.abrupt("return", true);
-            case 5:
-              _context2.prev = 5;
               _context2.next = 8;
-              return navigator.mediaDevices.getUserMedia({
-                audio: true
-              });
+              return audioContext.resume();
             case 8:
-              stream = _context2.sent;
-              audioContext = new (window.AudioContext || window.webkitAudioContext)();
-              if (!(isIos() && audioContext.state === "suspended")) {
-                _context2.next = 13;
+              _context2.next = 10;
+              return new Promise(function(resolve2) {
+                return setTimeout(resolve2, 50);
+              });
+            case 10:
+              if (!(audioContext.state !== "running")) {
+                _context2.next = 12;
                 break;
               }
-              _context2.next = 13;
-              return audioContext.resume();
-            case 13:
-              this.audioPermissionGranted = audioContext.state === "running";
+              throw AudioPermissionError.create(
+                "AutoplayBlocked"
+                /* AUTOPLAY_BLOCKED */
+              );
+            case 12:
+              return _context2.abrupt("return", Promise.resolve());
+            case 15:
+              _context2.prev = 15;
+              _context2.t0 = _context2["catch"](1);
+              if (!(_context2.t0 instanceof AudioPermissionError)) {
+                _context2.next = 19;
+                break;
+              }
+              return _context2.abrupt("return", Promise.reject(_context2.t0));
+            case 19:
+              unknownError = AudioPermissionError.create("AutoplayUnknownError", _context2.t0 instanceof Error ? _context2.t0.message : void 0);
+              return _context2.abrupt("return", Promise.reject(unknownError));
+            case 21:
+              _context2.prev = 21;
+              if (!(audioContext && audioContext.state !== "closed")) {
+                _context2.next = 30;
+                break;
+              }
+              _context2.prev = 23;
+              _context2.next = 26;
+              return audioContext.close();
+            case 26:
+              _context2.next = 30;
+              break;
+            case 28:
+              _context2.prev = 28;
+              _context2.t1 = _context2["catch"](23);
+            case 30:
+              return _context2.finish(21);
+            case 31:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[1, 15, 21, 31], [23, 28]]);
+      }));
+      function requestPlaybackPermission() {
+        return _requestPlaybackPermission.apply(this, arguments);
+      }
+      return requestPlaybackPermission;
+    }()
+  }]);
+}();
+var MicrophonePermission = /* @__PURE__ */ function() {
+  function MicrophonePermission2() {
+    _classCallCheck(this, MicrophonePermission2);
+    _defineProperty(this, "microphonePermissionGranted", false);
+    _defineProperty(this, "permissionDeniedPermanently", false);
+  }
+  return _createClass(MicrophonePermission2, [{
+    key: "isSecureContext",
+    value: (
+      /**
+       * 检查是否在安全上下文中
+       */
+      function isSecureContext() {
+        return window.isSecureContext || location.protocol === "https:" || location.hostname === "localhost";
+      }
+    )
+    /**
+     * 请求麦克风权限
+     * 根据MediaDevices.getUserMedia规范实现
+     */
+  }, {
+    key: "requestMicrophonePermission",
+    value: function() {
+      var _requestMicrophonePermission = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee3() {
+        var stream, errorType, audioError, unknownError;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              if (this.isSecureContext()) {
+                _context3.next = 3;
+                break;
+              }
+              throw AudioPermissionError.create(
+                "SecureContextError"
+                /* SECURE_CONTEXT_ERROR */
+              );
+            case 3:
+              if (!this.permissionDeniedPermanently) {
+                _context3.next = 5;
+                break;
+              }
+              throw AudioPermissionError.create(
+                "PermissionDeniedPermanently"
+                /* PERMISSION_DENIED_PERMANENTLY */
+              );
+            case 5:
+              if (!this.microphonePermissionGranted) {
+                _context3.next = 7;
+                break;
+              }
+              return _context3.abrupt("return", Promise.resolve());
+            case 7:
+              if (!(!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia)) {
+                _context3.next = 9;
+                break;
+              }
+              throw AudioPermissionError.create(
+                "MediaDevicesApiUnavailable"
+                /* MEDIA_DEVICES_API_UNAVAILABLE */
+              );
+            case 9:
+              _context3.next = 11;
+              return navigator.mediaDevices.getUserMedia({
+                audio: {
+                  echoCancellation: true,
+                  noiseSuppression: true,
+                  autoGainControl: true
+                }
+              });
+            case 11:
+              stream = _context3.sent;
+              this.microphonePermissionGranted = true;
               stream.getTracks().forEach(function(track2) {
-                return track2.stop();
+                track2.stop();
               });
-              audioContext.close();
-              return _context2.abrupt("return", this.audioPermissionGranted);
-            case 19:
-              _context2.prev = 19;
-              _context2.t0 = _context2["catch"](5);
-              console.error("音频权限获取失败:", _context2.t0);
-              if (!(_context2.t0 instanceof DOMException)) {
-                _context2.next = 33;
+              return _context3.abrupt("return", Promise.resolve());
+            case 17:
+              _context3.prev = 17;
+              _context3.t0 = _context3["catch"](0);
+              this.microphonePermissionGranted = false;
+              if (!(_context3.t0 instanceof AudioPermissionError)) {
+                _context3.next = 22;
                 break;
               }
-              _context2.t1 = _context2.t0.name;
-              _context2.next = _context2.t1 === "NotAllowedError" ? 26 : _context2.t1 === "NotFoundError" ? 28 : _context2.t1 === "NotSupportedError" ? 30 : 32;
+              return _context3.abrupt("return", Promise.reject(_context3.t0));
+            case 22:
+              if (!(_context3.t0 instanceof DOMException)) {
+                _context3.next = 40;
+                break;
+              }
+              _context3.t1 = _context3.t0.name;
+              _context3.next = _context3.t1 === "NotFoundError" ? 26 : _context3.t1 === "NotAllowedError" ? 28 : _context3.t1 === "NotReadableError" ? 31 : _context3.t1 === "OverconstrainedError" ? 33 : _context3.t1 === "SecurityError" ? 35 : 37;
               break;
             case 26:
-              console.warn("用户拒绝了音频权限请求");
-              return _context2.abrupt("break", 33);
+              errorType = "NotFoundError";
+              return _context3.abrupt("break", 38);
             case 28:
-              console.warn("未找到音频设备");
-              return _context2.abrupt("break", 33);
-            case 30:
-              console.warn("浏览器不支持音频权限请求");
-              return _context2.abrupt("break", 33);
-            case 32:
-              console.warn("未知的权限请求错误:", _context2.t0.message);
+              this.permissionDeniedPermanently = true;
+              errorType = "NotAllowedError";
+              return _context3.abrupt("break", 38);
+            case 31:
+              errorType = "NotReadableError";
+              return _context3.abrupt("break", 38);
             case 33:
-              this.audioPermissionGranted = false;
-              return _context2.abrupt("return", false);
+              errorType = "OverconstrainedError";
+              return _context3.abrupt("break", 38);
             case 35:
+              errorType = "SecurityError";
+              return _context3.abrupt("break", 38);
+            case 37:
+              errorType = "MicrophoneUnknownError";
+            case 38:
+              audioError = AudioPermissionError.create(errorType);
+              return _context3.abrupt("return", Promise.reject(audioError));
+            case 40:
+              unknownError = AudioPermissionError.create("MicrophoneUnknownError", _context3.t0 instanceof Error ? _context3.t0.message : void 0);
+              return _context3.abrupt("return", Promise.reject(unknownError));
+            case 42:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
-        }, _callee2, this, [[5, 19]]);
+        }, _callee3, this, [[0, 17]]);
       }));
-      function requestAudioPermission() {
-        return _requestAudioPermission.apply(this, arguments);
+      function requestMicrophonePermission() {
+        return _requestMicrophonePermission.apply(this, arguments);
       }
-      return requestAudioPermission;
+      return requestMicrophonePermission;
+    }()
+  }]);
+}();
+var AudioPermission = /* @__PURE__ */ function() {
+  function AudioPermission2() {
+    _classCallCheck(this, AudioPermission2);
+    _defineProperty(this, "playbackPermission", void 0);
+    _defineProperty(this, "microphonePermission", void 0);
+    this.playbackPermission = new AudioPlaybackPermission();
+    this.microphonePermission = new MicrophonePermission();
+  }
+  return _createClass(AudioPermission2, [{
+    key: "requestPlaybackPermission",
+    value: function() {
+      var _requestPlaybackPermission2 = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee4() {
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", this.playbackPermission.requestPlaybackPermission());
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function requestPlaybackPermission() {
+        return _requestPlaybackPermission2.apply(this, arguments);
+      }
+      return requestPlaybackPermission;
+    }()
+  }, {
+    key: "requestMicrophonePermission",
+    value: function() {
+      var _requestMicrophonePermission2 = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee5() {
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.abrupt("return", this.microphonePermission.requestMicrophonePermission());
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function requestMicrophonePermission() {
+        return _requestMicrophonePermission2.apply(this, arguments);
+      }
+      return requestMicrophonePermission;
     }()
   }]);
 }();
@@ -13399,6 +13639,14 @@ function createAudioPermission() {
   }
   return audioPermissionInstance;
 }
+function isAndroid() {
+  var userAgent2 = navigator.userAgent.toLowerCase();
+  return /android/.test(userAgent2);
+}
+function isIos() {
+  var userAgent2 = navigator.userAgent.toLowerCase();
+  return /iphone|ipad|ipod/.test(userAgent2);
+}
 function isMobile() {
   return isAndroid() || isIos();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@minto-ai/tools",
   "type": "module",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "description": "明途公共工具库",
   "author": "hcc",
   "license": "ISC",
@@ -12,14 +12,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    }
-  },
-  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [