@wfrog/vc-ui 1.0.0

package/dist/es/chunk/D3uV7vm-.mjs

@@ -0,0 +1,45 @@
+import { isRef, computed, watch, onScopeDispose } from 'vue';
+import { t as throwError, u as useNamespace } from './E_WRn0OP.mjs';
+import { h as hasClass, b as addClass, g as getStyle, r as removeClass } from './D5259bwd.mjs';
+import { e as getScrollBarWidth } from './DyDMGLoF.mjs';
+
+const useLockscreen = (trigger, options = {}) => {
+  if (!isRef(trigger)) {
+    throwError("[useLockscreen]", "You need to pass a ref param to this function");
+  }
+  const ns = options.ns || useNamespace("popup");
+  const hiddenCls = computed(() => ns.bm("parent", "hidden"));
+  let scrollBarWidth = 0;
+  let withoutHiddenClass = false;
+  let bodyWidth = "0";
+  const cleanup = () => {
+    setTimeout(() => {
+      if (typeof document === "undefined")
+        return;
+      if (withoutHiddenClass && document) {
+        document.body.style.width = bodyWidth;
+        removeClass(document.body, hiddenCls.value);
+      }
+    }, 200);
+  };
+  watch(trigger, (val) => {
+    if (!val) {
+      cleanup();
+      return;
+    }
+    withoutHiddenClass = !hasClass(document.body, hiddenCls.value);
+    if (withoutHiddenClass) {
+      bodyWidth = document.body.style.width;
+      addClass(document.body, hiddenCls.value);
+    }
+    scrollBarWidth = getScrollBarWidth(ns.namespace.value);
+    const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
+    const bodyOverflowY = getStyle(document.body, "overflowY");
+    if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
+      document.body.style.width = `calc(100% - ${scrollBarWidth}px)`;
+    }
+  });
+  onScopeDispose(() => cleanup());
+};
+
+export { useLockscreen as u };

package/dist/es/chunk/D5259bwd.mjs

@@ -0,0 +1,50 @@
+import { f as isNumber, I as isStringNumber, h as isString, e as debugWarn, o as isClient, J as camelize } from './E_WRn0OP.mjs';
+
+const SCOPE = "utils/dom/style";
+const classNameToArray = (cls = "") => cls.split(" ").filter((item) => !!item.trim());
+const hasClass = (el, cls) => {
+  if (!el || !cls)
+    return false;
+  if (cls.includes(" "))
+    throw new Error("className should not contain space.");
+  return el.classList.contains(cls);
+};
+const addClass = (el, cls) => {
+  if (!el || !cls.trim())
+    return;
+  el.classList.add(...classNameToArray(cls));
+};
+const removeClass = (el, cls) => {
+  if (!el || !cls.trim())
+    return;
+  el.classList.remove(...classNameToArray(cls));
+};
+const getStyle = (element, styleName) => {
+  var _a;
+  if (!isClient || !element || !styleName)
+    return "";
+  let key = camelize(styleName);
+  if (key === "float")
+    key = "cssFloat";
+  try {
+    const style = element.style[key];
+    if (style)
+      return style;
+    const computed = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(element, "");
+    return computed ? computed[key] : "";
+  } catch (e) {
+    return element.style[key];
+  }
+};
+function addUnit(value, defaultUnit = "px") {
+  if (!value && value !== 0)
+    return "";
+  if (isNumber(value) || isStringNumber(value)) {
+    return `${value}${defaultUnit}`;
+  } else if (isString(value)) {
+    return value;
+  }
+  debugWarn(SCOPE, "binding value must be a string or number");
+}
+
+export { addUnit as a, addClass as b, getStyle as g, hasClass as h, removeClass as r };

package/dist/es/chunk/DMHNh_tw.mjs

@@ -0,0 +1,49 @@
+import { defineComponent, computed, createElementBlock, openBlock, mergeProps, unref, renderSlot } from 'vue';
+import { c as buildProps, d as definePropType, u as useNamespace } from './E_WRn0OP.mjs';
+import { _ as _export_sfc, w as withInstall } from './D389hx_T.mjs';
+import { a as addUnit } from './D5259bwd.mjs';
+
+const iconProps = buildProps({
+  size: {
+    type: definePropType([Number, String])
+  },
+  color: {
+    type: String
+  }
+});
+
+const __default__ = defineComponent({
+  name: "ElIcon",
+  inheritAttrs: false
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: iconProps,
+  setup(__props) {
+    const props = __props;
+    const ns = useNamespace("icon");
+    const style = computed(() => {
+      const { size, color } = props;
+      const fontSize = addUnit(size);
+      if (!fontSize && !color)
+        return {};
+      return {
+        fontSize,
+        "--color": color
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("i", mergeProps({
+        class: unref(ns).b(),
+        style: unref(style)
+      }, _ctx.$attrs), [
+        renderSlot(_ctx.$slots, "default")
+      ], 16);
+    };
+  }
+});
+var Icon = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "icon.vue"]]);
+
+const ElIcon = withInstall(Icon);
+
+export { ElIcon as E };

package/dist/es/chunk/DVNTpOBR.mjs

@@ -0,0 +1,4 @@
+const keysOf = (arr) => Object.keys(arr);
+const entriesOf = (arr) => Object.entries(arr);
+
+export { entriesOf as e, keysOf as k };

package/dist/es/chunk/DZACQ9LT.mjs

@@ -0,0 +1,95 @@
+import { inject, ref, getCurrentInstance, computed, onMounted, watch, toRef, onUnmounted, unref } from 'vue';
+import { b as formContextKey, f as formItemContextKey, u as useId } from './8rLUmOVR.mjs';
+import { a as useGlobalSize } from './CS4VKsqy.mjs';
+
+const useFormItem = () => {
+  const form = inject(formContextKey, void 0);
+  const formItem = inject(formItemContextKey, void 0);
+  return {
+    form,
+    formItem
+  };
+};
+const useFormItemInputId = (props, {
+  formItemContext,
+  disableIdGeneration,
+  disableIdManagement
+}) => {
+  if (!disableIdGeneration) {
+    disableIdGeneration = ref(false);
+  }
+  if (!disableIdManagement) {
+    disableIdManagement = ref(false);
+  }
+  const instance = getCurrentInstance();
+  const inLabel = () => {
+    let parent = instance == null ? void 0 : instance.parent;
+    while (parent) {
+      if (parent.type.name === "ElFormItem") {
+        return false;
+      }
+      if (parent.type.name === "ElLabelWrap") {
+        return true;
+      }
+      parent = parent.parent;
+    }
+    return false;
+  };
+  const inputId = ref();
+  let idUnwatch = void 0;
+  const isLabeledByFormItem = computed(() => {
+    var _a;
+    return !!(!(props.label || props.ariaLabel) && formItemContext && formItemContext.inputIds && ((_a = formItemContext.inputIds) == null ? void 0 : _a.length) <= 1);
+  });
+  onMounted(() => {
+    idUnwatch = watch([toRef(props, "id"), disableIdGeneration], ([id, disableIdGeneration2]) => {
+      const newId = id != null ? id : !disableIdGeneration2 ? useId().value : void 0;
+      if (newId !== inputId.value) {
+        if ((formItemContext == null ? void 0 : formItemContext.removeInputId) && !inLabel()) {
+          inputId.value && formItemContext.removeInputId(inputId.value);
+          if (!(disableIdManagement == null ? void 0 : disableIdManagement.value) && !disableIdGeneration2 && newId) {
+            formItemContext.addInputId(newId);
+          }
+        }
+        inputId.value = newId;
+      }
+    }, { immediate: true });
+  });
+  onUnmounted(() => {
+    idUnwatch && idUnwatch();
+    if (formItemContext == null ? void 0 : formItemContext.removeInputId) {
+      inputId.value && formItemContext.removeInputId(inputId.value);
+    }
+  });
+  return {
+    isLabeledByFormItem,
+    inputId
+  };
+};
+
+const useProp = (name) => {
+  const vm = getCurrentInstance();
+  return computed(() => {
+    var _a, _b;
+    return (_b = (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$props) == null ? void 0 : _b[name];
+  });
+};
+
+const useFormSize = (fallback, ignore = {}) => {
+  const emptyRef = ref(void 0);
+  const size = ignore.prop ? emptyRef : useProp("size");
+  const globalConfig = ignore.global ? emptyRef : useGlobalSize();
+  const form = ignore.form ? { size: void 0 } : inject(formContextKey, void 0);
+  const formItem = ignore.formItem ? { size: void 0 } : inject(formItemContextKey, void 0);
+  return computed(() => size.value || unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig.value || "");
+};
+const useFormDisabled = (fallback) => {
+  const disabled = useProp("disabled");
+  const form = inject(formContextKey, void 0);
+  return computed(() => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = disabled.value) != null ? _a : unref(fallback)) != null ? _b : form == null ? void 0 : form.disabled) != null ? _c : false;
+  });
+};
+
+export { useFormItemInputId as a, useFormDisabled as b, useFormSize as c, useFormItem as u };

package/dist/es/chunk/De_EXLIy.mjs

@@ -0,0 +1,22 @@
+import { computed, getCurrentInstance } from 'vue';
+import { e as debugWarn, n as fromPairs } from './E_WRn0OP.mjs';
+
+const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
+const LISTENER_PREFIX = /^on[A-Z]/;
+const useAttrs = (params = {}) => {
+  const { excludeListeners = false, excludeKeys } = params;
+  const allExcludeKeys = computed(() => {
+    return ((excludeKeys == null ? void 0 : excludeKeys.value) || []).concat(DEFAULT_EXCLUDE_KEYS);
+  });
+  const instance = getCurrentInstance();
+  if (!instance) {
+    debugWarn("use-attrs", "getCurrentInstance() returned null. useAttrs() must be called at the top of a setup function");
+    return computed(() => ({}));
+  }
+  return computed(() => {
+    var _a;
+    return fromPairs(Object.entries((_a = instance.proxy) == null ? void 0 : _a.$attrs).filter(([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
+  });
+};
+
+export { useAttrs as u };

package/dist/es/chunk/Dh4jaUSg.mjs

@@ -0,0 +1,89 @@
+import { getCurrentInstance, inject, ref, computed, unref, provide } from 'vue';
+import { u as useNamespace, E as defaultNamespace, e as debugWarn, K as namespaceContextKey } from './E_WRn0OP.mjs';
+import { u as useZIndex, d as defaultInitialZIndex, z as zIndexContextKey } from './CEm0brzD.mjs';
+import { u as useLocale, l as localeContextKey } from './aibQ9WSZ.mjs';
+import { S as SIZE_INJECTION_KEY } from './CS4VKsqy.mjs';
+import { e as emptyValuesContextKey } from './C5hWsUfD.mjs';
+import { k as keysOf } from './DVNTpOBR.mjs';
+
+const configProviderContextKey = Symbol();
+
+const globalConfig = ref();
+function useGlobalConfig(key, defaultValue = void 0) {
+  const config = getCurrentInstance() ? inject(configProviderContextKey, globalConfig) : globalConfig;
+  if (key) {
+    return computed(() => {
+      var _a, _b;
+      return (_b = (_a = config.value) == null ? void 0 : _a[key]) != null ? _b : defaultValue;
+    });
+  } else {
+    return config;
+  }
+}
+function useGlobalComponentSettings(block, sizeFallback) {
+  const config = useGlobalConfig();
+  const ns = useNamespace(block, computed(() => {
+    var _a;
+    return ((_a = config.value) == null ? void 0 : _a.namespace) || defaultNamespace;
+  }));
+  const locale = useLocale(computed(() => {
+    var _a;
+    return (_a = config.value) == null ? void 0 : _a.locale;
+  }));
+  const zIndex = useZIndex(computed(() => {
+    var _a;
+    return ((_a = config.value) == null ? void 0 : _a.zIndex) || defaultInitialZIndex;
+  }));
+  const size = computed(() => {
+    var _a;
+    return unref(sizeFallback) || ((_a = config.value) == null ? void 0 : _a.size) || "";
+  });
+  provideGlobalConfig(computed(() => unref(config) || {}));
+  return {
+    ns,
+    locale,
+    zIndex,
+    size
+  };
+}
+const provideGlobalConfig = (config, app, global = false) => {
+  var _a;
+  const inSetup = !!getCurrentInstance();
+  const oldConfig = inSetup ? useGlobalConfig() : void 0;
+  const provideFn = (_a = void 0 ) != null ? _a : inSetup ? provide : void 0;
+  if (!provideFn) {
+    debugWarn("provideGlobalConfig", "provideGlobalConfig() can only be used inside setup().");
+    return;
+  }
+  const context = computed(() => {
+    const cfg = unref(config);
+    if (!(oldConfig == null ? void 0 : oldConfig.value))
+      return cfg;
+    return mergeConfig(oldConfig.value, cfg);
+  });
+  provideFn(configProviderContextKey, context);
+  provideFn(localeContextKey, computed(() => context.value.locale));
+  provideFn(namespaceContextKey, computed(() => context.value.namespace));
+  provideFn(zIndexContextKey, computed(() => context.value.zIndex));
+  provideFn(SIZE_INJECTION_KEY, {
+    size: computed(() => context.value.size || "")
+  });
+  provideFn(emptyValuesContextKey, computed(() => ({
+    emptyValues: context.value.emptyValues,
+    valueOnClear: context.value.valueOnClear
+  })));
+  if (global || !globalConfig.value) {
+    globalConfig.value = context.value;
+  }
+  return context;
+};
+const mergeConfig = (a, b) => {
+  const keys = [.../* @__PURE__ */ new Set([...keysOf(a), ...keysOf(b)])];
+  const obj = {};
+  for (const key of keys) {
+    obj[key] = b[key] !== void 0 ? b[key] : a[key];
+  }
+  return obj;
+};
+
+export { useGlobalComponentSettings as a, useGlobalConfig as u };