@tb-dev/vue 2.2.0 → 3.0.0

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

@@ -1,3 +1,18 @@
-import { WatchSource } from 'vue';
-export declare function log<T>(source: WatchSource<T>): import('vue').WatchHandle;
-export declare function warn<T>(source: WatchSource<T>): import('vue').WatchHandle;
+import { MaybeNilRef } from '../../types';
+export declare const console: {
+    readonly assert: typeof assert;
+    readonly debug: typeof debug;
+    readonly error: typeof error;
+    readonly info: typeof info;
+    readonly log: typeof log;
+    readonly trace: typeof trace;
+    readonly warn: typeof warn;
+};
+declare function assert(cond: MaybeNilRef<boolean>, message: string): import('vue').WatchStopHandle;
+declare function debug<T>(source: MaybeNilRef<T>): import('vue').WatchStopHandle;
+declare function error<T>(source: MaybeNilRef<T>): import('vue').WatchStopHandle;
+declare function info<T>(source: MaybeNilRef<T>): import('vue').WatchStopHandle;
+declare function log<T>(source: MaybeNilRef<T>): import('vue').WatchStopHandle;
+declare function trace<T>(source: MaybeNilRef<T>): import('vue').WatchStopHandle;
+declare function warn<T>(source: MaybeNilRef<T>): import('vue').WatchStopHandle;
+export {};

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

@@ -1,6 +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<T>;
+    lock: <T = unknown>(fn: () => Promise<T>) => Promise<void | T>;
 };

package/dist/index.js

@@ -1,38 +1,40 @@
-import { watch, ref, readonly, inject as inject$1, computed, effectScope, toValue, toRef } from 'vue';
+import { toRef, inject as inject$1, ref, readonly, computed, effectScope, toValue } from 'vue';
+import { watchImmediate, useAsyncState, useLocalStorage, tryOnScopeDispose, onKeyStroke, useSessionStorage, computedAsync, useWindowSize, useElementSize as useElementSize$1 } from '@vueuse/core';
+export { useWindowSize } from '@vueuse/core';
 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';
-export { useWindowSize } from '@vueuse/core';
 
+const console = {
+  assert,
+  debug,
+  error,
+  info,
+  log,
+  trace,
+  warn
+};
+function assert(cond, message) {
+  return watchImmediate(toRef(cond), (value) => {
+    globalThis.console.assert(value ?? false, message);
+  });
+}
+function debug(source) {
+  return watchImmediate(toRef(source), (value) => globalThis.console.debug(value));
+}
+function error(source) {
+  return watchImmediate(toRef(source), (value) => globalThis.console.error(value));
+}
+function info(source) {
+  return watchImmediate(toRef(source), (value) => globalThis.console.info(value));
+}
 function log(source) {
-  return watch(source, (value) => console.log(value));
+  return watchImmediate(toRef(source), (value) => globalThis.console.log(value));
 }
-function warn(source) {
-  return watch(source, (value) => console.warn(value));
+function trace(source) {
+  return watchImmediate(toRef(source), (value) => globalThis.console.trace(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;
-  }
-  function lock(fn) {
-    const { resolve, reject, promise } = Promise.withResolvers();
-    acquire().then(() => fn()).then((value) => resolve(value)).catch(reject).finally(release);
-    return promise;
-  }
-  return {
-    locked: readonly(locked),
-    acquire,
-    release,
-    lock
-  };
+function warn(source) {
+  return watchImmediate(toRef(source), (value) => globalThis.console.warn(value));
 }
 
 function create$1() {
@@ -113,6 +115,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, {
@@ -275,4 +310,4 @@ function maybe(value, fn) {
   return isNil(_value) ? null : fn(_value);
 }
 
-export { asyncComputed, asyncRef, getCurrentApp, getErrorHandler, handleError, inject, localRef, log, maybe, onAltKeyDown, onCtrlKeyDown, onCtrlShiftKeyDown, onKeyDown, onShiftKeyDown, provide, runWithContext, sessionRef, setCurrentApp, setErrorHandler, tryGetCurrentApp, tryInject, tryInjectOrElse, trySetCurrentApp, useElementSize, useHeight, useHeightDiff, useMutex, useWidth, useWidthDiff, useWindowHeight, useWindowWidth, warn };
+export { asyncComputed, asyncRef, console, getCurrentApp, getErrorHandler, handleError, inject, localRef, maybe, onAltKeyDown, onCtrlKeyDown, onCtrlShiftKeyDown, onKeyDown, onShiftKeyDown, provide, runWithContext, sessionRef, setCurrentApp, setErrorHandler, tryGetCurrentApp, tryInject, tryInjectOrElse, trySetCurrentApp, useElementSize, useHeight, useHeightDiff, useMutex, useWidth, useWidthDiff, useWindowHeight, useWindowWidth };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tb-dev/vue",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "Vue utilities",
   "license": "MIT",
   "type": "module",
@@ -26,13 +26,13 @@
   "dependencies": {
     "@tb-dev/utils": "^7.0.8",
     "@vueuse/core": "^13.5.0",
-    "es-toolkit": "^1.39.7",
+    "es-toolkit": "^1.39.8",
     "vue": "^3.5.18"
   },
   "devDependencies": {
     "@tb-dev/eslint-config": "^8.0.3",
     "@types/node": "^24.1.0",
-    "eslint": "^9.31.0",
+    "eslint": "^9.32.0",
     "prettier": "^3.6.2",
     "tslib": "^2.8.1",
     "typedoc": "^0.28.7",