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/components/tree/src/tree2.mjs ADDED Viewed

@@ -0,0 +1,314 @@
+import { defineComponent, resolveComponent, createElementBlock, openBlock, normalizeClass, createCommentVNode, withDirectives, Fragment, renderList, createBlock, renderSlot, createElementVNode, toDisplayString, vShow, ref, getCurrentInstance, computed, watch, provide } from 'vue';
+import TreeStore from './model/tree-store.mjs';
+import { handleCurrentChange, getNodeKey } from './model/util.mjs';
+import ElTreeNode from './tree-node.mjs';
+import { useNodeExpandEventBroadcast } from './model/useNodeExpandEventBroadcast.mjs';
+import { useDragNodeHandler } from './model/useDragNode.mjs';
+import { useKeydown } from './model/useKeydown.mjs';
+import { ROOT_TREE_INJECTION_KEY } from './tokens.mjs';
+import { treeEmits, treeProps } from './tree.mjs';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
+import { useLocale } from '../../../hooks/use-locale/index.mjs';
+import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
+import { formItemContextKey } from '../../form/src/constants.mjs';
+import isEqual from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEqual.mjs';
+const _sfc_main = defineComponent({
+  name: "ElTree",
+  components: { ElTreeNode },
+  props: treeProps,
+  emits: treeEmits,
+  setup(props, ctx) {
+    const { t } = useLocale();
+    const ns = useNamespace("tree");
+    const store = ref(
+      new TreeStore({
+        key: props.nodeKey,
+        data: props.data,
+        lazy: props.lazy,
+        props: props.props,
+        load: props.load,
+        currentNodeKey: props.currentNodeKey,
+        checkStrictly: props.checkStrictly,
+        checkDescendants: props.checkDescendants,
+        defaultCheckedKeys: props.defaultCheckedKeys,
+        defaultExpandedKeys: props.defaultExpandedKeys,
+        autoExpandParent: props.autoExpandParent,
+        defaultExpandAll: props.defaultExpandAll,
+        filterNodeMethod: props.filterNodeMethod
+      })
+    );
+    store.value.initialize();
+    const root = ref(store.value.root);
+    const currentNode = ref(null);
+    const el$ = ref(null);
+    const dropIndicator$ = ref(null);
+    const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
+    const { dragState } = useDragNodeHandler({
+      props,
+      ctx,
+      el$,
+      dropIndicator$,
+      store
+    });
+    useKeydown({ el$ }, store);
+    const instance = getCurrentInstance();
+    const isSelectTree = computed(() => {
+      let parent = instance == null ? void 0 : instance.parent;
+      while (parent) {
+        if (parent.type.name === "ElTreeSelect") {
+          return true;
+        }
+        parent = parent.parent;
+      }
+      return false;
+    });
+    const isEmpty = computed(() => {
+      const { childNodes } = root.value;
+      return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
+    });
+    watch(
+      () => props.currentNodeKey,
+      (newVal) => {
+        store.value.setCurrentNodeKey(newVal != null ? newVal : null);
+      }
+    );
+    watch(
+      () => props.defaultCheckedKeys,
+      (newVal, oldVal) => {
+        if (isEqual(newVal, oldVal))
+          return;
+        store.value.setDefaultCheckedKey(newVal != null ? newVal : []);
+      }
+    );
+    watch(
+      () => props.defaultExpandedKeys,
+      (newVal) => {
+        store.value.setDefaultExpandedKeys(newVal != null ? newVal : []);
+      }
+    );
+    watch(
+      () => props.data,
+      (newVal) => {
+        store.value.setData(newVal);
+      },
+      { deep: true }
+    );
+    watch(
+      () => props.checkStrictly,
+      (newVal) => {
+        store.value.checkStrictly = newVal;
+      }
+    );
+    const filter = (value) => {
+      if (!props.filterNodeMethod)
+        throw new Error("[Tree] filterNodeMethod is required when filter");
+      store.value.filter(value);
+    };
+    const getNodeKey$1 = (node) => {
+      return getNodeKey(props.nodeKey, node.data);
+    };
+    const requireNodeKey = (methodName) => {
+      if (!props.nodeKey) {
+        throw new Error(`[Tree] nodeKey is required in ${methodName}`);
+      }
+    };
+    const getNodePath = (data) => {
+      requireNodeKey("getNodePath");
+      const node = store.value.getNode(data);
+      if (!node)
+        return [];
+      const path = [node.data];
+      let parent = node.parent;
+      while (parent && parent !== root.value) {
+        path.push(parent.data);
+        parent = parent.parent;
+      }
+      return path.reverse();
+    };
+    const getCheckedNodes = (leafOnly, includeHalfChecked) => {
+      return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
+    };
+    const getCheckedKeys = (leafOnly) => {
+      return store.value.getCheckedKeys(leafOnly);
+    };
+    const getCurrentNode = () => {
+      const currentNode2 = store.value.getCurrentNode();
+      return currentNode2 ? currentNode2.data : null;
+    };
+    const getCurrentKey = () => {
+      requireNodeKey("getCurrentKey");
+      const currentNode2 = getCurrentNode();
+      return currentNode2 ? currentNode2[props.nodeKey] : null;
+    };
+    const setCheckedNodes = (nodes, leafOnly) => {
+      requireNodeKey("setCheckedNodes");
+      store.value.setCheckedNodes(nodes, leafOnly);
+    };
+    const setCheckedKeys = (keys, leafOnly) => {
+      requireNodeKey("setCheckedKeys");
+      store.value.setCheckedKeys(keys, leafOnly);
+    };
+    const setChecked = (data, checked, deep) => {
+      store.value.setChecked(data, checked, deep);
+    };
+    const getHalfCheckedNodes = () => {
+      return store.value.getHalfCheckedNodes();
+    };
+    const getHalfCheckedKeys = () => {
+      return store.value.getHalfCheckedKeys();
+    };
+    const setCurrentNode = (node, shouldAutoExpandParent = true) => {
+      requireNodeKey("setCurrentNode");
+      handleCurrentChange(store, ctx.emit, () => {
+        broadcastExpanded(node);
+        store.value.setUserCurrentNode(node, shouldAutoExpandParent);
+      });
+    };
+    const setCurrentKey = (key = null, shouldAutoExpandParent = true) => {
+      requireNodeKey("setCurrentKey");
+      handleCurrentChange(store, ctx.emit, () => {
+        broadcastExpanded();
+        store.value.setCurrentNodeKey(key, shouldAutoExpandParent);
+      });
+    };
+    const getNode = (data) => {
+      return store.value.getNode(data);
+    };
+    const remove = (data) => {
+      store.value.remove(data);
+    };
+    const append = (data, parentNode) => {
+      store.value.append(data, parentNode);
+    };
+    const insertBefore = (data, refNode) => {
+      store.value.insertBefore(data, refNode);
+    };
+    const insertAfter = (data, refNode) => {
+      store.value.insertAfter(data, refNode);
+    };
+    const handleNodeExpand = (nodeData, node, instance2) => {
+      broadcastExpanded(node);
+      ctx.emit("node-expand", nodeData, node, instance2);
+    };
+    const updateKeyChildren = (key, data) => {
+      requireNodeKey("updateKeyChild");
+      store.value.updateChildren(key, data);
+    };
+    provide(ROOT_TREE_INJECTION_KEY, {
+      ctx,
+      props,
+      store,
+      root,
+      currentNode,
+      instance
+    });
+    provide(formItemContextKey, void 0);
+    return {
+      ns,
+      store,
+      root,
+      currentNode,
+      dragState,
+      el$,
+      dropIndicator$,
+      isEmpty,
+      filter,
+      getNodeKey: getNodeKey$1,
+      getNodePath,
+      getCheckedNodes,
+      getCheckedKeys,
+      getCurrentNode,
+      getCurrentKey,
+      setCheckedNodes,
+      setCheckedKeys,
+      setChecked,
+      getHalfCheckedNodes,
+      getHalfCheckedKeys,
+      setCurrentNode,
+      setCurrentKey,
+      t,
+      getNode,
+      remove,
+      append,
+      insertBefore,
+      insertAfter,
+      handleNodeExpand,
+      updateKeyChildren
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_tree_node = resolveComponent("el-tree-node");
+  return openBlock(), createElementBlock(
+    "div",
+    {
+      ref: "el$",
+      class: normalizeClass([
+        _ctx.ns.b(),
+        _ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
+        _ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
+        _ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
+        { [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
+      ]),
+      role: "tree"
+    },
+    [
+      (openBlock(true), createElementBlock(
+        Fragment,
+        null,
+        renderList(_ctx.root.childNodes, (child) => {
+          return openBlock(), createBlock(_component_el_tree_node, {
+            key: _ctx.getNodeKey(child),
+            node: child,
+            props: _ctx.props,
+            accordion: _ctx.accordion,
+            "render-after-expand": _ctx.renderAfterExpand,
+            "show-checkbox": _ctx.showCheckbox,
+            "render-content": _ctx.renderContent,
+            onNodeExpand: _ctx.handleNodeExpand
+          }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]);
+        }),
+        128
+      )),
+      _ctx.isEmpty ? (openBlock(), createElementBlock(
+        "div",
+        {
+          key: 0,
+          class: normalizeClass(_ctx.ns.e("empty-block"))
+        },
+        [
+          renderSlot(_ctx.$slots, "empty", {}, () => {
+            var _a;
+            return [
+              createElementVNode(
+                "span",
+                {
+                  class: normalizeClass(_ctx.ns.e("empty-text"))
+                },
+                toDisplayString((_a = _ctx.emptyText) != null ? _a : _ctx.t("el.tree.emptyText")),
+                3
+              )
+            ];
+          })
+        ],
+        2
+      )) : createCommentVNode("v-if", true),
+      withDirectives(createElementVNode(
+        "div",
+        {
+          ref: "dropIndicator$",
+          class: normalizeClass(_ctx.ns.e("drop-indicator"))
+        },
+        null,
+        2
+      ), [
+        [vShow, _ctx.dragState.showDropIndicator]
+      ])
+    ],
+    2
+  );
+}
+var Tree = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tree/src/tree.vue"]]);
+export { Tree as default };

@@ -0,0 +1,3 @@
+const HORIZONTAL = "horizontal";
+export { HORIZONTAL };

@@ -0,0 +1,37 @@
+import { HORIZONTAL } from '../defaults.mjs';
+import { cAF, rAF } from '../../../../utils/raf.mjs';
+import { isFirefox } from '../../../../utils/browser.mjs';
+const useWheel = ({ atEndEdge, atStartEdge, layout }, onWheelDelta) => {
+  let frameHandle;
+  let offset = 0;
+  const hasReachedEdge = (offset2) => {
+    const edgeReached = offset2 < 0 && atStartEdge.value || offset2 > 0 && atEndEdge.value;
+    return edgeReached;
+  };
+  const onWheel = (e) => {
+    cAF(frameHandle);
+    let { deltaX, deltaY } = e;
+    if (e.shiftKey && deltaY !== 0) {
+      deltaX = deltaY;
+      deltaY = 0;
+    }
+    const newOffset = layout.value === HORIZONTAL ? deltaX : deltaY;
+    if (hasReachedEdge(newOffset))
+      return;
+    offset += newOffset;
+    if (!isFirefox() && newOffset !== 0) {
+      e.preventDefault();
+    }
+    frameHandle = rAF(() => {
+      onWheelDelta(offset);
+      offset = 0;
+    });
+  };
+  return {
+    hasReachedEdge,
+    onWheel
+  };
+};
+export { useWheel as default };

@@ -0,0 +1,19 @@
+const EVENT_CODE = {
+  tab: "Tab",
+  enter: "Enter",
+  space: "Space",
+  left: "ArrowLeft",
+  up: "ArrowUp",
+  right: "ArrowRight",
+  down: "ArrowDown",
+  esc: "Escape",
+  delete: "Delete",
+  backspace: "Backspace",
+  numpadEnter: "NumpadEnter",
+  pageUp: "PageUp",
+  pageDown: "PageDown",
+  home: "Home",
+  end: "End"
+};
+export { EVENT_CODE };

@@ -0,0 +1,16 @@
+const datePickTypes = [
+  "year",
+  "years",
+  "month",
+  "months",
+  "date",
+  "dates",
+  "week",
+  "datetime",
+  "datetimerange",
+  "daterange",
+  "monthrange",
+  "yearrange"
+];
+export { datePickTypes };

@@ -0,0 +1,5 @@
+const UPDATE_MODEL_EVENT = "update:modelValue";
+const CHANGE_EVENT = "change";
+const INPUT_EVENT = "input";
+export { CHANGE_EVENT, INPUT_EVENT, UPDATE_MODEL_EVENT };

@@ -0,0 +1,4 @@
+const MINIMUM_INPUT_WIDTH = 11;
+const BORDER_HORIZONTAL_WIDTH = 2;
+export { BORDER_HORIZONTAL_WIDTH, MINIMUM_INPUT_WIDTH };

@@ -0,0 +1,3 @@
+const componentSizes = ["", "default", "small", "large"];
+export { componentSizes };

@@ -0,0 +1,76 @@
+import { isArray } from '../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.mjs';
+import { isElement } from '../../utils/types.mjs';
+import { isClient } from '../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs';
+const nodeList = /* @__PURE__ */ new Map();
+if (isClient) {
+  let startClick;
+  document.addEventListener("mousedown", (e) => startClick = e);
+  document.addEventListener("mouseup", (e) => {
+    if (startClick) {
+      for (const handlers of nodeList.values()) {
+        for (const { documentHandler } of handlers) {
+          documentHandler(e, startClick);
+        }
+      }
+      startClick = void 0;
+    }
+  });
+}
+function createDocumentHandler(el, binding) {
+  let excludes = [];
+  if (isArray(binding.arg)) {
+    excludes = binding.arg;
+  } else if (isElement(binding.arg)) {
+    excludes.push(binding.arg);
+  }
+  return function(mouseup, mousedown) {
+    const popperRef = binding.instance.popperRef;
+    const mouseUpTarget = mouseup.target;
+    const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
+    const isBound = !binding || !binding.instance;
+    const isTargetExists = !mouseUpTarget || !mouseDownTarget;
+    const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
+    const isSelf = el === mouseUpTarget;
+    const isTargetExcluded = excludes.length && excludes.some((item) => item == null ? void 0 : item.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
+    const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
+    if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
+      return;
+    }
+    binding.value(mouseup, mousedown);
+  };
+}
+const ClickOutside = {
+  beforeMount(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
+    }
+    nodeList.get(el).push({
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
+    });
+  },
+  updated(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
+    }
+    const handlers = nodeList.get(el);
+    const oldHandlerIndex = handlers.findIndex(
+      (item) => item.bindingFn === binding.oldValue
+    );
+    const newHandler = {
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
+    };
+    if (oldHandlerIndex >= 0) {
+      handlers.splice(oldHandlerIndex, 1, newHandler);
+    } else {
+      handlers.push(newHandler);
+    }
+  },
+  unmounted(el) {
+    nodeList.delete(el);
+  }
+};
+export { ClickOutside as default };

@@ -0,0 +1,55 @@
+import { isFunction } from '../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.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 { REPEAT_DELAY, REPEAT_INTERVAL, vRepeatClick };

@@ -0,0 +1,16 @@
+import { buildProps } from '../../utils/vue/props/runtime.mjs';
+import pick from '../../../../../../lodash-es@4.17.21/node_modules/lodash-es/pick.mjs';
+const ariaProps = buildProps({
+  ariaLabel: String,
+  ariaOrientation: {
+    type: String,
+    values: ["horizontal", "vertical", "undefined"]
+  },
+  ariaControls: String
+});
+const useAriaProps = (arias) => {
+  return pick(ariaProps, arias);
+};
+export { ariaProps, useAriaProps };

@@ -0,0 +1,32 @@
+import { computed, getCurrentInstance } from 'vue';
+import { debugWarn } from '../../utils/error.mjs';
+import fromPairs from '../../../../../../lodash-es@4.17.21/node_modules/lodash-es/fromPairs.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 };

@@ -0,0 +1,23 @@
+import { shallowRef, ref, computed } from 'vue';
+import { useResizeObserver } from '../../../../../../@vueuse_core@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/index.mjs';
+import { MINIMUM_INPUT_WIDTH } from '../../constants/form.mjs';
+function useCalcInputWidth() {
+  const calculatorRef = shallowRef();
+  const calculatorWidth = ref(0);
+  const inputStyle = computed(() => ({
+    minWidth: `${Math.max(calculatorWidth.value, MINIMUM_INPUT_WIDTH)}px`
+  }));
+  const resetCalculatorWidth = () => {
+    var _a, _b;
+    calculatorWidth.value = (_b = (_a = calculatorRef.value) == null ? void 0 : _a.getBoundingClientRect().width) != null ? _b : 0;
+  };
+  useResizeObserver(calculatorRef, resetCalculatorWidth);
+  return {
+    calculatorRef,
+    calculatorWidth,
+    inputStyle
+  };
+}
+export { useCalcInputWidth };

@@ -0,0 +1,39 @@
+import { ref, nextTick } from 'vue';
+import { isKorean } from '../../utils/i18n.mjs';
+function useComposition({
+  afterComposition,
+  emit
+}) {
+  const isComposing = ref(false);
+  const handleCompositionStart = (event) => {
+    emit == null ? void 0 : emit("compositionstart", event);
+    isComposing.value = true;
+  };
+  const handleCompositionUpdate = (event) => {
+    var _a;
+    emit == null ? void 0 : emit("compositionupdate", event);
+    const text = (_a = event.target) == null ? void 0 : _a.value;
+    const lastCharacter = text[text.length - 1] || "";
+    isComposing.value = !isKorean(lastCharacter);
+  };
+  const handleCompositionEnd = (event) => {
+    emit == null ? void 0 : emit("compositionend", event);
+    if (isComposing.value) {
+      isComposing.value = false;
+      nextTick(() => afterComposition(event));
+    }
+  };
+  const handleComposition = (event) => {
+    event.type === "compositionend" ? handleCompositionEnd(event) : handleCompositionUpdate(event);
+  };
+  return {
+    isComposing,
+    handleComposition,
+    handleCompositionStart,
+    handleCompositionUpdate,
+    handleCompositionEnd
+  };
+}
+export { useComposition };