@maas/vue-equipment 1.0.0-beta.9 → 1.0.0

package/dist/plugins/MagicPlayer/src/components/MagicPlayerAudio.vue

@@ -1,79 +1,114 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
-const _hoisted_1 = {
-  ref: "el",
-  class: "magic-player-audio"
-};
+<template>
+  <audio ref="el" class="magic-player-audio" />
+</template>
+
+<script setup>
 import {
-  useTemplateRef,
-  shallowRef,
+  computed,
   inject,
+  onBeforeUnmount,
   onMounted,
-  onBeforeUnmount
+  shallowRef,
+  toRefs,
+  useTemplateRef,
+  watch
 } from "vue";
-import { useIntersectionObserver } from "@vueuse/core";
+import {
+  defaultWindow,
+  useElementVisibility,
+  useEventListener
+} from "@vueuse/core";
+import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
 import { usePlayerAudioApi } from "../composables/private/usePlayerAudioApi";
 import { usePlayerMediaApi } from "../composables/private/usePlayerMediaApi";
 import { usePlayerRuntime } from "../composables/private/usePlayerRuntime";
-import { MagicPlayerInstanceId, MagicPlayerOptionsKey } from "../symbols";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicPlayerAudio",
-  setup(__props) {
-    const injectedId = inject(MagicPlayerInstanceId, void 0);
-    const injectedOptions = inject(MagicPlayerOptionsKey, void 0);
-    if (!injectedId) {
-      throw new Error("MagicPlayerVideo must be used within a MagicPlayerProvider");
+import { usePlayerState } from "../composables/private/usePlayerState";
+import { audioModePlaybackDefaults } from "../utils/playbackDefaults";
+import {
+  MagicPlayerCurrentSrcKey,
+  MagicPlayerInstanceId,
+  MagicPlayerOptionsKey,
+  MagicPlayerRef
+} from "../symbols";
+const magicError = useMagicError({
+  prefix: "MagicPlayer",
+  source: "MagicPlayerAudio"
+});
+const injectedInstanceId = inject(MagicPlayerInstanceId, void 0);
+const injectedOptions = inject(MagicPlayerOptionsKey, void 0);
+const injectedPlayerRef = inject(MagicPlayerRef, void 0);
+const injectedCurrentSrc = inject(MagicPlayerCurrentSrcKey, void 0);
+let cancelFocus = void 0;
+let cancelBlur = void 0;
+magicError.assert(injectedInstanceId, {
+  message: "MagicPlayerAudio must be used within a MagicPlayerProvider",
+  errorCode: "missing_instance_id"
+});
+magicError.assert(injectedOptions, {
+  message: "MagicPlayerAudio must be used within a MagicPlayerProvider",
+  errorCode: "missing_options"
+});
+const elRef = useTemplateRef("el");
+const { initialize } = usePlayerRuntime({
+  id: injectedInstanceId,
+  mediaRef: elRef,
+  src: injectedCurrentSrc,
+  srcType: injectedOptions.srcType,
+  debug: injectedOptions.debug
+});
+usePlayerMediaApi({
+  id: injectedInstanceId,
+  mediaRef: elRef
+});
+const { play, pause } = usePlayerAudioApi({
+  id: injectedInstanceId
+});
+const { initializeState } = usePlayerState(injectedInstanceId);
+const state = initializeState();
+const { playing, started } = toRefs(state);
+const wasPlaying = shallowRef(false);
+const isVisible = useElementVisibility(injectedPlayerRef);
+const manageWindow = computed(() => {
+  const playbackOptions = injectedOptions.playback || audioModePlaybackDefaults;
+  return playbackOptions !== false && playbackOptions?.includes("window");
+});
+const manageViewport = computed(() => {
+  const playbackOptions = injectedOptions.playback || audioModePlaybackDefaults;
+  return playbackOptions !== false && playbackOptions?.includes("viewport");
+});
+function onWindowFocus() {
+  if (isVisible.value && wasPlaying.value) {
+    play();
+  }
+}
+function onWindowBlur() {
+  wasPlaying.value = playing.value;
+  pause();
+}
+if (manageWindow.value) {
+  cancelFocus = useEventListener(defaultWindow, "focus", onWindowFocus);
+  cancelBlur = useEventListener(defaultWindow, "blur", onWindowBlur);
+}
+if (manageViewport.value) {
+  watch(isVisible, (value) => {
+    if (!value) {
+      wasPlaying.value = playing.value;
+      pause();
     }
-    if (!injectedOptions) {
-      throw new Error("MagicPlayerVideo must be used within a MagicPlayerProvider");
+    if (value && wasPlaying.value) {
+      play();
     }
-    const elRef = useTemplateRef("el");
-    const pausedByIntersection = shallowRef(false);
-    const { initialize, destroy } = usePlayerRuntime({
-      id: injectedId,
-      mediaRef: elRef,
-      src: injectedOptions.src,
-      srcType: injectedOptions.srcType
-    });
-    const { playing } = usePlayerMediaApi({
-      id: injectedId,
-      mediaRef: elRef
-    });
-    const { play, pause } = usePlayerAudioApi({
-      id: injectedId
-    });
-    useIntersectionObserver(
-      elRef,
-      ([{ isIntersecting }]) => {
-        if (!isIntersecting && playing.value) {
-          pause();
-          pausedByIntersection.value = true;
-        } else if (isIntersecting && !playing.value && pausedByIntersection.value) {
-          pausedByIntersection.value = false;
-          play();
-        }
-      },
-      {
-        immediate: true
-      }
-    );
-    onMounted(() => {
-      initialize();
-    });
-    onBeforeUnmount(() => {
-      destroy();
-    });
-    return (_ctx, _cache) => {
-      return _openBlock(), _createElementBlock(
-        "audio",
-        _hoisted_1,
-        null,
-        512
-        /* NEED_PATCH */
-      );
-    };
-  }
+    if (value && injectedOptions.autoplay && !started.value) {
+      play();
+    }
+  });
+}
+onMounted(() => {
+  initialize();
+});
+onBeforeUnmount(() => {
+  cancelFocus?.();
+  cancelBlur?.();
 });
 </script>
 

package/dist/plugins/MagicPlayer/src/components/MagicPlayerAudio.vue.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/plugins/MagicPlayer/src/components/MagicPlayerAudioControls.d.vue.ts

@@ -0,0 +1,18 @@
+interface MagicAudioPlayerControlsProps {
+    instanceId?: string;
+}
+declare var __VLS_1: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
+    playIcon?: (props: typeof __VLS_1) => any;
+} & {
+    pauseIcon?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicAudioPlayerControlsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicAudioPlayerControlsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/plugins/MagicPlayer/src/components/MagicPlayerAudioControls.vue

@@ -1,128 +1,130 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { unref as _unref, renderSlot as _renderSlot, createVNode as _createVNode, openBlock as _openBlock, createElementBlock as _createElementBlock, createElementVNode as _createElementVNode, resolveComponent as _resolveComponent } from "vue";
-const _hoisted_1 = ["data-touched", "data-playing", "data-paused", "data-waiting", "data-idle", "data-hover"];
-const _hoisted_2 = { class: "magic-player-audio-controls__bar" };
-const _hoisted_3 = {
-  ref: "bar",
-  class: "magic-player-audio-controls__bar--inner"
-};
-const _hoisted_4 = {
-  class: "magic-player-audio-controls__item -shrink-0",
-  "data-slot": "play-toggle"
-};
-const _hoisted_5 = {
-  class: "magic-player-audio-controls__item -shrink-0",
-  "data-slot": "display-time-current"
-};
-const _hoisted_6 = {
-  class: "magic-player-audio-controls__item -grow",
-  "data-slot": "timeline"
-};
-const _hoisted_7 = {
-  ref: "track",
-  class: "magic-player-audio-controls__timeline"
-};
-const _hoisted_8 = {
-  class: "magic-player-audio-controls__item -shrink-0",
-  "data-slot": "display-time-duration"
-};
-import { computed, inject, provide, useTemplateRef } from "vue";
+<template>
+  <div
+    class="magic-player-audio-controls"
+    :data-touched="touched"
+    :data-dragging="dragging"
+    :data-started="started"
+    :data-playing="playing"
+    :data-paused="paused"
+    :data-waiting="waiting"
+    :data-muted="muted"
+    :data-idle="idle"
+    :data-hover="controlsMouseEntered"
+    @mouseenter="onMouseenter"
+    @mouseleave="onMouseleave"
+  >
+    <div class="magic-player-audio-controls__bar">
+      <div ref="bar" class="magic-player-audio-controls__bar--inner">
+        <div
+          class="magic-player-audio-controls__item -shrink-0"
+          data-slot="play-toggle"
+        >
+          <button v-if="!playing" @click="play">
+            <slot name="playIcon">
+              <icon-play />
+            </slot>
+          </button>
+          <button v-else @click="pause">
+            <slot name="pauseIcon">
+              <icon-pause />
+            </slot>
+          </button>
+        </div>
+        <div
+          class="magic-player-audio-controls__item -shrink-0"
+          data-slot="display-time-current"
+        >
+          <magic-player-display-time type="current" />
+        </div>
+        <div
+          class="magic-player-audio-controls__item -grow"
+          data-slot="timeline"
+        >
+          <div
+            ref="track"
+            class="magic-player-audio-controls__timeline"
+            @mouseleave="onMouseleaveTimeline"
+          >
+            <magic-player-timeline />
+          </div>
+        </div>
+        <div
+          class="magic-player-audio-controls__item -shrink-0"
+          data-slot="display-time-duration"
+        >
+          <magic-player-display-time type="duration" />
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import {
+  computed,
+  inject,
+  onBeforeUnmount,
+  provide,
+  toRefs,
+  useTemplateRef
+} from "vue";
 import { useIdle } from "@vueuse/core";
-import { usePlayerMediaApi } from "../composables/private/usePlayerMediaApi";
+import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
+import { usePlayerState } from "../composables/private/usePlayerState";
 import { usePlayerAudioApi } from "../composables/private/usePlayerAudioApi";
 import { usePlayerControlsApi } from "../composables/private/usePlayerControlsApi";
 import IconPlay from "./icons/Play.vue";
 import IconPause from "./icons/Pause.vue";
-import { MagicPlayerInstanceId } from "../symbols";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicPlayerAudioControls",
-  props: {
-    instanceId: { type: String, required: false }
-  },
-  setup(__props) {
-    const injectedInstanceId = inject(MagicPlayerInstanceId, void 0);
-    const mappedInstanceId = computed(() => __props.instanceId ?? injectedInstanceId);
-    if (!mappedInstanceId.value) {
-      throw new Error(
-        "MagicAudioPlayerControls must be nested inside MagicAudioPlayer or an instanceId must be provided."
-      );
-    }
-    const barRef = useTemplateRef("bar");
-    const trackRef = useTemplateRef("track");
-    const { playing, waiting } = usePlayerMediaApi({
-      id: mappedInstanceId.value
-    });
-    const { play, pause, touched, mouseEntered } = usePlayerAudioApi({
-      id: mappedInstanceId.value
-    });
-    usePlayerControlsApi({
-      id: mappedInstanceId.value,
-      barRef,
-      trackRef
-    });
-    const { idle } = useIdle(3e3);
-    provide(MagicPlayerInstanceId, mappedInstanceId.value);
-    return (_ctx, _cache) => {
-      const _component_magic_player_display_time = _resolveComponent("magic-player-display-time");
-      const _component_magic_player_timeline = _resolveComponent("magic-player-timeline");
-      return _openBlock(), _createElementBlock("div", {
-        class: "magic-player-audio-controls",
-        "data-touched": _unref(touched),
-        "data-playing": _unref(playing),
-        "data-paused": !_unref(playing),
-        "data-waiting": _unref(waiting),
-        "data-idle": _unref(idle),
-        "data-hover": _unref(mouseEntered)
-      }, [
-        _createElementVNode("div", _hoisted_2, [
-          _createElementVNode(
-            "div",
-            _hoisted_3,
-            [
-              _createElementVNode("div", _hoisted_4, [
-                !_unref(playing) ? (_openBlock(), _createElementBlock("button", {
-                  key: 0,
-                  onClick: _cache[0] || (_cache[0] = //@ts-ignore
-                  (...args) => _unref(play) && _unref(play)(...args))
-                }, [
-                  _renderSlot(_ctx.$slots, "playIcon", {}, () => [
-                    _createVNode(IconPlay)
-                  ])
-                ])) : (_openBlock(), _createElementBlock("button", {
-                  key: 1,
-                  onClick: _cache[1] || (_cache[1] = //@ts-ignore
-                  (...args) => _unref(pause) && _unref(pause)(...args))
-                }, [
-                  _renderSlot(_ctx.$slots, "pauseIcon", {}, () => [
-                    _createVNode(IconPause)
-                  ])
-                ]))
-              ]),
-              _createElementVNode("div", _hoisted_5, [
-                _createVNode(_component_magic_player_display_time, { type: "current" })
-              ]),
-              _createElementVNode("div", _hoisted_6, [
-                _createElementVNode(
-                  "div",
-                  _hoisted_7,
-                  [
-                    _createVNode(_component_magic_player_timeline)
-                  ],
-                  512
-                  /* NEED_PATCH */
-                )
-              ]),
-              _createElementVNode("div", _hoisted_8, [
-                _createVNode(_component_magic_player_display_time, { type: "duration" })
-              ])
-            ],
-            512
-            /* NEED_PATCH */
-          )
-        ])
-      ], 8, _hoisted_1);
-    };
-  }
+import {
+  MagicPlayerBarRef,
+  MagicPlayerInstanceId,
+  MagicPlayerOptionsKey,
+  MagicPlayerTrackRef
+} from "../symbols";
+const { instanceId } = defineProps({
+  instanceId: { type: String, required: false }
 });
+const magicError = useMagicError({
+  prefix: "MagicPlayer",
+  source: "MagicPlayerAudioControls"
+});
+const injectedInstanceId = inject(MagicPlayerInstanceId, void 0);
+const injectedOptions = inject(MagicPlayerOptionsKey, void 0);
+const mappedInstanceId = computed(() => instanceId ?? injectedInstanceId);
+magicError.assert(mappedInstanceId.value, {
+  message: "MagicAudioPlayerControls must be nested inside MagicAudioPlayer or an instanceId must be provided",
+  errorCode: "missing_instance_id"
+});
+const barRef = useTemplateRef("bar");
+const trackRef = useTemplateRef("track");
+const { play, pause } = usePlayerAudioApi({
+  id: mappedInstanceId.value
+});
+const { initialize, onMouseenter, onMouseleave, onMouseleaveTimeline } = usePlayerControlsApi({
+  id: mappedInstanceId.value,
+  barRef,
+  trackRef
+});
+const { initializeState } = usePlayerState(mappedInstanceId.value);
+const state = initializeState();
+const {
+  playing,
+  paused,
+  started,
+  muted,
+  waiting,
+  touched,
+  dragging,
+  controlsMouseEntered
+} = toRefs(state);
+const { idle } = useIdle(injectedOptions?.threshold?.idle);
+initialize();
+onBeforeUnmount(() => {
+  state.controlsBarRect = void 0;
+  state.controlsTrackRect = void 0;
+  state.controlsPopoverRect = void 0;
+});
+provide(MagicPlayerInstanceId, mappedInstanceId.value);
+provide(MagicPlayerTrackRef, trackRef);
+provide(MagicPlayerBarRef, barRef);
 </script>

package/dist/plugins/MagicPlayer/src/components/MagicPlayerAudioControls.vue.d.ts

@@ -1,31 +1,15 @@
-import IconPlay from './icons/Play.vue.js';
-import IconPause from './icons/Pause.vue.js';
 interface MagicAudioPlayerControlsProps {
     instanceId?: string;
 }
-declare const playing: import("vue").ShallowRef<boolean, boolean>, waiting: import("vue").ShallowRef<boolean, boolean>;
-declare const play: () => void, pause: () => void, touched: import("vue").ShallowRef<boolean, boolean>, mouseEntered: import("vue").ShallowRef<boolean, boolean>;
-declare const idle: import("vue").Ref<boolean, boolean>;
-declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
-declare var __VLS_1: {}, __VLS_6: {};
-type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+declare var __VLS_1: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
     playIcon?: (props: typeof __VLS_1) => any;
 } & {
-    pauseIcon?: (props: typeof __VLS_6) => any;
-}>;
-declare const __VLS_self: import("vue").DefineComponent<MagicAudioPlayerControlsProps, {
-    IconPlay: typeof IconPlay;
-    IconPause: typeof IconPause;
-    playing: typeof playing;
-    waiting: typeof waiting;
-    play: typeof play;
-    pause: typeof pause;
-    touched: typeof touched;
-    mouseEntered: typeof mouseEntered;
-    idle: typeof idle;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicAudioPlayerControlsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_component: import("vue").DefineComponent<MagicAudioPlayerControlsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicAudioPlayerControlsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+    pauseIcon?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicAudioPlayerControlsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicAudioPlayerControlsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/plugins/MagicPlayer/src/components/MagicPlayerDisplayTime.d.vue.ts

@@ -0,0 +1,6 @@
+interface MagicPlayerDisplayTimeProps {
+    type?: 'current' | 'remaining' | 'duration';
+}
+declare const __VLS_export: import("vue").DefineComponent<MagicPlayerDisplayTimeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicPlayerDisplayTimeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/plugins/MagicPlayer/src/components/MagicPlayerDisplayTime.vue

@@ -1,47 +1,41 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { toDisplayString as _toDisplayString, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
-const _hoisted_1 = { class: "magic-player-display-time" };
-import { computed, inject } from "vue";
-import { usePlayerMediaApi } from "../composables/private/usePlayerMediaApi";
+<template>
+  <div class="magic-player-display-time">
+    {{ stringifiedTime }}
+  </div>
+</template>
+
+<script setup>
+import { computed, inject, toRefs } from "vue";
+import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
 import { formatTime } from "@maas/vue-equipment/utils";
+import { usePlayerState } from "../composables/private/usePlayerState";
 import { MagicPlayerInstanceId } from "../symbols";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicPlayerDisplayTime",
-  props: {
-    type: { type: String, required: false, default: "current" }
-  },
-  setup(__props) {
-    const instanceId = inject(MagicPlayerInstanceId);
-    if (!instanceId) {
-      throw new Error(
-        "MagicPlayerDisplayTime must be nested inside MagicPlayerVideoControls or MagicPlayerAudioControls."
-      );
-    }
-    const { currentTime, remainingTime, duration } = usePlayerMediaApi({
-      id: instanceId
-    });
-    const stringifiedTime = computed(() => {
-      switch (__props.type) {
-        case "current":
-          return formatTime(currentTime.value, currentTime.value);
-        case "remaining":
-          return `-${formatTime(remainingTime.value, remainingTime.value)}`;
-        case "duration":
-          return formatTime(duration.value, duration.value);
-        default:
-          return "";
-      }
-    });
-    return (_ctx, _cache) => {
-      return _openBlock(), _createElementBlock(
-        "div",
-        _hoisted_1,
-        _toDisplayString(stringifiedTime.value),
-        1
-        /* TEXT */
-      );
-    };
+const { type = "current" } = defineProps({
+  type: { type: String, required: false }
+});
+const magicError = useMagicError({
+  prefix: "MagicPlayer",
+  source: "MagicPlayerDisplayTime"
+});
+const instanceId = inject(MagicPlayerInstanceId);
+magicError.assert(instanceId, {
+  message: "MagicPlayerDisplayTime must be nested inside MagicPlayerVideoControls or MagicPlayerAudioControls",
+  errorCode: "missing_instance_id"
+});
+const { initializeState } = usePlayerState(instanceId);
+const state = initializeState();
+const { currentTime, duration } = toRefs(state);
+const remainingTime = computed(() => duration.value - currentTime.value);
+const stringifiedTime = computed(() => {
+  switch (type) {
+    case "current":
+      return formatTime(currentTime.value, currentTime.value);
+    case "remaining":
+      return `-${formatTime(remainingTime.value, remainingTime.value)}`;
+    case "duration":
+      return formatTime(duration.value, duration.value);
+    default:
+      return "";
   }
 });
 </script>

package/dist/plugins/MagicPlayer/src/components/MagicPlayerDisplayTime.vue.d.ts

@@ -1,5 +1,6 @@
 interface MagicPlayerDisplayTimeProps {
     type?: 'current' | 'remaining' | 'duration';
 }
-declare const _default: import("vue").DefineComponent<MagicPlayerDisplayTimeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicPlayerDisplayTimeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<MagicPlayerDisplayTimeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicPlayerDisplayTimeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/plugins/MagicPlayer/src/components/MagicPlayerMuxPopover.d.vue.ts

@@ -0,0 +1,6 @@
+interface MagicPlayerMuxPopoverProps {
+    playbackId?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<MagicPlayerMuxPopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicPlayerMuxPopoverProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;