vft 0.0.373 → 0.0.375

package/es/components/router-view-content/router-view-content.vue2.js

@@ -1,55 +1,79 @@
-import { defineComponent as v, computed as u, resolveComponent as C, createBlock as n, openBlock as a, withCtx as m, createVNode as d, unref as r, KeepAlive as A, createCommentVNode as k, resolveDynamicComponent as f, Transition as B, mergeProps as N } from "vue";
-import { getRouterKeyPath as R } from "@vft/router";
+import { defineComponent, computed, resolveComponent, createBlock, openBlock, withCtx, createVNode, unref, KeepAlive, createCommentVNode, resolveDynamicComponent, Transition, mergeProps } from "vue";
+import { getRouterKeyPath } from "@vft/router";
 import "vue-router";
-import { createReusableTemplate as K } from "@vueuse/core";
-const P = v({
+import { createReusableTemplate } from "@vueuse/core";
+const __default__ = defineComponent({
   name: "vft-router-view-content"
-}), x = /* @__PURE__ */ v({
-  ...P,
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
   props: {
     cacheList: {},
     transitionName: {},
     transitionAttr: {},
-    openKeepAlive: { type: Boolean, default: !0 },
+    openKeepAlive: { type: Boolean, default: true },
     isReloadFlag: { type: Boolean },
     pageErrorStatus: { type: Boolean },
     enableErrorHandle: { type: Boolean },
     exceptionComp: {}
   },
-  setup(t) {
-    const h = u(() => t.openKeepAlive ? t.cacheList : []), c = u(() => (e) => t.enableErrorHandle && t.pageErrorStatus && t.exceptionComp || e), y = u(() => (e) => {
-      let o = e.name;
-      return e.meta?.currentActivePath && (o = e.matched?.filter((l) => l.path === e.meta?.currentActivePath)?.[0].name), t.isReloadFlag ? void 0 : o;
-    }), [g, s] = K();
-    return (e, o) => {
-      const l = C("router-view");
-      return a(), n(l, null, {
-        default: m(({ Component: p, route: i }) => [
-          d(r(g), null, {
-            default: m(() => [
-              e.openKeepAlive ? (a(), n(A, {
+  setup(__props) {
+    const getCaches = computed(() => {
+      if (!__props.openKeepAlive) {
+        return [];
+      }
+      return __props.cacheList;
+    });
+    const pageComponent = computed(() => {
+      return (component) => {
+        if (__props.enableErrorHandle) {
+          return __props.pageErrorStatus ? __props.exceptionComp || component : component;
+        } else {
+          return component;
+        }
+      };
+    });
+    const excludeNames = computed(() => {
+      return (route) => {
+        let name = route.name;
+        if (route.meta?.currentActivePath) {
+          name = route.matched?.filter((item) => {
+            return item.path === route.meta?.currentActivePath;
+          })?.[0].name;
+        }
+        return __props.isReloadFlag ? void 0 : name;
+      };
+    });
+    const [DefineTemplate, ReuseTemplate] = createReusableTemplate();
+    return (_ctx, _cache) => {
+      const _component_router_view = resolveComponent("router-view");
+      return openBlock(), createBlock(_component_router_view, null, {
+        default: withCtx(({ Component: Comp, route }) => [
+          createVNode(unref(DefineTemplate), null, {
+            default: withCtx(() => [
+              _ctx.openKeepAlive ? (openBlock(), createBlock(KeepAlive, {
                 key: 0,
-                include: h.value,
-                exclude: y.value(i)
+                include: getCaches.value,
+                exclude: excludeNames.value(route)
               }, [
-                e.isReloadFlag ? (a(), n(f(c.value(p)), {
-                  key: r(R)(i)
-                })) : k("", !0)
-              ], 1032, ["include", "exclude"])) : (a(), n(f(c.value(p)), {
-                key: i.fullPath
+                _ctx.isReloadFlag ? (openBlock(), createBlock(resolveDynamicComponent(pageComponent.value(Comp)), {
+                  key: unref(getRouterKeyPath)(route)
+                })) : createCommentVNode("", true)
+              ], 1032, ["include", "exclude"])) : (openBlock(), createBlock(resolveDynamicComponent(pageComponent.value(Comp)), {
+                key: route.fullPath
               }))
             ]),
             _: 2
           }, 1024),
-          e.transitionName ? (a(), n(B, N({
+          _ctx.transitionName ? (openBlock(), createBlock(Transition, mergeProps({
             key: 0,
-            name: e.transitionName
-          }, e.transitionAttr), {
-            default: m(() => [
-              d(r(s))
+            name: _ctx.transitionName
+          }, _ctx.transitionAttr), {
+            default: withCtx(() => [
+              createVNode(unref(ReuseTemplate))
             ]),
             _: 1
-          }, 16, ["name"])) : (a(), n(r(s), { key: 1 }))
+          }, 16, ["name"])) : (openBlock(), createBlock(unref(ReuseTemplate), { key: 1 }))
         ]),
         _: 1
       });
@@ -57,5 +81,5 @@ const P = v({
   }
 });
 export {
-  x as default
+  _sfc_main as default
 };

package/es/components/roving-focus-group/index.js

@@ -1,23 +1,23 @@
-import t from "./roving-focus-group.vue2.js";
-import { default as I } from "./roving-focus-group-impl.vue2.js";
-import { default as _ } from "./roving-focus-item.vue2.js";
-import { ROVING_FOCUS_COLLECTION_INJECTION_KEY as O, ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY as l, VftCollection as s, VftCollectionItem as c, VftCollection as N, VftCollectionItem as i } from "./types.js";
-import { ROVING_FOCUS_GROUP_INJECTION_KEY as n, ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY as u } from "./tokens.js";
-import { focusFirst as E, getFocusIntent as a, reorderArray as p } from "./utils.js";
+import _sfc_main from "./roving-focus-group.vue2.js";
+import { default as default2 } from "./roving-focus-group-impl.vue2.js";
+import { default as default3 } from "./roving-focus-item.vue2.js";
+import { ROVING_FOCUS_COLLECTION_INJECTION_KEY, ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY, VftCollection, VftCollectionItem, VftCollection as VftCollection2, VftCollectionItem as VftCollectionItem2 } from "./types.js";
+import { ROVING_FOCUS_GROUP_INJECTION_KEY, ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY } from "./tokens.js";
+import { focusFirst, getFocusIntent, reorderArray } from "./utils.js";
 export {
-  O as ROVING_FOCUS_COLLECTION_INJECTION_KEY,
-  n as ROVING_FOCUS_GROUP_INJECTION_KEY,
-  u as ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY,
-  l as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY,
-  s as VftCollection,
-  c as VftCollectionItem,
-  N as VftFocusGroupCollection,
-  i as VftRovingFocusCollectionItem,
-  t as VftRovingFocusGroup,
-  I as VftRovingFocusGroupImpl,
-  _ as VftRovingFocusItem,
-  t as default,
-  E as focusFirst,
-  a as getFocusIntent,
-  p as reorderArray
+  ROVING_FOCUS_COLLECTION_INJECTION_KEY,
+  ROVING_FOCUS_GROUP_INJECTION_KEY,
+  ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY,
+  ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY,
+  VftCollection,
+  VftCollectionItem,
+  VftCollection2 as VftFocusGroupCollection,
+  VftCollectionItem2 as VftRovingFocusCollectionItem,
+  _sfc_main as VftRovingFocusGroup,
+  default2 as VftRovingFocusGroupImpl,
+  default3 as VftRovingFocusItem,
+  _sfc_main as default,
+  focusFirst,
+  getFocusIntent,
+  reorderArray
 };

package/es/components/roving-focus-group/roving-focus-group-impl.vue.js

@@ -1,4 +1,4 @@
-import f from "./roving-focus-group-impl.vue2.js";
+import _sfc_main from "./roving-focus-group-impl.vue2.js";
 export {
-  f as default
+  _sfc_main as default
 };

package/es/components/roving-focus-group/roving-focus-group-impl.vue2.js

@@ -1,17 +1,20 @@
-import { defineComponent as b, ref as r, inject as L, computed as _, unref as s, provide as U, toRef as i, readonly as A, watch as K, renderSlot as Y } from "vue";
-import { useEventListener as J } from "@vueuse/core";
+import { defineComponent, ref, inject, computed, unref, provide, toRef, readonly, watch, renderSlot } from "vue";
+import { useEventListener } from "@vueuse/core";
 import "@vft/utils";
-import { composeEventHandlers as l } from "../../utils/event.js";
+import { composeEventHandlers } from "../../utils/event.js";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { ROVING_FOCUS_GROUP_INJECTION_KEY as M } from "./tokens.js";
-import { ROVING_FOCUS_COLLECTION_INJECTION_KEY as P } from "./types.js";
-import { focusFirst as j } from "./utils.js";
-const k = "currentTabIdChange", T = "rovingFocusGroup.entryFocus", x = b({
+import { ROVING_FOCUS_GROUP_INJECTION_KEY } from "./tokens.js";
+import { ROVING_FOCUS_COLLECTION_INJECTION_KEY as COLLECTION_INJECTION_KEY } from "./types.js";
+import { focusFirst } from "./utils.js";
+const CURRENT_TAB_ID_CHANGE_EVT = "currentTabIdChange";
+const ENTRY_FOCUS_EVT = "rovingFocusGroup.entryFocus";
+const __default__ = defineComponent({
   name: "VftRovingFocusGroupImpl",
-  inheritAttrs: !1
-}), ot = /* @__PURE__ */ b({
-  ...x,
+  inheritAttrs: false
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
   props: {
     style: { type: [Boolean, null, String, Object, Array] },
     currentTabId: {},
@@ -24,75 +27,104 @@ const k = "currentTabIdChange", T = "rovingFocusGroup.entryFocus", x = b({
     onMousedown: {}
   },
   emits: ["currentTabIdChange", "entryFocus"],
-  setup(E, { emit: v }) {
-    const o = E, d = v, F = { bubbles: !1, cancelable: !0 }, c = r(
-      (o.currentTabId || o.defaultCurrentTabId) ?? null
-    ), n = r(!1), u = r(!1), f = r(null), { getItems: C } = L(P, void 0), O = _(() => [
-      {
-        outline: "none"
-      },
-      o.style
-    ]), N = (t) => {
-      d(k, t);
-    }, y = () => {
-      n.value = !0;
-    }, g = l(
-      (t) => {
-        o.onMousedown?.(t);
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const EVT_OPTS = { bubbles: false, cancelable: true };
+    const currentTabbedId = ref(
+      (props.currentTabId || props.defaultCurrentTabId) ?? null
+    );
+    const isBackingOut = ref(false);
+    const isClickFocus = ref(false);
+    const rovingFocusGroupRef = ref(null);
+    const { getItems } = inject(COLLECTION_INJECTION_KEY, void 0);
+    const rovingFocusGroupRootStyle = computed(() => {
+      return [
+        {
+          outline: "none"
+        },
+        props.style
+      ];
+    });
+    const onItemFocus = (tabbedId) => {
+      emit(CURRENT_TAB_ID_CHANGE_EVT, tabbedId);
+    };
+    const onItemShiftTab = () => {
+      isBackingOut.value = true;
+    };
+    const onMousedown = composeEventHandlers(
+      (e) => {
+        props.onMousedown?.(e);
       },
       () => {
-        u.value = !0;
+        isClickFocus.value = true;
       }
-    ), R = l(
-      (t) => {
-        o.onFocus?.(t);
+    );
+    const onFocus = composeEventHandlers(
+      (e) => {
+        props.onFocus?.(e);
       },
-      (t) => {
-        const m = !s(u), { target: G, currentTarget: p } = t;
-        if (G === p && m && !s(n)) {
-          const I = new Event(T, F);
-          if (p?.dispatchEvent(I), !I.defaultPrevented) {
-            const a = C().filter((e) => e.focusable), S = a.find((e) => e.active), V = a.find(
-              (e) => e.id === s(c)
-            ), w = [S, V, ...a].filter(
+      (e) => {
+        const isKeyboardFocus = !unref(isClickFocus);
+        const { target, currentTarget } = e;
+        if (target === currentTarget && isKeyboardFocus && !unref(isBackingOut)) {
+          const entryFocusEvt = new Event(ENTRY_FOCUS_EVT, EVT_OPTS);
+          currentTarget?.dispatchEvent(entryFocusEvt);
+          if (!entryFocusEvt.defaultPrevented) {
+            const items = getItems().filter((item) => item.focusable);
+            const activeItem = items.find((item) => item.active);
+            const currentItem = items.find(
+              (item) => item.id === unref(currentTabbedId)
+            );
+            const candidates = [activeItem, currentItem, ...items].filter(
               Boolean
-            ).map((e) => e.ref);
-            j(w);
+            );
+            const candidateNodes = candidates.map((item) => item.ref);
+            focusFirst(candidateNodes);
           }
         }
-        u.value = !1;
+        isClickFocus.value = false;
       }
-    ), h = l(
-      (t) => {
-        o.onBlur?.(t);
+    );
+    const onBlur = composeEventHandlers(
+      (e) => {
+        props.onBlur?.(e);
       },
       () => {
-        n.value = !1;
+        isBackingOut.value = false;
       }
-    ), B = (...t) => {
-      d("entryFocus", ...t);
+    );
+    const handleEntryFocus = (...args) => {
+      emit("entryFocus", ...args);
     };
-    return U(M, {
-      currentTabbedId: A(c),
-      loop: i(o, "loop"),
-      tabIndex: _(() => s(n) ? -1 : 0),
-      rovingFocusGroupRef: f,
-      rovingFocusGroupRootStyle: O,
-      orientation: i(o, "orientation"),
-      dir: i(o, "dir"),
-      onItemFocus: N,
-      onItemShiftTab: y,
-      onBlur: h,
-      onFocus: R,
-      onMousedown: g
-    }), K(
-      () => o.currentTabId,
-      (t) => {
-        c.value = t ?? null;
+    provide(ROVING_FOCUS_GROUP_INJECTION_KEY, {
+      currentTabbedId: readonly(currentTabbedId),
+      loop: toRef(props, "loop"),
+      tabIndex: computed(() => {
+        return unref(isBackingOut) ? -1 : 0;
+      }),
+      rovingFocusGroupRef,
+      rovingFocusGroupRootStyle,
+      orientation: toRef(props, "orientation"),
+      dir: toRef(props, "dir"),
+      onItemFocus,
+      onItemShiftTab,
+      onBlur,
+      onFocus,
+      onMousedown
+    });
+    watch(
+      () => props.currentTabId,
+      (val) => {
+        currentTabbedId.value = val ?? null;
       }
-    ), J(f, T, B), (t, m) => Y(t.$slots, "default");
+    );
+    useEventListener(rovingFocusGroupRef, ENTRY_FOCUS_EVT, handleEntryFocus);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
   }
 });
 export {
-  ot as default
+  _sfc_main as default
 };

package/es/components/roving-focus-group/roving-focus-group.vue.js

@@ -1,4 +1,4 @@
-import f from "./roving-focus-group.vue2.js";
+import _sfc_main from "./roving-focus-group.vue2.js";
 export {
-  f as default
+  _sfc_main as default
 };

package/es/components/roving-focus-group/roving-focus-group.vue2.js

@@ -1,28 +1,31 @@
-import { defineComponent as t, createBlock as c, openBlock as l, unref as u, withCtx as e, createVNode as a, normalizeProps as f, guardReactiveProps as p, renderSlot as s } from "vue";
-import r from "./roving-focus-group-impl.vue2.js";
-import { VftCollection as n } from "./types.js";
-const i = t({
+import { defineComponent, createBlock, openBlock, unref, withCtx, createVNode, normalizeProps, guardReactiveProps, renderSlot } from "vue";
+import _sfc_main$1 from "./roving-focus-group-impl.vue2.js";
+import { VftCollection } from "./types.js";
+const __default__ = defineComponent({
   name: "VftRovingFocusGroup",
   components: {
-    "focus-group-collection": n,
-    "roving-focus-group-impl": r
+    "focus-group-collection": VftCollection,
+    "roving-focus-group-impl": _sfc_main$1
   }
-}), C = /* @__PURE__ */ t({
-  ...i,
-  setup(m) {
-    return (o, _) => (l(), c(u(n), null, {
-      default: e(() => [
-        a(r, f(p(o.$attrs)), {
-          default: e(() => [
-            s(o.$slots, "default")
-          ]),
-          _: 3
-        }, 16)
-      ]),
-      _: 3
-    }));
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(VftCollection), null, {
+        default: withCtx(() => [
+          createVNode(_sfc_main$1, normalizeProps(guardReactiveProps(_ctx.$attrs)), {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 16)
+        ]),
+        _: 3
+      });
+    };
   }
 });
 export {
-  C as default
+  _sfc_main as default
 };

package/es/components/roving-focus-group/roving-focus-item.vue.js

@@ -1,4 +1,4 @@
-import f from "./roving-focus-item.vue2.js";
+import _sfc_main from "./roving-focus-item.vue2.js";
 export {
-  f as default
+  _sfc_main as default
 };

package/es/components/roving-focus-group/roving-focus-item.vue2.js

@@ -1,99 +1,119 @@
-import { defineComponent as p, inject as m, ref as g, unref as r, nextTick as R, computed as l, provide as G, createBlock as K, openBlock as V, withCtx as x, renderSlot as S } from "vue";
-import { EVENT_CODE as U } from "../../constants/aria.js";
+import { defineComponent, inject, ref, unref, nextTick, computed, provide, createBlock, openBlock, withCtx, renderSlot } from "vue";
+import { EVENT_CODE } from "../../constants/aria.js";
 import "@vueuse/core";
 import "@vft/utils";
-import { composeEventHandlers as i } from "../../utils/event.js";
+import { composeEventHandlers } from "../../utils/event.js";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useId as B } from "../../hooks/use-id/index.js";
+import { useId } from "../../hooks/use-id/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-import { ROVING_FOCUS_GROUP_INJECTION_KEY as J, ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY as L } from "./tokens.js";
-import { VftCollectionItem as d, ROVING_FOCUS_COLLECTION_INJECTION_KEY as Y } from "./types.js";
-import { getFocusIntent as D, reorderArray as M, focusFirst as P } from "./utils.js";
-const j = p({
+import { ROVING_FOCUS_GROUP_INJECTION_KEY, ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY } from "./tokens.js";
+import { VftCollectionItem, ROVING_FOCUS_COLLECTION_INJECTION_KEY as COLLECTION_INJECTION_KEY } from "./types.js";
+import { getFocusIntent, reorderArray, focusFirst } from "./utils.js";
+const __default__ = defineComponent({
   name: "VftRovingFocusItem",
   components: {
-    "roving-focus-collection-item": d
+    "roving-focus-collection-item": VftCollectionItem
   }
-}), ce = /* @__PURE__ */ p({
-  ...j,
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
   props: {
-    focusable: { type: Boolean, default: !0 },
-    active: { type: Boolean, default: !1 }
+    focusable: { type: Boolean, default: true },
+    active: { type: Boolean, default: false }
   },
   emits: ["mousedown", "focus", "keydown"],
-  setup(I, { emit: _ }) {
-    const v = I, s = _, { currentTabbedId: O, loop: C, onItemFocus: a, onItemShiftTab: E } = m(
-      J,
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { currentTabbedId, loop, onItemFocus, onItemShiftTab } = inject(
+      ROVING_FOCUS_GROUP_INJECTION_KEY,
       void 0
-    ), { getItems: b } = m(Y, void 0), n = B(), N = g(null), T = i(
+    );
+    const { getItems } = inject(COLLECTION_INJECTION_KEY, void 0);
+    const id = useId();
+    const rovingFocusGroupItemRef = ref(null);
+    const handleMousedown = composeEventHandlers(
       (e) => {
-        s("mousedown", e);
+        emit("mousedown", e);
       },
       (e) => {
-        v.focusable ? a(r(n)) : e.preventDefault();
+        if (!props.focusable) {
+          e.preventDefault();
+        } else {
+          onItemFocus(unref(id));
+        }
       }
-    ), F = i(
+    );
+    const handleFocus = composeEventHandlers(
       (e) => {
-        s("focus", e);
+        emit("focus", e);
       },
       () => {
-        a(r(n));
+        onItemFocus(unref(id));
       }
-    ), h = i(
+    );
+    const handleKeydown = composeEventHandlers(
       (e) => {
-        s("keydown", e);
+        emit("keydown", e);
       },
       (e) => {
-        const { key: f, shiftKey: w, target: y, currentTarget: u } = e;
-        if (f === U.tab && w) {
-          E();
+        const { key, shiftKey, target, currentTarget } = e;
+        if (key === EVENT_CODE.tab && shiftKey) {
+          onItemShiftTab();
           return;
         }
-        if (y !== u) return;
-        const c = D(e);
-        if (c) {
+        if (target !== currentTarget) return;
+        const focusIntent = getFocusIntent(e);
+        if (focusIntent) {
           e.preventDefault();
-          let t = b().filter((o) => o.focusable).map((o) => o.ref);
-          switch (c) {
+          const items = getItems().filter((item) => item.focusable);
+          let elements = items.map((item) => item.ref);
+          switch (focusIntent) {
             case "last": {
-              t.reverse();
+              elements.reverse();
               break;
             }
             case "prev":
             case "next": {
-              c === "prev" && t.reverse();
-              const o = t.indexOf(u);
-              t = C.value ? M(t, o + 1) : t.slice(o + 1);
+              if (focusIntent === "prev") {
+                elements.reverse();
+              }
+              const currentIdx = elements.indexOf(currentTarget);
+              elements = loop.value ? reorderArray(elements, currentIdx + 1) : elements.slice(currentIdx + 1);
               break;
             }
           }
-          R(() => {
-            P(t);
+          nextTick(() => {
+            focusFirst(elements);
           });
         }
       }
-    ), k = l(() => O.value === r(n));
-    return G(L, {
-      rovingFocusGroupItemRef: N,
-      tabIndex: l(() => r(k) ? 0 : -1),
-      handleMousedown: T,
-      handleFocus: F,
-      handleKeydown: h
-    }), (e, f) => (V(), K(r(d), {
-      id: r(n),
-      focusable: e.focusable,
-      active: e.active
-    }, {
-      default: x(() => [
-        S(e.$slots, "default")
-      ]),
-      _: 3
-    }, 8, ["id", "focusable", "active"]));
+    );
+    const isCurrentTab = computed(() => currentTabbedId.value === unref(id));
+    provide(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, {
+      rovingFocusGroupItemRef,
+      tabIndex: computed(() => unref(isCurrentTab) ? 0 : -1),
+      handleMousedown,
+      handleFocus,
+      handleKeydown
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(VftCollectionItem), {
+        id: unref(id),
+        focusable: _ctx.focusable,
+        active: _ctx.active
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["id", "focusable", "active"]);
+    };
   }
 });
 export {
-  ce as default
+  _sfc_main as default
 };

package/es/components/roving-focus-group/tokens.js

@@ -1,5 +1,6 @@
-const o = Symbol("vftRovingFocusGroup"), _ = Symbol("vftRovingFocusGroupItem");
+const ROVING_FOCUS_GROUP_INJECTION_KEY = Symbol("vftRovingFocusGroup");
+const ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY = Symbol("vftRovingFocusGroupItem");
 export {
-  o as ROVING_FOCUS_GROUP_INJECTION_KEY,
-  _ as ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY
+  ROVING_FOCUS_GROUP_INJECTION_KEY,
+  ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY
 };

package/es/components/roving-focus-group/types.js

@@ -1,13 +1,13 @@
-import { createCollectionWithScope as C } from "../collection/collection.js";
+import { createCollectionWithScope } from "../collection/collection.js";
 const {
-  VftCollection: O,
-  VftCollectionItem: o,
-  COLLECTION_INJECTION_KEY: E,
-  COLLECTION_ITEM_INJECTION_KEY: N
-} = C("RovingFocusGroup");
+  VftCollection,
+  VftCollectionItem,
+  COLLECTION_INJECTION_KEY,
+  COLLECTION_ITEM_INJECTION_KEY
+} = createCollectionWithScope("RovingFocusGroup");
 export {
-  E as ROVING_FOCUS_COLLECTION_INJECTION_KEY,
-  N as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY,
-  O as VftCollection,
-  o as VftCollectionItem
+  COLLECTION_INJECTION_KEY as ROVING_FOCUS_COLLECTION_INJECTION_KEY,
+  COLLECTION_ITEM_INJECTION_KEY as ROVING_FOCUS_ITEM_COLLECTION_INJECTION_KEY,
+  VftCollection,
+  VftCollectionItem
 };