@minto-ai/tools 1.0.56 → 1.0.58

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

@@ -0,0 +1,45 @@
+/**
+ * 音频权限管理类
+ *
+ * 用于处理浏览器中的音频播放和录音权限问题，解决自动播放限制。
+ *
+ * 平台差异处理：
+ * - 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状态，直接返回成功
+ */
+declare class AudioPermission {
+    private userInteracted;
+    private audioPermissionGranted;
+    constructor();
+    /**
+     * 初始化音频权限检测流程
+     * 根据不同平台采用相应的权限检测策略
+     */
+    private initAudioPermission;
+    /**
+     * 监听用户交互事件
+     * 监听多种交互事件类型，确保在各种设备上都能正确检测到用户操作
+     */
+    private waitForUserInteraction;
+    /**
+     * 请求音频权限（包含录音和播放权限）
+     *
+     * @returns Promise<boolean> 返回权限获取结果，true表示成功，false表示失败
+     */
+    requestAudioPermission(): Promise<boolean>;
+}
+/**
+ * 创建或获取音频权限管理实例
+ *
+ * @returns AudioPermission 音频权限管理实例
+ */
+declare function createAudioPermission(): AudioPermission;
+export default createAudioPermission;

package/dist/browser/index.d.ts

@@ -1,7 +1,7 @@
 import { default as copyText } from './copy-text';
+import { default as createAudioPermission } from './create-audio-permission';
 import { default as isAndroid } from './is-android';
 import { default as isIos } from './is-ios';
 import { default as isMobile } from './is-mobile';
 import { default as isPc } from './is-pc';
-import { default as waitForUserInteraction } from './wait-for-user-interaction';
-export { copyText, isAndroid, isIos, isMobile, isPc, waitForUserInteraction };
+export { copyText, createAudioPermission, isAndroid, isIos, isMobile, isPc };

package/dist/index.js

@@ -13246,52 +13246,164 @@ function isIos() {
   var userAgent2 = navigator.userAgent.toLowerCase();
   return /iphone|ipad|ipod/.test(userAgent2);
 }
-function isMobile() {
-  return isAndroid() || isIos();
-}
-function isPc() {
-  return !isMobile();
-}
-function waitForUserInteraction() {
-  return new Promise(function(resolve2) {
-    var audioContext = new (window.AudioContext || window.webkitAudioContext)();
-    if (audioContext.state === "running") {
-      audioContext.close();
-      resolve2(true);
-      return;
-    }
-    var interactionEvents = ["click", "touchstart", "touchend", "keydown", "mousedown", "pointerdown"];
-    var timeoutId = null;
-    var isResolved = false;
-    function handleInteraction() {
-      if (isResolved) {
-        return;
-      }
-      isResolved = true;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
+var AudioPermission = /* @__PURE__ */ function() {
+  function AudioPermission2() {
+    _classCallCheck(this, AudioPermission2);
+    _defineProperty(this, "userInteracted", false);
+    _defineProperty(this, "audioPermissionGranted", false);
+    this.initAudioPermission();
+  }
+  return _createClass(AudioPermission2, [{
+    key: "initAudioPermission",
+    value: function() {
+      var _initAudioPermission = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee() {
+        var audioContext;
+        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();
+                }
+              }
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function initAudioPermission() {
+        return _initAudioPermission.apply(this, arguments);
       }
+      return initAudioPermission;
+    }()
+  }, {
+    key: "waitForUserInteraction",
+    value: function waitForUserInteraction() {
+      var _this = this;
+      var interactionEvents = ["click", "touchstart", "touchend", "keydown", "mousedown", "pointerdown"];
+      var _handleInteraction = function handleInteraction() {
+        _this.userInteracted = true;
+        interactionEvents.forEach(function(eventType) {
+          document.removeEventListener(eventType, _handleInteraction);
+        });
+      };
       interactionEvents.forEach(function(eventType) {
-        document.removeEventListener(eventType, handleInteraction);
+        document.addEventListener(eventType, _handleInteraction, {
+          passive: true
+        });
       });
-      resolve2(true);
     }
-    timeoutId = setTimeout(function() {
-      if (isResolved) {
-        return;
+    /**
+     * 请求音频权限（包含录音和播放权限）
+     *
+     * @returns Promise<boolean> 返回权限获取结果，true表示成功，false表示失败
+     */
+  }, {
+    key: "requestAudioPermission",
+    value: function() {
+      var _requestAudioPermission = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee2() {
+        var stream, audioContext;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (this.userInteracted) {
+                _context2.next = 3;
+                break;
+              }
+              console.warn("用户尚未产生交互，无法获取音频权限");
+              return _context2.abrupt("return", false);
+            case 3:
+              if (!(this.audioPermissionGranted && !isIos())) {
+                _context2.next = 5;
+                break;
+              }
+              return _context2.abrupt("return", true);
+            case 5:
+              _context2.prev = 5;
+              _context2.next = 8;
+              return navigator.mediaDevices.getUserMedia({
+                audio: true
+              });
+            case 8:
+              stream = _context2.sent;
+              audioContext = new (window.AudioContext || window.webkitAudioContext)();
+              if (!(isIos() && audioContext.state === "suspended")) {
+                _context2.next = 13;
+                break;
+              }
+              _context2.next = 13;
+              return audioContext.resume();
+            case 13:
+              this.audioPermissionGranted = audioContext.state === "running";
+              stream.getTracks().forEach(function(track2) {
+                return 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;
+                break;
+              }
+              _context2.t1 = _context2.t0.name;
+              _context2.next = _context2.t1 === "NotAllowedError" ? 26 : _context2.t1 === "NotFoundError" ? 28 : _context2.t1 === "NotSupportedError" ? 30 : 32;
+              break;
+            case 26:
+              console.warn("用户拒绝了音频权限请求");
+              return _context2.abrupt("break", 33);
+            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);
+            case 33:
+              this.audioPermissionGranted = false;
+              return _context2.abrupt("return", false);
+            case 35:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[5, 19]]);
+      }));
+      function requestAudioPermission() {
+        return _requestAudioPermission.apply(this, arguments);
       }
-      isResolved = true;
-      interactionEvents.forEach(function(eventType) {
-        document.removeEventListener(eventType, handleInteraction);
-      });
-      resolve2(false);
-    }, 1e4);
-    interactionEvents.forEach(function(eventType) {
-      document.addEventListener(eventType, handleInteraction, {
-        passive: true
-      });
-    });
-  });
+      return requestAudioPermission;
+    }()
+  }]);
+}();
+var audioPermissionInstance = null;
+function createAudioPermission() {
+  if (!audioPermissionInstance) {
+    audioPermissionInstance = new AudioPermission();
+  }
+  return audioPermissionInstance;
+}
+function isMobile() {
+  return isAndroid() || isIos();
+}
+function isPc() {
+  return !isMobile();
 }
 function isNumber(value) {
   return typeof value === "number";
@@ -16180,6 +16292,7 @@ export {
   chunkString,
   closeWorker,
   copyText,
+  createAudioPermission,
   createWebSocket,
   createWorker,
   debounce,
@@ -16222,6 +16335,5 @@ export {
   throttle,
   timeDelay,
   updateFilePathQuery,
-  useTheme,
-  waitForUserInteraction
+  useTheme
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@minto-ai/tools",
   "type": "module",
-  "version": "1.0.56",
+  "version": "1.0.58",
   "description": "明途公共工具库",
   "author": "hcc",
   "license": "ISC",
@@ -12,6 +12,14 @@
   "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": [

package/dist/browser/wait-for-user-interaction.d.ts

@@ -1,7 +0,0 @@
-/**
- * 等待用户交互的Promise函数
- * 创建AudioContext检测是否已有用户交互，如果没有则监听多种用户交互事件
- * @returns {Promise<boolean>} 返回Promise，用户交互后resolve为true，超时后resolve为false
- */
-declare function waitForUserInteraction(): Promise<boolean>;
-export default waitForUserInteraction;