@vunk/plus 1.3.11 → 1.3.12

package/components/chat-independent/src/index.vue.d.ts

@@ -443,22 +443,18 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     };
                     default: () => string[];
                 };
-                pause: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
                 keepRead: {
                     type: BooleanConstructor;
                     default: boolean;
                 };
-                webSpeech: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
                 textToSpeech: {
                     type: import("vue").PropType<import("./types").TextToSpeech>;
                     default: undefined;
                 };
+                processing: {
+                    type: import("vue").PropType<(paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => void>;
+                    default: import("@vunk/shared").AnyFunc;
+                };
             }>, {
                 theData: import("vue").ComputedRef<import("../../broadcasting-markdown/src/types").Paragraph[]>;
                 ParagraphStatus: typeof import("../../broadcasting-markdown").ParagraphStatus;
@@ -466,13 +462,17 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 isPrevParagraphFulfilled: (currentIndex: number) => boolean;
                 isParagraphEnabled: (currentIndex: number) => boolean;
                 processingParagraph: (paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => Promise<void> | undefined;
-                thePause: import("vue").ComputedRef<boolean>;
+                isInterrupted: import("vue").Ref<boolean, boolean>;
+                setData: (obj: any, e: import("@vunk/core").SetDataEvent) => void;
+                Broadcast: typeof import("@vunk/shared/enum").TickerStatus;
+                isPaused: import("vue").ComputedRef<boolean>;
             }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                 setData: (e: import("@vunk/core").SetDataEvent) => import("@vunk/core").SetDataEvent;
                 interrupt: null;
                 'update:broadcasting': (_: boolean) => boolean;
                 'update:completed': (_: boolean) => boolean;
                 'update:error': (_: boolean) => boolean;
+                paragraphLoad: (_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => boolean;
             }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                 render: {
                     type: import("vue").PropType<(text: string) => string>;
@@ -520,37 +520,33 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     };
                     default: () => string[];
                 };
-                pause: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
                 keepRead: {
                     type: BooleanConstructor;
                     default: boolean;
                 };
-                webSpeech: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
                 textToSpeech: {
                     type: import("vue").PropType<import("./types").TextToSpeech>;
                     default: undefined;
                 };
+                processing: {
+                    type: import("vue").PropType<(paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => void>;
+                    default: import("@vunk/shared").AnyFunc;
+                };
             }>> & Readonly<{
                 onSetData?: ((e: import("@vunk/core").SetDataEvent) => any) | undefined;
                 onInterrupt?: ((...args: any[]) => any) | undefined;
                 "onUpdate:broadcasting"?: ((_: boolean) => any) | undefined;
                 "onUpdate:completed"?: ((_: boolean) => any) | undefined;
                 "onUpdate:error"?: ((_: boolean) => any) | undefined;
+                onParagraphLoad?: ((_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => any) | undefined;
             }>, {
+                processing: (paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => void;
                 source: string;
                 delay: number;
-                pause: boolean;
                 render: (text: string) => string;
                 data: import("../../broadcasting-markdown/src/types").Paragraph[];
                 separators: string[];
                 keepRead: boolean;
-                webSpeech: boolean;
                 textToSpeech: import("./types").TextToSpeech;
             }, {}, {
                 ParagraphView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
@@ -562,10 +558,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                         type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
                         default: import("../../broadcasting-markdown").ParagraphStatus;
                     };
-                    pause: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
                     processing: {
                         type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
                         default: import("@vunk/shared").AnyFunc;
@@ -584,10 +576,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                             type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
                             default: import("../../broadcasting-markdown").ParagraphStatus;
                         };
-                        pause: {
-                            type: BooleanConstructor;
-                            default: boolean;
-                        };
                         processing: {
                             type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
                             default: import("@vunk/shared").AnyFunc;
@@ -619,10 +607,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                         type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
                         default: import("../../broadcasting-markdown").ParagraphStatus;
                     };
-                    pause: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
                     processing: {
                         type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
                         default: import("@vunk/shared").AnyFunc;
@@ -635,9 +619,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     "onUpdate:status"?: ((...args: any[]) => any) | undefined;
                 }>, {
                     processing: import("@vunk/shared").AnyFunc;
-                    pause: boolean;
-                    enable: boolean;
                     status: import("../../broadcasting-markdown").ParagraphStatus;
+                    enable: boolean;
                     retryTimes: number;
                 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                 VkTypingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
@@ -696,112 +679,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     disabled: boolean;
                     markdownItSetup: (md: import("markdown-it-async").MarkdownItAsync) => void;
                 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-                WebSpeechView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-                    voice: {
-                        type: import("vue").PropType<SpeechSynthesisVoice>;
-                        required: false;
-                    };
-                    data: {
-                        type: import("vue").PropType<import("../../broadcasting-markdown/src/types").Paragraph>;
-                        default: () => {};
-                    };
-                    deferred: {
-                        type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
-                        required: true;
-                    };
-                    pause: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                    render: {
-                        type: import("vue").PropType<(text: string) => string>;
-                        required: true;
-                    };
-                }>, (() => null) | (() => false | JSX.Element), {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-                    voice: {
-                        type: import("vue").PropType<SpeechSynthesisVoice>;
-                        required: false;
-                    };
-                    data: {
-                        type: import("vue").PropType<import("../../broadcasting-markdown/src/types").Paragraph>;
-                        default: () => {};
-                    };
-                    deferred: {
-                        type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
-                        required: true;
-                    };
-                    pause: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                    render: {
-                        type: import("vue").PropType<(text: string) => string>;
-                        required: true;
-                    };
-                }>> & Readonly<{}>, {
-                    pause: boolean;
-                    data: import("../../broadcasting-markdown/src/types").Paragraph;
-                }, {}, {
-                    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: import("element-plus/es/utils").SFCWithInstall<{
-                            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                                readonly size: {
-                                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
-                                    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<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
-                                    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?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                            readonly size: {
-                                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
-                                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").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                 HowlerSpeechView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                     data: {
                         type: import("vue").PropType<import("../../broadcasting-markdown/src/types").Paragraph>;
@@ -811,19 +688,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                         type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
                         required: true;
                     };
-                    pause: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                    url: {
-                        type: StringConstructor;
-                        default: string;
-                    };
                     render: {
                         type: import("vue").PropType<(text: string) => string>;
-                        required: true;
+                        default: typeof import("../../broadcasting-markdown").defaultRender;
                     };
-                }>, (() => null) | (() => JSX.Element), {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                }>, (() => null) | (() => JSX.Element), {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    setData: (e: import("@vunk/core").SetDataEvent<keyof import("../../broadcasting-markdown/src/types").Paragraph>) => import("@vunk/core").SetDataEvent<keyof import("../../broadcasting-markdown/src/types").Paragraph>;
+                    load: (_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => boolean;
+                }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                     data: {
                         type: import("vue").PropType<import("../../broadcasting-markdown/src/types").Paragraph>;
                         default: () => {};
@@ -832,22 +704,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                         type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
                         required: true;
                     };
-                    pause: {
-                        type: BooleanConstructor;
-                        default: boolean;
-                    };
-                    url: {
-                        type: StringConstructor;
-                        default: string;
-                    };
                     render: {
                         type: import("vue").PropType<(text: string) => string>;
-                        required: true;
+                        default: typeof import("../../broadcasting-markdown").defaultRender;
                     };
-                }>> & Readonly<{}>, {
-                    pause: boolean;
+                }>> & Readonly<{
+                    onSetData?: ((e: import("@vunk/core").SetDataEvent<keyof import("../../broadcasting-markdown/src/types").Paragraph>) => any) | undefined;
+                    onLoad?: ((_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => any) | undefined;
+                }>, {
+                    render: (text: string) => string;
                     data: import("../../broadcasting-markdown/src/types").Paragraph;
-                    url: 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>;

package/components/colorToUniform.mjs

@@ -0,0 +1,266 @@
+const blendModeIds = {
+  normal: 0,
+  add: 1,
+  multiply: 2,
+  screen: 3,
+  overlay: 4,
+  erase: 5,
+  "normal-npm": 6,
+  "add-npm": 7,
+  "screen-npm": 8,
+  min: 9,
+  max: 10
+};
+const BLEND = 0;
+const OFFSET = 1;
+const CULLING = 2;
+const DEPTH_TEST = 3;
+const WINDING = 4;
+const DEPTH_MASK = 5;
+const _State = class _State {
+  constructor() {
+    this.data = 0;
+    this.blendMode = "normal";
+    this.polygonOffset = 0;
+    this.blend = true;
+    this.depthMask = true;
+  }
+  /**
+   * Activates blending of the computed fragment color values.
+   * @default true
+   */
+  get blend() {
+    return !!(this.data & 1 << BLEND);
+  }
+  set blend(value) {
+    if (!!(this.data & 1 << BLEND) !== value) {
+      this.data ^= 1 << BLEND;
+    }
+  }
+  /**
+   * Activates adding an offset to depth values of polygon's fragments
+   * @default false
+   */
+  get offsets() {
+    return !!(this.data & 1 << OFFSET);
+  }
+  set offsets(value) {
+    if (!!(this.data & 1 << OFFSET) !== value) {
+      this.data ^= 1 << OFFSET;
+    }
+  }
+  /** The culling settings for this state none - No culling back - Back face culling front - Front face culling */
+  set cullMode(value) {
+    if (value === "none") {
+      this.culling = false;
+      return;
+    }
+    this.culling = true;
+    this.clockwiseFrontFace = value === "front";
+  }
+  get cullMode() {
+    if (!this.culling) {
+      return "none";
+    }
+    return this.clockwiseFrontFace ? "front" : "back";
+  }
+  /**
+   * Activates culling of polygons.
+   * @default false
+   */
+  get culling() {
+    return !!(this.data & 1 << CULLING);
+  }
+  set culling(value) {
+    if (!!(this.data & 1 << CULLING) !== value) {
+      this.data ^= 1 << CULLING;
+    }
+  }
+  /**
+   * Activates depth comparisons and updates to the depth buffer.
+   * @default false
+   */
+  get depthTest() {
+    return !!(this.data & 1 << DEPTH_TEST);
+  }
+  set depthTest(value) {
+    if (!!(this.data & 1 << DEPTH_TEST) !== value) {
+      this.data ^= 1 << DEPTH_TEST;
+    }
+  }
+  /**
+   * Enables or disables writing to the depth buffer.
+   * @default true
+   */
+  get depthMask() {
+    return !!(this.data & 1 << DEPTH_MASK);
+  }
+  set depthMask(value) {
+    if (!!(this.data & 1 << DEPTH_MASK) !== value) {
+      this.data ^= 1 << DEPTH_MASK;
+    }
+  }
+  /**
+   * Specifies whether or not front or back-facing polygons can be culled.
+   * @default false
+   */
+  get clockwiseFrontFace() {
+    return !!(this.data & 1 << WINDING);
+  }
+  set clockwiseFrontFace(value) {
+    if (!!(this.data & 1 << WINDING) !== value) {
+      this.data ^= 1 << WINDING;
+    }
+  }
+  /**
+   * The blend mode to be applied when this state is set. Apply a value of `normal` to reset the blend mode.
+   * Setting this mode to anything other than NO_BLEND will automatically switch blending on.
+   * @default 'normal'
+   */
+  get blendMode() {
+    return this._blendMode;
+  }
+  set blendMode(value) {
+    this.blend = value !== "none";
+    this._blendMode = value;
+    this._blendModeId = blendModeIds[value] || 0;
+  }
+  /**
+   * The polygon offset. Setting this property to anything other than 0 will automatically enable polygon offset fill.
+   * @default 0
+   */
+  get polygonOffset() {
+    return this._polygonOffset;
+  }
+  set polygonOffset(value) {
+    this.offsets = !!value;
+    this._polygonOffset = value;
+  }
+  toString() {
+    return `[pixi.js/core:State blendMode=${this.blendMode} clockwiseFrontFace=${this.clockwiseFrontFace} culling=${this.culling} depthMask=${this.depthMask} polygonOffset=${this.polygonOffset}]`;
+  }
+  /**
+   * A quickly getting an instance of a State that is configured for 2d rendering.
+   * @returns a new State with values set for 2d rendering
+   */
+  static for2d() {
+    const state = new _State();
+    state.depthTest = false;
+    state.blend = true;
+    return state;
+  }
+};
+_State.default2d = _State.for2d();
+let State = _State;
+
+const localUniformBit = {
+  name: "local-uniform-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+
+            struct LocalUniforms {
+                uTransformMatrix:mat3x3<f32>,
+                uColor:vec4<f32>,
+                uRound:f32,
+            }
+
+            @group(1) @binding(0) var<uniform> localUniforms : LocalUniforms;
+        `
+    ),
+    main: (
+      /* wgsl */
+      `
+            vColor *= localUniforms.uColor;
+            modelMatrix *= localUniforms.uTransformMatrix;
+        `
+    ),
+    end: (
+      /* wgsl */
+      `
+            if(localUniforms.uRound == 1)
+            {
+                vPosition = vec4(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw);
+            }
+        `
+    )
+  }
+};
+const localUniformBitGroup2 = {
+  ...localUniformBit,
+  vertex: {
+    ...localUniformBit.vertex,
+    // replace the group!
+    header: localUniformBit.vertex.header.replace("group(1)", "group(2)")
+  }
+};
+const localUniformBitGl = {
+  name: "local-uniform-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+
+            uniform mat3 uTransformMatrix;
+            uniform vec4 uColor;
+            uniform float uRound;
+        `
+    ),
+    main: (
+      /* glsl */
+      `
+            vColor *= uColor;
+            modelMatrix = uTransformMatrix;
+        `
+    ),
+    end: (
+      /* glsl */
+      `
+            if(uRound == 1.)
+            {
+                gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
+            }
+        `
+    )
+  }
+};
+
+class BatchableSprite {
+  constructor() {
+    this.batcherName = "default";
+    this.topology = "triangle-list";
+    // batch specific..
+    this.attributeSize = 4;
+    this.indexSize = 6;
+    this.packAsQuad = true;
+    this.roundPixels = 0;
+    this._attributeStart = 0;
+    // location in the buffer
+    this._batcher = null;
+    this._batch = null;
+  }
+  get blendMode() {
+    return this.renderable.groupBlendMode;
+  }
+  get color() {
+    return this.renderable.groupColorAlpha;
+  }
+  reset() {
+    this.renderable = null;
+    this.texture = null;
+    this._batcher = null;
+    this._batch = null;
+    this.bounds = null;
+  }
+}
+
+function color32BitToUniform(abgr, out, offset) {
+  const alpha = (abgr >> 24 & 255) / 255;
+  out[offset++] = (abgr & 255) / 255 * alpha;
+  out[offset++] = (abgr >> 8 & 255) / 255 * alpha;
+  out[offset++] = (abgr >> 16 & 255) / 255 * alpha;
+  out[offset++] = alpha;
+}
+
+export { BatchableSprite as B, State as S, localUniformBit as a, localUniformBitGl as b, color32BitToUniform as c, localUniformBitGroup2 as l };