@growing-web/esm-pack-core
Version:
esm pack build core.
1,406 lines (1,346 loc) • 40.5 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
var vueDemi = require('vue-demi');
var __defProp$8 = Object.defineProperty;
var __defProps$5 = Object.defineProperties;
var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
var __hasOwnProp$a = Object.prototype.hasOwnProperty;
var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$8 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$a.call(b, prop))
__defNormalProp$8(a, prop, b[prop]);
if (__getOwnPropSymbols$a)
for (var prop of __getOwnPropSymbols$a(b)) {
if (__propIsEnum$a.call(b, prop))
__defNormalProp$8(a, prop, b[prop]);
}
return a;
};
var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
function computedEager(fn, options) {
var _a;
const result = vueDemi.shallowRef();
vueDemi.watchEffect(() => {
result.value = fn();
}, __spreadProps$5(__spreadValues$8({}, options), {
flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
}));
return vueDemi.readonly(result);
}
function computedWithControl(source, fn) {
let v = void 0;
let track;
let trigger;
const dirty = vueDemi.ref(true);
vueDemi.watch(source, () => {
dirty.value = true;
trigger();
}, { flush: "sync" });
return vueDemi.customRef((_track, _trigger) => {
track = _track;
trigger = _trigger;
return {
get() {
if (dirty.value) {
v = fn();
dirty.value = false;
}
track();
return v;
},
set() {
}
};
});
}
function createEventHook() {
const fns = [];
const off = (fn) => {
const index = fns.indexOf(fn);
if (index !== -1)
fns.splice(index, 1);
};
const on = (fn) => {
fns.push(fn);
return {
off: () => off(fn)
};
};
const trigger = (param) => {
fns.forEach((fn) => fn(param));
};
return {
on,
off,
trigger
};
}
function createGlobalState(stateFactory) {
let initialized = false;
let state;
const scope = vueDemi.effectScope(true);
return () => {
if (!initialized) {
state = scope.run(stateFactory);
initialized = true;
}
return state;
};
}
function createInjectionState(composable) {
const key = Symbol("InjectionState");
const useProvidingState = (...args) => {
vueDemi.provide(key, composable(...args));
};
const useInjectedState = () => vueDemi.inject(key);
return [useProvidingState, useInjectedState];
}
function tryOnScopeDispose(fn) {
if (vueDemi.getCurrentScope()) {
vueDemi.onScopeDispose(fn);
return true;
}
return false;
}
function createSharedComposable(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 (!state) {
scope = vueDemi.effectScope(true);
state = scope.run(() => composable(...args));
}
tryOnScopeDispose(dispose);
return state;
};
}
function __onlyVue3(name = "this function") {
if (vueDemi.isVue3)
return;
throw new Error(`[VueUse] ${name} is only works on Vue 3.`);
}
const directiveHooks = {
mounted: vueDemi.isVue3 ? "mounted" : "inserted",
updated: vueDemi.isVue3 ? "updated" : "componentUpdated",
unmounted: vueDemi.isVue3 ? "unmounted" : "unbind"
};
function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
__onlyVue3();
for (const [key, value] of Object.entries(extend)) {
if (key === "value")
continue;
if (vueDemi.isRef(value) && unwrap) {
Object.defineProperty(ref, key, {
get() {
return value.value;
},
set(v) {
value.value = v;
},
enumerable
});
} else {
Object.defineProperty(ref, key, { value, enumerable });
}
}
return ref;
}
function get(obj, key) {
if (key == null)
return vueDemi.unref(obj);
return vueDemi.unref(obj)[key];
}
function isDefined(v) {
return vueDemi.unref(v) != null;
}
function logicAnd(...args) {
return vueDemi.computed(() => args.every((i) => vueDemi.unref(i)));
}
function logicNot(v) {
return vueDemi.computed(() => !vueDemi.unref(v));
}
function logicOr(...args) {
return vueDemi.computed(() => args.some((i) => vueDemi.unref(i)));
}
var __defProp$7 = Object.defineProperty;
var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$7 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$9.call(b, prop))
__defNormalProp$7(a, prop, b[prop]);
if (__getOwnPropSymbols$9)
for (var prop of __getOwnPropSymbols$9(b)) {
if (__propIsEnum$9.call(b, prop))
__defNormalProp$7(a, prop, b[prop]);
}
return a;
};
function makeDestructurable(obj, arr) {
if (typeof Symbol !== "undefined") {
const clone = __spreadValues$7({}, obj);
Object.defineProperty(clone, Symbol.iterator, {
enumerable: false,
value() {
let index = 0;
return {
next: () => ({
value: arr[index++],
done: index > arr.length
})
};
}
});
return clone;
} else {
return Object.assign([...arr], obj);
}
}
function reactify(fn) {
return function(...args) {
return vueDemi.computed(() => fn.apply(this, args.map((i) => vueDemi.unref(i))));
};
}
function reactifyObject(obj, optionsOrKeys = {}) {
let keys = [];
if (Array.isArray(optionsOrKeys)) {
keys = optionsOrKeys;
} else {
const { includeOwnProperties = true } = optionsOrKeys;
keys.push(...Object.keys(obj));
if (includeOwnProperties)
keys.push(...Object.getOwnPropertyNames(obj));
}
return Object.fromEntries(keys.map((key) => {
const value = obj[key];
return [
key,
typeof value === "function" ? reactify(value.bind(obj)) : value
];
}));
}
function toReactive(objectRef) {
if (!vueDemi.isRef(objectRef))
return vueDemi.reactive(objectRef);
const proxy = new Proxy({}, {
get(_, p, receiver) {
return vueDemi.unref(Reflect.get(objectRef.value, p, receiver));
},
set(_, p, value) {
if (vueDemi.isRef(objectRef.value[p]) && !vueDemi.isRef(value))
objectRef.value[p].value = value;
else
objectRef.value[p] = value;
return true;
},
deleteProperty(_, p) {
return Reflect.deleteProperty(objectRef.value, p);
},
has(_, p) {
return Reflect.has(objectRef.value, p);
},
ownKeys() {
return Object.keys(objectRef.value);
},
getOwnPropertyDescriptor() {
return {
enumerable: true,
configurable: true
};
}
});
return vueDemi.reactive(proxy);
}
function reactiveComputed(fn) {
return toReactive(vueDemi.computed(fn));
}
function reactiveOmit(obj, ...keys) {
return reactiveComputed(() => Object.fromEntries(Object.entries(vueDemi.toRefs(obj)).filter((e) => !keys.includes(e[0]))));
}
function reactivePick(obj, ...keys) {
return vueDemi.reactive(Object.fromEntries(keys.map((k) => [k, vueDemi.toRef(obj, k)])));
}
function refAutoReset(defaultValue, afterMs = 1e4) {
return vueDemi.customRef((track, trigger) => {
let value = defaultValue;
let timer;
const resetAfter = () => setTimeout(() => {
value = defaultValue;
trigger();
}, vueDemi.unref(afterMs));
return {
get() {
track();
return value;
},
set(newValue) {
value = newValue;
trigger();
clearTimeout(timer);
timer = resetAfter();
}
};
});
}
const isClient = typeof window !== "undefined";
const isDef = (val) => typeof val !== "undefined";
const assert = (condition, ...infos) => {
if (!condition)
console.warn(...infos);
};
const toString = Object.prototype.toString;
const isBoolean = (val) => typeof val === "boolean";
const isFunction = (val) => typeof val === "function";
const isNumber = (val) => typeof val === "number";
const isString = (val) => typeof val === "string";
const isObject = (val) => toString.call(val) === "[object Object]";
const isWindow = (val) => typeof window !== "undefined" && toString.call(val) === "[object Window]";
const now = () => Date.now();
const timestamp = () => +Date.now();
const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
const noop = () => {
};
const rand = (min, max) => {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
};
function createFilterWrapper(filter, fn) {
function wrapper(...args) {
filter(() => fn.apply(this, args), { fn, thisArg: this, args });
}
return wrapper;
}
const bypassFilter = (invoke) => {
return invoke();
};
function debounceFilter(ms, options = {}) {
let timer;
let maxTimer;
const filter = (invoke) => {
const duration = vueDemi.unref(ms);
const maxDuration = vueDemi.unref(options.maxWait);
if (timer)
clearTimeout(timer);
if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
if (maxTimer) {
clearTimeout(maxTimer);
maxTimer = null;
}
return invoke();
}
if (maxDuration && !maxTimer) {
maxTimer = setTimeout(() => {
if (timer)
clearTimeout(timer);
maxTimer = null;
invoke();
}, maxDuration);
}
timer = setTimeout(() => {
if (maxTimer)
clearTimeout(maxTimer);
maxTimer = null;
invoke();
}, duration);
};
return filter;
}
function throttleFilter(ms, trailing = true, leading = true) {
let lastExec = 0;
let timer;
let preventLeading = !leading;
const clear = () => {
if (timer) {
clearTimeout(timer);
timer = void 0;
}
};
const filter = (invoke) => {
const duration = vueDemi.unref(ms);
const elapsed = Date.now() - lastExec;
clear();
if (duration <= 0) {
lastExec = Date.now();
return invoke();
}
if (elapsed > duration) {
lastExec = Date.now();
if (preventLeading)
preventLeading = false;
else
invoke();
}
if (trailing) {
timer = setTimeout(() => {
lastExec = Date.now();
if (!leading)
preventLeading = true;
clear();
invoke();
}, duration);
}
if (!leading && !timer)
timer = setTimeout(() => preventLeading = true, duration);
};
return filter;
}
function pausableFilter(extendFilter = bypassFilter) {
const isActive = vueDemi.ref(true);
function pause() {
isActive.value = false;
}
function resume() {
isActive.value = true;
}
const eventFilter = (...args) => {
if (isActive.value)
extendFilter(...args);
};
return { isActive, pause, resume, eventFilter };
}
function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
return new Promise((resolve, reject) => {
if (throwOnTimeout)
setTimeout(() => reject(reason), ms);
else
setTimeout(resolve, ms);
});
}
function identity(arg) {
return arg;
}
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 invoke(fn) {
return fn();
}
function containsProp(obj, ...props) {
return props.some((k) => k in obj);
}
function increaseWithUnit(target, delta) {
var _a;
if (typeof target === "number")
return target + delta;
const value = ((_a = target.match(/^-?[0-9]+\.?[0-9]*/)) == null ? void 0 : _a[0]) || "";
const unit = target.slice(value.length);
const result = parseFloat(value) + delta;
if (Number.isNaN(result))
return target;
return result + unit;
}
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;
}, {});
}
function useDebounceFn(fn, ms = 200, options = {}) {
return createFilterWrapper(debounceFilter(ms, options), fn);
}
function refDebounced(value, ms = 200, options = {}) {
if (ms <= 0)
return value;
const debounced = vueDemi.ref(value.value);
const updater = useDebounceFn(() => {
debounced.value = value.value;
}, ms, options);
vueDemi.watch(value, () => updater());
return debounced;
}
function refDefault(source, defaultValue) {
return vueDemi.computed({
get() {
var _a;
return (_a = source.value) != null ? _a : defaultValue;
},
set(value) {
source.value = value;
}
});
}
function useThrottleFn(fn, ms = 200, trailing = true, leading = true) {
return createFilterWrapper(throttleFilter(ms, trailing, leading), fn);
}
function refThrottled(value, delay = 200, trailing = true, leading = true) {
if (delay <= 0)
return value;
const throttled = vueDemi.ref(value.value);
const updater = useThrottleFn(() => {
throttled.value = value.value;
}, delay, trailing, leading);
vueDemi.watch(value, () => updater());
return throttled;
}
function refWithControl(initial, options = {}) {
let source = initial;
let track;
let trigger;
const ref = vueDemi.customRef((_track, _trigger) => {
track = _track;
trigger = _trigger;
return {
get() {
return get();
},
set(v) {
set(v);
}
};
});
function get(tracking = true) {
if (tracking)
track();
return source;
}
function set(value, triggering = true) {
var _a, _b;
if (value === source)
return;
const old = source;
if (((_a = options.onBeforeChange) == null ? void 0 : _a.call(options, value, old)) === false)
return;
source = value;
(_b = options.onChanged) == null ? void 0 : _b.call(options, value, old);
if (triggering)
trigger();
}
const untrackedGet = () => get(false);
const silentSet = (v) => set(v, false);
const peek = () => get(false);
const lay = (v) => set(v, false);
return extendRef(ref, {
get,
set,
untrackedGet,
silentSet,
peek,
lay
}, { enumerable: true });
}
const controlledRef = refWithControl;
function set(...args) {
if (args.length === 2) {
const [ref, value] = args;
ref.value = value;
}
if (args.length === 3) {
if (vueDemi.isVue2) {
vueDemi.set(...args);
} else {
const [target, key, value] = args;
target[key] = value;
}
}
}
function syncRef(left, right, options = {}) {
const {
flush = "sync",
deep = false,
immediate = true,
direction = "both"
} = options;
let stop1, stop2;
if (direction === "both" || direction === "ltr") {
stop1 = vueDemi.watch(left, (newValue) => right.value = newValue, { flush, deep, immediate });
}
if (direction === "both" || direction === "rtl") {
stop2 = vueDemi.watch(right, (newValue) => left.value = newValue, { flush, deep, immediate });
}
return () => {
stop1 == null ? void 0 : stop1();
stop2 == null ? void 0 : stop2();
};
}
function syncRefs(source, targets, options = {}) {
const {
flush = "sync",
deep = false,
immediate = true
} = options;
if (!Array.isArray(targets))
targets = [targets];
return vueDemi.watch(source, (newValue) => targets.forEach((target) => target.value = newValue), { flush, deep, immediate });
}
var __defProp$6 = Object.defineProperty;
var __defProps$4 = Object.defineProperties;
var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$6 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$8.call(b, prop))
__defNormalProp$6(a, prop, b[prop]);
if (__getOwnPropSymbols$8)
for (var prop of __getOwnPropSymbols$8(b)) {
if (__propIsEnum$8.call(b, prop))
__defNormalProp$6(a, prop, b[prop]);
}
return a;
};
var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
function toRefs(objectRef) {
if (!vueDemi.isRef(objectRef))
return vueDemi.toRefs(objectRef);
const result = Array.isArray(objectRef.value) ? new Array(objectRef.value.length) : {};
for (const key in objectRef.value) {
result[key] = vueDemi.customRef(() => ({
get() {
return objectRef.value[key];
},
set(v) {
if (Array.isArray(objectRef.value)) {
const copy = [...objectRef.value];
copy[key] = v;
objectRef.value = copy;
} else {
objectRef.value = __spreadProps$4(__spreadValues$6({}, objectRef.value), { [key]: v });
}
}
}));
}
return result;
}
function tryOnBeforeMount(fn, sync = true) {
if (vueDemi.getCurrentInstance())
vueDemi.onBeforeMount(fn);
else if (sync)
fn();
else
vueDemi.nextTick(fn);
}
function tryOnBeforeUnmount(fn) {
if (vueDemi.getCurrentInstance())
vueDemi.onBeforeUnmount(fn);
}
function tryOnMounted(fn, sync = true) {
if (vueDemi.getCurrentInstance())
vueDemi.onMounted(fn);
else if (sync)
fn();
else
vueDemi.nextTick(fn);
}
function tryOnUnmounted(fn) {
if (vueDemi.getCurrentInstance())
vueDemi.onUnmounted(fn);
}
function until(r) {
let isNot = false;
function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
let stop = null;
const watcher = new Promise((resolve) => {
stop = vueDemi.watch(r, (v) => {
if (condition(v) === !isNot) {
stop == null ? void 0 : stop();
resolve();
}
}, {
flush,
deep,
immediate: true
});
});
const promises = [watcher];
if (timeout) {
promises.push(promiseTimeout(timeout, throwOnTimeout).finally(() => {
stop == null ? void 0 : stop();
}));
}
return Promise.race(promises);
}
function toBe(value, options) {
return toMatch((v) => v === vueDemi.unref(value), options);
}
function toBeTruthy(options) {
return toMatch((v) => Boolean(v), options);
}
function toBeNull(options) {
return toBe(null, options);
}
function toBeUndefined(options) {
return toBe(void 0, options);
}
function toBeNaN(options) {
return toMatch(Number.isNaN, options);
}
function toContains(value, options) {
return toMatch((v) => {
const array = Array.from(v);
return array.includes(value) || array.includes(vueDemi.unref(value));
}, options);
}
function changed(options) {
return changedTimes(1, options);
}
function changedTimes(n = 1, options) {
let count = -1;
return toMatch(() => {
count += 1;
return count >= n;
}, options);
}
if (Array.isArray(vueDemi.unref(r))) {
const instance = {
toMatch,
toContains,
changed,
changedTimes,
get not() {
isNot = !isNot;
return this;
}
};
return instance;
} else {
const instance = {
toMatch,
toBe,
toBeTruthy,
toBeNull,
toBeNaN,
toBeUndefined,
changed,
changedTimes,
get not() {
isNot = !isNot;
return this;
}
};
return instance;
}
}
function useCounter(initialValue = 0, options = {}) {
const count = vueDemi.ref(initialValue);
const {
max = Infinity,
min = -Infinity
} = options;
const inc = (delta = 1) => count.value = Math.min(max, count.value + delta);
const dec = (delta = 1) => count.value = Math.max(min, count.value - delta);
const get = () => count.value;
const set = (val) => count.value = val;
const reset = (val = initialValue) => {
initialValue = val;
return set(val);
};
return { count, inc, dec, get, set, reset };
}
const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
const formatDate = (date, formatStr) => {
const years = date.getFullYear();
const month = date.getMonth();
const days = date.getDate();
const hours = date.getHours();
const minutes = date.getMinutes();
const seconds = date.getSeconds();
const milliseconds = date.getMilliseconds();
const matches = {
YY: String(years).slice(-2),
YYYY: years,
M: month + 1,
MM: `${month + 1}`.padStart(2, "0"),
D: String(days),
DD: `${days}`.padStart(2, "0"),
H: String(hours),
HH: `${hours}`.padStart(2, "0"),
h: `${hours % 12 || 12}`.padStart(1, "0"),
hh: `${hours % 12 || 12}`.padStart(2, "0"),
m: String(minutes),
mm: `${minutes}`.padStart(2, "0"),
s: String(seconds),
ss: `${seconds}`.padStart(2, "0"),
SSS: `${milliseconds}`.padStart(3, "0")
};
return formatStr.replace(REGEX_FORMAT, (match, $1) => $1 || matches[match]);
};
const normalizeDate = (date) => {
if (date === null)
return new Date(NaN);
if (date === void 0)
return new Date();
if (date instanceof Date)
return new Date(date);
if (typeof date === "string" && !/Z$/i.test(date)) {
const d = date.match(REGEX_PARSE);
if (d) {
const m = d[2] - 1 || 0;
const ms = (d[7] || "0").substring(0, 3);
return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
}
}
return new Date(date);
};
function useDateFormat(date, formatStr = "HH:mm:ss") {
return vueDemi.computed(() => formatDate(normalizeDate(vueDemi.unref(date)), vueDemi.unref(formatStr)));
}
function useIntervalFn(cb, interval = 1e3, options = {}) {
const {
immediate = true,
immediateCallback = false
} = options;
let timer = null;
const isActive = vueDemi.ref(false);
function clean() {
if (timer) {
clearInterval(timer);
timer = null;
}
}
function pause() {
isActive.value = false;
clean();
}
function resume() {
if (interval <= 0)
return;
isActive.value = true;
if (immediateCallback)
cb();
clean();
timer = setInterval(cb, vueDemi.unref(interval));
}
if (immediate && isClient)
resume();
if (vueDemi.isRef(interval)) {
const stopWatch = vueDemi.watch(interval, () => {
if (immediate && isClient)
resume();
});
tryOnScopeDispose(stopWatch);
}
tryOnScopeDispose(pause);
return {
isActive,
pause,
resume
};
}
var __defProp$5 = Object.defineProperty;
var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$5 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$7.call(b, prop))
__defNormalProp$5(a, prop, b[prop]);
if (__getOwnPropSymbols$7)
for (var prop of __getOwnPropSymbols$7(b)) {
if (__propIsEnum$7.call(b, prop))
__defNormalProp$5(a, prop, b[prop]);
}
return a;
};
function useInterval(interval = 1e3, options = {}) {
const {
controls: exposeControls = false,
immediate = true
} = options;
const counter = vueDemi.ref(0);
const controls = useIntervalFn(() => counter.value += 1, interval, { immediate });
if (exposeControls) {
return __spreadValues$5({
counter
}, controls);
} else {
return counter;
}
}
function useLastChanged(source, options = {}) {
var _a;
const ms = vueDemi.ref((_a = options.initialValue) != null ? _a : null);
vueDemi.watch(source, () => ms.value = timestamp(), options);
return ms;
}
function useTimeoutFn(cb, interval, options = {}) {
const {
immediate = true
} = options;
const isPending = vueDemi.ref(false);
let timer = null;
function clear() {
if (timer) {
clearTimeout(timer);
timer = null;
}
}
function stop() {
isPending.value = false;
clear();
}
function start(...args) {
clear();
isPending.value = true;
timer = setTimeout(() => {
isPending.value = false;
timer = null;
cb(...args);
}, vueDemi.unref(interval));
}
if (immediate) {
isPending.value = true;
if (isClient)
start();
}
tryOnScopeDispose(stop);
return {
isPending,
start,
stop
};
}
var __defProp$4 = Object.defineProperty;
var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$4 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$6.call(b, prop))
__defNormalProp$4(a, prop, b[prop]);
if (__getOwnPropSymbols$6)
for (var prop of __getOwnPropSymbols$6(b)) {
if (__propIsEnum$6.call(b, prop))
__defNormalProp$4(a, prop, b[prop]);
}
return a;
};
function useTimeout(interval = 1e3, options = {}) {
const {
controls: exposeControls = false
} = options;
const controls = useTimeoutFn(noop, interval, options);
const ready = vueDemi.computed(() => !controls.isPending.value);
if (exposeControls) {
return __spreadValues$4({
ready
}, controls);
} else {
return ready;
}
}
function useToggle(initialValue = false) {
if (vueDemi.isRef(initialValue)) {
return (value) => {
initialValue.value = typeof value === "boolean" ? value : !initialValue.value;
return initialValue.value;
};
} else {
const boolean = vueDemi.ref(initialValue);
const toggle = (value) => {
boolean.value = typeof value === "boolean" ? value : !boolean.value;
return boolean.value;
};
return [boolean, toggle];
}
}
var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
var __objRest$5 = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp$5.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols$5)
for (var prop of __getOwnPropSymbols$5(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum$5.call(source, prop))
target[prop] = source[prop];
}
return target;
};
function watchWithFilter(source, cb, options = {}) {
const _a = options, {
eventFilter = bypassFilter
} = _a, watchOptions = __objRest$5(_a, [
"eventFilter"
]);
return vueDemi.watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
}
var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
var __objRest$4 = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols$4)
for (var prop of __getOwnPropSymbols$4(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
target[prop] = source[prop];
}
return target;
};
function watchAtMost(source, cb, options) {
const _a = options, {
count
} = _a, watchOptions = __objRest$4(_a, [
"count"
]);
const current = vueDemi.ref(0);
const stop = watchWithFilter(source, (...args) => {
current.value += 1;
if (current.value >= vueDemi.unref(count))
vueDemi.nextTick(() => stop());
cb(...args);
}, watchOptions);
return { count: current, stop };
}
var __defProp$3 = Object.defineProperty;
var __defProps$3 = Object.defineProperties;
var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$3 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$3.call(b, prop))
__defNormalProp$3(a, prop, b[prop]);
if (__getOwnPropSymbols$3)
for (var prop of __getOwnPropSymbols$3(b)) {
if (__propIsEnum$3.call(b, prop))
__defNormalProp$3(a, prop, b[prop]);
}
return a;
};
var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
var __objRest$3 = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols$3)
for (var prop of __getOwnPropSymbols$3(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
target[prop] = source[prop];
}
return target;
};
function watchDebounced(source, cb, options = {}) {
const _a = options, {
debounce = 0
} = _a, watchOptions = __objRest$3(_a, [
"debounce"
]);
return watchWithFilter(source, cb, __spreadProps$3(__spreadValues$3({}, watchOptions), {
eventFilter: debounceFilter(debounce)
}));
}
var __defProp$2 = Object.defineProperty;
var __defProps$2 = Object.defineProperties;
var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$2 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$2.call(b, prop))
__defNormalProp$2(a, prop, b[prop]);
if (__getOwnPropSymbols$2)
for (var prop of __getOwnPropSymbols$2(b)) {
if (__propIsEnum$2.call(b, prop))
__defNormalProp$2(a, prop, b[prop]);
}
return a;
};
var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
var __objRest$2 = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols$2)
for (var prop of __getOwnPropSymbols$2(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
target[prop] = source[prop];
}
return target;
};
function watchIgnorable(source, cb, options = {}) {
const _a = options, {
eventFilter = bypassFilter
} = _a, watchOptions = __objRest$2(_a, [
"eventFilter"
]);
const filteredCb = createFilterWrapper(eventFilter, cb);
let ignoreUpdates;
let ignorePrevAsyncUpdates;
let stop;
if (watchOptions.flush === "sync") {
const ignore = vueDemi.ref(false);
ignorePrevAsyncUpdates = () => {
};
ignoreUpdates = (updater) => {
ignore.value = true;
updater();
ignore.value = false;
};
stop = vueDemi.watch(source, (...args) => {
if (!ignore.value)
filteredCb(...args);
}, watchOptions);
} else {
const disposables = [];
const ignoreCounter = vueDemi.ref(0);
const syncCounter = vueDemi.ref(0);
ignorePrevAsyncUpdates = () => {
ignoreCounter.value = syncCounter.value;
};
disposables.push(vueDemi.watch(source, () => {
syncCounter.value++;
}, __spreadProps$2(__spreadValues$2({}, watchOptions), { flush: "sync" })));
ignoreUpdates = (updater) => {
const syncCounterPrev = syncCounter.value;
updater();
ignoreCounter.value += syncCounter.value - syncCounterPrev;
};
disposables.push(vueDemi.watch(source, (...args) => {
const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
ignoreCounter.value = 0;
syncCounter.value = 0;
if (ignore)
return;
filteredCb(...args);
}, watchOptions));
stop = () => {
disposables.forEach((fn) => fn());
};
}
return { stop, ignoreUpdates, ignorePrevAsyncUpdates };
}
function watchOnce(source, cb, options) {
const stop = vueDemi.watch(source, (...args) => {
vueDemi.nextTick(() => stop());
return cb(...args);
}, options);
}
var __defProp$1 = Object.defineProperty;
var __defProps$1 = Object.defineProperties;
var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$1 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
if (__getOwnPropSymbols$1)
for (var prop of __getOwnPropSymbols$1(b)) {
if (__propIsEnum$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
}
return a;
};
var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
var __objRest$1 = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols$1)
for (var prop of __getOwnPropSymbols$1(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
target[prop] = source[prop];
}
return target;
};
function watchPausable(source, cb, options = {}) {
const _a = options, {
eventFilter: filter
} = _a, watchOptions = __objRest$1(_a, [
"eventFilter"
]);
const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
const stop = watchWithFilter(source, cb, __spreadProps$1(__spreadValues$1({}, watchOptions), {
eventFilter
}));
return { stop, pause, resume, isActive };
}
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
function watchThrottled(source, cb, options = {}) {
const _a = options, {
throttle = 0,
trailing = true,
leading = true
} = _a, watchOptions = __objRest(_a, [
"throttle",
"trailing",
"leading"
]);
return watchWithFilter(source, cb, __spreadProps(__spreadValues({}, watchOptions), {
eventFilter: throttleFilter(throttle, trailing, leading)
}));
}
function whenever(source, cb, options) {
return vueDemi.watch(source, (v, ov, onInvalidate) => {
if (v)
cb(v, ov, onInvalidate);
}, options);
}
exports.__onlyVue3 = __onlyVue3;
exports.and = logicAnd;
exports.assert = assert;
exports.autoResetRef = refAutoReset;
exports.bypassFilter = bypassFilter;
exports.clamp = clamp;
exports.computedEager = computedEager;
exports.computedWithControl = computedWithControl;
exports.containsProp = containsProp;
exports.controlledComputed = computedWithControl;
exports.controlledRef = controlledRef;
exports.createEventHook = createEventHook;
exports.createFilterWrapper = createFilterWrapper;
exports.createGlobalState = createGlobalState;
exports.createInjectionState = createInjectionState;
exports.createReactiveFn = reactify;
exports.createSharedComposable = createSharedComposable;
exports.createSingletonPromise = createSingletonPromise;
exports.debounceFilter = debounceFilter;
exports.debouncedRef = refDebounced;
exports.debouncedWatch = watchDebounced;
exports.directiveHooks = directiveHooks;
exports.eagerComputed = computedEager;
exports.extendRef = extendRef;
exports.formatDate = formatDate;
exports.get = get;
exports.identity = identity;
exports.ignorableWatch = watchIgnorable;
exports.increaseWithUnit = increaseWithUnit;
exports.invoke = invoke;
exports.isBoolean = isBoolean;
exports.isClient = isClient;
exports.isDef = isDef;
exports.isDefined = isDefined;
exports.isFunction = isFunction;
exports.isNumber = isNumber;
exports.isObject = isObject;
exports.isString = isString;
exports.isWindow = isWindow;
exports.logicAnd = logicAnd;
exports.logicNot = logicNot;
exports.logicOr = logicOr;
exports.makeDestructurable = makeDestructurable;
exports.noop = noop;
exports.normalizeDate = normalizeDate;
exports.not = logicNot;
exports.now = now;
exports.objectPick = objectPick;
exports.or = logicOr;
exports.pausableFilter = pausableFilter;
exports.pausableWatch = watchPausable;
exports.promiseTimeout = promiseTimeout;
exports.rand = rand;
exports.reactify = reactify;
exports.reactifyObject = reactifyObject;
exports.reactiveComputed = reactiveComputed;
exports.reactiveOmit = reactiveOmit;
exports.reactivePick = reactivePick;
exports.refAutoReset = refAutoReset;
exports.refDebounced = refDebounced;
exports.refDefault = refDefault;
exports.refThrottled = refThrottled;
exports.refWithControl = refWithControl;
exports.set = set;
exports.syncRef = syncRef;
exports.syncRefs = syncRefs;
exports.throttleFilter = throttleFilter;
exports.throttledRef = refThrottled;
exports.throttledWatch = watchThrottled;
exports.timestamp = timestamp;
exports.toReactive = toReactive;
exports.toRefs = toRefs;
exports.tryOnBeforeMount = tryOnBeforeMount;
exports.tryOnBeforeUnmount = tryOnBeforeUnmount;
exports.tryOnMounted = tryOnMounted;
exports.tryOnScopeDispose = tryOnScopeDispose;
exports.tryOnUnmounted = tryOnUnmounted;
exports.until = until;
exports.useCounter = useCounter;
exports.useDateFormat = useDateFormat;
exports.useDebounce = refDebounced;
exports.useDebounceFn = useDebounceFn;
exports.useInterval = useInterval;
exports.useIntervalFn = useIntervalFn;
exports.useLastChanged = useLastChanged;
exports.useThrottle = refThrottled;
exports.useThrottleFn = useThrottleFn;
exports.useTimeout = useTimeout;
exports.useTimeoutFn = useTimeoutFn;
exports.useToggle = useToggle;
exports.watchAtMost = watchAtMost;
exports.watchDebounced = watchDebounced;
exports.watchIgnorable = watchIgnorable;
exports.watchOnce = watchOnce;
exports.watchPausable = watchPausable;
exports.watchThrottled = watchThrottled;
exports.watchWithFilter = watchWithFilter;
exports.whenever = whenever;