@tb-dev/vue 0.1.6 → 0.1.8

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,74 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 });
 
 function create$1() {
+  let APP = null;
+  function get() {
+    return unwrap(APP, "no active app");
+  }
+  function tryGet() {
+    return APP;
+  }
+  function set(app) {
+    APP = app;
+  }
+  function trySet(app) {
+    APP ??= app;
+  }
+  return { get, set, tryGet, trySet };
+}
+const {
+  get: getCurrentApp,
+  set: setCurrentApp,
+  tryGet: tryGetCurrentApp,
+  trySet: trySetCurrentApp
+} = create$1();
+function runWithContext(fn) {
+  return getCurrentApp().runWithContext(fn);
+}
+function provide(key, value) {
+  getCurrentApp().provide(key, value);
+}
+function inject(key) {
+  const value = tryInject(key);
+  if (typeof value === "undefined") {
+    throw new TypeError("injection failed: value not provided");
+  }
+  return value;
+}
+function tryInject(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) {
+      let _app;
+      if (app === true) {
+        _app = getCurrentApp();
+      } else {
+        trySetCurrentApp(app);
+        _app = 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,37 +211,9 @@ 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);
 }
 
-export { _sfc_main as Link, asyncComputed, asyncRef, fallibleInject, getCurrentApp, getErrorHandler, handleError, inject, localRef, maybe, onAltKeyDown, onCtrlKeyDown, onCtrlShiftKeyDown, onKeyDown, onShiftKeyDown, provide, runWithContext, setCurrentApp, setErrorHandler, useElementSize, useHeight, useWidth, useWindowHeight, useWindowWidth };
+export { _sfc_main as Link, asyncComputed, asyncRef, getCurrentApp, getErrorHandler, handleError, inject, localRef, maybe, onAltKeyDown, onCtrlKeyDown, onCtrlShiftKeyDown, onKeyDown, onShiftKeyDown, provide, runWithContext, setCurrentApp, setErrorHandler, tryGetCurrentApp, tryInject, trySetCurrentApp, useElementSize, useHeight, useWidth, useWindowHeight, useWindowWidth };

package/dist/utils/app.d.ts

@@ -1,6 +1,7 @@
+import { Option } from '@tb-dev/utils';
 import { App, InjectionKey } from 'vue';
-export declare const getCurrentApp: () => App<any>, setCurrentApp: (app: App) => void;
+export declare const getCurrentApp: () => App, setCurrentApp: (app: App) => void, tryGetCurrentApp: () => Option<App>, trySetCurrentApp: (app: App) => void;
 export declare function runWithContext<T>(fn: () => T): T;
 export declare function provide<T>(key: InjectionKey<T>, value: T): void;
 export declare function inject<T>(key: InjectionKey<T>): T;
-export declare function fallibleInject<T>(key: InjectionKey<T>): T | undefined;
+export declare function tryInject<T>(key: InjectionKey<T>): T | undefined;

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.8",
   "description": "Vue utilities",
   "license": "MIT",
   "type": "module",