@funcho/ui 1.0.0

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/tabs/src/tab-bar2.js

@@ -0,0 +1,111 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const index$1 = require('../../../../../../../@vueuse_core@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/index.js');
+const constants = require('./constants.js');
+const tabBar = require('./tab-bar.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const strings = require('../../../utils/strings.js');
+const error = require('../../../utils/error.js');
+const index = require('../../../hooks/use-namespace/index.js');
+const types = require('../../../utils/types.js');
+
+const COMPONENT_NAME = "ElTabBar";
+const _sfc_main = vue.defineComponent({
+  ...{
+    name: COMPONENT_NAME
+  },
+  __name: "tab-bar",
+  props: tabBar.tabBarProps,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const rootTabs = vue.inject(constants.tabsRootContextKey);
+    if (!rootTabs)
+      error.throwError(COMPONENT_NAME, "<el-tabs><el-tab-bar /></el-tabs>");
+    const ns = index.useNamespace("tabs");
+    const barRef = vue.ref();
+    const barStyle = vue.ref();
+    const renderActiveBar = vue.computed(
+      () => {
+        var _a;
+        return types.isUndefined(rootTabs.props.defaultValue) || Boolean((_a = barStyle.value) == null ? void 0 : _a.transform);
+      }
+    );
+    const getBarStyle = () => {
+      let offset = 0;
+      let tabSize = 0;
+      const sizeName = ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height";
+      const sizeDir = sizeName === "width" ? "x" : "y";
+      const position = sizeDir === "x" ? "left" : "top";
+      props.tabs.every((tab) => {
+        if (types.isUndefined(tab.paneName))
+          return false;
+        const $el = props.tabRefs[tab.paneName];
+        if (!$el)
+          return false;
+        if (!tab.active) {
+          return true;
+        }
+        offset = $el[`offset${strings.capitalize(position)}`];
+        tabSize = $el[`client${strings.capitalize(sizeName)}`];
+        const tabStyles = window.getComputedStyle($el);
+        if (sizeName === "width") {
+          tabSize -= Number.parseFloat(tabStyles.paddingLeft) + Number.parseFloat(tabStyles.paddingRight);
+          offset += Number.parseFloat(tabStyles.paddingLeft);
+        }
+        return false;
+      });
+      return {
+        [sizeName]: `${tabSize}px`,
+        transform: `translate${strings.capitalize(sizeDir)}(${offset}px)`
+      };
+    };
+    const update = () => barStyle.value = getBarStyle();
+    const tabObservers = [];
+    const observerTabs = () => {
+      tabObservers.forEach((observer) => observer.stop());
+      tabObservers.length = 0;
+      Object.values(props.tabRefs).forEach((tab) => {
+        tabObservers.push(index$1.useResizeObserver(tab, update));
+      });
+    };
+    vue.watch(
+      () => props.tabs,
+      async () => {
+        await vue.nextTick();
+        update();
+        observerTabs();
+      },
+      { immediate: true }
+    );
+    const barObserver = index$1.useResizeObserver(barRef, () => update());
+    vue.onBeforeUnmount(() => {
+      tabObservers.forEach((observer) => observer.stop());
+      tabObservers.length = 0;
+      barObserver.stop();
+    });
+    __expose({
+      ref: barRef,
+      update
+    });
+    return (_ctx, _cache) => {
+      return renderActiveBar.value ? (vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          key: 0,
+          ref_key: "barRef",
+          ref: barRef,
+          class: vue.normalizeClass([vue.unref(ns).e("active-bar"), vue.unref(ns).is(vue.unref(rootTabs).props.tabPosition)]),
+          style: vue.normalizeStyle(barStyle.value)
+        },
+        null,
+        6
+      )) : vue.createCommentVNode("v-if", true);
+    };
+  }
+});
+var TabBar = /* @__PURE__ */ pluginVue_exportHelper.default(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tabs/src/tab-bar.vue"]]);
+
+exports.default = TabBar;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/tabs/src/tab-nav.js

@@ -0,0 +1,325 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const index$1 = require('../../../../../../../@vueuse_core@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/index.js');
+const index$2 = require('../../icon/index.js');
+const index$3 = require('../../../../../../../@element-plus_icons-vue@2.3.2_vue@3.5.22_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.js');
+const useWheel = require('../../virtual-list/src/hooks/use-wheel.js');
+const tabBar2 = require('./tab-bar2.js');
+const constants = require('./constants.js');
+const runtime = require('../../../utils/vue/props/runtime.js');
+const typescript = require('../../../utils/typescript.js');
+const error = require('../../../utils/error.js');
+const index = require('../../../hooks/use-namespace/index.js');
+const raf = require('../../../utils/raf.js');
+const event = require('../../../utils/dom/event.js');
+const aria = require('../../../constants/aria.js');
+const strings = require('../../../utils/strings.js');
+const clamp = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clamp.js');
+
+const tabNavProps = runtime.buildProps({
+  panes: {
+    type: runtime.definePropType(Array),
+    default: () => typescript.mutable([])
+  },
+  currentName: {
+    type: [String, Number],
+    default: ""
+  },
+  editable: Boolean,
+  type: {
+    type: String,
+    values: ["card", "border-card", ""],
+    default: ""
+  },
+  stretch: Boolean,
+  tabindex: {
+    type: [String, Number],
+    default: void 0
+  }
+});
+const tabNavEmits = {
+  tabClick: (tab, tabName, ev) => ev instanceof Event,
+  tabRemove: (tab, ev) => ev instanceof Event
+};
+const COMPONENT_NAME = "ElTabNav";
+const TabNav = vue.defineComponent({
+  name: COMPONENT_NAME,
+  props: tabNavProps,
+  emits: tabNavEmits,
+  setup(props, {
+    expose,
+    emit
+  }) {
+    const rootTabs = vue.inject(constants.tabsRootContextKey);
+    if (!rootTabs)
+      error.throwError(COMPONENT_NAME, `<el-tabs><tab-nav /></el-tabs>`);
+    const ns = index.useNamespace("tabs");
+    const visibility = index$1.useDocumentVisibility();
+    const focused = index$1.useWindowFocus();
+    const navScroll$ = vue.ref();
+    const nav$ = vue.ref();
+    const el$ = vue.ref();
+    const tabRefsMap = vue.ref({});
+    const tabBarRef = vue.ref();
+    const scrollable = vue.ref(false);
+    const navOffset = vue.ref(0);
+    const isFocus = vue.ref(false);
+    const focusable = vue.ref(true);
+    const tracker = vue.shallowRef();
+    const isHorizontal = vue.computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition));
+    const sizeName = vue.computed(() => isHorizontal.value ? "width" : "height");
+    const navStyle = vue.computed(() => {
+      const dir = sizeName.value === "width" ? "X" : "Y";
+      return {
+        transform: `translate${dir}(-${navOffset.value}px)`
+      };
+    });
+    const {
+      width: navContainerWidth,
+      height: navContainerHeight
+    } = index$1.useElementSize(navScroll$);
+    const {
+      width: navWidth,
+      height: navHeight
+    } = index$1.useElementSize(nav$, {
+      width: 0,
+      height: 0
+    }, {
+      box: "border-box"
+    });
+    const navContainerSize = vue.computed(() => isHorizontal.value ? navContainerWidth.value : navContainerHeight.value);
+    const navSize = vue.computed(() => isHorizontal.value ? navWidth.value : navHeight.value);
+    const {
+      onWheel
+    } = useWheel.default({
+      atStartEdge: vue.computed(() => navOffset.value <= 0),
+      atEndEdge: vue.computed(() => navSize.value - navOffset.value <= navContainerSize.value),
+      layout: vue.computed(() => isHorizontal.value ? "horizontal" : "vertical")
+    }, (offset) => {
+      navOffset.value = clamp.default(navOffset.value + offset, 0, navSize.value - navContainerSize.value);
+    });
+    const scrollPrev = () => {
+      if (!navScroll$.value)
+        return;
+      const containerSize = navScroll$.value[`offset${strings.capitalize(sizeName.value)}`];
+      const currentOffset = navOffset.value;
+      if (!currentOffset)
+        return;
+      const newOffset = currentOffset > containerSize ? currentOffset - containerSize : 0;
+      navOffset.value = newOffset;
+    };
+    const scrollNext = () => {
+      if (!navScroll$.value || !nav$.value)
+        return;
+      const navSize2 = nav$.value[`offset${strings.capitalize(sizeName.value)}`];
+      const containerSize = navScroll$.value[`offset${strings.capitalize(sizeName.value)}`];
+      const currentOffset = navOffset.value;
+      if (navSize2 - currentOffset <= containerSize)
+        return;
+      const newOffset = navSize2 - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize2 - containerSize;
+      navOffset.value = newOffset;
+    };
+    const scrollToActiveTab = async () => {
+      const nav = nav$.value;
+      if (!scrollable.value || !el$.value || !navScroll$.value || !nav)
+        return;
+      await vue.nextTick();
+      const activeTab = tabRefsMap.value[props.currentName];
+      if (!activeTab)
+        return;
+      const navScroll = navScroll$.value;
+      const activeTabBounding = activeTab.getBoundingClientRect();
+      const navScrollBounding = navScroll.getBoundingClientRect();
+      const maxOffset = isHorizontal.value ? nav.offsetWidth - navScrollBounding.width : nav.offsetHeight - navScrollBounding.height;
+      const currentOffset = navOffset.value;
+      let newOffset = currentOffset;
+      if (isHorizontal.value) {
+        if (activeTabBounding.left < navScrollBounding.left) {
+          newOffset = currentOffset - (navScrollBounding.left - activeTabBounding.left);
+        }
+        if (activeTabBounding.right > navScrollBounding.right) {
+          newOffset = currentOffset + activeTabBounding.right - navScrollBounding.right;
+        }
+      } else {
+        if (activeTabBounding.top < navScrollBounding.top) {
+          newOffset = currentOffset - (navScrollBounding.top - activeTabBounding.top);
+        }
+        if (activeTabBounding.bottom > navScrollBounding.bottom) {
+          newOffset = currentOffset + (activeTabBounding.bottom - navScrollBounding.bottom);
+        }
+      }
+      newOffset = Math.max(newOffset, 0);
+      navOffset.value = Math.min(newOffset, maxOffset);
+    };
+    const update = () => {
+      var _a;
+      if (!nav$.value || !navScroll$.value)
+        return;
+      props.stretch && ((_a = tabBarRef.value) == null ? void 0 : _a.update());
+      const navSize2 = nav$.value[`offset${strings.capitalize(sizeName.value)}`];
+      const containerSize = navScroll$.value[`offset${strings.capitalize(sizeName.value)}`];
+      const currentOffset = navOffset.value;
+      if (containerSize < navSize2) {
+        scrollable.value = scrollable.value || {};
+        scrollable.value.prev = currentOffset;
+        scrollable.value.next = currentOffset + containerSize < navSize2;
+        if (navSize2 - currentOffset < containerSize) {
+          navOffset.value = navSize2 - containerSize;
+        }
+      } else {
+        scrollable.value = false;
+        if (currentOffset > 0) {
+          navOffset.value = 0;
+        }
+      }
+    };
+    const changeTab = (event$1) => {
+      const code = event.getEventCode(event$1);
+      let step = 0;
+      switch (code) {
+        case aria.EVENT_CODE.left:
+        case aria.EVENT_CODE.up:
+          step = -1;
+          break;
+        case aria.EVENT_CODE.right:
+        case aria.EVENT_CODE.down:
+          step = 1;
+          break;
+        default:
+          return;
+      }
+      const tabList = Array.from(event$1.currentTarget.querySelectorAll("[role=tab]:not(.is-disabled)"));
+      const currentIndex = tabList.indexOf(event$1.target);
+      let nextIndex = currentIndex + step;
+      if (nextIndex < 0) {
+        nextIndex = tabList.length - 1;
+      } else if (nextIndex >= tabList.length) {
+        nextIndex = 0;
+      }
+      tabList[nextIndex].focus({
+        preventScroll: true
+      });
+      tabList[nextIndex].click();
+      setFocus();
+    };
+    const setFocus = () => {
+      if (focusable.value)
+        isFocus.value = true;
+    };
+    const removeFocus = () => isFocus.value = false;
+    const setRefs = (el, key) => {
+      tabRefsMap.value[key] = el;
+    };
+    const focusActiveTab = async () => {
+      await vue.nextTick();
+      const activeTab = tabRefsMap.value[props.currentName];
+      activeTab == null ? void 0 : activeTab.focus({
+        preventScroll: true
+      });
+    };
+    vue.watch(visibility, (visibility2) => {
+      if (visibility2 === "hidden") {
+        focusable.value = false;
+      } else if (visibility2 === "visible") {
+        setTimeout(() => focusable.value = true, 50);
+      }
+    });
+    vue.watch(focused, (focused2) => {
+      if (focused2) {
+        setTimeout(() => focusable.value = true, 50);
+      } else {
+        focusable.value = false;
+      }
+    });
+    index$1.useResizeObserver(el$, () => {
+      raf.rAF(update);
+    });
+    vue.onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
+    vue.onUpdated(() => update());
+    expose({
+      scrollToActiveTab,
+      removeFocus,
+      focusActiveTab,
+      tabListRef: nav$,
+      tabBarRef,
+      scheduleRender: () => vue.triggerRef(tracker)
+    });
+    return () => {
+      const scrollBtn = scrollable.value ? [vue.createVNode("span", {
+        "class": [ns.e("nav-prev"), ns.is("disabled", !scrollable.value.prev)],
+        "onClick": scrollPrev
+      }, [vue.createVNode(index$2.ElIcon, null, {
+        default: () => [vue.createVNode(index$3.ArrowLeft, null, null)]
+      })]), vue.createVNode("span", {
+        "class": [ns.e("nav-next"), ns.is("disabled", !scrollable.value.next)],
+        "onClick": scrollNext
+      }, [vue.createVNode(index$2.ElIcon, null, {
+        default: () => [vue.createVNode(index$3.ArrowRight, null, null)]
+      })])] : null;
+      const tabs = props.panes.map((pane, index) => {
+        var _a, _b, _c, _d, _e;
+        const uid = pane.uid;
+        const disabled = pane.props.disabled;
+        const tabName = (_b = (_a = pane.props.name) != null ? _a : pane.index) != null ? _b : `${index}`;
+        const closable = !disabled && (pane.isClosable || pane.props.closable !== false && props.editable);
+        pane.index = `${index}`;
+        const btnClose = closable ? vue.createVNode(index$2.ElIcon, {
+          "class": "is-icon-close",
+          "onClick": (ev) => emit("tabRemove", pane, ev)
+        }, {
+          default: () => [vue.createVNode(index$3.Close, null, null)]
+        }) : null;
+        const tabLabelContent = ((_d = (_c = pane.slots).label) == null ? void 0 : _d.call(_c)) || pane.props.label;
+        const tabindex = !disabled && pane.active ? (_e = props.tabindex) != null ? _e : rootTabs.props.tabindex : -1;
+        return vue.createVNode("div", {
+          "ref": (el) => setRefs(el, tabName),
+          "class": [ns.e("item"), ns.is(rootTabs.props.tabPosition), ns.is("active", pane.active), ns.is("disabled", disabled), ns.is("closable", closable), ns.is("focus", isFocus.value)],
+          "id": `tab-${tabName}`,
+          "key": `tab-${uid}`,
+          "aria-controls": `pane-${tabName}`,
+          "role": "tab",
+          "aria-selected": pane.active,
+          "tabindex": tabindex,
+          "onFocus": () => setFocus(),
+          "onBlur": () => removeFocus(),
+          "onClick": (ev) => {
+            removeFocus();
+            emit("tabClick", pane, tabName, ev);
+          },
+          "onKeydown": (ev) => {
+            const code = event.getEventCode(ev);
+            if (closable && (code === aria.EVENT_CODE.delete || code === aria.EVENT_CODE.backspace)) {
+              emit("tabRemove", pane, ev);
+            }
+          }
+        }, [...[tabLabelContent, btnClose]]);
+      });
+      tracker.value;
+      return vue.createVNode("div", {
+        "ref": el$,
+        "class": [ns.e("nav-wrap"), ns.is("scrollable", !!scrollable.value), ns.is(rootTabs.props.tabPosition)]
+      }, [scrollBtn, vue.createVNode("div", {
+        "class": ns.e("nav-scroll"),
+        "ref": navScroll$
+      }, [props.panes.length > 0 ? vue.createVNode("div", {
+        "class": [ns.e("nav"), ns.is(rootTabs.props.tabPosition), ns.is("stretch", props.stretch && ["top", "bottom"].includes(rootTabs.props.tabPosition))],
+        "ref": nav$,
+        "style": navStyle.value,
+        "role": "tablist",
+        "onKeydown": changeTab,
+        "onWheel": onWheel
+      }, [...[!props.type ? vue.createVNode(tabBar2.default, {
+        "ref": tabBarRef,
+        "tabs": [...props.panes],
+        "tabRefs": tabRefsMap.value
+      }, null) : null, tabs]]) : null])]);
+    };
+  }
+});
+
+exports.default = TabNav;
+exports.tabNavEmits = tabNavEmits;
+exports.tabNavProps = tabNavProps;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/tabs/src/tab-pane.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const runtime = require('../../../utils/vue/props/runtime.js');
+
+const tabPaneProps = runtime.buildProps({
+  label: {
+    type: String,
+    default: ""
+  },
+  name: {
+    type: [String, Number]
+  },
+  closable: {
+    type: Boolean,
+    default: void 0
+  },
+  disabled: Boolean,
+  lazy: Boolean
+});
+
+exports.tabPaneProps = tabPaneProps;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/tabs/src/tab-pane2.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const constants = require('./constants.js');
+const tabPane = require('./tab-pane.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const error = require('../../../utils/error.js');
+const index = require('../../../hooks/use-namespace/index.js');
+
+const _hoisted_1 = ["id", "aria-hidden", "aria-labelledby"];
+const COMPONENT_NAME = "ElTabPane";
+const _sfc_main = vue.defineComponent({
+  ...{
+    name: COMPONENT_NAME
+  },
+  __name: "tab-pane",
+  props: tabPane.tabPaneProps,
+  setup(__props) {
+    const props = __props;
+    const instance = vue.getCurrentInstance();
+    const slots = vue.useSlots();
+    const tabsRoot = vue.inject(constants.tabsRootContextKey);
+    if (!tabsRoot)
+      error.throwError(COMPONENT_NAME, "usage: <el-tabs><el-tab-pane /></el-tabs/>");
+    const ns = index.useNamespace("tab-pane");
+    const paneRef = vue.ref();
+    const index$1 = vue.ref();
+    const isClosable = vue.computed(() => {
+      var _a;
+      return (_a = props.closable) != null ? _a : tabsRoot.props.closable;
+    });
+    const active = vue.computed(
+      () => {
+        var _a;
+        return tabsRoot.currentName.value === ((_a = props.name) != null ? _a : index$1.value);
+      }
+    );
+    const loaded = vue.ref(active.value);
+    const paneName = vue.computed(() => {
+      var _a;
+      return (_a = props.name) != null ? _a : index$1.value;
+    });
+    const shouldBeRender = vue.computed(
+      () => !props.lazy || loaded.value || active.value
+    );
+    const isFocusInsidePane = () => {
+      var _a;
+      return (_a = paneRef.value) == null ? void 0 : _a.contains(document.activeElement);
+    };
+    vue.watch(active, (val) => {
+      if (val)
+        loaded.value = true;
+    });
+    const pane = vue.reactive({
+      uid: instance.uid,
+      getVnode: () => instance.vnode,
+      slots,
+      props,
+      paneName,
+      active,
+      index: index$1,
+      isClosable,
+      isFocusInsidePane
+    });
+    tabsRoot.registerPane(pane);
+    vue.onBeforeUnmount(() => {
+      tabsRoot.unregisterPane(pane);
+    });
+    vue.onBeforeUpdate(() => {
+      var _a;
+      if (slots.label)
+        (_a = tabsRoot.nav$.value) == null ? void 0 : _a.scheduleRender();
+    });
+    return (_ctx, _cache) => {
+      return shouldBeRender.value ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        id: `pane-${paneName.value}`,
+        ref_key: "paneRef",
+        ref: paneRef,
+        class: vue.normalizeClass(vue.unref(ns).b()),
+        role: "tabpanel",
+        "aria-hidden": !active.value,
+        "aria-labelledby": `tab-${paneName.value}`
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 10, _hoisted_1)), [
+        [vue.vShow, active.value]
+      ]) : vue.createCommentVNode("v-if", true);
+    };
+  }
+});
+var TabPane = /* @__PURE__ */ pluginVue_exportHelper.default(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tabs/src/tab-pane.vue"]]);
+
+exports.default = TabPane;