@wfrog/vc-ui 1.0.0

package/dist/es/chunk/qY9OvNHY.mjs

@@ -0,0 +1,283 @@
+import { isRef, toValue, shallowRef, getCurrentScope, onScopeDispose, onMounted, nextTick, watch, readonly, getCurrentInstance, toRef as toRef$1, ref, customRef, hasInjectionContext, inject } from 'vue';
+
+//#endregion
+//#region tryOnScopeDispose/index.ts
+/**
+* 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;
+}
+
+//#endregion
+//#region provideLocal/map.ts
+const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+
+//#endregion
+//#region injectLocal/index.ts
+/**
+* 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__
+*/
+const 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);
+};
+
+//#endregion
+//#region utils/is.ts
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const isDef = (val) => typeof val !== "undefined";
+const toString = Object.prototype.toString;
+const isObject = (val) => toString.call(val) === "[object Object]";
+const noop = () => {};
+
+//#endregion
+//#region toRef/index.ts
+function toRef(...args) {
+	if (args.length !== 1) return toRef$1(...args);
+	const r = args[0];
+	return typeof r === "function" ? readonly(customRef(() => ({
+		get: r,
+		set: noop
+	}))) : ref(r);
+}
+
+//#endregion
+//#region utils/filters.ts
+/**
+* @internal
+*/
+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);
+		});
+	}
+	return wrapper;
+}
+const bypassFilter = (invoke$1) => {
+	return invoke$1();
+};
+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$1 = () => {
+			return lastValue = _invoke();
+		};
+		clear();
+		if (duration <= 0) {
+			lastExec = Date.now();
+			return invoke$1();
+		}
+		if (elapsed > duration) {
+			lastExec = Date.now();
+			if (leading || !isLeading) invoke$1();
+		} else if (trailing) lastValue = new Promise((resolve, reject) => {
+			lastRejector = rejectOnCancel ? reject : resolve;
+			timer = setTimeout(() => {
+				lastExec = Date.now();
+				isLeading = true;
+				resolve(invoke$1());
+				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(initialState === "active");
+	function pause() {
+		isActive.value = false;
+	}
+	function resume() {
+		isActive.value = true;
+	}
+	const eventFilter = (...args) => {
+		if (isActive.value) extendFilter(...args);
+	};
+	return {
+		isActive: readonly(isActive),
+		pause,
+		resume,
+		eventFilter
+	};
+}
+/**
+* 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);
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+
+//#endregion
+//#region utils/vue.ts
+function getLifeCycleTarget(target) {
+	return getCurrentInstance();
+}
+
+//#endregion
+//#region useThrottleFn/index.ts
+/**
+* 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);
+}
+
+//#endregion
+//#region watchWithFilter/index.ts
+function watchWithFilter(source, cb, options = {}) {
+	const { eventFilter = bypassFilter,...watchOptions } = options;
+	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+
+//#endregion
+//#region watchPausable/index.ts
+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
+	};
+}
+/** @deprecated use `watchPausable` instead */
+const pausableWatch = watchPausable;
+
+//#endregion
+//#region tryOnMounted/index.ts
+/**
+* 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()) onMounted(fn, target);
+	else if (sync) fn();
+	else nextTick(fn);
+}
+
+//#endregion
+//#region useToggle/index.ts
+/**
+* A boolean ref with a toggler
+*
+* @see https://vueuse.org/useToggle
+* @param [initialValue]
+* @param options
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useToggle(initialValue = false, options = {}) {
+	const { truthyValue = true, falsyValue = false } = options;
+	const valueIsRef = isRef(initialValue);
+	const _value = shallowRef(initialValue);
+	function toggle(value) {
+		if (arguments.length) {
+			_value.value = value;
+			return _value.value;
+		} else {
+			const truthy = toValue(truthyValue);
+			_value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
+			return _value.value;
+		}
+	}
+	if (valueIsRef) return toggle;
+	else return [_value, toggle];
+}
+
+//#endregion
+//#region watchImmediate/index.ts
+/**
+* Shorthand for watching value with {immediate: true}
+*
+* @see https://vueuse.org/watchImmediate
+*/
+function watchImmediate(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		immediate: true
+	});
+}
+
+export { useThrottleFn as a, isClient as b, tryOnMounted as c, toArray as d, pxValue as e, injectLocal as f, isObject as g, isDef as i, noop as n, pausableWatch as p, tryOnScopeDispose as t, useToggle as u, watchImmediate as w };

package/dist/es/chunk/su2Zrql0.mjs

@@ -0,0 +1,53 @@
+import { j as isFunction } from './E_WRn0OP.mjs';
+
+const REPEAT_INTERVAL = 100;
+const REPEAT_DELAY = 600;
+const SCOPE = "_RepeatClick";
+const vRepeatClick = {
+  beforeMount(el, binding) {
+    const value = binding.value;
+    const { interval = REPEAT_INTERVAL, delay = REPEAT_DELAY } = isFunction(value) ? {} : value;
+    let intervalId;
+    let delayId;
+    const handler = () => isFunction(value) ? value() : value.handler();
+    const clear = () => {
+      if (delayId) {
+        clearTimeout(delayId);
+        delayId = void 0;
+      }
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = void 0;
+      }
+    };
+    const start = (evt) => {
+      if (evt.button !== 0)
+        return;
+      clear();
+      handler();
+      document.addEventListener("mouseup", clear, { once: true });
+      delayId = setTimeout(() => {
+        intervalId = setInterval(() => {
+          handler();
+        }, interval);
+      }, delay);
+    };
+    el[SCOPE] = { start, clear };
+    el.addEventListener("mousedown", start);
+  },
+  unmounted(el) {
+    if (!el[SCOPE])
+      return;
+    const { start, clear } = el[SCOPE];
+    if (start) {
+      el.removeEventListener("mousedown", start);
+    }
+    if (clear) {
+      clear();
+      document.removeEventListener("mouseup", clear);
+    }
+    el[SCOPE] = null;
+  }
+};
+
+export { vRepeatClick as v };

package/dist/es/chunk/zfg5SOj1.mjs

@@ -0,0 +1,138 @@
+import { defineComponent, useSlots, ref, computed, createBlock, openBlock, Transition, unref, withCtx, withDirectives, createElementVNode, normalizeClass, createCommentVNode, renderSlot, resolveDynamicComponent, createElementBlock, createTextVNode, toDisplayString, Fragment, createVNode, vShow } from 'vue';
+import { E as ElIcon } from './DMHNh_tw.mjs';
+import { T as TypeComponentsMap, a as TypeComponents } from '../components/icon/icon2.mjs';
+import { c as buildProps, u as useNamespace, e as debugWarn } from './E_WRn0OP.mjs';
+import { k as keysOf } from './DVNTpOBR.mjs';
+import { _ as _export_sfc, w as withInstall } from './D389hx_T.mjs';
+
+const alertEffects = ["light", "dark"];
+const alertProps = buildProps({
+  title: {
+    type: String,
+    default: ""
+  },
+  description: {
+    type: String,
+    default: ""
+  },
+  type: {
+    type: String,
+    values: keysOf(TypeComponentsMap),
+    default: "info"
+  },
+  closable: {
+    type: Boolean,
+    default: true
+  },
+  closeText: {
+    type: String,
+    default: ""
+  },
+  showIcon: Boolean,
+  center: Boolean,
+  effect: {
+    type: String,
+    values: alertEffects,
+    default: "light"
+  },
+  showAfter: Number,
+  hideAfter: Number,
+  autoClose: Number
+});
+const alertEmits = {
+  close: (evt) => evt instanceof MouseEvent
+};
+
+const __default__ = defineComponent({
+  name: "ElAlert"
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: alertProps,
+  emits: alertEmits,
+  setup(__props, { emit }) {
+    const props = __props;
+    const { Close } = TypeComponents;
+    const slots = useSlots();
+    const ns = useNamespace("alert");
+    const visible = ref(true);
+    const iconComponent = computed(() => TypeComponentsMap[props.type]);
+    const hasDesc = computed(() => !!(props.description || slots.default));
+    const close = (evt) => {
+      visible.value = false;
+      emit("close", evt);
+    };
+    if (props.showAfter || props.hideAfter || props.autoClose) {
+      debugWarn("el-alert", "The `show-after`, `hide-after`, and `auto-close` attributes were removed after 2.11.8. Please use `v-if` and `v-show` to manually replace them, visit: https://github.com/element-plus/element-plus/pull/22560");
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, {
+        name: unref(ns).b("fade"),
+        persisted: ""
+      }, {
+        default: withCtx(() => [
+          withDirectives(createElementVNode("div", {
+            class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.type), unref(ns).is("center", _ctx.center), unref(ns).is(_ctx.effect)]),
+            role: "alert"
+          }, [
+            _ctx.showIcon && (_ctx.$slots.icon || unref(iconComponent)) ? (openBlock(), createBlock(unref(ElIcon), {
+              key: 0,
+              class: normalizeClass([unref(ns).e("icon"), unref(ns).is("big", unref(hasDesc))])
+            }, {
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "icon", {}, () => [
+                  (openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
+                ])
+              ]),
+              _: 3
+            }, 8, ["class"])) : createCommentVNode("v-if", true),
+            createElementVNode("div", {
+              class: normalizeClass(unref(ns).e("content"))
+            }, [
+              _ctx.title || _ctx.$slots.title ? (openBlock(), createElementBlock("span", {
+                key: 0,
+                class: normalizeClass([unref(ns).e("title"), { "with-description": unref(hasDesc) }])
+              }, [
+                renderSlot(_ctx.$slots, "title", {}, () => [
+                  createTextVNode(toDisplayString(_ctx.title), 1)
+                ])
+              ], 2)) : createCommentVNode("v-if", true),
+              unref(hasDesc) ? (openBlock(), createElementBlock("p", {
+                key: 1,
+                class: normalizeClass(unref(ns).e("description"))
+              }, [
+                renderSlot(_ctx.$slots, "default", {}, () => [
+                  createTextVNode(toDisplayString(_ctx.description), 1)
+                ])
+              ], 2)) : createCommentVNode("v-if", true),
+              _ctx.closable ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+                _ctx.closeText ? (openBlock(), createElementBlock("div", {
+                  key: 0,
+                  class: normalizeClass([unref(ns).e("close-btn"), unref(ns).is("customed")]),
+                  onClick: close
+                }, toDisplayString(_ctx.closeText), 3)) : (openBlock(), createBlock(unref(ElIcon), {
+                  key: 1,
+                  class: normalizeClass(unref(ns).e("close-btn")),
+                  onClick: close
+                }, {
+                  default: withCtx(() => [
+                    createVNode(unref(Close))
+                  ]),
+                  _: 1
+                }, 8, ["class"]))
+              ], 64)) : createCommentVNode("v-if", true)
+            ], 2)
+          ], 2), [
+            [vShow, visible.value]
+          ])
+        ]),
+        _: 3
+      }, 8, ["name"]);
+    };
+  }
+});
+var Alert = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "alert.vue"]]);
+
+const ElAlert = withInstall(Alert);
+
+export { ElAlert as E };

package/dist/es/components/awesome-icon/awesome-icon.d.ts

@@ -0,0 +1,6 @@
+export interface IAwesomeIconProps {
+    name: string;
+    mode?: 'css' | 'svg';
+    size?: number | string;
+    color?: string;
+}

package/dist/es/components/awesome-icon/awesome-icon.mjs

@@ -0,0 +1,41 @@
+import { defineComponent, computed, onMounted, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref } from 'vue';
+import { d as defaultWindow, i as index } from '../../chunk/BdDihk0t.mjs';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "awesome-icon",
+  props: {
+    name: {},
+    mode: { default: "css" },
+    size: {},
+    color: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const mySize = computed(() => {
+      if (props.size && Number.isNaN(+props.size)) {
+        return props.size;
+      }
+      return `${props.size}px`;
+    });
+    async function loaderSource() {
+      const cdn = props.mode === "svg" ? "fontawesomeJs" : "fontawesomeCss";
+      await index.loadCdnSingle(cdn);
+    }
+    onMounted(() => {
+      if (defaultWindow) {
+        if (!defaultWindow.VC?.isAwesomeIconLock) {
+          defaultWindow.VC = { ...defaultWindow.VC, isAwesomeIconLock: true };
+          loaderSource();
+        }
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("i", {
+        class: normalizeClass(["awesome-icon", props.name]),
+        style: normalizeStyle({ fontSize: unref(mySize), color: __props.color })
+      }, null, 6);
+    };
+  }
+});
+
+export { _sfc_main as _ };

package/dist/es/components/awesome-icon/awesome-icon.vue.d.ts

@@ -0,0 +1,5 @@
+import { IAwesomeIconProps } from './awesome-icon';
+declare const _default: import('vue').DefineComponent<IAwesomeIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IAwesomeIconProps> & Readonly<{}>, {
+    mode: "css" | "svg";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/es/components/awesome-icon/index.d.ts

@@ -0,0 +1,4 @@
+import { SFCWithInstall } from '../../utils/typescript';
+import { default as Component } from './awesome-icon.vue';
+export declare const VcAwesomeIcon: SFCWithInstall<typeof Component>;
+export default VcAwesomeIcon;

package/dist/es/components/awesome-icon/index.mjs

@@ -0,0 +1,6 @@
+import { w as withInstall } from '../../chunk/ClZGuAIb.mjs';
+import { _ as _sfc_main } from './awesome-icon.mjs';
+
+const VcAwesomeIcon = withInstall(_sfc_main);
+
+export { VcAwesomeIcon, VcAwesomeIcon as default };

package/dist/es/components/backbottom/backbottom.d.ts

@@ -0,0 +1,7 @@
+export interface IBackBottomProps {
+    target?: HTMLElement | string | null;
+    right?: number;
+    bottom?: number;
+    visibilityHeight?: number;
+    parent?: boolean;
+}