@tb-dev/vue 0.1.6 → 0.1.7

package/dist/index.js

@@ -1,7 +1,7 @@
-import { defineComponent, createBlock, openBlock, unref, withCtx, createElementBlock, renderSlot, toDisplayString, toRef, effectScope, toValue, computed, inject as inject$1 } from 'vue';
+import { defineComponent, createBlock, openBlock, unref, withCtx, createElementBlock, renderSlot, toDisplayString, inject as inject$1, toRef, effectScope, toValue, computed } from 'vue';
 import { RouterLink } from 'vue-router';
-import { computedAsync, useAsyncState, useElementSize as useElementSize$1, tryOnScopeDispose, onKeyStroke, useLocalStorage, useWindowSize } from '@vueuse/core';
 import { unwrap, isNil } from '@tb-dev/utils';
+import { computedAsync, useAsyncState, useElementSize as useElementSize$1, tryOnScopeDispose, onKeyStroke, useLocalStorage, useWindowSize } from '@vueuse/core';
 
 const _hoisted_1 = { key: 0 };
 const _sfc_main = /* @__PURE__ */ defineComponent({
@@ -25,28 +25,57 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 });
 
 function create$1() {
+  let APP = null;
+  function get() {
+    return unwrap(APP, "no active app");
+  }
+  function set(app) {
+    APP = app;
+  }
+  return { get, set };
+}
+const { get: getCurrentApp, set: setCurrentApp } = create$1();
+function runWithContext(fn) {
+  return getCurrentApp().runWithContext(fn);
+}
+function provide(key, value) {
+  getCurrentApp().provide(key, value);
+}
+function inject(key) {
+  const value = fallibleInject(key);
+  if (typeof value === "undefined") {
+    throw new TypeError("injection failed: value not provided");
+  }
+  return value;
+}
+function fallibleInject(key) {
+  return runWithContext(() => inject$1(key));
+}
+
+function create() {
   let ERROR_HANDLER_FN = null;
   function get() {
     return ERROR_HANDLER_FN;
   }
-  function set(fn, options) {
+  function set(fn, app = true) {
     ERROR_HANDLER_FN = fn;
-    if (options?.app) {
-      options.app.config.errorHandler = (err) => {
-        handle(err, { rethrow: true });
+    if (app) {
+      const _app = app === true ? getCurrentApp() : app;
+      _app.config.errorHandler = (err) => {
+        handle(err, true);
       };
     }
   }
-  function handle(err, options) {
+  function handle(err, rethrow = true) {
     if (ERROR_HANDLER_FN) {
       void Promise.try(ERROR_HANDLER_FN, err);
-    } else if (options?.rethrow ?? true) {
+    } else if (rethrow) {
       throw err;
     }
   }
   return { get, set, handle };
 }
-const { get: getErrorHandler, set: setErrorHandler, handle: handleError } = create$1();
+const { get: getErrorHandler, set: setErrorHandler, handle: handleError } = create();
 
 function asyncComputed(initial, callback, options) {
   const state = computedAsync(callback, initial, {
@@ -165,34 +194,6 @@ function useWindowWidth() {
   return useWindowSize().width;
 }
 
-function create() {
-  let APP = null;
-  function get() {
-    return unwrap(APP, "no active app");
-  }
-  function set(app) {
-    APP = app;
-  }
-  return { get, set };
-}
-const { get: getCurrentApp, set: setCurrentApp } = create();
-function runWithContext(fn) {
-  return getCurrentApp().runWithContext(fn);
-}
-function provide(key, value) {
-  getCurrentApp().provide(key, value);
-}
-function inject(key) {
-  const value = fallibleInject(key);
-  if (typeof value === "undefined") {
-    throw new TypeError("injection failed: value not provided");
-  }
-  return value;
-}
-function fallibleInject(key) {
-  return runWithContext(() => inject$1(key));
-}
-
 function maybe(value, fn) {
   const _value = toValue(value);
   return isNil(_value) ? null : fn(_value);

package/dist/utils/error.d.ts

@@ -1,10 +1,4 @@
 import { App } from 'vue';
 import { MaybePromise, Option } from '@tb-dev/utils';
 export type ErrorHandler = (err: unknown) => MaybePromise<void>;
-export interface SetErrorHandlerOptions {
-    app?: App;
-}
-export interface HandleErrorOptions {
-    rethrow?: boolean;
-}
-export declare const getErrorHandler: () => Option<ErrorHandler>, setErrorHandler: (fn: ErrorHandler, options?: SetErrorHandlerOptions) => void, handleError: (err: unknown, options?: HandleErrorOptions) => void;
+export declare const getErrorHandler: () => Option<ErrorHandler>, setErrorHandler: (fn: ErrorHandler, app?: Option<App | boolean>) => void, handleError: (err: unknown, rethrow?: boolean) => void;

package/package.json

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