super-page-runtime 2.3.17-sit4 → 2.3.18-tmp1

package/dist/lib/components/runtime/views/assemblys/container/fixed/FixedBox.vue2.js

@@ -0,0 +1,99 @@
+"use strict";
+const Vue = require("vue");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "FixedBox",
+  props: {
+    isFixed: {
+      type: Boolean,
+      default: true
+    },
+    position: {
+      type: String,
+      default: "top"
+    },
+    offset: {
+      type: Number,
+      default: 0
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const fixedMaxRef = Vue.ref(null);
+    const fixedRef = Vue.ref(null);
+    const defaultStyle = Vue.ref({});
+    const containerStyle = Vue.ref({});
+    const observers = [];
+    const getContentRect = () => {
+      var _a, _b;
+      if (!fixedRef.value) {
+        defaultStyle.value = {};
+        containerStyle.value = {};
+      } else {
+        const mainRect = (_b = (_a = fixedMaxRef.value) == null ? void 0 : _a.getBoundingClientRect) == null ? void 0 : _b.call(_a);
+        const rect = fixedRef.value.getBoundingClientRect();
+        defaultStyle.value = {
+          width: "100%",
+          // `${rect.width}px`,
+          height: `${rect.height}px`
+        };
+        containerStyle.value = {
+          width: `${(mainRect == null ? void 0 : mainRect.width) ?? rect.width}px`,
+          position: props.isFixed ? "fixed" : "static",
+          [props.position]: `${props.offset}px`,
+          left: `${(mainRect == null ? void 0 : mainRect.left) ?? rect.left}px`,
+          zIndex: 100,
+          pointerEvents: "auto"
+        };
+      }
+    };
+    const updateLayout = () => {
+      getContentRect();
+    };
+    const initObservers = () => {
+      observers.forEach((obs) => obs.disconnect());
+      observers.length = 0;
+      if (fixedRef.value) {
+        const observer = new ResizeObserver(updateLayout);
+        observer.observe(fixedRef.value);
+        observers.push(observer);
+      }
+    };
+    const initEvent = (is) => {
+      if (is) {
+        initObservers();
+        window.addEventListener("resize", updateLayout);
+      } else {
+        window.removeEventListener("resize", updateLayout);
+        observers.forEach((obs) => obs.disconnect());
+      }
+      updateLayout();
+    };
+    Vue.onMounted(() => {
+      Vue.nextTick(() => {
+        initEvent(props.isFixed);
+      });
+    });
+    Vue.onUnmounted(() => {
+      initEvent(false);
+    });
+    Vue.watch(() => props.isFixed, initEvent);
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createElementBlock("div", {
+        ref_key: "fixedMaxRef",
+        ref: fixedMaxRef,
+        class: Vue.normalizeClass(["yx-fixed-box-main", { [`is-${__props.position}`]: true, "is-fixed": props.isFixed }]),
+        style: Vue.normalizeStyle(defaultStyle.value)
+      }, [
+        Vue.createElementVNode("div", {
+          ref_key: "fixedRef",
+          ref: fixedRef,
+          class: "yx-fixed-box-container",
+          style: Vue.normalizeStyle(containerStyle.value)
+        }, [
+          Vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 4)
+      ], 6);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/container/fixed/YxAffix.vue.d.ts

@@ -0,0 +1,94 @@
+import { PropType } from 'vue';
+
+type Position = 'top' | 'bottom';
+type Target = string | HTMLElement | Window;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: PropType<Position>;
+        default: string;
+        validator: (value: string) => value is Position;
+    };
+    target: {
+        type: PropType<Target>;
+        default: () => Window & typeof globalThis;
+    };
+    autoDetectParentScroll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stickyInScrollContainer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    enableIntervalUpdate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableIntervalTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (fixed: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: PropType<Position>;
+        default: string;
+        validator: (value: string) => value is Position;
+    };
+    target: {
+        type: PropType<Target>;
+        default: () => Window & typeof globalThis;
+    };
+    autoDetectParentScroll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stickyInScrollContainer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    enableIntervalUpdate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableIntervalTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onChange?: (fixed: boolean) => any;
+}>, {
+    position: Position;
+    offset: number;
+    zIndex: number;
+    target: Target;
+    autoDetectParentScroll: boolean;
+    stickyInScrollContainer: boolean;
+    enableIntervalUpdate: boolean;
+    enableIntervalTime: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/lib/components/runtime/views/assemblys/container/fixed/YxAffix.vue.js

@@ -0,0 +1,6 @@
+"use strict";
+const YxAffix_vue_vue_type_script_setup_true_lang = require("./YxAffix.vue2.js");
+;/* empty css              */
+const _pluginVue_exportHelper = require("../../../../../../_virtual/_plugin-vue_export-helper.js");
+const YxAffix = /* @__PURE__ */ _pluginVue_exportHelper(YxAffix_vue_vue_type_script_setup_true_lang, [["__scopeId", "data-v-a994b02d"]]);
+module.exports = YxAffix;

package/dist/lib/components/runtime/views/assemblys/container/fixed/YxAffix.vue2.js

@@ -0,0 +1,224 @@
+"use strict";
+const Vue = require("vue");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "YxAffix",
+  props: {
+    offset: {
+      type: Number,
+      default: 0
+    },
+    position: {
+      type: String,
+      default: "top",
+      validator: (value) => ["top", "bottom"].includes(value)
+    },
+    target: {
+      type: [String, HTMLElement],
+      default: () => window
+    },
+    autoDetectParentScroll: {
+      type: Boolean,
+      default: true
+    },
+    stickyInScrollContainer: {
+      type: Boolean,
+      default: true
+    },
+    zIndex: {
+      type: Number,
+      default: 100
+    },
+    // 是否开启间隔监听
+    enableIntervalUpdate: {
+      type: Boolean,
+      default: true
+    },
+    enableIntervalTime: {
+      type: Number,
+      default: 2e3
+    }
+  },
+  emits: ["change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const affixMainRef = Vue.ref(null);
+    const affixRef = Vue.ref(null);
+    const isFixed = Vue.ref(false);
+    const placeholderStyle = Vue.ref({});
+    const scrollContainerDatas = Vue.ref([]);
+    const scrollContainer = Vue.ref(window);
+    const adjustedOffset = Vue.ref(0);
+    const intervalId = Vue.ref(null);
+    const onResize = (entry) => {
+      if (entry.contentRect.height) {
+        placeholderStyle.value.height = entry.contentRect.height;
+      }
+    };
+    const getAffixOffset = (containerRect) => {
+      const isTop = ["top"].includes(props.position);
+      const isBottom = ["bottom"].includes(props.position);
+      if (!affixMainRef.value) return { isTop, isBottom };
+      const affixMainRect = affixMainRef.value.getBoundingClientRect();
+      const offsetTop = affixMainRect.top - containerRect.top;
+      const offsetLeft = affixMainRect.left - containerRect.left;
+      const offsetBottom = containerRect.height - affixMainRect.height - offsetTop;
+      const containerTop = containerRect.top;
+      const containerBottom = window.innerHeight - containerRect.bottom;
+      const isFixTop = isTop && offsetTop < 0;
+      const isFixBottom = isBottom && offsetBottom < 0;
+      const containerOffset = isTop ? containerTop : isBottom ? containerBottom : 0;
+      return {
+        isTop,
+        isBottom,
+        containerTop,
+        containerBottom,
+        containerOffset,
+        offsetTop,
+        offsetLeft,
+        offsetBottom,
+        // 是否开启顶部悬浮
+        isFixTop,
+        // 是否开启底部悬浮
+        isFixBottom
+      };
+    };
+    const getScrollContainer = () => {
+      if (props.autoDetectParentScroll && affixRef.value) {
+        const list = [];
+        let parent = affixRef.value.parentElement;
+        while (parent && parent !== document.body) {
+          const { overflowY } = window.getComputedStyle(parent);
+          if (/(auto|scroll)/.test(overflowY)) {
+            list.push(parent);
+          }
+          parent = parent.parentElement;
+        }
+        return [...list, window];
+      }
+      if (typeof props.target === "string") {
+        const el = document.querySelector(props.target);
+        return [...el ? [el] : [], window];
+      }
+      return [window];
+    };
+    const update = () => {
+      try {
+        if (!affixRef.value) return;
+        const rect = affixRef.value.getBoundingClientRect();
+        const container = scrollContainer.value;
+        if (container === window) {
+          const shouldFix = props.position === "top" ? rect.top <= props.offset : rect.bottom >= window.innerHeight - props.offset;
+          adjustedOffset.value = 0;
+          updateFixedState(shouldFix, rect);
+        } else if (props.stickyInScrollContainer) {
+          const containerRect = container.getBoundingClientRect();
+          const { isFixTop, isFixBottom, containerOffset } = getAffixOffset(containerRect);
+          adjustedOffset.value = containerOffset ?? 0;
+          updateFixedState(isFixTop || isFixBottom || false, rect);
+        }
+      } catch (error) {
+        console.error(error);
+      }
+    };
+    const updateFixedState = (shouldFix, rect) => {
+      var _a;
+      if (!rect.height) return;
+      if (shouldFix !== isFixed.value || ((_a = placeholderStyle.value) == null ? void 0 : _a.height) !== `${rect.height}px`) {
+        isFixed.value = shouldFix;
+        emits("change", shouldFix);
+        if (shouldFix) {
+          placeholderStyle.value = {
+            width: `100%`,
+            height: `${rect.height}px`
+          };
+        } else {
+          placeholderStyle.value = {};
+        }
+      }
+    };
+    const handleScroll = () => {
+      requestAnimationFrame(update);
+    };
+    let resizeTimer;
+    const handleResize = () => {
+      isFixed.value = false;
+      clearTimeout(resizeTimer);
+      resizeTimer = window.setTimeout(() => {
+        update();
+      }, 100);
+    };
+    Vue.onMounted(() => {
+      setTimeout(() => {
+        Vue.nextTick(() => {
+          try {
+            if (props.enableIntervalUpdate) {
+              intervalId.value = setInterval(handleScroll, props.enableIntervalTime);
+            }
+            const scrollList = getScrollContainer();
+            console.log("检测父级滚动节点", scrollList);
+            scrollContainerDatas.value = scrollList;
+            scrollContainer.value = scrollList[0];
+            scrollContainerDatas.value.forEach((dom) => dom.addEventListener("scroll", handleScroll));
+            window.addEventListener("resize", handleResize);
+            update();
+          } catch (error) {
+            console.error(error);
+          }
+        });
+      }, 100);
+    });
+    Vue.onUnmounted(() => {
+      if (scrollContainer.value) {
+        scrollContainerDatas.value.forEach((dom) => dom.removeEventListener("scroll", handleScroll));
+      }
+      window.removeEventListener("resize", handleResize);
+      clearTimeout(resizeTimer);
+      if (intervalId.value) clearInterval(intervalId.value);
+    });
+    Vue.watchEffect(() => {
+      Vue.nextTick(() => {
+        handleScroll();
+      });
+    });
+    const affixStyle = Vue.computed(() => {
+      var _a, _b;
+      if (isFixed.value && ((_a = affixRef.value) == null ? void 0 : _a.offsetWidth)) {
+        return {
+          position: "fixed",
+          width: `${(_b = affixRef.value) == null ? void 0 : _b.offsetWidth}px`,
+          zIndex: props.zIndex,
+          [props.position]: `${props.offset + adjustedOffset.value}px`
+        };
+      }
+      return {
+        position: "relative"
+      };
+    });
+    return (_ctx, _cache) => {
+      const _directive_resize = Vue.resolveDirective("resize");
+      return Vue.openBlock(), Vue.createElementBlock("div", {
+        ref_key: "affixMainRef",
+        ref: affixMainRef,
+        class: "yx-affix",
+        style: Vue.normalizeStyle({ height: isFixed.value ? placeholderStyle.value.height : void 0 })
+      }, [
+        Vue.withDirectives((Vue.openBlock(), Vue.createElementBlock("div", {
+          ref_key: "affixRef",
+          ref: affixRef,
+          style: Vue.normalizeStyle(affixStyle.value),
+          class: Vue.normalizeClass([{
+            "is-fixed": isFixed.value,
+            "is-top": props.position === "top",
+            "is-bottom": props.position === "bottom"
+          }, "yx-affix-content"])
+        }, [
+          Vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 6)), [
+          [_directive_resize, onResize]
+        ])
+      ], 4);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/container/flex/flex-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const flexRuntime_vue_vue_type_script_setup_true_lang = require("./flex-runtime.vue2.js");
+module.exports = flexRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/container/flex/flex-runtime.vue2.js

@@ -0,0 +1,82 @@
+"use strict";
+const Vue = require("vue");
+const objectRender_vue_vue_type_script_setup_true_lang = require("../../object-render.vue.js");
+const pageDesignTypes = require("../../../../utils/interfaces/page-design-types.js");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "flex-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const thisRef = Vue.ref(null);
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const designProperty = Vue.ref(runtimeInfo.props ? runtimeInfo.props : {});
+    if (props.configure.items) {
+      const pageDimensions = props.pageContext && props.pageContext.dimensions ? props.pageContext.dimensions : pageDesignTypes.PageDimensions.PC;
+      for (let item of props.configure.items) {
+        const itemCommon = item.runtime && item.runtime.common ? item.runtime.common : {};
+        const sizeStyle = itemCommon.style ? itemCommon.style[pageDimensions + "_style"] : void 0;
+        const itemStyle = {};
+        if (sizeStyle) {
+          item.flexSpan = sizeStyle.flexSpan ? sizeStyle.flexSpan : -2;
+          Object.assign(itemStyle, sizeStyle);
+          delete itemStyle.height;
+          delete sizeStyle.width;
+        }
+        item.itemStyle = itemStyle;
+        if (itemCommon.style) {
+          itemCommon.style[pageDimensions + "_class"] = "";
+        }
+      }
+    }
+    Vue.onMounted(() => {
+      Vue.nextTick(() => {
+        eventUtil.handleAfterInitEvent(null, props.pageContext, props.configure, {
+          componentRef: thisRef.value,
+          entity: props.pageContext.entity.data,
+          pageData: props.pageContext.entity.page
+        });
+      });
+    });
+    return (_ctx, _cache) => {
+      const _component_el_col = Vue.resolveComponent("el-col");
+      const _component_el_row = Vue.resolveComponent("el-row");
+      return Vue.openBlock(), Vue.createBlock(_component_el_row, {
+        ref_key: "thisRef",
+        ref: thisRef,
+        justify: designProperty.value.flexJustify,
+        gutter: designProperty.value.flexGutter,
+        align: designProperty.value.alignItems,
+        style: Vue.normalizeStyle([{ "display": "flex" }, Vue.unref(runtimeStyle)]),
+        class: Vue.normalizeClass(Vue.unref(runtimeClass))
+      }, {
+        default: Vue.withCtx(() => [
+          (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(_ctx.configure.items, (element, itemIndex) => {
+            return Vue.withDirectives((Vue.openBlock(), Vue.createBlock(_component_el_col, {
+              key: element.uuid,
+              style: Vue.normalizeStyle(element.itemStyle),
+              span: element.flexSpan
+            }, {
+              default: Vue.withCtx(() => [
+                Vue.createVNode(objectRender_vue_vue_type_script_setup_true_lang, {
+                  pageContext: _ctx.pageContext,
+                  configure: element
+                }, null, 8, ["pageContext", "configure"])
+              ]),
+              _: 2
+            }, 1032, ["style", "span"])), [
+              [Vue.vShow, element._dynamicShowFlag]
+            ]);
+          }), 128))
+        ]),
+        _: 1
+      }, 8, ["justify", "gutter", "align", "style", "class"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/container/form/form-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const formRuntime_vue_vue_type_script_setup_true_lang = require("./form-runtime.vue2.js");
+module.exports = formRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/container/form/form-runtime.vue2.js

@@ -0,0 +1,69 @@
+"use strict";
+const Vue = require("vue");
+const objectRender_vue_vue_type_script_setup_true_lang = require("../../object-render.vue.js");
+const pageDesignTypes = require("../../../../utils/interfaces/page-design-types.js");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "form-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props) {
+    const props = __props;
+    if (!props.configure.items) {
+      props.configure.items = [];
+    }
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeProps = runtimeInfo.props ? runtimeInfo.props : {};
+    const runtimeStyle = Vue.ref(runtimeInfo.style ? runtimeInfo.style : {});
+    const runtimeClass = runtimeInfo.class;
+    const titleStyle = Vue.ref(runtimeInfo.titleStyle ? runtimeInfo.titleStyle : {});
+    const labelPosition = Vue.ref(runtimeProps.labelPosition);
+    const thisRef = Vue.ref(null);
+    const pageDimensionType = props.pageContext && props.pageContext.dimensions ? props.pageContext.dimensions : pageDesignTypes.PageDimensions.PC;
+    if (pageDimensionType && pageDimensionType === pageDesignTypes.PageDimensions.PHONE) {
+      labelPosition.value = "top";
+    }
+    Vue.onMounted(() => {
+      Vue.nextTick(() => {
+        eventUtil.handleFormEvent(null, props.pageContext, props.configure, "afterFormLoad", {
+          componentRef: thisRef.value,
+          entity: props.pageContext.entity.data,
+          pageData: props.pageContext.entity.page
+        });
+      });
+    });
+    return (_ctx, _cache) => {
+      const _component_el_form = Vue.resolveComponent("el-form");
+      return Vue.openBlock(), Vue.createElementBlock("div", null, [
+        Vue.createVNode(_component_el_form, {
+          ref_key: "thisRef",
+          ref: thisRef,
+          "label-width": Vue.unref(runtimeProps).labelWidth,
+          "label-position": labelPosition.value,
+          size: Vue.unref(runtimeProps).componentSize,
+          style: Vue.normalizeStyle(runtimeStyle.value),
+          class: Vue.normalizeClass(Vue.unref(runtimeClass))
+        }, {
+          default: Vue.withCtx(() => [
+            Vue.unref(runtimeProps).formTitle ? (Vue.openBlock(), Vue.createElementBlock("div", {
+              key: 0,
+              class: "amb-widget-form-title",
+              style: Vue.normalizeStyle(titleStyle.value)
+            }, Vue.toDisplayString(Vue.unref(runtimeProps).formTitle), 5)) : Vue.createCommentVNode("", true),
+            (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(_ctx.configure.items, (element, itemIndex) => {
+              return Vue.openBlock(), Vue.createBlock(objectRender_vue_vue_type_script_setup_true_lang, {
+                key: element.uuid,
+                pageContext: _ctx.pageContext,
+                configure: element
+              }, null, 8, ["pageContext", "configure"]);
+            }), 128))
+          ]),
+          _: 1
+        }, 8, ["label-width", "label-position", "size", "style", "class"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/container/iframe/iframe-runtime.vue.js

@@ -0,0 +1,3 @@
+"use strict";
+const iframeRuntime_vue_vue_type_script_setup_true_lang = require("./iframe-runtime.vue2.js");
+module.exports = iframeRuntime_vue_vue_type_script_setup_true_lang;

package/dist/lib/components/runtime/views/assemblys/container/iframe/iframe-runtime.vue2.js

@@ -0,0 +1,40 @@
+"use strict";
+const Vue = require("vue");
+require("../../../../utils/global-refs.js");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const _hoisted_1 = ["src"];
+const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
+  __name: "iframe-runtime",
+  props: {
+    pageContext: {},
+    configure: {},
+    indexObj: {},
+    selectWidget: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const thisRef = Vue.ref(null);
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    Vue.onMounted(() => {
+      Vue.nextTick(() => {
+        eventUtil.handleAfterInitEvent(null, props.pageContext, props.configure, {
+          componentRef: thisRef.value,
+          entity: props.pageContext.entity.data,
+          pageData: props.pageContext.entity.page
+        });
+      });
+    });
+    return (_ctx, _cache) => {
+      return Vue.openBlock(), Vue.createElementBlock("iframe", {
+        ref_key: "thisRef",
+        ref: thisRef,
+        src: _ctx.configure.props.src,
+        class: Vue.normalizeClass(["amb-widget-container-iframe", Vue.unref(runtimeClass)]),
+        style: Vue.normalizeStyle(Vue.unref(runtimeStyle))
+      }, null, 14, _hoisted_1);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/components/runtime/views/assemblys/container/tabs/tabs-runtime.vue.js

@@ -0,0 +1,6 @@
+"use strict";
+const tabsRuntime_vue_vue_type_script_setup_true_lang = require("./tabs-runtime.vue2.js");
+;/* empty css                   */
+const _pluginVue_exportHelper = require("../../../../../../_virtual/_plugin-vue_export-helper.js");
+const tabsRuntime = /* @__PURE__ */ _pluginVue_exportHelper(tabsRuntime_vue_vue_type_script_setup_true_lang, [["__scopeId", "data-v-df9efce2"]]);
+module.exports = tabsRuntime;