@rotki/ui-library 3.0.0-beta.1 → 3.0.0-beta.3

package/dist/vendor/@vueuse/shared/dist/index.js

@@ -0,0 +1,563 @@
+import { computed, customRef, effectScope, getCurrentInstance, getCurrentScope, hasInjectionContext, inject, isRef, nextTick, onMounted, onScopeDispose, readonly, ref, shallowReadonly, shallowRef, toRef, toValue, unref, watch } from "vue";
+//#region vendor/@vueuse/shared/dist/index.js
+/**
+* Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
+*
+* @param fn
+*/
+function tryOnScopeDispose(fn, failSilently) {
+	if (getCurrentScope()) {
+		onScopeDispose(fn, failSilently);
+		return true;
+	}
+	return false;
+}
+var localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+/**
+* On the basis of `inject`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+*
+* @example
+* ```ts
+* injectLocal('MyInjectionKey', 1)
+* const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+* ```
+*
+* @__NO_SIDE_EFFECTS__
+*/
+var injectLocal = (...args) => {
+	var _getCurrentInstance;
+	const key = args[0];
+	const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+	const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
+	if (owner == null && !hasInjectionContext()) throw new Error("injectLocal must be called in setup");
+	if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
+	return inject(...args);
+};
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+var notNullish = (val) => val != null;
+var toString = Object.prototype.toString;
+var isObject = (val) => toString.call(val) === "[object Object]";
+var clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+var noop = () => {};
+var isIOS = /* #__PURE__ */ getIsIOS();
+function getIsIOS() {
+	var _window, _window2, _window3;
+	return isClient && !!((_window = window) === null || _window === void 0 || (_window = _window.navigator) === null || _window === void 0 ? void 0 : _window.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_window2 = window) === null || _window2 === void 0 || (_window2 = _window2.navigator) === null || _window2 === void 0 ? void 0 : _window2.maxTouchPoints) > 2 && /iPad|Macintosh/.test((_window3 = window) === null || _window3 === void 0 ? void 0 : _window3.navigator.userAgent));
+}
+function toRef$1(...args) {
+	if (args.length !== 1) return toRef(...args);
+	const r = args[0];
+	return typeof r === "function" ? readonly(customRef(() => ({
+		get: r,
+		set: noop
+	}))) : ref(r);
+}
+function createFilterWrapper(filter, fn) {
+	function wrapper(...args) {
+		return new Promise((resolve, reject) => {
+			Promise.resolve(filter(() => fn.apply(this, args), {
+				fn,
+				thisArg: this,
+				args
+			})).then(resolve).catch(reject);
+		});
+	}
+	if ("cancel" in filter) Object.assign(wrapper, {
+		cancel: filter.cancel,
+		flush: filter.flush,
+		isPending: filter.isPending
+	});
+	return wrapper;
+}
+var bypassFilter = (invoke) => {
+	return invoke();
+};
+/**
+* Create an EventFilter that debounce the events
+*/
+function debounceFilter(ms, options = {}) {
+	let timer;
+	let maxTimer;
+	let lastRejector = noop;
+	let lastResolve = noop;
+	const _pending = shallowRef(false);
+	const _clearTimeout = (timer) => {
+		clearTimeout(timer);
+		lastRejector();
+		lastRejector = noop;
+	};
+	let lastInvoker;
+	const handler = (invoke) => {
+		const duration = toValue(ms);
+		const maxDuration = toValue(options.maxWait);
+		if (timer) _clearTimeout(timer);
+		if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+			if (maxTimer) {
+				_clearTimeout(maxTimer);
+				maxTimer = void 0;
+			}
+			_pending.value = false;
+			return Promise.resolve(invoke());
+		}
+		_pending.value = true;
+		return new Promise((resolve, reject) => {
+			lastRejector = options.rejectOnCancel ? reject : resolve;
+			lastResolve = resolve;
+			lastInvoker = invoke;
+			if (maxDuration && !maxTimer) maxTimer = setTimeout(() => {
+				if (timer) _clearTimeout(timer);
+				maxTimer = void 0;
+				_pending.value = false;
+				resolve(lastInvoker());
+			}, maxDuration);
+			timer = setTimeout(() => {
+				if (maxTimer) _clearTimeout(maxTimer);
+				maxTimer = void 0;
+				_pending.value = false;
+				resolve(invoke());
+			}, duration);
+		});
+	};
+	return Object.assign(handler, {
+		cancel: () => {
+			if (timer) {
+				_clearTimeout(timer);
+				timer = void 0;
+			}
+			if (maxTimer) {
+				_clearTimeout(maxTimer);
+				maxTimer = void 0;
+			}
+			_pending.value = false;
+			lastResolve = noop;
+		},
+		flush: () => {
+			if (_pending.value) {
+				if (timer) {
+					clearTimeout(timer);
+					timer = void 0;
+				}
+				if (maxTimer) {
+					clearTimeout(maxTimer);
+					maxTimer = void 0;
+				}
+				_pending.value = false;
+				const resolve = lastResolve;
+				lastRejector = noop;
+				lastResolve = noop;
+				resolve(lastInvoker());
+			}
+		},
+		isPending: shallowReadonly(_pending)
+	});
+}
+function throttleFilter(...args) {
+	let lastExec = 0;
+	let timer;
+	let isLeading = true;
+	let lastRejector = noop;
+	let lastValue;
+	let ms;
+	let trailing;
+	let leading;
+	let rejectOnCancel;
+	if (!isRef(args[0]) && typeof args[0] === "object") ({delay: ms, trailing = true, leading = true, rejectOnCancel = false} = args[0]);
+	else [ms, trailing = true, leading = true, rejectOnCancel = false] = args;
+	const clear = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+			lastRejector();
+			lastRejector = noop;
+		}
+	};
+	const filter = (_invoke) => {
+		const duration = toValue(ms);
+		const elapsed = Date.now() - lastExec;
+		const invoke = () => {
+			return lastValue = _invoke();
+		};
+		clear();
+		if (duration <= 0) {
+			lastExec = Date.now();
+			return invoke();
+		}
+		if (elapsed > duration) {
+			lastExec = Date.now();
+			if (leading || !isLeading) invoke();
+		} else if (trailing) lastValue = new Promise((resolve, reject) => {
+			lastRejector = rejectOnCancel ? reject : resolve;
+			timer = setTimeout(() => {
+				lastExec = Date.now();
+				isLeading = true;
+				resolve(invoke());
+				clear();
+			}, Math.max(0, duration - elapsed));
+		});
+		if (!leading && !timer) timer = setTimeout(() => isLeading = true, duration);
+		isLeading = false;
+		return lastValue;
+	};
+	return filter;
+}
+/**
+* EventFilter that gives extra controls to pause and resume the filter
+*
+* @param extendFilter  Extra filter to apply when the PausableFilter is active, default to none
+* @param options Options to configure the filter
+*/
+function pausableFilter(extendFilter = bypassFilter, options = {}) {
+	const { initialState = "active" } = options;
+	const isActive = toRef$1(initialState === "active");
+	function pause() {
+		isActive.value = false;
+	}
+	function resume() {
+		isActive.value = true;
+	}
+	const eventFilter = (...args) => {
+		if (isActive.value) extendFilter(...args);
+	};
+	return {
+		isActive: shallowReadonly(isActive),
+		pause,
+		resume,
+		eventFilter
+	};
+}
+/**
+* Create singleton promise function
+*
+* @example
+* ```
+* const promise = createSingletonPromise(async () => { ... })
+*
+* await promise()
+* await promise() // all of them will be bind to a single promise instance
+* await promise() // and be resolved together
+* ```
+*/
+function createSingletonPromise(fn) {
+	let _promise;
+	function wrapper() {
+		if (!_promise) _promise = fn();
+		return _promise;
+	}
+	wrapper.reset = async () => {
+		const _prev = _promise;
+		_promise = void 0;
+		if (_prev) await _prev;
+	};
+	return wrapper;
+}
+function increaseWithUnit(target, delta) {
+	var _target$match;
+	if (typeof target === "number") return target + delta;
+	const value = ((_target$match = target.match(/^-?\d+\.?\d*/)) === null || _target$match === void 0 ? void 0 : _target$match[0]) || "";
+	const unit = target.slice(value.length);
+	const result = Number.parseFloat(value) + delta;
+	if (Number.isNaN(result)) return target;
+	return result + unit;
+}
+/**
+* Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client
+*/
+function pxValue(px) {
+	return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
+}
+/**
+* Create a new subset object by giving keys
+*/
+function objectPick(obj, keys, omitUndefined = false) {
+	return keys.reduce((n, k) => {
+		if (k in obj) {
+			if (!omitUndefined || obj[k] !== void 0) n[k] = obj[k];
+		}
+		return n;
+	}, {});
+}
+/**
+* Create a new subset object by omit giving keys
+*/
+function objectOmit(obj, keys, omitUndefined = false) {
+	return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+		return (!omitUndefined || value !== void 0) && !keys.includes(key);
+	}));
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function getLifeCycleTarget(target) {
+	return target || getCurrentInstance();
+}
+/**
+* Make a composable function usable with multiple Vue instances.
+*
+* @see https://vueuse.org/createSharedComposable
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function createSharedComposable(composable) {
+	if (!isClient) return composable;
+	let subscribers = 0;
+	let state;
+	let scope;
+	const dispose = () => {
+		subscribers -= 1;
+		if (scope && subscribers <= 0) {
+			scope.stop();
+			state = void 0;
+			scope = void 0;
+		}
+	};
+	return ((...args) => {
+		subscribers += 1;
+		if (!scope) {
+			scope = effectScope(true);
+			state = scope.run(() => composable(...args));
+		}
+		tryOnScopeDispose(dispose);
+		return state;
+	});
+}
+function get(obj, key) {
+	if (key == null) return unref(obj);
+	return unref(obj)[key];
+}
+function isDefined(v) {
+	return unref(v) != null;
+}
+/**
+* Debounce execution of a function.
+*
+* @see https://vueuse.org/useDebounceFn
+* @param  fn          A function to be executed after delay milliseconds debounced.
+* @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+* @param  options     Options
+*
+* @return A new, debounced, function with isPending, cancel, and flush properties.
+*/
+function useDebounceFn(fn, ms = 200, options = {}) {
+	return createFilterWrapper(debounceFilter(ms, options), fn);
+}
+/**
+* Debounce updates of a ref.
+*
+* @return A new debounced ref.
+*/
+function refDebounced(value, ms = 200, options = {}) {
+	const debounced = ref(toValue(value));
+	const updater = useDebounceFn(() => {
+		debounced.value = value.value;
+	}, ms, options);
+	watch(value, () => updater());
+	return shallowReadonly(debounced);
+}
+/**
+* Throttle execution of a function. Especially useful for rate limiting
+* execution of handlers on events like resize and scroll.
+*
+* @param   fn             A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+*                                    to `callback` when the throttled-function is executed.
+* @param   ms             A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+*                                    (default value: 200)
+*
+* @param [trailing] if true, call fn again after the time is up (default value: false)
+*
+* @param [leading] if true, call fn on the leading edge of the ms timeout (default value: true)
+*
+* @param [rejectOnCancel] if true, reject the last call if it's been cancel (default value: false)
+*
+* @return  A new, throttled, function.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
+	return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
+}
+/**
+*  Shorthand for `ref.value = x`
+*/
+function set(...args) {
+	if (args.length === 2) {
+		const [ref, value] = args;
+		ref.value = value;
+	}
+	if (args.length === 3) {
+		const [target, key, value] = args;
+		target[key] = value;
+	}
+}
+function watchWithFilter(source, cb, options = {}) {
+	const { eventFilter = bypassFilter, ...watchOptions } = options;
+	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
+function watchPausable(source, cb, options = {}) {
+	const { eventFilter: filter, initialState = "active", ...watchOptions } = options;
+	const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
+	return {
+		stop: watchWithFilter(source, cb, {
+			...watchOptions,
+			eventFilter
+		}),
+		pause,
+		resume,
+		isActive
+	};
+}
+/**
+* Call onMounted() if it's inside a component lifecycle, if not, just call the function
+*
+* @param fn
+* @param sync if set to false, it will run in the nextTick() of Vue
+* @param target
+*/
+function tryOnMounted(fn, sync = true, target) {
+	if (getLifeCycleTarget(target)) onMounted(fn, target);
+	else if (sync) fn();
+	else nextTick(fn);
+}
+/**
+* Reactive `Array.map`
+*
+* @see https://vueuse.org/useArrayMap
+* @param list - the array was called upon.
+* @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
+*
+* @returns a new array with each element being the result of the callback function.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useArrayMap(list, fn) {
+	return computed(() => toValue(list).map((i) => toValue(i)).map(fn));
+}
+/**
+* Wrapper for `setTimeout` with controls.
+*
+* @param cb
+* @param interval
+* @param options
+*/
+function useTimeoutFn(cb, interval, options = {}) {
+	const { immediate = true, immediateCallback = false } = options;
+	const isPending = shallowRef(false);
+	let timer;
+	function clear() {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	}
+	function stop() {
+		isPending.value = false;
+		clear();
+	}
+	function start(...args) {
+		if (immediateCallback) cb();
+		clear();
+		isPending.value = true;
+		timer = setTimeout(() => {
+			isPending.value = false;
+			timer = void 0;
+			cb(...args);
+		}, toValue(interval));
+	}
+	if (immediate) {
+		isPending.value = true;
+		if (isClient) start();
+	}
+	tryOnScopeDispose(stop);
+	return {
+		isPending: shallowReadonly(isPending),
+		start,
+		stop
+	};
+}
+function watchDebounced(source, cb, options = {}) {
+	const { debounce = 0, maxWait = void 0, ...watchOptions } = options;
+	return watchWithFilter(source, cb, {
+		...watchOptions,
+		eventFilter: debounceFilter(debounce, { maxWait })
+	});
+}
+function watchIgnorable(source, cb, options = {}) {
+	const { eventFilter = bypassFilter, ...watchOptions } = options;
+	const filteredCb = createFilterWrapper(eventFilter, cb);
+	let ignoreUpdates;
+	let ignorePrevAsyncUpdates;
+	let stop;
+	if (watchOptions.flush === "sync") {
+		let ignore = false;
+		ignorePrevAsyncUpdates = () => {};
+		ignoreUpdates = (updater) => {
+			ignore = true;
+			updater();
+			ignore = false;
+		};
+		stop = watch(source, (...args) => {
+			if (!ignore) filteredCb(...args);
+		}, watchOptions);
+	} else {
+		const disposables = [];
+		let ignoreCounter = 0;
+		let syncCounter = 0;
+		ignorePrevAsyncUpdates = () => {
+			ignoreCounter = syncCounter;
+		};
+		disposables.push(watch(source, () => {
+			syncCounter++;
+		}, {
+			...watchOptions,
+			flush: "sync"
+		}));
+		ignoreUpdates = (updater) => {
+			const syncCounterPrev = syncCounter;
+			updater();
+			ignoreCounter += syncCounter - syncCounterPrev;
+		};
+		disposables.push(watch(source, (...args) => {
+			const ignore = ignoreCounter > 0 && ignoreCounter === syncCounter;
+			ignoreCounter = 0;
+			syncCounter = 0;
+			if (ignore) return;
+			filteredCb(...args);
+		}, watchOptions));
+		stop = () => {
+			disposables.forEach((fn) => fn());
+		};
+	}
+	return {
+		stop,
+		ignoreUpdates,
+		ignorePrevAsyncUpdates
+	};
+}
+/**
+* Shorthand for watching value with {immediate: true}
+*
+* @see https://vueuse.org/watchImmediate
+*/
+function watchImmediate(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		immediate: true
+	});
+}
+function whenever(source, cb, options) {
+	const stop = watch(source, (v, ov, onInvalidate) => {
+		if (v) {
+			if (options === null || options === void 0 ? void 0 : options.once) nextTick(() => stop());
+			cb(v, ov, onInvalidate);
+		}
+	}, {
+		...options,
+		once: false
+	});
+	return stop;
+}
+//#endregion
+export { bypassFilter, clamp, createFilterWrapper, createSharedComposable, createSingletonPromise, debounceFilter, get, getLifeCycleTarget, increaseWithUnit, injectLocal, isClient, isDefined, isIOS, isObject, noop, notNullish, objectOmit, objectPick, pausableFilter, pxValue, refDebounced, set, throttleFilter, toArray, toRef$1 as toRef, tryOnMounted, tryOnScopeDispose, useArrayMap, useDebounceFn, useThrottleFn, useTimeoutFn, watchDebounced, watchIgnorable, watchImmediate, watchPausable, watchWithFilter, whenever };
+
+//# sourceMappingURL=index.js.map