@vunk/plus 1.7.3 → 1.7.4

package/components/broadcasting-markdown/index.mjs

@@ -3,11 +3,10 @@ import { setData } from '@vunk/core';
 import { useDeferred, useDataComputed } from '@vunk/core/composables';
 import { blobToDataURL } from '@vunk/shared/data/blob';
 import { TickerStatus } from '@vunk/shared/enum';
-import { defineComponent, openBlock, createElementBlock, createElementVNode, Fragment, createVNode, withCtx, shallowRef, computed, watch, onBeforeUnmount, watchEffect, onMounted, nextTick, renderSlot, createCommentVNode, ref, resolveComponent, renderList, createBlock } from 'vue';
+import { shallowRef, computed, watch, onBeforeUnmount, watchEffect, defineComponent, onMounted, renderSlot, nextTick, createCommentVNode, ref, resolveComponent, openBlock, createElementBlock, Fragment, createVNode, renderList, createBlock, withCtx } from 'vue';
 import { noop } from '@vunk/shared/function';
-import { ElIcon } from 'element-plus';
-import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 import { c as commonjsGlobal } from '../_commonjsHelpers.mjs';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 import { Deferred } from '@vunk/shared/promise';
 
 function markdownToPlainText(md) {
@@ -94,12 +93,9 @@ const props = {
 };
 const emits = {
   "setData": (e) => e,
-  "interrupt": null,
-  "update:broadcasting": (_) => true,
-  "update:completed": (_) => true,
-  "update:error": (_) => true,
   "update:status": (_) => true,
-  "paragraphLoad": (_) => true
+  "paragraphLoad": (_) => true,
+  "complete": () => true
 };
 const paragraphProps = {
   data: {
@@ -128,75 +124,6 @@ var ctx = /*#__PURE__*/Object.freeze({
   props: props
 });
 
-/*! Element Plus Icons Vue v2.3.1 */
-
-var close_bold_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
-  name: "CloseBold",
-  __name: "close-bold",
-  setup(__props) {
-    return (_ctx, _cache) => (openBlock(), createElementBlock("svg", {
-      xmlns: "http://www.w3.org/2000/svg",
-      viewBox: "0 0 1024 1024"
-    }, [
-      createElementVNode("path", {
-        fill: "currentColor",
-        d: "M195.2 195.2a64 64 0 0 1 90.496 0L512 421.504 738.304 195.2a64 64 0 0 1 90.496 90.496L602.496 512 828.8 738.304a64 64 0 0 1-90.496 90.496L512 602.496 285.696 828.8a64 64 0 0 1-90.496-90.496L421.504 512 195.2 285.696a64 64 0 0 1 0-90.496z"
-      })
-    ]));
-  }
-});
-
-// src/components/close-bold.vue
-var close_bold_default = close_bold_vue_vue_type_script_setup_true_lang_default;
-
-var _sfc_main$3 = /* @__PURE__ */ defineComponent({
-  __name: "speech-error",
-  setup(__props, { expose: __expose }) {
-    __expose();
-    const __returned__ = { get CloseBold() {
-      return close_bold_default;
-    }, get ElIcon() {
-      return ElIcon;
-    } };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
-  }
-});
-
-function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock(
-    Fragment,
-    null,
-    [
-      createVNode($setup["ElIcon"], {
-        color: "var(--el-color-danger)",
-        size: "1.5em",
-        style: {
-          verticalAlign: "text-bottom"
-        }
-      }, {
-        default: withCtx(() => [
-          createVNode($setup["CloseBold"])
-        ]),
-        _: 1
-        /* STABLE */
-      }),
-      _cache[0] || (_cache[0] = createElementVNode(
-        "span",
-        { style: {
-          color: "var(--el-color-danger)"
-        } },
-        " \u64AD\u62A5\u5931\u8D25 ",
-        -1
-        /* HOISTED */
-      ))
-    ],
-    64
-    /* STABLE_FRAGMENT */
-  );
-}
-var SpeechError = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["render", _sfc_render$2], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/broadcasting-markdown/src/speech-error.vue"]]);
-
 var howler = {};
 
 /*!
@@ -3449,6 +3376,12 @@ howler.Howl.prototype.play = function(soundId) {
 };
 function useHowlerParagraph(props, emit) {
   const sound = shallowRef(null);
+  const broadcast = computed({
+    get: () => props.status,
+    set: (val) => {
+      emit("update:status", val);
+    }
+  });
   const createSound = (url2) => {
     if (!url2)
       return null;
@@ -3460,54 +3393,34 @@ function useHowlerParagraph(props, emit) {
       format: ["mp3", "wav", "aac"],
       // 事件处理
       onplay: () => {
-        emit("setData", {
-          k: "broadcast",
-          v: Broadcast.playing
-        });
+        broadcast.value = TickerStatus.playing;
       },
       onpause: () => {
-        emit("setData", {
-          k: "broadcast",
-          v: Broadcast.paused
-        });
+        broadcast.value = TickerStatus.paused;
       },
       onend: () => {
-        emit("setData", {
-          k: "broadcast",
-          v: Broadcast.stopped
-        });
+        broadcast.value = TickerStatus.stopped;
         setTimeout(() => {
           if (sound.value) {
             sound.value.unload();
             sound.value = null;
           }
         }, 400);
-        props.deferred.resolve(true);
       },
       onstop: () => {
-        emit("setData", {
-          k: "broadcast",
-          v: Broadcast.stopped
-        });
+        broadcast.value = TickerStatus.stopped;
       },
       onloaderror: (_, error) => {
-        emit("setData", {
-          k: "broadcast",
-          v: Broadcast.failed
-        });
-        props.deferred.reject(error);
+        broadcast.value = TickerStatus.failed;
+        emit("error", error);
       },
       onplayerror: (_, error) => {
-        emit("setData", {
-          k: "broadcast",
-          v: Broadcast.failed
-        });
-        props.deferred.reject(error);
+        broadcast.value = TickerStatus.failed;
+        emit("error", error);
       }
     });
   };
-  const url = computed(() => props.data.url);
-  const broadcast = computed(() => props.data.broadcast);
+  const url = computed(() => props.source);
   watch(() => url.value, (newUrl) => {
     if (newUrl) {
       sound.value = createSound(newUrl);
@@ -3540,36 +3453,47 @@ function useHowlerParagraph(props, emit) {
 }
 
 var _sfc_main$2 = /* @__PURE__ */ defineComponent({
-  components: {
-    SpeechError
+  __name: "howler-speech",
+  props: {
+    /**
+     * 语音资源
+     */
+    source: {
+      type: String,
+      default: ""
+    },
+    status: {
+      type: String,
+      default: TickerStatus.pending
+    }
   },
-  props: paragraphProps,
-  emits: paragraphEmits,
-  setup(props, {
-    emit
-  }) {
-    const value = props.render(props.data.value);
-    const theData = computed(() => props.data);
-    if (!value.trim()) {
-      props.deferred.resolve(true);
-      emit("setData", {
-        k: "broadcast",
-        v: Broadcast.stopped
-      });
-      return () => null;
+  emits: {
+    "update:status": null,
+    "load": null,
+    "error": null
+  },
+  setup(__props, { expose: __expose, emit: __emit }) {
+    __expose();
+    const props = __props;
+    const emit = __emit;
+    if (!props.source) {
+      emit("update:status", TickerStatus.stopped);
+    } else {
+      useHowlerParagraph(props, emit);
     }
-    useHowlerParagraph(props, emit);
     onMounted(() => {
-      emit("load", {
-        data: props.data,
-        deferred: props.deferred
-      });
+      emit("load");
     });
-    return () => createVNode(Fragment, null, [theData.value.status === ParagraphStatus.rejected && createVNode(SpeechError, null, null)]);
+    const __returned__ = { props, emit };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
   }
 });
 
-var HowlerSpeechView = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/broadcasting-markdown/src/howler-speech.vue"]]);
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  return renderSlot(_ctx.$slots, "default", { status: $props.status });
+}
+var HowlerSpeechView = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/broadcasting-markdown/src/howler-speech.vue"]]);
 
 const LogLevels = {
   silent: Number.NEGATIVE_INFINITY,
@@ -4135,12 +4059,15 @@ var _sfc_main = defineComponent({
   },
   props,
   emits,
-  setup(props2, { emit, expose, slots }) {
+  setup(props2, { emit }) {
     const [theData, handleSetData] = useDataComputed({
       default: []
     }, props2, emit);
     const addParagraph = (paragraph) => {
       const k = theData.value.length;
+      if (k === 0) {
+        paragraph.broadcast = props2.status;
+      }
       handleSetData({
         k,
         v: paragraph
@@ -4150,6 +4077,9 @@ var _sfc_main = defineComponent({
       if (!props2.textToSpeech) {
         return;
       }
+      if (props2.separators.includes(paragraph.value)) {
+        return;
+      }
       const value = props2.render(paragraph.value);
       if (!value) {
         return;
@@ -4174,15 +4104,6 @@ var _sfc_main = defineComponent({
       return props2.source.substring(0, currentIndex.value);
     });
     const fulfilledTextValue = computed(() => {
-      if (theData.value.length === 0) {
-        return "......";
-      }
-      if (theData.value[0].broadcast === Broadcast.failed) {
-        return "";
-      }
-      if (theData.value[0].broadcast === Broadcast.pending) {
-        return "......";
-      }
       return theData.value.filter(
         (item) => item.status === ParagraphStatus.fulfilled || item.status === ParagraphStatus.pending
       ).map((item) => item.value).join("");
@@ -4226,7 +4147,7 @@ var _sfc_main = defineComponent({
               end,
               status: ParagraphStatus.initial,
               value,
-              broadcast: Broadcast.pending
+              broadcast: Broadcast.play
             };
             addParagraph(paragraph);
           }
@@ -4260,113 +4181,51 @@ var _sfc_main = defineComponent({
             end,
             status: ParagraphStatus.initial,
             value,
-            broadcast: Broadcast.pending
+            broadcast: Broadcast.play
           };
           addParagraph(paragraph);
         }
       }
     }
-    const isInterrupted = ref(false);
-    function interrupt() {
-      isInterrupted.value = true;
-      theData.value.forEach((item) => {
-        item.broadcast = Broadcast.stop;
-      });
-      emit("interrupt");
+    function isPrevParagraphFulfilled(currentIndex2) {
+      const last = theData.value[currentIndex2 - 1];
+      return last ? last.status === ParagraphStatus.fulfilled : true;
     }
-    const currentParagraph = computed(() => {
-      return theData.value.find(
-        (item) => item.status === ParagraphStatus.pending
-      );
+    function isParagraphEnabled(currentIndex2) {
+      const isPrevFulfilled = isPrevParagraphFulfilled(currentIndex2);
+      return isPrevFulfilled;
+    }
+    const currentPragraph = computed(() => {
+      return theData.value.find((item) => item.status === ParagraphStatus.pending);
     });
-    watchEffect(() => {
-      if (!currentParagraph.value) {
+    watch(() => props2.status, () => {
+      if (!currentPragraph.value) {
         return;
       }
-      if (currentParagraph.value.broadcast === props2.status) {
-        return;
+      if (currentPragraph.value.broadcast !== props2.status) {
+        currentPragraph.value.broadcast = props2.status;
       }
-      props2.status === TickerStatus.play && (currentParagraph.value.broadcast = TickerStatus.play);
-      props2.status === TickerStatus.pause && (currentParagraph.value.broadcast = TickerStatus.pause);
-      props2.status === TickerStatus.stop && (currentParagraph.value.broadcast = TickerStatus.stop);
-    });
-    watchEffect(() => {
-      if (isInterrupted.value) {
-        return;
+      if (props2.status === TickerStatus.stop) {
+        theData.value.forEach((item) => {
+          item.broadcast = Broadcast.stop;
+        });
       }
-      const fulfilledCount = theData.value.filter((item) => item.status === ParagraphStatus.fulfilled).length;
-      const nextParagraph = theData.value.find(
-        (item) => item.status === ParagraphStatus.pending && item.broadcast === Broadcast.pending
-      );
-      if (fulfilledCount > 0 && nextParagraph) {
-        const currentlyPlaying = theData.value.find(
-          (item) => item.broadcast === Broadcast.playing || item.broadcast === Broadcast.play
-        );
-        if (!currentlyPlaying) {
-          nextParagraph.broadcast = Broadcast.play;
-        }
+    }, { immediate: true });
+    function handleParagraphStatus(para, v) {
+      if (para.status === ParagraphStatus.pending) {
+        emit("update:status", v);
       }
-    });
-    const isPaused = computed(() => {
-      return theData.value.some(
-        (item) => item.status === ParagraphStatus.pending && item.broadcast === Broadcast.paused
-      );
-    });
-    watchEffect(() => {
-      isPaused.value && emit("update:status", TickerStatus.paused);
-    });
-    const isBroadcasting = computed(() => {
-      return theData.value.some(
-        (item) => item.broadcast === Broadcast.playing
-      );
-    });
-    watchEffect(() => {
-      isBroadcasting.value && emit("update:broadcasting", isBroadcasting.value);
-      emit("update:status", TickerStatus.playing);
-    });
-    const isTypingFinished = ref(!!slots.paragraphs);
-    const isCompleted = computed(() => {
-      return isTypingFinished.value && props2.keepRead === false && theData.value.every(
-        (item) => item.status === ParagraphStatus.fulfilled
-      );
-    });
-    watchEffect(() => {
-      emit("update:completed", isCompleted.value);
-      isCompleted.value && emit("update:status", TickerStatus.stopped);
-    });
-    const isError = computed(() => {
-      return theData.value.some(
-        (item) => item.status === ParagraphStatus.rejected
-      );
-    });
-    watchEffect(() => {
-      emit("update:error", isError.value);
-    });
-    function isPrevParagraphFulfilled(currentIndex2) {
-      return theData.value[currentIndex2 - 1] ? [
-        ParagraphStatus.fulfilled
-      ].includes(theData.value[currentIndex2 - 1].status) : true;
     }
-    function isParagraphEnabled(currentIndex2) {
-      const isPrevFulfilled = isPrevParagraphFulfilled(currentIndex2);
-      return isPrevFulfilled;
-    }
-    expose({
-      interrupt
-    });
     return {
       theData,
       ParagraphStatus,
       fulfilledTextValue,
-      isPrevParagraphFulfilled,
-      isParagraphEnabled,
       processingParagraph,
-      isInterrupted,
       setData,
       Broadcast,
-      isPaused,
-      isTypingFinished,
-      currentParagraph
+      isParagraphEnabled,
+      TickerStatus,
+      handleParagraphStatus
     };
   }
 });
@@ -4381,12 +4240,9 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     [
       renderSlot(_ctx.$slots, "default", { paragraphs: _ctx.theData }, () => [
         createVNode(_component_VkTypingMarkdown, {
-          finished: _ctx.isTypingFinished,
-          "onUpdate:finished": _cache[0] || (_cache[0] = ($event) => _ctx.isTypingFinished = $event),
           source: _ctx.fulfilledTextValue,
-          delay: 120,
-          pause: _ctx.isInterrupted || _ctx.isPaused
-        }, null, 8, ["finished", "source", "pause"])
+          pause: _ctx.status === _ctx.TickerStatus.stopped
+        }, null, 8, ["source", "pause"])
       ]),
       (openBlock(true), createElementBlock(
         Fragment,
@@ -4405,12 +4261,19 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
                 deferred
               }, () => [
                 createVNode(_component_HowlerSpeechView, {
-                  render: _ctx.render,
-                  deferred,
-                  data: item,
-                  onSetData: ($event) => _ctx.setData(item, $event),
-                  onLoad: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("paragraphLoad", $event))
-                }, null, 8, ["render", "deferred", "data", "onSetData"])
+                  status: item.broadcast,
+                  "onUpdate:status": [($event) => item.broadcast = $event, (e) => {
+                    _ctx.handleParagraphStatus(item, e);
+                    e === _ctx.TickerStatus.stopped && deferred.resolve(true);
+                    index === _ctx.theData.length - 1 && e === _ctx.TickerStatus.stopped && _ctx.$emit("complete");
+                  }],
+                  source: item.url,
+                  onError: ($event) => deferred.reject($event),
+                  onLoad: ($event) => _ctx.$emit("paragraphLoad", {
+                    data: item,
+                    deferred
+                  })
+                }, null, 8, ["status", "onUpdate:status", "source", "onError", "onLoad"])
               ])
             ]),
             _: 2

package/components/broadcasting-markdown/src/ctx.d.ts

@@ -102,12 +102,9 @@ export declare const props: {
 };
 export declare const emits: {
     setData: (e: SetDataEvent) => SetDataEvent;
-    interrupt: null;
-    'update:broadcasting': (_: boolean) => boolean;
-    'update:completed': (_: boolean) => boolean;
-    'update:error': (_: boolean) => boolean;
     'update:status': (_: TickerStatus) => boolean;
     paragraphLoad: (_: ParagraphLoadEvent) => boolean;
+    complete: () => boolean;
 };
 export declare const paragraphProps: {
     data: {

package/components/broadcasting-markdown/src/howler-speech.vue.d.ts

@@ -1,97 +1,58 @@
+import type { PropType } from 'vue';
+import { TickerStatus } from '@vunk/shared/enum';
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    data: {
-        type: import("vue").PropType<import("./types").Paragraph>;
-        default: () => {};
+    /**
+     * 语音资源
+     */
+    source: {
+        type: StringConstructor;
+        default: string;
     };
-    deferred: {
-        type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
-        required: true;
+    status: {
+        type: PropType<TickerStatus>;
+        default: TickerStatus;
     };
-    render: {
-        type: import("vue").PropType<(text: string) => string>;
-        default: typeof import("./const").defaultRender;
-    };
-}>, (() => null) | (() => JSX.Element), {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    setData: (e: import("@vunk/core").SetDataEvent<keyof import("./types").Paragraph>) => import("@vunk/core").SetDataEvent<keyof import("./types").Paragraph>;
-    load: (_: import("./types").ParagraphLoadEvent) => boolean;
+}>, {
+    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        /**
+         * 语音资源
+         */
+        source: {
+            type: StringConstructor;
+            default: string;
+        };
+        status: {
+            type: PropType<TickerStatus>;
+            default: TickerStatus;
+        };
+    }>> & Readonly<{
+        "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+        onError?: ((...args: any[]) => any) | undefined;
+        onLoad?: ((...args: any[]) => any) | undefined;
+    }> & {}>;
+    emit: ((event: "update:status", ...args: any[]) => void) & ((event: "error", ...args: any[]) => void) & ((event: "load", ...args: any[]) => void);
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:status': null;
+    load: null;
+    error: null;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    data: {
-        type: import("vue").PropType<import("./types").Paragraph>;
-        default: () => {};
-    };
-    deferred: {
-        type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
-        required: true;
+    /**
+     * 语音资源
+     */
+    source: {
+        type: StringConstructor;
+        default: string;
     };
-    render: {
-        type: import("vue").PropType<(text: string) => string>;
-        default: typeof import("./const").defaultRender;
+    status: {
+        type: PropType<TickerStatus>;
+        default: TickerStatus;
     };
 }>> & Readonly<{
-    onSetData?: ((e: import("@vunk/core").SetDataEvent<keyof import("./types").Paragraph>) => any) | undefined;
-    onLoad?: ((_: import("./types").ParagraphLoadEvent) => any) | undefined;
+    "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
+    onLoad?: ((...args: any[]) => any) | undefined;
 }>, {
-    data: import("./types").Paragraph;
-    render: (text: string) => string;
-}, {}, {
-    SpeechError: import("vue").DefineComponent<{}, {
-        readonly CloseBold: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-        readonly ElIcon: {
-            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                readonly size: {
-                    readonly type: import("vue").PropType<string | number>;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                };
-                readonly color: {
-                    readonly type: import("vue").PropType<string>;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                };
-            }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<import("vue").ExtractPropTypes<{
-                readonly size: {
-                    readonly type: import("vue").PropType<string | number>;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                };
-                readonly color: {
-                    readonly type: import("vue").PropType<string>;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                };
-            }>>, {}, {}, {}, {}, {}>;
-            __isFragment?: never;
-            __isTeleport?: never;
-            __isSuspense?: never;
-        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            readonly size: {
-                readonly type: import("vue").PropType<string | number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly color: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-            $slots: {
-                default?(_: {}): any;
-            };
-        }) & import("vue").Plugin;
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    source: string;
+    status: TickerStatus;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;