@vunk/plus 1.10.2 → 1.11.0

package/components/metahuman-broadcasting/src/index.vue.d.ts

@@ -1,9 +1,7 @@
 import type { __VkBroadcastingMarkdown } from '@vunk/plus/components/broadcasting-markdown';
-import type { ImageDataResponse } from '@vunk/plus/shared/audioToFrames';
-import type JSZip from 'jszip';
 import type { Ref } from 'vue';
-import { StreamingInferenceService } from '@vunk/plus/shared/audioToFrames';
 import { TickerStatus } from '@vunk/shared/enum';
+import { FeatureExtractor, InferenceEngine } from 'sophontalk-services';
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     source: {
         type: StringConstructor;
@@ -33,6 +31,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: NumberConstructor;
         default: number;
     };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>, {
     props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
         source: {
@@ -63,36 +65,25 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: NumberConstructor;
             default: number;
         };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
     }>> & Readonly<{
         "onUpdate:status"?: ((...args: any[]) => any) | undefined;
     }> & {}>;
     emit: (event: "update:status", ...args: any[]) => void;
     paragraphData: Ref<__VkBroadcastingMarkdown.Paragraph[], __VkBroadcastingMarkdown.Paragraph[]>;
-    streamingInferenceService: StreamingInferenceService;
-    frameUrls: Ref<{
-        readonly height: number;
-        readonly width: number;
-        close: () => void;
-    }[], ImageBitmap[] | {
-        readonly height: number;
-        readonly width: number;
-        close: () => void;
-    }[]>;
-    silentFrameUrls: import("vue").ShallowReactive<string[]>;
-    startedDef: {
-        _ref: import("vue").ShallowRef<unknown, unknown>;
-        readonly value: unknown;
-        promise: Promise<unknown>;
-        resolve: import("@vunk/core/shared").AnyFunc;
-        reject: (reason?: any) => void;
-    };
-    frameStatus: import("vue").WritableComputedRef<TickerStatus, TickerStatus>;
+    extractor: FeatureExtractor;
+    engine: InferenceEngine;
+    silentFrameGenerator: AsyncGenerator<ImageBitmap, void, unknown>;
     slientFrameStatus: Ref<TickerStatus, TickerStatus>;
-    requestProcessStreaming: (buffer: AudioBuffer) => Promise<void>;
+    frames: Ref<ImageBitmap[], ImageBitmap[]>;
+    frameStatus: import("vue").WritableComputedRef<TickerStatus, TickerStatus>;
     processingParagraph: (item: __VkBroadcastingMarkdown.Paragraph) => Promise<void>;
     allParagraphCompleted: () => void;
-    ready: Ref<boolean, boolean>;
-    loadAllSilentFrames: (dataset: ImageDataResponse, zip: JSZip) => Promise<void>;
+    onProgress: (processed: number, total: number) => void;
+    onFrame: (frame: ImageBitmap) => void;
     readonly VkBroadcastingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
         render: {
             type: import("vue").PropType<(text: string) => string>;
@@ -164,6 +155,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: NumberConstructor;
             default: number;
         };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
     }>, {
         theData: import("vue").ComputedRef<__VkBroadcastingMarkdown.Paragraph[]>;
         ParagraphStatus: typeof import("@vunk/plus/components/broadcasting-markdown").ParagraphStatus;
@@ -250,6 +245,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: NumberConstructor;
             default: number;
         };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
     }>> & Readonly<{
         onComplete?: (() => any) | undefined;
         "onUpdate:status"?: ((_: TickerStatus) => any) | undefined;
@@ -259,6 +258,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         data: __VkBroadcastingMarkdown.Paragraph[];
         source: string;
         render: (text: string) => string;
+        disabled: boolean;
         processing: (paragraph: __VkBroadcastingMarkdown.Paragraph) => void;
         delay: number;
         status: TickerStatus;
@@ -341,6 +341,52 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             enable: boolean;
             retryTimes: number;
         }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        HowlerSpeechView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            source: {
+                type: StringConstructor;
+                default: string;
+            };
+            status: {
+                type: import("vue").PropType<TickerStatus>;
+                default: TickerStatus;
+            };
+        }>, {
+            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                source: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                status: {
+                    type: import("vue").PropType<TickerStatus>;
+                    default: TickerStatus;
+                };
+            }>> & Readonly<{
+                onError?: ((...args: any[]) => any) | undefined;
+                onLoad?: ((...args: any[]) => any) | undefined;
+                "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+            }> & {}>;
+            emit: ((event: "error", ...args: any[]) => void) & ((event: "load", ...args: any[]) => void) & ((event: "update:status", ...args: any[]) => void);
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            'update:status': null;
+            load: null;
+            error: null;
+        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            source: {
+                type: StringConstructor;
+                default: string;
+            };
+            status: {
+                type: import("vue").PropType<TickerStatus>;
+                default: TickerStatus;
+            };
+        }>> & Readonly<{
+            onError?: ((...args: any[]) => any) | undefined;
+            onLoad?: ((...args: any[]) => any) | undefined;
+            "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            source: string;
+            status: TickerStatus;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
         VkTypingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
             source: {
                 type: StringConstructor;
@@ -415,52 +461,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             markdownItSetup: (md: import("markdown-it-async").MarkdownItAsync) => void;
             finished: boolean;
         }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-        HowlerSpeechView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-            source: {
-                type: StringConstructor;
-                default: string;
-            };
-            status: {
-                type: import("vue").PropType<TickerStatus>;
-                default: TickerStatus;
-            };
-        }>, {
-            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
-                source: {
-                    type: StringConstructor;
-                    default: string;
-                };
-                status: {
-                    type: import("vue").PropType<TickerStatus>;
-                    default: TickerStatus;
-                };
-            }>> & Readonly<{
-                onError?: ((...args: any[]) => any) | undefined;
-                onLoad?: ((...args: any[]) => any) | undefined;
-                "onUpdate:status"?: ((...args: any[]) => any) | undefined;
-            }> & {}>;
-            emit: ((event: "error", ...args: any[]) => void) & ((event: "load", ...args: any[]) => void) & ((event: "update:status", ...args: any[]) => void);
-        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            'update:status': null;
-            load: null;
-            error: null;
-        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-            source: {
-                type: StringConstructor;
-                default: string;
-            };
-            status: {
-                type: import("vue").PropType<TickerStatus>;
-                default: TickerStatus;
-            };
-        }>> & Readonly<{
-            onError?: ((...args: any[]) => any) | undefined;
-            onLoad?: ((...args: any[]) => any) | undefined;
-            "onUpdate:status"?: ((...args: any[]) => any) | undefined;
-        }>, {
-            source: string;
-            status: TickerStatus;
-        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     readonly VkPixiFrameBitmap: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
         data: {
@@ -544,15 +544,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             onNotFound?: ((_index: number) => any) | undefined;
         }> & {}>;
         emit: ((event: "load", e: import("../../pixi-frame/src/types").LoadEvent) => void) & ((event: "update:status", ...args: any[]) => void) & ((event: "setData", ...args: any[]) => void) & ((event: "update:data", ...args: any[]) => void) & ((event: "update:frameIndex", ...args: any[]) => void) & ((event: "notFound", _index: number) => void);
-        compId: string;
-        getAlias: (key: string | number) => string;
         sprite: import("pixi.js").Sprite;
         resizeSprite: () => void;
         application: import("pixi.js").Application<import("pixi.js").Renderer>;
-        textureMap: Map<string, import("pixi.js").Texture<import("pixi.js").TextureSource<any>>>;
-        completedIndex: Ref<number, number>;
-        enabledData: import("vue").ComputedRef<ImageBitmap[]>;
+        texture: import("pixi.js").Texture<import("pixi.js").TextureSource<any>>;
+        updateTextureFromBitmap: (bitmap: ImageBitmap) => void;
         index: import("vue").WritableComputedRef<number, number>;
+        lastScheduledClearIndex: Ref<number, number>;
+        scheduleClearFrame: (frameIndex: number) => void;
         drawFrame: () => void;
         play: () => void;
         pause: () => void;
@@ -615,172 +614,145 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         prerender: boolean;
         frameRate: number;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-    readonly VkPixiFrameCore: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        data: {
-            type: import("vue").PropType<import("../../pixi-frame/src/types").Datum[] | string[]>;
+    readonly VkPixiFrameBitmapGenerator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        generator: {
+            type: import("vue").PropType<AsyncGenerator<ImageBitmap>>;
             required: true;
         };
-        frameIndex: {
-            type: NumberConstructor;
-        };
-        url: {
-            type: StringConstructor;
-            requierd: false;
+        data: {
+            type: import("vue").PropType<any[]>;
+            default: () => never[];
         };
-        loop: {
+        visible: {
             type: BooleanConstructor;
             default: boolean;
         };
-        status: {
-            type: import("vue").PropType<TickerStatus>;
-            default: TickerStatus;
-        };
-        frameRate: {
-            type: NumberConstructor;
-            default: number;
+        resize: {
+            type: import("vue").PropType<import("../../pixi-frame/src/types").Resize>;
+            default: undefined;
         };
         label: {
             type: StringConstructor;
             default: string;
         };
-        resize: {
-            type: import("vue").PropType<import("../../pixi-frame/src/types").Resize>;
-            default: undefined;
+        status: {
+            type: import("vue").PropType<TickerStatus>;
+            default: TickerStatus;
+        };
+        url: {
+            type: StringConstructor;
+            requierd: false;
         };
         prerender: {
             type: BooleanConstructor;
             default: boolean;
         };
-        visible: {
-            type: BooleanConstructor;
-            default: boolean;
+        frameRate: {
+            type: NumberConstructor;
+            default: number;
         };
     }>, {
         props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
-            data: {
-                type: import("vue").PropType<import("../../pixi-frame/src/types").Datum[] | string[]>;
+            generator: {
+                type: import("vue").PropType<AsyncGenerator<ImageBitmap>>;
                 required: true;
             };
-            frameIndex: {
-                type: NumberConstructor;
-            };
-            url: {
-                type: StringConstructor;
-                requierd: false;
+            data: {
+                type: import("vue").PropType<any[]>;
+                default: () => never[];
             };
-            loop: {
+            visible: {
                 type: BooleanConstructor;
                 default: boolean;
             };
-            status: {
-                type: import("vue").PropType<TickerStatus>;
-                default: TickerStatus;
-            };
-            frameRate: {
-                type: NumberConstructor;
-                default: number;
+            resize: {
+                type: import("vue").PropType<import("../../pixi-frame/src/types").Resize>;
+                default: undefined;
             };
             label: {
                 type: StringConstructor;
                 default: string;
             };
-            resize: {
-                type: import("vue").PropType<import("../../pixi-frame/src/types").Resize>;
-                default: undefined;
+            status: {
+                type: import("vue").PropType<TickerStatus>;
+                default: TickerStatus;
+            };
+            url: {
+                type: StringConstructor;
+                requierd: false;
             };
             prerender: {
                 type: BooleanConstructor;
                 default: boolean;
             };
-            visible: {
-                type: BooleanConstructor;
-                default: boolean;
+            frameRate: {
+                type: NumberConstructor;
+                default: number;
             };
         }>> & Readonly<{
             onLoad?: ((e: import("../../pixi-frame/src/types").LoadEvent) => any) | undefined;
             "onUpdate:status"?: ((...args: any[]) => any) | undefined;
-            onSetData?: ((...args: any[]) => any) | undefined;
-            "onUpdate:data"?: ((...args: any[]) => any) | undefined;
-            "onUpdate:frameIndex"?: ((...args: any[]) => any) | undefined;
-            onNotFound?: ((_index: number) => any) | undefined;
         }> & {}>;
-        emit: ((event: "load", e: import("../../pixi-frame/src/types").LoadEvent) => void) & ((event: "update:status", ...args: any[]) => void) & ((event: "setData", ...args: any[]) => void) & ((event: "update:data", ...args: any[]) => void) & ((event: "update:frameIndex", ...args: any[]) => void) & ((event: "notFound", _index: number) => void);
-        compId: string;
-        getAlias: (key: string | number) => string;
+        emit: ((event: "load", e: import("../../pixi-frame/src/types").LoadEvent) => void) & ((event: "update:status", ...args: any[]) => void);
         sprite: import("pixi.js").Sprite;
         resizeSprite: () => void;
         application: import("pixi.js").Application<import("pixi.js").Renderer>;
-        textureMap: Map<string, import("pixi.js").Texture<import("pixi.js").TextureSource<any>>>;
-        completedIndex: Ref<number, number>;
-        enabledData: import("vue").ComputedRef<string[] | import("../../pixi-frame/src/types").Datum[]>;
-        index: import("vue").WritableComputedRef<number, number>;
-        animationId: number | null;
-        lastFrameTime: number;
-        startFrameLoop: () => void;
+        texture: import("pixi.js").Texture<import("pixi.js").TextureSource<any>>;
+        updateTextureFromBitmap: (bitmap: ImageBitmap) => void;
+        drawFrame: () => void;
         play: () => void;
         pause: () => void;
         stop: () => void;
     }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        load: (e: import("../../pixi-frame/src/types").LoadEvent) => import("../../pixi-frame/src/types").LoadEvent;
-        'update:frameIndex': null;
-        notFound: (_index: number) => true;
         'update:status': null;
-        'update:data': null;
-        setData: null;
+        load: (e: import("../../pixi-frame/src/types").LoadEvent) => import("../../pixi-frame/src/types").LoadEvent;
     }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        data: {
-            type: import("vue").PropType<import("../../pixi-frame/src/types").Datum[] | string[]>;
+        generator: {
+            type: import("vue").PropType<AsyncGenerator<ImageBitmap>>;
             required: true;
         };
-        frameIndex: {
-            type: NumberConstructor;
-        };
-        url: {
-            type: StringConstructor;
-            requierd: false;
+        data: {
+            type: import("vue").PropType<any[]>;
+            default: () => never[];
         };
-        loop: {
+        visible: {
             type: BooleanConstructor;
             default: boolean;
         };
-        status: {
-            type: import("vue").PropType<TickerStatus>;
-            default: TickerStatus;
-        };
-        frameRate: {
-            type: NumberConstructor;
-            default: number;
+        resize: {
+            type: import("vue").PropType<import("../../pixi-frame/src/types").Resize>;
+            default: undefined;
         };
         label: {
             type: StringConstructor;
             default: string;
         };
-        resize: {
-            type: import("vue").PropType<import("../../pixi-frame/src/types").Resize>;
-            default: undefined;
+        status: {
+            type: import("vue").PropType<TickerStatus>;
+            default: TickerStatus;
+        };
+        url: {
+            type: StringConstructor;
+            requierd: false;
         };
         prerender: {
             type: BooleanConstructor;
             default: boolean;
         };
-        visible: {
-            type: BooleanConstructor;
-            default: boolean;
+        frameRate: {
+            type: NumberConstructor;
+            default: number;
         };
     }>> & Readonly<{
         onLoad?: ((e: import("../../pixi-frame/src/types").LoadEvent) => any) | undefined;
         "onUpdate:status"?: ((...args: any[]) => any) | undefined;
-        onSetData?: ((...args: any[]) => any) | undefined;
-        "onUpdate:data"?: ((...args: any[]) => any) | undefined;
-        "onUpdate:frameIndex"?: ((...args: any[]) => any) | undefined;
-        onNotFound?: ((_index: number) => any) | undefined;
     }>, {
+        data: any[];
         visible: boolean;
         resize: import("../../pixi-frame/src/types").Resize;
         label: string;
         status: TickerStatus;
         prerender: boolean;
-        loop: boolean;
         frameRate: number;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     readonly setData: (obj: any, e: import("@vunk/core/shared").SetDataEvent) => void;
@@ -816,10 +788,15 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: NumberConstructor;
         default: number;
     };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>> & Readonly<{
     "onUpdate:status"?: ((...args: any[]) => any) | undefined;
 }>, {
     source: string;
+    disabled: boolean;
     status: TickerStatus;
     playAfterCache: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/components/pixi-frame/index.d.ts

@@ -1,4 +1,5 @@
 import VkPixiFrameApng from './src/apng.vue';
+import VkPixiFrameBitmapGenerator from './src/bitmap-generator.vue';
 import VkPixiFrameBitmap from './src/bitmap.vue';
 import VkPixiFrameCore from './src/core.vue';
 import VkPixiFrame from './src/index.vue';
@@ -6,6 +7,8 @@ import VkPixiFrameProvider from './src/provider.vue';
 import VkPixiFrameVideo from './src/video.vue';
 import VkPixiFrameView from './src/view.vue';
 export * as __VkPixiFrame from './src/types';
+export { usePixiApp } from './src/use';
+export { useSprite } from './src/useSprite';
 export { TickerStatus } from '@vunk/shared/enum';
-export { VkPixiFrame, VkPixiFrameApng, VkPixiFrameBitmap, VkPixiFrameCore, VkPixiFrameProvider, VkPixiFrameVideo, VkPixiFrameView, };
+export { VkPixiFrame, VkPixiFrameApng, VkPixiFrameBitmap, VkPixiFrameBitmapGenerator, VkPixiFrameCore, VkPixiFrameProvider, VkPixiFrameVideo, VkPixiFrameView, };
 export default VkPixiFrame;

package/components/pixi-frame/index.mjs

@@ -1,8 +1,8 @@
-export { ap as VkPixiFrame, aq as VkPixiFrameApng, ar as VkPixiFrameBitmap, as as VkPixiFrameCore, at as VkPixiFrameProvider, au as VkPixiFrameVideo, av as VkPixiFrameView, aw as __VkPixiFrame, ap as default } from '../index2.mjs';
+export { ap as VkPixiFrame, aq as VkPixiFrameApng, ar as VkPixiFrameBitmap, as as VkPixiFrameBitmapGenerator, at as VkPixiFrameCore, au as VkPixiFrameProvider, av as VkPixiFrameVideo, aw as VkPixiFrameView, ax as __VkPixiFrame, ap as default, ay as usePixiApp, az as useSprite } from '../index2.mjs';
 export { TickerStatus } from '@vunk/shared/enum';
 import 'vue';
 import '@vunk/shared/promise';
 import '../_commonjsHelpers.mjs';
 import '../_plugin-vue_export-helper.mjs';
-import '@vunk/core/composables';
 import '@vunk/shared/object';
+import '@vunk/core/composables';

package/components/pixi-frame/src/bitmap-generator.vue.d.ts

@@ -0,0 +1,146 @@
+import type { PropType } from 'vue';
+import type { LoadEvent } from './types';
+import { TickerStatus } from '@vunk/shared/enum';
+import { Texture } from 'pixi.js';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    generator: {
+        type: PropType<AsyncGenerator<ImageBitmap>>;
+        required: true;
+    };
+    data: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    resize: {
+        type: PropType<import("./types").Resize>;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    status: {
+        type: PropType<TickerStatus>;
+        default: TickerStatus;
+    };
+    url: {
+        type: StringConstructor;
+        requierd: false;
+    };
+    prerender: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    frameRate: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {
+    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        generator: {
+            type: PropType<AsyncGenerator<ImageBitmap>>;
+            required: true;
+        };
+        data: {
+            type: PropType<any[]>;
+            default: () => never[];
+        };
+        visible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        resize: {
+            type: PropType<import("./types").Resize>;
+            default: undefined;
+        };
+        label: {
+            type: StringConstructor;
+            default: string;
+        };
+        status: {
+            type: PropType<TickerStatus>;
+            default: TickerStatus;
+        };
+        url: {
+            type: StringConstructor;
+            requierd: false;
+        };
+        prerender: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        frameRate: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{
+        onLoad?: ((e: LoadEvent) => any) | undefined;
+        "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+    }> & {}>;
+    emit: ((event: "load", e: LoadEvent) => void) & ((event: "update:status", ...args: any[]) => void);
+    sprite: import("pixi.js").Sprite;
+    resizeSprite: () => void;
+    application: import("pixi.js").Application<import("pixi.js").Renderer>;
+    texture: Texture<import("pixi.js").TextureSource<any>>;
+    updateTextureFromBitmap: (bitmap: ImageBitmap) => void;
+    drawFrame: () => void;
+    play: () => void;
+    pause: () => void;
+    stop: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:status': null;
+    load: (e: LoadEvent) => LoadEvent;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    generator: {
+        type: PropType<AsyncGenerator<ImageBitmap>>;
+        required: true;
+    };
+    data: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    resize: {
+        type: PropType<import("./types").Resize>;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    status: {
+        type: PropType<TickerStatus>;
+        default: TickerStatus;
+    };
+    url: {
+        type: StringConstructor;
+        requierd: false;
+    };
+    prerender: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    frameRate: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onLoad?: ((e: LoadEvent) => any) | undefined;
+    "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+}>, {
+    data: any[];
+    visible: boolean;
+    resize: import("./types").Resize;
+    label: string;
+    status: TickerStatus;
+    prerender: boolean;
+    frameRate: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/pixi-frame/src/bitmap.vue.d.ts

@@ -84,15 +84,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         onNotFound?: ((_index: number) => any) | undefined;
     }> & {}>;
     emit: ((event: "load", e: LoadEvent) => void) & ((event: "update:status", ...args: any[]) => void) & ((event: "setData", ...args: any[]) => void) & ((event: "update:data", ...args: any[]) => void) & ((event: "update:frameIndex", ...args: any[]) => void) & ((event: "notFound", _index: number) => void);
-    compId: string;
-    getAlias: (key: string | number) => string;
     sprite: import("pixi.js").Sprite;
     resizeSprite: () => void;
     application: import("pixi.js").Application<import("pixi.js").Renderer>;
-    textureMap: Map<string, Texture<import("pixi.js").TextureSource<any>>>;
-    completedIndex: import("vue").Ref<number, number>;
-    enabledData: import("vue").ComputedRef<ImageBitmap[]>;
+    texture: Texture<import("pixi.js").TextureSource<any>>;
+    updateTextureFromBitmap: (bitmap: ImageBitmap) => void;
     index: import("vue").WritableComputedRef<number, number>;
+    lastScheduledClearIndex: import("vue").Ref<number, number>;
+    scheduleClearFrame: (frameIndex: number) => void;
     drawFrame: () => void;
     play: () => void;
     pause: () => void;