@tb-dev/vue 2.1.0 → 2.2.1

package/dist/composables/useMutex/index.d.ts

@@ -1,5 +1,9 @@
-export declare function useMutex(): {
+export interface UseMutexOptions {
+    onError?: ((err: unknown) => void) | boolean;
+}
+export declare function useMutex(options?: UseMutexOptions): {
     locked: Readonly<import('vue').Ref<boolean, boolean>>;
     acquire: () => Promise<void>;
     release: () => void;
+    lock: <T = unknown>(fn: () => Promise<T>) => Promise<void | T>;
 };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { watch, ref, readonly, inject as inject$1, computed, effectScope, toValue, toRef } from 'vue';
+import { watch, inject as inject$1, ref, readonly, computed, effectScope, toValue, toRef } from 'vue';
 import { Mutex } from 'es-toolkit';
 import { unwrap, isNil } from '@tb-dev/utils';
 import { useAsyncState, useLocalStorage, tryOnScopeDispose, onKeyStroke, useSessionStorage, computedAsync, useWindowSize, useElementSize as useElementSize$1 } from '@vueuse/core';
@@ -11,24 +11,6 @@ function warn(source) {
   return watch(source, (value) => console.warn(value));
 }
 
-function useMutex() {
-  const mutex = new Mutex();
-  const locked = ref(mutex.isLocked);
-  async function acquire() {
-    await mutex.acquire();
-    locked.value = mutex.isLocked;
-  }
-  function release() {
-    mutex.release();
-    locked.value = mutex.isLocked;
-  }
-  return {
-    locked: readonly(locked),
-    acquire,
-    release
-  };
-}
-
 function create$1() {
   let APP = null;
   function get() {
@@ -107,6 +89,39 @@ function create() {
 }
 const { get: getErrorHandler, set: setErrorHandler, handle: handleError } = create();
 
+function useMutex(options) {
+  const mutex = new Mutex();
+  const locked = ref(mutex.isLocked);
+  let onError;
+  if (typeof options?.onError === "function") {
+    onError = options.onError;
+  } else if (options?.onError !== false) {
+    onError = handleError;
+  }
+  async function acquire() {
+    await mutex.acquire();
+    locked.value = mutex.isLocked;
+  }
+  function release() {
+    mutex.release();
+    locked.value = mutex.isLocked;
+  }
+  function lock(fn) {
+    const { resolve, reject, promise } = Promise.withResolvers();
+    acquire().then(() => fn()).then((value) => resolve(value)).catch(reject).finally(release);
+    if (onError) {
+      return promise.catch(onError);
+    }
+    return promise;
+  }
+  return {
+    locked: readonly(locked),
+    acquire,
+    release,
+    lock
+  };
+}
+
 function asyncRef(initial, fn, options = {}) {
   const { immediate = true } = options;
   const value = useAsyncState(fn, initial, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tb-dev/vue",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "Vue utilities",
   "license": "MIT",
   "type": "module",