npm - @funcho/ui - Versions diffs - 1.0.0 - Mend

@funcho/ui 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1050) hide show

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/hooks/use-namespace/index.mjs ADDED Viewed

@@ -0,0 +1,76 @@
+import { getCurrentInstance, inject, ref, computed, unref } from 'vue';
+const defaultNamespace = "el";
+const statePrefix = "is-";
+const _bem = (namespace, block, blockSuffix, element, modifier) => {
+  let cls = `${namespace}-${block}`;
+  if (blockSuffix) {
+    cls += `-${blockSuffix}`;
+  }
+  if (element) {
+    cls += `__${element}`;
+  }
+  if (modifier) {
+    cls += `--${modifier}`;
+  }
+  return cls;
+};
+const namespaceContextKey = Symbol("namespaceContextKey");
+const useGetDerivedNamespace = (namespaceOverrides) => {
+  const derivedNamespace = (getCurrentInstance() ? inject(namespaceContextKey, ref(defaultNamespace)) : ref(defaultNamespace));
+  const namespace = computed(() => {
+    return unref(derivedNamespace) || defaultNamespace;
+  });
+  return namespace;
+};
+const useNamespace = (block, namespaceOverrides) => {
+  const namespace = useGetDerivedNamespace();
+  const b = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
+  const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
+  const m = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
+  const be = (blockSuffix, element) => blockSuffix && element ? _bem(namespace.value, block, blockSuffix, element, "") : "";
+  const em = (element, modifier) => element && modifier ? _bem(namespace.value, block, "", element, modifier) : "";
+  const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(namespace.value, block, blockSuffix, "", modifier) : "";
+  const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(namespace.value, block, blockSuffix, element, modifier) : "";
+  const is = (name, ...args) => {
+    const state = args.length >= 1 ? args[0] : true;
+    return name && state ? `${statePrefix}${name}` : "";
+  };
+  const cssVar = (object) => {
+    const styles = {};
+    for (const key in object) {
+      if (object[key]) {
+        styles[`--${namespace.value}-${key}`] = object[key];
+      }
+    }
+    return styles;
+  };
+  const cssVarBlock = (object) => {
+    const styles = {};
+    for (const key in object) {
+      if (object[key]) {
+        styles[`--${namespace.value}-${block}-${key}`] = object[key];
+      }
+    }
+    return styles;
+  };
+  const cssVarName = (name) => `--${namespace.value}-${name}`;
+  const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
+  return {
+    namespace,
+    b,
+    e,
+    m,
+    be,
+    em,
+    bm,
+    bem,
+    is,
+    cssVar,
+    cssVarName,
+    cssVarBlock,
+    cssVarBlockName
+  };
+};
+export { defaultNamespace, namespaceContextKey, useGetDerivedNamespace, useNamespace };

@@ -0,0 +1,74 @@
+import { shallowRef, defineComponent, h, triggerRef, onMounted, isVNode } from 'vue';
+import { flattedChildren } from '../../utils/vue/vnode.mjs';
+const getOrderedChildren = (vm, childComponentName, children) => {
+  const nodes = flattedChildren(vm.subTree).filter(
+    (n) => {
+      var _a;
+      return isVNode(n) && ((_a = n.type) == null ? void 0 : _a.name) === childComponentName && !!n.component;
+    }
+  );
+  const uids = nodes.map((n) => n.component.uid);
+  return uids.map((uid) => children[uid]).filter((p) => !!p);
+};
+const useOrderedChildren = (vm, childComponentName) => {
+  const children = shallowRef({});
+  const orderedChildren = shallowRef([]);
+  const nodesMap = /* @__PURE__ */ new WeakMap();
+  const addChild = (child) => {
+    children.value[child.uid] = child;
+    triggerRef(children);
+    onMounted(() => {
+      const childNode = child.getVnode().el;
+      const parentNode = childNode.parentNode;
+      if (!nodesMap.has(parentNode)) {
+        nodesMap.set(parentNode, []);
+        const originalFn = parentNode.insertBefore.bind(parentNode);
+        parentNode.insertBefore = (node, anchor) => {
+          const shouldSortChildren = nodesMap.get(parentNode).some((el) => node === el || anchor === el);
+          if (shouldSortChildren)
+            triggerRef(children);
+          return originalFn(node, anchor);
+        };
+      }
+      nodesMap.get(parentNode).push(childNode);
+    });
+  };
+  const removeChild = (child) => {
+    delete children.value[child.uid];
+    triggerRef(children);
+    const childNode = child.getVnode().el;
+    const parentNode = childNode.parentNode;
+    const childNodes = nodesMap.get(parentNode);
+    const index = childNodes.indexOf(childNode);
+    childNodes.splice(index, 1);
+  };
+  const sortChildren = () => {
+    orderedChildren.value = getOrderedChildren(
+      vm,
+      childComponentName,
+      children.value
+    );
+  };
+  const IsolatedRenderer = (props) => {
+    return props.render();
+  };
+  const ChildrenSorter = defineComponent({
+    setup(_, { slots }) {
+      return () => {
+        sortChildren();
+        return slots.default ? h(IsolatedRenderer, {
+          render: slots.default
+        }) : null;
+      };
+    }
+  });
+  return {
+    children: orderedChildren,
+    addChild,
+    removeChild,
+    ChildrenSorter
+  };
+};
+export { useOrderedChildren };

@@ -0,0 +1,113 @@
+import { computed, unref, shallowRef, ref, watch, onBeforeUnmount } from 'vue';
+import { createPopper as yn } from '../../../../../../@sxzz_popperjs-es@2.11.7/node_modules/@sxzz/popperjs-es/dist/index.mjs';
+import fromPairs from '../../../../../../lodash-es@4.17.21/node_modules/lodash-es/fromPairs.mjs';
+const usePopper = (referenceElementRef, popperElementRef, opts = {}) => {
+  const stateUpdater = {
+    name: "updateState",
+    enabled: true,
+    phase: "write",
+    fn: ({ state }) => {
+      const derivedState = deriveState(state);
+      Object.assign(states.value, derivedState);
+    },
+    requires: ["computeStyles"]
+  };
+  const options = computed(() => {
+    const { onFirstUpdate, placement, strategy, modifiers } = unref(opts);
+    return {
+      onFirstUpdate,
+      placement: placement || "bottom",
+      strategy: strategy || "absolute",
+      modifiers: [
+        ...modifiers || [],
+        stateUpdater,
+        { name: "applyStyles", enabled: false }
+      ]
+    };
+  });
+  const instanceRef = shallowRef();
+  const states = ref({
+    styles: {
+      popper: {
+        position: unref(options).strategy,
+        left: "0",
+        top: "0"
+      },
+      arrow: {
+        position: "absolute"
+      }
+    },
+    attributes: {}
+  });
+  const destroy = () => {
+    if (!instanceRef.value)
+      return;
+    instanceRef.value.destroy();
+    instanceRef.value = void 0;
+  };
+  watch(
+    options,
+    (newOptions) => {
+      const instance = unref(instanceRef);
+      if (instance) {
+        instance.setOptions(newOptions);
+      }
+    },
+    {
+      deep: true
+    }
+  );
+  watch(
+    [referenceElementRef, popperElementRef],
+    ([referenceElement, popperElement]) => {
+      destroy();
+      if (!referenceElement || !popperElement)
+        return;
+      instanceRef.value = yn(
+        referenceElement,
+        popperElement,
+        unref(options)
+      );
+    }
+  );
+  onBeforeUnmount(() => {
+    destroy();
+  });
+  return {
+    state: computed(() => {
+      var _a;
+      return { ...((_a = unref(instanceRef)) == null ? void 0 : _a.state) || {} };
+    }),
+    styles: computed(() => unref(states).styles),
+    attributes: computed(() => unref(states).attributes),
+    update: () => {
+      var _a;
+      return (_a = unref(instanceRef)) == null ? void 0 : _a.update();
+    },
+    forceUpdate: () => {
+      var _a;
+      return (_a = unref(instanceRef)) == null ? void 0 : _a.forceUpdate();
+    },
+    instanceRef: computed(() => unref(instanceRef))
+  };
+};
+function deriveState(state) {
+  const elements = Object.keys(state.elements);
+  const styles = fromPairs(
+    elements.map(
+      (element) => [element, state.styles[element] || {}]
+    )
+  );
+  const attributes = fromPairs(
+    elements.map(
+      (element) => [element, state.attributes[element]]
+    )
+  );
+  return {
+    styles,
+    attributes
+  };
+}
+export { usePopper };

@@ -0,0 +1,39 @@
+import { onBeforeMount, computed } from 'vue';
+import { useGetDerivedNamespace } from '../use-namespace/index.mjs';
+import { useIdInjection } from '../use-id/index.mjs';
+import { isClient } from '../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs';
+const usePopperContainerId = () => {
+  const namespace = useGetDerivedNamespace();
+  const idInjection = useIdInjection();
+  const id = computed(() => {
+    return `${namespace.value}-popper-container-${idInjection.prefix}`;
+  });
+  const selector = computed(() => `#${id.value}`);
+  return {
+    id,
+    selector
+  };
+};
+const createContainer = (id) => {
+  const container = document.createElement("div");
+  container.id = id;
+  document.body.appendChild(container);
+  return container;
+};
+const usePopperContainer = () => {
+  const { id, selector } = usePopperContainerId();
+  onBeforeMount(() => {
+    if (!isClient)
+      return;
+    if (process.env.NODE_ENV === "test" || !document.body.querySelector(selector.value)) {
+      createContainer(id.value);
+    }
+  });
+  return {
+    id,
+    selector
+  };
+};
+export { usePopperContainer, usePopperContainerId };

@@ -0,0 +1,11 @@
+import { getCurrentInstance, computed } from 'vue';
+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];
+  });
+};
+export { useProp };

@@ -0,0 +1,24 @@
+import { NOOP } from '../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.mjs';
+const useSameTarget = (handleClick) => {
+  if (!handleClick) {
+    return { onClick: NOOP, onMousedown: NOOP, onMouseup: NOOP };
+  }
+  let mousedownTarget = false;
+  let mouseupTarget = false;
+  const onClick = (e) => {
+    if (mousedownTarget && mouseupTarget) {
+      handleClick(e);
+    }
+    mousedownTarget = mouseupTarget = false;
+  };
+  const onMousedown = (e) => {
+    mousedownTarget = e.target === e.currentTarget;
+  };
+  const onMouseup = (e) => {
+    mouseupTarget = e.target === e.currentTarget;
+  };
+  return { onClick, onMousedown, onMouseup };
+};
+export { useSameTarget };

@@ -0,0 +1,18 @@
+import { inject, computed, unref } from 'vue';
+import { buildProp } from '../../utils/vue/props/runtime.mjs';
+import { componentSizes } from '../../constants/size.mjs';
+const useSizeProp = buildProp({
+  type: String,
+  values: componentSizes,
+  required: false
+});
+const SIZE_INJECTION_KEY = Symbol("size");
+const useGlobalSize = () => {
+  const injectedSize = inject(SIZE_INJECTION_KEY, {});
+  return computed(() => {
+    return unref(injectedSize.size) || "";
+  });
+};
+export { SIZE_INJECTION_KEY, useGlobalSize, useSizeProp };

@@ -0,0 +1,17 @@
+import { tryOnScopeDispose } from '../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs';
+function useTimeout() {
+  let timeoutHandle;
+  const registerTimeout = (fn, delay) => {
+    cancelTimeout();
+    timeoutHandle = window.setTimeout(fn, delay);
+  };
+  const cancelTimeout = () => window.clearTimeout(timeoutHandle);
+  tryOnScopeDispose(() => cancelTimeout());
+  return {
+    registerTimeout,
+    cancelTimeout
+  };
+}
+export { useTimeout };

@@ -0,0 +1,40 @@
+import { getCurrentInstance, inject, computed, unref, ref } from 'vue';
+import { isNumber } from '../../utils/types.mjs';
+import { debugWarn } from '../../utils/error.mjs';
+import { isClient } from '../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs';
+const initial = {
+  current: 0
+};
+const zIndex = ref(0);
+const defaultInitialZIndex = 2e3;
+const ZINDEX_INJECTION_KEY = Symbol("elZIndexContextKey");
+const zIndexContextKey = Symbol("zIndexContextKey");
+const useZIndex = (zIndexOverrides) => {
+  const increasingInjection = getCurrentInstance() ? inject(ZINDEX_INJECTION_KEY, initial) : initial;
+  const zIndexInjection = (getCurrentInstance() ? inject(zIndexContextKey, void 0) : void 0);
+  const initialZIndex = computed(() => {
+    const zIndexFromInjection = unref(zIndexInjection);
+    return isNumber(zIndexFromInjection) ? zIndexFromInjection : defaultInitialZIndex;
+  });
+  const currentZIndex = computed(() => initialZIndex.value + zIndex.value);
+  const nextZIndex = () => {
+    increasingInjection.current++;
+    zIndex.value = increasingInjection.current;
+    return currentZIndex.value;
+  };
+  if (!isClient && !inject(ZINDEX_INJECTION_KEY)) {
+    debugWarn(
+      "ZIndexInjection",
+      `Looks like you are using server rendering, you must provide a z-index provider to ensure the hydration process to be succeed
+usage: app.provide(ZINDEX_INJECTION_KEY, { current: 0 })`
+    );
+  }
+  return {
+    initialZIndex,
+    currentZIndex,
+    nextZIndex
+  };
+};
+export { ZINDEX_INJECTION_KEY, defaultInitialZIndex, useZIndex, zIndexContextKey };

@@ -0,0 +1,196 @@
+var English = {
+  name: "en",
+  el: {
+    breadcrumb: {
+      label: "Breadcrumb"
+    },
+    colorpicker: {
+      confirm: "OK",
+      clear: "Clear",
+      defaultLabel: "color picker",
+      description: "current color is {color}. press enter to select a new color.",
+      alphaLabel: "pick alpha value",
+      alphaDescription: "alpha {alpha}, current color is {color}",
+      hueLabel: "pick hue value",
+      hueDescription: "hue {hue}, current color is {color}",
+      svLabel: "pick saturation and brightness value",
+      svDescription: "saturation {saturation}, brightness {brightness}, current color is {color}",
+      predefineDescription: "select {value} as the color"
+    },
+    datepicker: {
+      now: "Now",
+      today: "Today",
+      cancel: "Cancel",
+      clear: "Clear",
+      confirm: "OK",
+      dateTablePrompt: "Use the arrow keys and enter to select the day of the month",
+      monthTablePrompt: "Use the arrow keys and enter to select the month",
+      yearTablePrompt: "Use the arrow keys and enter to select the year",
+      selectedDate: "Selected date",
+      selectDate: "Select date",
+      selectTime: "Select time",
+      startDate: "Start Date",
+      startTime: "Start Time",
+      endDate: "End Date",
+      endTime: "End Time",
+      prevYear: "Previous Year",
+      nextYear: "Next Year",
+      prevMonth: "Previous Month",
+      nextMonth: "Next Month",
+      year: "",
+      month1: "January",
+      month2: "February",
+      month3: "March",
+      month4: "April",
+      month5: "May",
+      month6: "June",
+      month7: "July",
+      month8: "August",
+      month9: "September",
+      month10: "October",
+      month11: "November",
+      month12: "December",
+      weeks: {
+        sun: "Sun",
+        mon: "Mon",
+        tue: "Tue",
+        wed: "Wed",
+        thu: "Thu",
+        fri: "Fri",
+        sat: "Sat"
+      },
+      weeksFull: {
+        sun: "Sunday",
+        mon: "Monday",
+        tue: "Tuesday",
+        wed: "Wednesday",
+        thu: "Thursday",
+        fri: "Friday",
+        sat: "Saturday"
+      },
+      months: {
+        jan: "Jan",
+        feb: "Feb",
+        mar: "Mar",
+        apr: "Apr",
+        may: "May",
+        jun: "Jun",
+        jul: "Jul",
+        aug: "Aug",
+        sep: "Sep",
+        oct: "Oct",
+        nov: "Nov",
+        dec: "Dec"
+      }
+    },
+    inputNumber: {
+      decrease: "decrease number",
+      increase: "increase number"
+    },
+    select: {
+      loading: "Loading",
+      noMatch: "No matching data",
+      noData: "No data",
+      placeholder: "Select"
+    },
+    mention: {
+      loading: "Loading"
+    },
+    dropdown: {
+      toggleDropdown: "Toggle Dropdown"
+    },
+    cascader: {
+      noMatch: "No matching data",
+      loading: "Loading",
+      placeholder: "Select",
+      noData: "No data"
+    },
+    pagination: {
+      goto: "Go to",
+      pagesize: "/page",
+      total: "Total {total}",
+      pageClassifier: "",
+      page: "Page",
+      prev: "Go to previous page",
+      next: "Go to next page",
+      currentPage: "page {pager}",
+      prevPages: "Previous {pager} pages",
+      nextPages: "Next {pager} pages",
+      deprecationWarning: "Deprecated usages detected, please refer to the el-pagination documentation for more details"
+    },
+    dialog: {
+      close: "Close this dialog"
+    },
+    drawer: {
+      close: "Close this dialog"
+    },
+    messagebox: {
+      title: "Message",
+      confirm: "OK",
+      cancel: "Cancel",
+      error: "Illegal input",
+      close: "Close this dialog"
+    },
+    upload: {
+      deleteTip: "press delete to remove",
+      delete: "Delete",
+      preview: "Preview",
+      continue: "Continue"
+    },
+    slider: {
+      defaultLabel: "slider between {min} and {max}",
+      defaultRangeStartLabel: "pick start value",
+      defaultRangeEndLabel: "pick end value"
+    },
+    table: {
+      emptyText: "No Data",
+      confirmFilter: "Confirm",
+      resetFilter: "Reset",
+      clearFilter: "All",
+      sumText: "Sum",
+      selectAllLabel: "Select all rows",
+      selectRowLabel: "Select this row",
+      expandRowLabel: "Expand this row",
+      collapseRowLabel: "Collapse this row",
+      sortLabel: "Sort by {column}",
+      filterLabel: "Filter by {column}"
+    },
+    tag: {
+      close: "Close this tag"
+    },
+    tour: {
+      next: "Next",
+      previous: "Previous",
+      finish: "Finish",
+      close: "Close this dialog"
+    },
+    tree: {
+      emptyText: "No Data"
+    },
+    transfer: {
+      noMatch: "No matching data",
+      noData: "No data",
+      titles: ["List 1", "List 2"],
+      filterPlaceholder: "Enter keyword",
+      noCheckedFormat: "{total} items",
+      hasCheckedFormat: "{checked}/{total} checked"
+    },
+    image: {
+      error: "FAILED"
+    },
+    pageHeader: {
+      title: "Back"
+    },
+    popconfirm: {
+      confirmButtonText: "Yes",
+      cancelButtonText: "No"
+    },
+    carousel: {
+      leftArrow: "Carousel arrow left",
+      rightArrow: "Carousel arrow right",
+      indicator: "Carousel switch to index {index}"
+    }
+  }
+};
+export { English as default };