@vunk/plus 1.12.2 → 1.13.1

package/components/index.cjs

@@ -0,0 +1 @@
+"use strict";

package/components/index.d.ts

@@ -0,0 +1 @@
+export {};

package/components/lottie-animation/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("vue"),a=require("lottie-web"),l=require("../_plugin-vue_export-helper-BHFhmbuH.js"),s={path:{type:String,default:""}},u={load:t=>t},c=e.defineComponent({name:"VkLottieAnimation",props:s,emits:u,setup(t,{emit:r}){const n=e.ref();return e.onMounted(()=>{const i=a.loadAnimation({container:n.value,renderer:"svg",loop:!0,autoplay:!0,path:t.path});i.addEventListener("complete",()=>{r("load",{animation:i})})}),{lottieNode:n}}}),d={ref:"lottieNode",class:"vk-lottie-animation"};function p(t,r,n,i,_,f){return e.openBlock(),e.createElementBlock(e.Fragment,null,[e.createElementVNode("div",d,null,512),e.renderSlot(t.$slots,"default")],64)}const o=l._export_sfc(c,[["render",p]]),m=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));o.install=t=>{t.component(o.name||"VkLottieAnimation",o)};exports.VkLottieAnimation=o;exports.__VkLottieAnimation=m;exports.default=o;

package/components/lottie-animation/index.mjs

@@ -1,71 +1,52 @@
-import { defineComponent, ref, onMounted, openBlock, createElementBlock, Fragment, createElementVNode, renderSlot } from 'vue';
-import lottie from 'lottie-web';
-import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
-
-const props = {
+import { defineComponent as i, ref as r, onMounted as l, createElementBlock as s, openBlock as p, Fragment as c, createElementVNode as m, renderSlot as d } from "vue";
+import u from "lottie-web";
+import { _ } from "../_plugin-vue_export-helper-CHgC5LLL.mjs";
+const f = {
   path: {
     type: String,
     default: ""
   }
-};
-const emits = {
-  load: (e) => e
-};
-
-var _sfc_main = defineComponent({
+}, k = {
+  load: (t) => t
+}, v = i({
   name: "VkLottieAnimation",
-  props,
-  emits,
-  setup(props2, { emit }) {
-    const lottieNode = ref();
-    onMounted(() => {
-      const animation = lottie.loadAnimation({
-        container: lottieNode.value,
+  props: f,
+  emits: k,
+  setup(t, { emit: a }) {
+    const e = r();
+    return l(() => {
+      const o = u.loadAnimation({
+        container: e.value,
         renderer: "svg",
-        loop: true,
-        autoplay: true,
-        path: props2.path
+        loop: !0,
+        autoplay: !0,
+        path: t.path
       });
-      animation.addEventListener("complete", () => {
-        emit("load", { animation });
+      o.addEventListener("complete", () => {
+        a("load", { animation: o });
       });
-    });
-    return {
-      lottieNode
+    }), {
+      lottieNode: e
     };
   }
-});
-
-const _hoisted_1 = {
+}), g = {
   ref: "lottieNode",
   class: "vk-lottie-animation"
 };
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock(
-    Fragment,
-    null,
-    [
-      createElementVNode(
-        "div",
-        _hoisted_1,
-        null,
-        512
-        /* NEED_PATCH */
-      ),
-      renderSlot(_ctx.$slots, "default")
-    ],
-    64
-    /* STABLE_FRAGMENT */
-  );
+function h(t, a, e, o, y, A) {
+  return p(), s(c, null, [
+    m("div", g, null, 512),
+    d(t.$slots, "default")
+  ], 64);
 }
-var VkLottieAnimation = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/lottie-animation/src/index.vue"]]);
-
-var types = /*#__PURE__*/Object.freeze({
+const n = /* @__PURE__ */ _(v, [["render", h]]), S = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null
-});
-
-VkLottieAnimation.install = (app) => {
-  app.component(VkLottieAnimation.name || "VkLottieAnimation", VkLottieAnimation);
+}, Symbol.toStringTag, { value: "Module" }));
+n.install = (t) => {
+  t.component(n.name || "VkLottieAnimation", n);
+};
+export {
+  n as VkLottieAnimation,
+  S as __VkLottieAnimation,
+  n as default
 };
-
-export { VkLottieAnimation, types as __VkLottieAnimation, VkLottieAnimation as default };

package/components/lottie-animation/src/index.vue.d.ts

@@ -1,5 +1,7 @@
 import { Ref } from 'vue';
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     path: {
         type: StringConstructor;
         default: string;
@@ -18,4 +20,3 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     path: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export default _default;

package/components/metahuman-broadcasting/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("vue"),F=require("@vunk/plus/components/broadcasting-markdown"),m=require("@vunk/plus/components/pixi-frame"),M=require("@vunk/plus/shared/data"),T=require("@vunk/core/composables"),g=require("@vunk/core/shared"),o=require("@vunk/shared/enum"),f=require("sophontalk-services"),U={source:{type:String,default:""},textToSpeech:{type:Function,required:!0},modelUrl:{type:String,required:!0},datasetUrl:{type:String,required:!0},sourceUrl:{type:String,required:!0},status:{type:String,default:void 0},playAfterCache:{type:Number,default:100},disabled:{type:Boolean,default:!1}},V={"update:status":null},i=e.defineComponent({name:"VkMetahumanBroadcasting",inheritAttrs:!1,__name:"index",props:U,emits:V,setup(d,{emit:S}){const s=d,y=S,c=e.ref([]),v=new f.FeatureExtractor,u=new f.InferenceEngine({onFrame:q,onError(t){console.error("Inference engine error:",t)},onProgress:B}),b=u.createSilentFrameGenerator(),p=e.ref(o.TickerStatus.pending),l=e.ref([]),n=T.useModelComputed({default:o.TickerStatus.pending,key:"status"},s,y);e.onMounted(async()=>{const{dataset:t,zipBuffer:r}=await f.loadDataset({jsonUrl:s.datasetUrl,zipUrl:s.sourceUrl});u.init({modelPath:s.modelUrl,dataset:t,zipBuffer:r}),await u.when(),p.value=o.TickerStatus.play});async function h(t){if(t.blob)try{const r=await M.blobToAudioBuffer(t.blob),{dimensions:a,features:w}=await v.process(r);await u.when(),u.run({audioFeatures:w,audioDimensions:a,reset:!1})}catch(r){console.error("Error processing paragraph:",r)}}function k(){c.value.length&&(n.value=o.TickerStatus.stop,l.value.length=0)}function B(t,r){(r<s.playAfterCache&&t===r||t===s.playAfterCache)&&(n.value=o.TickerStatus.play)}function q(t){l.value.push(t)}return(t,r)=>(e.openBlock(),e.createElementBlock(e.Fragment,null,[e.createVNode(e.unref(F.VkBroadcastingMarkdown),e.mergeProps(t.$attrs,{status:e.unref(n),data:c.value,"text-to-speech":t.textToSpeech,source:t.source,processing:h,disabled:t.disabled,onSetData:r[0]||(r[0]=a=>e.unref(g.setData)(c.value,a)),onComplete:k}),{default:e.withCtx(({paragraphs:a})=>[e.renderSlot(t.$slots,"default",{paragraphs:a})]),_:3},16,["status","data","text-to-speech","source","disabled"]),e.createVNode(e.unref(m.VkPixiFrameBitmap),{status:e.unref(n),"onUpdate:status":r[1]||(r[1]=a=>e.isRef(n)?n.value=a:null),data:l.value,onSetData:r[2]||(r[2]=a=>e.unref(g.setData)(l.value,a))},null,8,["status","data"]),e.createVNode(e.unref(m.VkPixiFrameBitmapGenerator),{status:p.value,"onUpdate:status":r[3]||(r[3]=a=>p.value=a),generator:e.unref(b),visible:e.unref(n)!==e.unref(o.TickerStatus).playing},null,8,["status","generator","visible"])],64))}}),P=Object.freeze(Object.defineProperty({__proto__:null},Symbol.toStringTag,{value:"Module"}));i.install=d=>{d.component(i.name||"VkMetahumanBroadcasting",i)};exports.VkMetahumanBroadcasting=i;exports.__VkMetahumanBroadcasting=P;exports.default=i;

package/components/metahuman-broadcasting/index.mjs

@@ -1,14 +1,12 @@
-import { defineComponent, ref, onMounted, openBlock, createElementBlock, Fragment, createVNode, mergeProps, withCtx, renderSlot } from 'vue';
-import { VkBroadcastingMarkdown } from '@vunk/plus/components/broadcasting-markdown';
-import { VkPixiFrameBitmap, VkPixiFrameBitmapGenerator } from '@vunk/plus/components/pixi-frame';
-import { blobToAudioBuffer } from '@vunk/plus/shared/data';
-import { useModelComputed } from '@vunk/core/composables';
-import { setData } from '@vunk/core/shared';
-import { TickerStatus } from '@vunk/shared/enum';
-import { FeatureExtractor, InferenceEngine, loadDataset } from 'sophontalk-services';
-import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
-
-const props = {
+import { defineComponent as U, ref as m, onMounted as C, createElementBlock as M, openBlock as P, Fragment as V, createVNode as f, unref as r, mergeProps as x, withCtx as D, renderSlot as A, isRef as E } from "vue";
+import { VkBroadcastingMarkdown as T } from "@vunk/plus/components/broadcasting-markdown";
+import { VkPixiFrameBitmap as q, VkPixiFrameBitmapGenerator as j } from "@vunk/plus/components/pixi-frame";
+import { blobToAudioBuffer as z } from "@vunk/plus/shared/data";
+import { useModelComputed as G } from "@vunk/core/composables";
+import { setData as g } from "@vunk/core/shared";
+import { TickerStatus as s } from "@vunk/shared/enum";
+import { FeatureExtractor as I, InferenceEngine as N, loadDataset as O } from "sophontalk-services";
+const $ = {
   /**
    * @description 传入文本
    */
@@ -21,28 +19,28 @@ const props = {
    */
   textToSpeech: {
     type: Function,
-    required: true
+    required: !0
   },
   /**
    * @description 模型地址
    */
   modelUrl: {
     type: String,
-    required: true
+    required: !0
   },
   /**
    * @description 数据集地址
    */
   datasetUrl: {
     type: String,
-    required: true
+    required: !0
   },
   /**
    * @description zip 资源包地址
    */
   sourceUrl: {
     type: String,
-    required: true
+    required: !0
   },
   /**
    * @description 播报状态
@@ -61,147 +59,98 @@ const props = {
   },
   disabled: {
     type: Boolean,
-    default: false
+    default: !1
   }
-};
-const emits = {
+}, R = {
   "update:status": null
-};
-
-var _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "VkMetahumanBroadcasting",
-    inheritAttrs: false
-  },
+}, c = /* @__PURE__ */ U({
+  name: "VkMetahumanBroadcasting",
+  inheritAttrs: !1,
   __name: "index",
-  props: props,
-  emits,
-  setup(__props, { expose: __expose, emit: __emit }) {
-    __expose();
-    const props = __props;
-    const emit = __emit;
-    const paragraphData = ref([]);
-    const extractor = new FeatureExtractor();
-    const engine = new InferenceEngine({
-      onFrame,
-      onError(error) {
-        console.error("Inference engine error:", error);
+  props: $,
+  emits: R,
+  setup(l, { emit: y }) {
+    const n = l, h = y, p = m([]), v = new I(), u = new N({
+      onFrame: w,
+      onError(e) {
+        console.error("Inference engine error:", e);
       },
-      onProgress
-    });
-    const silentFrameGenerator = engine.createSilentFrameGenerator();
-    const slientFrameStatus = ref(TickerStatus.pending);
-    const frames = ref([]);
-    const frameStatus = useModelComputed({
-      default: TickerStatus.pending,
+      onProgress: k
+    }), b = u.createSilentFrameGenerator(), d = m(s.pending), i = m([]), o = G({
+      default: s.pending,
       key: "status"
-    }, props, emit);
-    onMounted(async () => {
-      const { dataset, zipBuffer } = await loadDataset({
-        jsonUrl: props.datasetUrl,
-        zipUrl: props.sourceUrl
+    }, n, h);
+    C(async () => {
+      const { dataset: e, zipBuffer: t } = await O({
+        jsonUrl: n.datasetUrl,
+        zipUrl: n.sourceUrl
       });
-      engine.init({
-        modelPath: props.modelUrl,
-        dataset,
-        zipBuffer
-      });
-      await engine.when();
-      slientFrameStatus.value = TickerStatus.play;
+      u.init({
+        modelPath: n.modelUrl,
+        dataset: e,
+        zipBuffer: t
+      }), await u.when(), d.value = s.play;
     });
-    async function processingParagraph(item) {
-      if (!item.blob) {
-        return;
-      }
-      try {
-        const audioBuffer = await blobToAudioBuffer(item.blob);
-        const { dimensions, features } = await extractor.process(audioBuffer);
-        await engine.when();
-        engine.run({
-          audioFeatures: features,
-          audioDimensions: dimensions,
-          reset: false
-        });
-      } catch (error) {
-        console.error("Error processing paragraph:", error);
-      }
+    async function S(e) {
+      if (e.blob)
+        try {
+          const t = await z(e.blob), { dimensions: a, features: F } = await v.process(t);
+          await u.when(), u.run({
+            audioFeatures: F,
+            audioDimensions: a,
+            reset: !1
+          });
+        } catch (t) {
+          console.error("Error processing paragraph:", t);
+        }
     }
-    function allParagraphCompleted() {
-      if (paragraphData.value.length) {
-        frameStatus.value = TickerStatus.stop;
-        frames.value.length = 0;
-      }
+    function B() {
+      p.value.length && (o.value = s.stop, i.value.length = 0);
     }
-    function onProgress(processed, total) {
-      if (total < props.playAfterCache && processed === total || processed === props.playAfterCache) {
-        frameStatus.value = TickerStatus.play;
-      }
+    function k(e, t) {
+      (t < n.playAfterCache && e === t || e === n.playAfterCache) && (o.value = s.play);
     }
-    function onFrame(frame) {
-      frames.value.push(frame);
+    function w(e) {
+      i.value.push(e);
     }
-    const __returned__ = { props, emit, paragraphData, extractor, engine, silentFrameGenerator, slientFrameStatus, frames, frameStatus, processingParagraph, allParagraphCompleted, onProgress, onFrame, get VkBroadcastingMarkdown() {
-      return VkBroadcastingMarkdown;
-    }, get VkPixiFrameBitmap() {
-      return VkPixiFrameBitmap;
-    }, get VkPixiFrameBitmapGenerator() {
-      return VkPixiFrameBitmapGenerator;
-    }, get setData() {
-      return setData;
-    }, get TickerStatus() {
-      return TickerStatus;
-    } };
-    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
-    return __returned__;
-  }
-});
-
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock(
-    Fragment,
-    null,
-    [
-      createVNode($setup["VkBroadcastingMarkdown"], mergeProps(_ctx.$attrs, {
-        status: $setup.frameStatus,
-        data: $setup.paragraphData,
-        "text-to-speech": _ctx.textToSpeech,
-        source: _ctx.source,
-        processing: $setup.processingParagraph,
-        disabled: _ctx.disabled,
-        onSetData: _cache[0] || (_cache[0] = ($event) => $setup.setData($setup.paragraphData, $event)),
-        onComplete: $setup.allParagraphCompleted
+    return (e, t) => (P(), M(V, null, [
+      f(r(T), x(e.$attrs, {
+        status: r(o),
+        data: p.value,
+        "text-to-speech": e.textToSpeech,
+        source: e.source,
+        processing: S,
+        disabled: e.disabled,
+        onSetData: t[0] || (t[0] = (a) => r(g)(p.value, a)),
+        onComplete: B
       }), {
-        default: withCtx(({ paragraphs }) => [
-          renderSlot(_ctx.$slots, "default", { paragraphs })
+        default: D(({ paragraphs: a }) => [
+          A(e.$slots, "default", { paragraphs: a })
         ]),
         _: 3
-        /* FORWARDED */
       }, 16, ["status", "data", "text-to-speech", "source", "disabled"]),
-      createVNode($setup["VkPixiFrameBitmap"], {
-        status: $setup.frameStatus,
-        "onUpdate:status": _cache[1] || (_cache[1] = ($event) => $setup.frameStatus = $event),
-        data: $setup.frames,
-        onSetData: _cache[2] || (_cache[2] = ($event) => $setup.setData($setup.frames, $event))
+      f(r(q), {
+        status: r(o),
+        "onUpdate:status": t[1] || (t[1] = (a) => E(o) ? o.value = a : null),
+        data: i.value,
+        onSetData: t[2] || (t[2] = (a) => r(g)(i.value, a))
       }, null, 8, ["status", "data"]),
-      createVNode($setup["VkPixiFrameBitmapGenerator"], {
-        status: $setup.slientFrameStatus,
-        "onUpdate:status": _cache[3] || (_cache[3] = ($event) => $setup.slientFrameStatus = $event),
-        generator: $setup.silentFrameGenerator,
-        visible: $setup.frameStatus !== $setup.TickerStatus.playing
+      f(r(j), {
+        status: d.value,
+        "onUpdate:status": t[3] || (t[3] = (a) => d.value = a),
+        generator: r(b),
+        visible: r(o) !== r(s).playing
       }, null, 8, ["status", "generator", "visible"])
-    ],
-    64
-    /* STABLE_FRAGMENT */
-  );
-}
-var VkMetahumanBroadcasting = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/metahuman-broadcasting/src/index.vue"]]);
-
-var types = /*#__PURE__*/Object.freeze({
+    ], 64));
+  }
+}), Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null
-});
-
-VkMetahumanBroadcasting.install = (app) => {
-  app.component(VkMetahumanBroadcasting.name || "VkMetahumanBroadcasting", VkMetahumanBroadcasting);
+}, Symbol.toStringTag, { value: "Module" }));
+c.install = (l) => {
+  l.component(c.name || "VkMetahumanBroadcasting", c);
+};
+export {
+  c as VkMetahumanBroadcasting,
+  Z as __VkMetahumanBroadcasting,
+  c as default
 };
-
-export { VkMetahumanBroadcasting, types as __VkMetahumanBroadcasting, VkMetahumanBroadcasting as default };