@maas/vue-equipment 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/plugins/MagicScroll/src/components/MagicScrollScene.vue.d.ts

@@ -3,32 +3,21 @@ interface MagicScrollSceneProps {
     from?: ScrollIntersection;
     to?: ScrollIntersection;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {
-            progress: number;
-        }): any;
-    };
-    refs: {
-        elRef: HTMLDivElement;
-    };
-    rootEl: HTMLDivElement;
+declare const progress: import("vue").ShallowRef<number, number>;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_1: {
+    progress: number;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicScrollSceneProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicScrollSceneProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    default?: (props: typeof __VLS_1) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<MagicScrollSceneProps, {
+    progress: typeof progress;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollSceneProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<MagicScrollSceneProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicScrollSceneProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicScroll/src/composables/private/useCollisionDetection.d.ts

@@ -2,8 +2,8 @@ import { type MaybeRef } from 'vue';
 import type { CollisionOffset } from '../../types/index.js';
 type UseCollisionDetectionArgs = {
     id: string;
-    child: MaybeRef<HTMLElement | undefined>;
-    parent: MaybeRef<HTMLElement | undefined>;
+    child: MaybeRef<HTMLElement | null>;
+    parent: MaybeRef<HTMLElement | null | undefined>;
     scrollY: MaybeRef<number>;
     offset?: CollisionOffset;
 };

package/dist/plugins/MagicScroll/src/composables/private/useCollisionDetection.mjs

@@ -1,5 +1,5 @@
-import { ref, reactive, computed, toValue } from "vue";
-import { useElementBounding } from "@vueuse/core";
+import { shallowRef, reactive, computed, toValue } from "vue";
+import { useElementBounding, useWindowSize } from "@vueuse/core";
 import { useMagicEmitter } from "@maas/vue-equipment/plugins";
 export function useCollisionDetection(args) {
   const { id, scrollY, child, parent, offset } = args;
@@ -25,11 +25,21 @@ export function useCollisionDetection(args) {
       }
     }
   });
+  const { width, height } = useWindowSize();
+  const windowBoundingRect = {
+    width,
+    height,
+    right: width,
+    bottom: height,
+    top: shallowRef(0),
+    left: shallowRef(0)
+  };
   const childBoundingRect = useElementBounding(child);
   const parentBoundingRect = useElementBounding(parent);
+  const mappedParentBoundingRect = toValue(parent) ? parentBoundingRect : windowBoundingRect;
   const mappedOffset = { top: 0, bottom: 0, ...offset };
-  const lastScrollY = ref(0);
-  const scrollDirection = ref();
+  const lastScrollY = shallowRef(0);
+  const scrollDirection = shallowRef();
   const oppositeScrollDirection = computed(
     () => scrollDirection.value === "up" ? "down" : "up"
   );
@@ -101,7 +111,7 @@ export function useCollisionDetection(args) {
     }
     const offset2 = mappedOffset[parentEdge];
     const mappedChildEdge = toValue(childBoundingRect[childEdge]);
-    const mappedParentEdge = toValue(parentBoundingRect[parentEdge]) + offset2;
+    const mappedParentEdge = toValue(mappedParentBoundingRect[parentEdge]) + offset2;
     if (direction === "down" && mappedChildEdge <= mappedParentEdge || direction === "up" && mappedChildEdge >= mappedParentEdge) {
       alerted[direction][childEdge][parentEdge] = true;
       useMagicEmitter().emit("collision", {
@@ -119,7 +129,7 @@ export function useCollisionDetection(args) {
     }
     const offset2 = mappedOffset[parentEdge];
     const mappedChildEdge = toValue(childBoundingRect[childEdge]);
-    const mappedParentEdge = toValue(parentBoundingRect[parentEdge]) + offset2;
+    const mappedParentEdge = toValue(mappedParentBoundingRect[parentEdge]) + offset2;
     if (direction === "down" && mappedChildEdge >= mappedParentEdge || direction === "up" && mappedChildEdge <= mappedParentEdge) {
       alerted[direction][childEdge][parentEdge] = false;
     }

package/dist/plugins/MagicScroll/src/composables/private/useScrollApi.d.ts

@@ -1,12 +1,12 @@
 import { type MaybeRef, type MaybeRefOrGetter } from 'vue';
 import type { ScrollIntersection } from '../../types/index.js';
-type UseScrollApiParams = {
+type UseScrollApiArgs = {
     child: MaybeRef<HTMLElement | null | undefined>;
     parent: MaybeRefOrGetter<HTMLElement | null | undefined>;
     from: ScrollIntersection;
     to: ScrollIntersection;
 };
-export declare function useScrollApi(params: UseScrollApiParams): {
+export declare function useScrollApi(args: UseScrollApiArgs): {
     getCalculations: () => void;
     getProgress: () => number;
 };

package/dist/plugins/MagicScroll/src/composables/private/useScrollApi.mjs

@@ -1,14 +1,28 @@
-import { ref, inject, toValue } from "vue";
-import { useWindowSize } from "@vueuse/core";
-import { MagicScrollReturn } from "../../symbols/index.mjs";
+import {
+  shallowRef,
+  inject,
+  toValue
+} from "vue";
+import { useElementBounding, useWindowSize } from "@vueuse/core";
 import { clampValue } from "@maas/vue-equipment/utils";
-export function useScrollApi(params) {
-  const { child, parent, from, to } = params;
+import { MagicScrollReturn } from "../../symbols/index.mjs";
+export function useScrollApi(args) {
+  const { child, parent, from, to } = args;
   const scrollReturn = inject(MagicScrollReturn, void 0);
-  const childRect = ref(void 0);
-  const parentRect = ref(void 0);
-  const start = ref(0);
-  const end = ref(0);
+  const start = shallowRef(0);
+  const end = shallowRef(0);
+  const { width, height } = useWindowSize();
+  const windowBoundingRect = {
+    width,
+    height,
+    right: width,
+    bottom: height,
+    top: shallowRef(0),
+    left: shallowRef(0)
+  };
+  const childBoundingRect = useElementBounding(child);
+  const parentBoundingRect = useElementBounding(parent);
+  const mappedParentBoundingRect = toValue(parent) ? parentBoundingRect : windowBoundingRect;
   function splitLocation(location) {
     return {
       child: location.match(/^[a-z]+/)[0],
@@ -17,51 +31,52 @@ export function useScrollApi(params) {
   }
   function getOffsetTop(points) {
     let y = 0;
-    if (!childRect.value) return y;
     const scrollY = toValue(scrollReturn?.y) || 0;
+    const parentTop = mappedParentBoundingRect.top.value;
+    const parentHeight = mappedParentBoundingRect.height.value;
+    const childTop = childBoundingRect.top.value;
+    const childHeight = childBoundingRect.height.value;
+    if (!childHeight) {
+      return y;
+    }
     switch (points.child) {
       case "top":
-        y += childRect.value.top + scrollY;
+        y += childTop + scrollY;
         break;
       case "center":
-        y += childRect.value.top + childRect.value.height / 2 + scrollY;
+        y += childTop + childHeight / 2 + scrollY;
         break;
       case "bottom":
-        y += childRect.value.top + childRect.value.height + scrollY;
+        y += childTop + childHeight + scrollY;
         break;
     }
-    if (!parentRect.value) {
+    if (!mappedParentBoundingRect.height.value) {
       return y;
     }
-    const dimensions = {
-      width: toValue(parentRect.value.width),
-      height: toValue(parentRect.value.height),
-      top: toValue(parentRect.value.top)
-    };
     switch (points.parent) {
       case "top":
-        y -= dimensions.top;
+        y -= parentTop;
         break;
       case "center":
-        y -= dimensions.top + dimensions.height / 2;
+        y -= parentTop + parentHeight / 2;
         break;
       case "bottom":
-        y -= dimensions.top + dimensions.height;
+        y -= parentTop + parentHeight;
         break;
       case "initial":
-        y -= childRect.value.top + scrollY;
+        y -= childTop + scrollY;
         break;
     }
     return y;
   }
   function getCalculations() {
-    childRect.value = toValue(child)?.getBoundingClientRect();
-    parentRect.value = toValue(parent) ? toValue(parent)?.getBoundingClientRect() : { ...useWindowSize(), top: 0 };
+    childBoundingRect.update();
+    parentBoundingRect.update();
     start.value = getOffsetTop(splitLocation(from));
     end.value = getOffsetTop(splitLocation(to));
   }
   function getProgress() {
-    const scrollY = toValue(scrollReturn?.y) || 0;
+    const scrollY = toValue(scrollReturn?.y) ?? 0;
     const total = Math.abs(end.value - start.value);
     const current = scrollY - start.value;
     return clampValue(current / total, 0, 1);

package/dist/plugins/MagicScroll/src/symbols/index.d.ts

@@ -1,6 +1,6 @@
 import type { InjectionKey, Ref, MaybeRef } from 'vue';
 import type { UseScrollReturn } from '@vueuse/core';
-declare const MagicScrollTarget: InjectionKey<MaybeRef<HTMLElement | undefined>>;
+declare const MagicScrollTarget: InjectionKey<MaybeRef<HTMLElement | null | undefined>>;
 declare const MagicScrollProgress: InjectionKey<Ref<number>>;
 declare const MagicScrollReturn: InjectionKey<UseScrollReturn | undefined>;
 export { MagicScrollTarget, MagicScrollProgress, MagicScrollReturn };

package/dist/plugins/MagicToast/nuxt.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@nuxt/schema").NuxtModule<import("@nuxt/schema").ModuleOptions, import("@nuxt/schema").ModuleOptions, false>;
+declare const _default: import("nuxt/schema").NuxtModule<import("nuxt/schema").ModuleOptions, import("nuxt/schema").ModuleOptions, false>;
 export default _default;

package/dist/plugins/MagicToast/src/components/MagicToastProvider.vue

@@ -1,17 +1,55 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { unref as _unref, renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, resolveDynamicComponent as _resolveDynamicComponent, mergeProps as _mergeProps, createBlock as _createBlock, withCtx as _withCtx, TransitionGroup as _TransitionGroup, createVNode as _createVNode, createElementVNode as _createElementVNode, Teleport as _Teleport } from "vue";
-const _hoisted_1 = ["id", "data-position", "data-expanded"];
+<template>
+  <teleport
+    :to="state.options.teleport?.target"
+    :disabled="state.options.teleport?.disabled"
+  >
+    <div
+      :data-id="mappedId"
+      :data-position="state.options.position"
+      :data-expanded="state.expanded"
+      class="magic-toast-provider"
+      v-bind="$attrs"
+    >
+      <transition-group
+        ref="list"
+        tag="ol"
+        class="magic-toast-provider__list"
+        :name="state.options.transition"
+        :on-before-enter="onBeforeEnter"
+        :on-enter="onEnter"
+        :on-after-enter="onAfterEnter"
+        :on-before-leave="onBeforeLeave"
+        :on-leave="onLeave"
+        :on-after-leave="onAfterLeave"
+        @mouseenter="onMouseenter"
+        @mouseleave="onMouseleave"
+      >
+        <magic-toast-view
+          v-for="(view, index) in state.views"
+          :id="view.id"
+          :key="view.id"
+          :index="index"
+        >
+          <component
+            :is="view.component"
+            v-bind="view.props"
+            @remove="deleteView(view.id)"
+          />
+        </magic-toast-view>
+      </transition-group>
+    </div>
+  </teleport>
+</template>
+
+<script setup>
 import {
   toValue,
-  ref,
+  useTemplateRef,
   provide,
-  useId,
   watch,
   onBeforeUnmount
 } from "vue";
 import { onClickOutside } from "@vueuse/core";
-import { defu } from "defu";
 import { useToastState } from "../composables/private/useToastState";
 import { useToastView } from "../composables/private/useToastView";
 import { useToastCallback } from "../composables/private/useToastCallback";
@@ -24,103 +62,41 @@ import "@maas/vue-equipment/utils/css/animations/slide-ltr-out.css";
 import "@maas/vue-equipment/utils/css/animations/slide-rtl-in.css";
 import "@maas/vue-equipment/utils/css/animations/slide-rtl-out.css";
 import { useToastListener } from "../composables/private/useToastListener";
-export default /* @__PURE__ */ _defineComponent({
-  ...{
-    inheritAttrs: false
-  },
-  __name: "MagicToastProvider",
-  props: {
-    id: { type: null, required: true },
-    options: { type: Object, required: false }
+const { id, options } = defineProps({
+  id: { type: null, required: true },
+  options: { type: Object, required: false }
+});
+const mappedId = toValue(id);
+defineOptions({
+  inheritAttrs: false
+});
+const { deleteView } = useToastView(id);
+const { deleteState, initializeState } = useToastState(id);
+const state = initializeState(options);
+const listRef = useTemplateRef("list");
+const {
+  onBeforeEnter,
+  onEnter,
+  onAfterEnter,
+  onBeforeLeave,
+  onLeave,
+  onAfterLeave
+} = useToastCallback(id);
+const { onMouseenter, onMouseleave, outsideClickCallback } = useToastListener(id);
+onClickOutside(listRef, outsideClickCallback);
+watch(
+  () => options,
+  (value) => {
+    initializeState(value);
   },
-  setup(__props) {
-    const teleportId = ref(useId());
-    const { deleteView } = useToastView(__props.id);
-    const { deleteState, initializeState } = useToastState(__props.id);
-    const state = initializeState(__props.options);
-    const listRef = ref(void 0);
-    const {
-      onBeforeEnter,
-      onEnter,
-      onAfterEnter,
-      onBeforeLeave,
-      onLeave,
-      onAfterLeave
-    } = useToastCallback(__props.id);
-    const { onMouseenter, onMouseleave, outsideClickCallback } = useToastListener(__props.id);
-    onClickOutside(listRef, outsideClickCallback);
-    watch(
-      () => __props.options,
-      (value) => {
-        state.options = defu(value, state.options);
-        teleportId.value = useId();
-      },
-      {
-        deep: true
-      }
-    );
-    onBeforeUnmount(() => {
-      deleteState();
-    });
-    provide(MagicToastInstanceId, __props.id);
-    return (_ctx, _cache) => {
-      return _openBlock(), _createBlock(_Teleport, {
-        key: teleportId.value,
-        to: _unref(state).options.teleport?.target,
-        disabled: _unref(state).options.teleport?.disabled
-      }, [
-        _createElementVNode("div", _mergeProps({
-          id: toValue(_ctx.id),
-          "data-position": _unref(state).options.position,
-          "data-expanded": _unref(state).expanded,
-          class: "magic-toast-provider"
-        }, _ctx.$attrs), [
-          _createVNode(_TransitionGroup, {
-            ref_key: "listRef",
-            ref: listRef,
-            tag: "ol",
-            class: "magic-toast-provider__list",
-            name: _unref(state).options.transition,
-            "on-before-enter": _unref(onBeforeEnter),
-            "on-enter": _unref(onEnter),
-            "on-after-enter": _unref(onAfterEnter),
-            "on-before-leave": _unref(onBeforeLeave),
-            "on-leave": _unref(onLeave),
-            "on-after-leave": _unref(onAfterLeave),
-            onMouseenter: _unref(onMouseenter),
-            onMouseleave: _unref(onMouseleave)
-          }, {
-            default: _withCtx(() => [
-              (_openBlock(true), _createElementBlock(
-                _Fragment,
-                null,
-                _renderList(_unref(state).views, (view, index) => {
-                  return _openBlock(), _createBlock(MagicToastView, {
-                    id: view.id,
-                    key: view.id,
-                    index
-                  }, {
-                    default: _withCtx(() => [
-                      (_openBlock(), _createBlock(_resolveDynamicComponent(view.component), _mergeProps({ ref_for: true }, view.props, {
-                        onRemove: ($event) => _unref(deleteView)(view.id)
-                      }), null, 16, ["onRemove"]))
-                    ]),
-                    _: 2
-                    /* DYNAMIC */
-                  }, 1032, ["id", "index"]);
-                }),
-                128
-                /* KEYED_FRAGMENT */
-              ))
-            ]),
-            _: 1
-            /* STABLE */
-          }, 8, ["name", "on-before-enter", "on-enter", "on-after-enter", "on-before-leave", "on-leave", "on-after-leave", "onMouseenter", "onMouseleave"])
-        ], 16, _hoisted_1)
-      ], 8, ["to", "disabled"]);
-    };
+  {
+    deep: true
   }
+);
+onBeforeUnmount(() => {
+  deleteState();
 });
+provide(MagicToastInstanceId, id);
 </script>
 
 <style>
@@ -164,7 +140,7 @@ export default /* @__PURE__ */ _defineComponent({
   --magic-toast-padding-y: 1rem;
   --magic-toast-padding-x: 1rem;
   --magic-toast-gap: 0.75rem;
-  --magic-toast-duration: 175ms;
+  --magic-toast-animation-duration: 175ms;
   --magic-toast-scale-factor: 0.05;
   --magic-toast-overlap-y: 1rem;
 
@@ -213,11 +189,11 @@ export default /* @__PURE__ */ _defineComponent({
 }
 
 .magic-toast-provider[data-position='top-left'],
-.magic-toast-provider[data-position='top-center'],
+.magic-toast-provider[data-position='top'],
 .magic-toast-provider[data-position='top-right'] {
-  --mt-enter-animation: mt-slide-ttb-in var(--magic-toast-duration)
+  --mt-enter-animation: mt-slide-ttb-in var(--magic-toast-animation-duration)
     var(--ease-in-out);
-  --mt-leave-animation: mt-slide-ttb-out var(--magic-toast-duration)
+  --mt-leave-animation: mt-slide-ttb-out var(--magic-toast-animation-duration)
     var(--ease-in-out);
   --mt-multiplier-y: 1;
   --mt-justify-content: flex-end;
@@ -225,11 +201,11 @@ export default /* @__PURE__ */ _defineComponent({
 }
 
 .magic-toast-provider[data-position='bottom-left'],
-.magic-toast-provider[data-position='bottom-center'],
+.magic-toast-provider[data-position='bottom'],
 .magic-toast-provider[data-position='bottom-right'] {
-  --mt-enter-animation: mt-slide-btt-in var(--magic-toast-duration)
+  --mt-enter-animation: mt-slide-btt-in var(--magic-toast-animation-duration)
     var(--ease-in-out);
-  --mt-leave-animation: mt-slide-btt-out var(--magic-toast-duration)
+  --mt-leave-animation: mt-slide-btt-out var(--magic-toast-animation-duration)
     var(--ease-in-out);
   --mt-multiplier-y: -1;
   --mt-justify-content: flex-end;
@@ -245,21 +221,21 @@ export default /* @__PURE__ */ _defineComponent({
   --mt-align-items: flex-end;
 }
 
-.magic-toast-provider[data-position='center-left'] {
+.magic-toast-provider[data-position='left'] {
   --mt-justify-content: center;
   --mt-align-items: flex-start;
-  --mt-enter-animation: slide-ltr-in var(--magic-toast-duration)
+  --mt-enter-animation: slide-ltr-in var(--magic-toast-animation-duration)
     var(--ease-in-out);
-  --mt-leave-animation: slide-ltr-out var(--magic-toast-duration)
+  --mt-leave-animation: slide-ltr-out var(--magic-toast-animation-duration)
     var(--ease-in-out);
 }
 
-.magic-toast-provider[data-position='center-right'] {
+.magic-toast-provider[data-position='right'] {
   --mt-justify-content: center;
   --mt-align-items: flex-end;
-  --mt-enter-animation: slide-rtl-in var(--magic-toast-duration)
+  --mt-enter-animation: slide-rtl-in var(--magic-toast-animation-duration)
     var(--ease-in-out);
-  --mt-leave-animation: slide-rtl-out var(--magic-toast-duration)
+  --mt-leave-animation: slide-rtl-out var(--magic-toast-animation-duration)
     var(--ease-in-out);
 }
 
@@ -268,20 +244,20 @@ export default /* @__PURE__ */ _defineComponent({
   position: absolute;
 
   &[data-position='bottom-left'],
-  &[data-position='bottom-center'],
+  &[data-position='bottom'],
   &[data-position='bottom-right'] {
     bottom: calc(var(--mt-height) * var(--mt-index) * 1px);
   }
 
   &[data-position='top-left'],
-  &[data-position='top-center'],
+  &[data-position='top'],
   &[data-position='top-right'] {
     top: calc(var(--mt-height) * var(--mt-index) * 1px);
   }
 }
 
 .magic-toast-leave-active {
-  animation: fade-out var(--magic-toast-duration) var(--ease-in-out);
+  animation: fade-out var(--magic-toast-animation-duration) var(--ease-in-out);
   position: absolute;
 }
 
@@ -291,6 +267,6 @@ export default /* @__PURE__ */ _defineComponent({
 }
 
 .magic-toast-move {
-  transition: all var(--magic-toast-duration) var(--ease-in-out);
+  transition: all var(--magic-toast-animation-duration) var(--ease-in-out);
 }
 </style>

package/dist/plugins/MagicToast/src/components/MagicToastProvider.vue.d.ts

@@ -10,14 +10,5 @@ interface MagicToastProps {
     id: MaybeRef<string>;
     options?: MagicToastOptions;
 }
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicToastProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicToastProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: import("vue").DefineComponent<MagicToastProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicToastProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};