@vunk/plus 1.6.8 → 1.6.9

package/components/WebGLRenderer.mjs

@@ -1,13 +1,13 @@
-import { E as ExtensionType, B as BufferUsage, w as warn, D as DOMAdapter, K as getAttributeInfoFromFormat, u as GlProgram, s as Shader, t as Texture, a3 as Geometry, j as TextureSource, S as STENCIL_MODES, O as Rectangle, i as CanvasSource, h as CLEAR, k as UniformGroup, q as getMaxTexturesPerBatch, M as Matrix, a4 as compileHighShaderGlProgram, a5 as colorBitGl, a6 as generateTextureBatchBitGl, a7 as roundPixelsBitGl, a8 as getBatchSamplersUniformGroup, A as AbstractRenderer, R as RendererType, e as extensions } from './index2.mjs';
+import { E as ExtensionType, B as BufferUsage, w as warn, D as DOMAdapter, J as getAttributeInfoFromFormat, a2 as Geometry, t as GlProgram, q as Shader, s as Texture, j as TextureSource, a3 as checkMaxIfStatementsInShader, S as STENCIL_MODES, N as Rectangle, i as CanvasSource, h as CLEAR, k as UniformGroup, M as Matrix, a4 as compileHighShaderGlProgram, a5 as colorBitGl, a6 as generateTextureBatchBitGl, a7 as roundPixelsBitGl, a8 as getBatchSamplersUniformGroup, e as extensions, A as AbstractRenderer, R as RendererType } from './index2.mjs';
 import { S as State, b as localUniformBitGl } from './colorToUniform.mjs';
 import { e as ensureAttributes, G as GpuStencilModesToPixi, c as createUboSyncFunction, b as uboSyncFunctionsSTD40, U as UboSystem, R as RenderTargetSystem, B as BufferResource, d as uniformParsers, f as textureBitGl, S as SharedSystems, a as SharedRenderPipes } from './SharedSystems.mjs';
 import 'vue';
 import '@vunk/shared/enum';
 import '@vunk/shared/promise';
 import './_commonjsHelpers.mjs';
+import './_plugin-vue_export-helper.mjs';
 import '@vunk/core/composables';
 import '@vunk/shared/object';
-import './_plugin-vue_export-helper.mjs';
 
 class GlBatchAdaptor {
   constructor() {
@@ -87,9 +87,7 @@ class GlBufferSystem {
     this._renderer = renderer;
     this._renderer.renderableGC.addManagedHash(this, "_gpuBuffers");
   }
-  /**
-   * @ignore
-   */
+  /** @ignore */
   destroy() {
     this._renderer = null;
     this._gl = null;
@@ -98,9 +96,9 @@ class GlBufferSystem {
   }
   /** Sets up the renderer context and necessary buffers. */
   contextChange() {
-    const gl = this._gl = this._renderer.gl;
+    this._gl = this._renderer.gl;
     this._gpuBuffers = /* @__PURE__ */ Object.create(null);
-    this._maxBindings = gl.MAX_UNIFORM_BUFFER_BINDINGS ? gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS) : 0;
+    this._maxBindings = this._renderer.limits.maxUniformBindings;
   }
   getGlBuffer(buffer) {
     return this._gpuBuffers[buffer.uid] || this.createGLBuffer(buffer);
@@ -1102,6 +1100,27 @@ GlEncoderSystem.extension = {
   name: "encoder"
 };
 
+class GlLimitsSystem {
+  constructor(renderer) {
+    this._renderer = renderer;
+  }
+  contextChange() {
+    const gl = this._renderer.gl;
+    this.maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
+    this.maxBatchableTextures = checkMaxIfStatementsInShader(this.maxTextures, gl);
+    this.maxUniformBindings = gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS);
+  }
+  destroy() {
+  }
+}
+/** @ignore */
+GlLimitsSystem.extension = {
+  type: [
+    ExtensionType.WebGLSystem
+  ],
+  name: "limits"
+};
+
 class GlRenderTarget {
   constructor() {
     this.width = -1;
@@ -1398,7 +1417,7 @@ class GlRenderTargetAdaptor {
     const gl = renderer.gl;
     const glRenderTarget = new GlRenderTarget();
     const colorTexture = renderTarget.colorTexture;
-    if (CanvasSource.test(colorTexture.resource)) {
+    if (colorTexture instanceof CanvasSource) {
       this._renderer.context.ensureCanvasSize(renderTarget.colorTexture.resource);
       glRenderTarget.framebuffer = null;
       return glRenderTarget;
@@ -2021,10 +2040,7 @@ const defaultSyncData = {
 };
 class GlShaderSystem {
   constructor(renderer) {
-    /**
-     * @internal
-     * @private
-     */
+    /** @internal */
     this._activeProgram = null;
     this._programDataHash = /* @__PURE__ */ Object.create(null);
     this._shaderSyncFunctions = /* @__PURE__ */ Object.create(null);
@@ -2036,7 +2052,6 @@ class GlShaderSystem {
     this._programDataHash = /* @__PURE__ */ Object.create(null);
     this._shaderSyncFunctions = /* @__PURE__ */ Object.create(null);
     this._activeProgram = null;
-    this.maxTextures = getMaxTexturesPerBatch();
   }
   /**
    * Changes the current shader to the one given in parameter.
@@ -2106,7 +2121,6 @@ class GlShaderSystem {
   /**
    * @param program - the program to get the data for
    * @internal
-   * @private
    */
   _getProgramData(program) {
     return this._programDataHash[program._key] || this._createProgramData(program);
@@ -2587,7 +2601,6 @@ const _GlStateSystem = class _GlStateSystem {
   setPolygonOffset(value, scale) {
     this.gl.polygonOffset(value, scale);
   }
-  // used
   /** Resets all the logic and disables the VAOs. */
   resetState() {
     this._glFrontFace = false;
@@ -2635,9 +2648,7 @@ const _GlStateSystem = class _GlStateSystem {
   static _checkPolygonOffset(system, state) {
     system.setPolygonOffset(1, state.polygonOffset);
   }
-  /**
-   * @ignore
-   */
+  /** @ignore */
   destroy() {
     this.gl = null;
     this.checks.length = 0;
@@ -3463,13 +3474,13 @@ GlTextureSystem.extension = {
 };
 
 class GlGraphicsAdaptor {
-  init() {
+  contextChange(renderer) {
     const uniforms = new UniformGroup({
       uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
       uTransformMatrix: { value: new Matrix(), type: "mat3x3<f32>" },
       uRound: { value: 0, type: "f32" }
     });
-    const maxTextures = getMaxTexturesPerBatch();
+    const maxTextures = renderer.limits.maxBatchableTextures;
     const glProgram = compileHighShaderGlProgram({
       name: "graphics",
       bits: [
@@ -3583,6 +3594,7 @@ const DefaultWebGLSystems = [
   GlUboSystem,
   GlBackBufferSystem,
   GlContextSystem,
+  GlLimitsSystem,
   GlBufferSystem,
   GlTextureSystem,
   GlRenderTargetSystem,

package/components/WebGPURenderer.mjs

@@ -1,13 +1,13 @@
-import { g as getTextureBatchBindGroup, E as ExtensionType, f as fastCopy, D as DOMAdapter, S as STENCIL_MODES, B as BufferUsage, b as Buffer, c as BindGroup, d as createIdFromString, w as warn, h as CLEAR, i as CanvasSource, j as TextureSource, k as UniformGroup, l as CanvasPool, M as Matrix, m as compileHighShaderGpuProgram, n as colorBit, o as generateTextureBatchBit, p as roundPixelsBit, q as getMaxTexturesPerBatch, s as Shader, t as Texture, A as AbstractRenderer, R as RendererType, e as extensions } from './index2.mjs';
+import { g as getTextureBatchBindGroup, E as ExtensionType, f as fastCopy, D as DOMAdapter, S as STENCIL_MODES, B as BufferUsage, b as Buffer, c as BindGroup, d as createIdFromString, w as warn, h as CLEAR, i as CanvasSource, j as TextureSource, k as UniformGroup, l as CanvasPool, M as Matrix, m as compileHighShaderGpuProgram, n as colorBit, o as generateTextureBatchBit, p as roundPixelsBit, q as Shader, s as Texture, e as extensions, A as AbstractRenderer, R as RendererType } from './index2.mjs';
 import { S as State, l as localUniformBitGroup2, a as localUniformBit } from './colorToUniform.mjs';
 import { c as createUboSyncFunction, u as uboSyncFunctionsWGSL, U as UboSystem, B as BufferResource, G as GpuStencilModesToPixi, e as ensureAttributes, R as RenderTargetSystem, t as textureBit, S as SharedSystems, a as SharedRenderPipes } from './SharedSystems.mjs';
 import 'vue';
 import '@vunk/shared/enum';
 import '@vunk/shared/promise';
 import './_commonjsHelpers.mjs';
+import './_plugin-vue_export-helper.mjs';
 import '@vunk/core/composables';
 import '@vunk/shared/object';
-import './_plugin-vue_export-helper.mjs';
 
 const tempState = State.for2d();
 class GpuBatchAdaptor {
@@ -34,7 +34,11 @@ class GpuBatchAdaptor {
     const encoder = renderer.encoder;
     if (!batch.bindGroup) {
       const textureBatch = batch.textures;
-      batch.bindGroup = getTextureBatchBindGroup(textureBatch.textures, textureBatch.count);
+      batch.bindGroup = getTextureBatchBindGroup(
+        textureBatch.textures,
+        textureBatch.count,
+        renderer.limits.maxBatchableTextures
+      );
     }
     tempState.blendMode = batch.blendMode;
     const gpuBindGroup = renderer.bindGroup.getBindGroup(
@@ -166,7 +170,7 @@ class GpuBufferSystem {
         data.buffer,
         0,
         // round to the nearest 4 bytes
-        (buffer._updateSize || data.byteLength) + 3 & -4
+        (buffer._updateSize || data.byteLength) + 3 & ~3
       );
     }
     return gpuBuffer;
@@ -526,6 +530,25 @@ GpuEncoderSystem.extension = {
   priority: 1
 };
 
+class GpuLimitsSystem {
+  constructor(renderer) {
+    this._renderer = renderer;
+  }
+  contextChange() {
+    this.maxTextures = this._renderer.device.gpu.device.limits.maxSampledTexturesPerShaderStage;
+    this.maxBatchableTextures = this.maxTextures;
+  }
+  destroy() {
+  }
+}
+/** @ignore */
+GpuLimitsSystem.extension = {
+  type: [
+    ExtensionType.WebGPUSystem
+  ],
+  name: "limits"
+};
+
 class GpuStencilSystem {
   constructor(renderer) {
     this._renderTargetStencilState = /* @__PURE__ */ Object.create(null);
@@ -1182,7 +1205,7 @@ class GpuRenderTargetAdaptor {
     renderTarget.isRoot = true;
     const gpuRenderTarget = new GpuRenderTarget();
     renderTarget.colorTextures.forEach((colorTexture, i) => {
-      if (CanvasSource.test(colorTexture.resource)) {
+      if (colorTexture instanceof CanvasSource) {
         const context = colorTexture.resource.getContext(
           "webgpu"
         );
@@ -1269,7 +1292,6 @@ class GpuShaderSystem {
   }
   contextChange(gpu) {
     this._gpu = gpu;
-    this.maxTextures = gpu.device.limits.maxSampledTexturesPerShaderStage;
   }
   getProgramData(program) {
     return this._gpuProgramData[program._layoutKey] || this._createGPUProgramData(program);
@@ -1547,6 +1569,13 @@ const gpuUploadImageResource = {
     const resource = source.resource;
     if (!resource)
       return;
+    if (globalThis.HTMLImageElement && resource instanceof HTMLImageElement) {
+      const canvas = DOMAdapter.get().createCanvas(resource.width, resource.height);
+      const context = canvas.getContext("2d");
+      context.drawImage(resource, 0, 0, resource.width, resource.height);
+      source.resource = canvas;
+      warn("ImageSource: Image element passed, converting to canvas and replacing resource.");
+    }
     const width = Math.min(gpuTexture.width, source.resourceWidth || source.pixelWidth);
     const height = Math.min(gpuTexture.height, source.resourceHeight || source.pixelHeight);
     const premultipliedAlpha = source.alphaMode === "premultiply-alpha-on-upload";
@@ -1753,7 +1782,7 @@ class GpuTextureSystem {
       usage |= GPUTextureUsage.RENDER_ATTACHMENT;
       usage |= GPUTextureUsage.COPY_SRC;
     }
-    const blockData = blockDataMap[source.format] || { blockWidth: 1, blockHeight: 1 };
+    const blockData = blockDataMap[source.format] || { blockBytes: 4, blockWidth: 1, blockHeight: 1 };
     const width = Math.ceil(source.pixelWidth / blockData.blockWidth) * blockData.blockWidth;
     const height = Math.ceil(source.pixelHeight / blockData.blockHeight) * blockData.blockHeight;
     const textureDescriptor = {
@@ -1929,17 +1958,21 @@ GpuTextureSystem.extension = {
 };
 
 class GpuGraphicsAdaptor {
-  init() {
+  constructor() {
+    this._maxTextures = 0;
+  }
+  contextChange(renderer) {
     const localUniforms = new UniformGroup({
       uTransformMatrix: { value: new Matrix(), type: "mat3x3<f32>" },
       uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
       uRound: { value: 0, type: "f32" }
     });
+    this._maxTextures = renderer.limits.maxBatchableTextures;
     const gpuProgram = compileHighShaderGpuProgram({
       name: "graphics",
       bits: [
         colorBit,
-        generateTextureBatchBit(getMaxTexturesPerBatch()),
+        generateTextureBatchBit(this._maxTextures),
         localUniformBitGroup2,
         roundPixelsBit
       ]
@@ -1983,7 +2016,11 @@ class GpuGraphicsAdaptor {
       shader.groups[1] = batch.bindGroup;
       if (!batch.gpuBindGroup) {
         const textureBatch = batch.textures;
-        batch.bindGroup = getTextureBatchBindGroup(textureBatch.textures, textureBatch.count);
+        batch.bindGroup = getTextureBatchBindGroup(
+          textureBatch.textures,
+          textureBatch.count,
+          this._maxTextures
+        );
         batch.gpuBindGroup = renderer.bindGroup.getBindGroup(
           batch.bindGroup,
           shader.gpuProgram,
@@ -2070,6 +2107,7 @@ const DefaultWebGPUSystems = [
   GpuUboSystem,
   GpuEncoderSystem,
   GpuDeviceSystem,
+  GpuLimitsSystem,
   GpuBufferSystem,
   GpuTextureSystem,
   GpuRenderTargetSystem,

package/components/agent-chat-provider/index.d.ts

@@ -0,0 +1,7 @@
+import VkAgentChatProvider from './src/index.vue';
+export * from './src/const';
+export * from './src/const-roles';
+export * as __VkAgentChatProvider from './src/types';
+export { useAgentChat } from './src/use';
+export { VkAgentChatProvider, };
+export default VkAgentChatProvider;

package/components/agent-chat-provider/index.mjs

@@ -1,6 +1,7 @@
 import { computed, provide, inject, defineComponent } from 'vue';
 import { restFetch } from '@vunk/shared/fetch';
 import { useXChat, useXAgent } from 'ant-design-x-vue';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 
 async function agentRequest(onmessage, data) {
   return restFetch.reader({
@@ -201,12 +202,14 @@ var _sfc_main = defineComponent({
   }
 });
 
+var VkAgentChatProvider = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/agent-chat-provider/src/index.vue"]]);
+
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null
 });
 
-_sfc_main.install = (app) => {
-  app.component(_sfc_main.name || "VkAgentChatProvider", _sfc_main);
+VkAgentChatProvider.install = (app) => {
+  app.component(VkAgentChatProvider.name || "VkAgentChatProvider", VkAgentChatProvider);
 };
 
-export { ChatAgentInjectKey, Role, _sfc_main as VkAgentChatProvider, types as __VkAgentChatProvider, _sfc_main as default, roleMap, roleOptions, useAgentChat };
+export { ChatAgentInjectKey, Role, VkAgentChatProvider, types as __VkAgentChatProvider, VkAgentChatProvider as default, roleMap, roleOptions, useAgentChat };

package/components/agent-chat-provider/src/api.d.ts

@@ -0,0 +1,3 @@
+import type { NormalObject } from '@vunk/shared';
+import type { RestFetchReaderOnmessage } from '@vunk/shared/fetch';
+export declare function agentRequest(onmessage: RestFetchReaderOnmessage, data: NormalObject): Promise<void>;

package/components/agent-chat-provider/src/const-roles.d.ts

@@ -0,0 +1,8 @@
+import type { RoleMedia } from './types';
+export declare enum Role {
+    User = "user",
+    Assistant = "assistant",
+    Broadcasting = "broadcasting"
+}
+export declare const roleOptions: RoleMedia[];
+export declare const roleMap: Record<Role, RoleMedia>;

package/components/agent-chat-provider/src/const.d.ts

@@ -0,0 +1 @@
+export declare const ChatAgentInjectKey = "vk_agent_chat_inject_key";

package/components/agent-chat-provider/src/index.vue.d.ts

@@ -0,0 +1,22 @@
+import type { AnyFunc } from '@vunk/shared';
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    request: {
+        type: PropType<AnyFunc>;
+    };
+    parser: {
+        type: PropType<AnyFunc>;
+    };
+}>, import("vue").Slot<any> | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: null;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    request: {
+        type: PropType<AnyFunc>;
+    };
+    parser: {
+        type: PropType<AnyFunc>;
+    };
+}>> & Readonly<{
+    onLoad?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/agent-chat-provider/src/types.d.ts

@@ -0,0 +1,50 @@
+import type { __VkBubbleTemplates } from '@vunk/plus/components/bubble-templates';
+import type { Media, NormalObject } from '@vunk/shared';
+import type { RequestFn, useXChat, XAgent } from 'ant-design-x-vue';
+import type { MaybeArray } from 'naive-ui/es/_utils';
+import type { ComputedRef } from 'vue';
+import type { BubbleListItemProps } from 'vue-element-plus-x/types/components/BubbleList/types';
+export interface AgentChatContext {
+    agent: ComputedRef<XAgent<AgentMessage>>;
+    chat: ReturnType<typeof useXChat<AgentMessage, BubbleMessage>>;
+    simplicity: {
+        onRequest: (message: string) => void;
+        items: ComputedRef<BubbleItem[]>;
+    };
+}
+export type Request = RequestFn<AgentMessage>;
+export type Parser = (message: AgentMessage) => MaybeArray<BubbleMessage>;
+/**
+ * @description   useXAgent request onSuccess 发送的数据
+ */
+export type AgentMessage = BubbleMessage & {
+    seviceLoading?: boolean;
+    seviceEnd?: boolean;
+};
+/**
+ * @description useXChat parser 解析数据
+ */
+export type BubbleMessage = Partial<BubbleListItemProps> & {
+    role: string;
+    content: string;
+    /**
+     * @description 服务端请求是否完成
+     */
+    seviceEnd?: boolean;
+    thinkingStatus?: 'start' | 'thinking' | 'end' | 'error';
+    thinkingContent?: string;
+    meta?: NormalObject;
+    abortController?: AbortController;
+    templateType?: string;
+    [key: string]: any;
+};
+export type BubbleItem = BubbleItemBasic & __VkBubbleTemplates.RenderItem;
+export type RoleMedia = RoleMediaBasic & __VkBubbleTemplates.RenderItem;
+export type BubbleItemModule = 'Thinking';
+export interface BubbleItemBasic extends BubbleMessage {
+    key: string;
+    modules?: BubbleItemModule[];
+}
+export interface RoleMediaBasic extends Partial<BubbleItemBasic>, Media {
+    value: string;
+}

package/components/agent-chat-provider/src/use.d.ts

@@ -0,0 +1,5 @@
+import type { RequestFn } from 'ant-design-x-vue';
+import type { AgentChatContext, AgentMessage, Parser } from './types';
+export declare function useAgent(request: RequestFn<AgentMessage>): import("vue").ComputedRef<import("ant-design-x-vue").XAgent<AgentMessage>>[];
+export declare function initAgentChat(request: RequestFn<AgentMessage>, parser: Parser): AgentChatContext;
+export declare function useAgentChat(): AgentChatContext;

package/components/avatar/index.d.ts

@@ -0,0 +1,4 @@
+import VkAvatar from './src/index.vue';
+export * as __VkAvatar from './src/types';
+export { VkAvatar, };
+export default VkAvatar;

package/components/avatar/index.mjs

@@ -1,5 +1,5 @@
 import { ElAvatar } from 'element-plus';
-import { defineComponent, resolveComponent, createBlock, openBlock, normalizeStyle, withCtx, renderSlot } from 'vue';
+import { defineComponent, resolveComponent, openBlock, createBlock, normalizeStyle, withCtx, renderSlot } from 'vue';
 import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 
 const props = {
@@ -36,7 +36,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     /* FORWARDED */
   }, 8, ["style"]);
 }
-var VkAvatar = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+var VkAvatar = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/avatar/src/index.vue"]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null

package/components/avatar/src/ctx.d.ts

@@ -0,0 +1,6 @@
+import type { avatarProps } from 'element-plus';
+export declare const props: typeof avatarProps & {
+    background: never;
+    color: never;
+};
+export declare const emits: {};

package/components/avatar/src/index.vue.d.ts

@@ -0,0 +1,180 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly size: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], "" | "default" | "small" | "large", number, "", boolean>;
+    readonly shape: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "circle" | "square", unknown, "circle", boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly alt: StringConstructor;
+    readonly srcSet: StringConstructor;
+    readonly fit: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ObjectFitProperty & {}) | (() => ObjectFitProperty) | ((new (...args: any[]) => ObjectFitProperty & {}) | (() => ObjectFitProperty))[], unknown, unknown, "cover", boolean>;
+} & {
+    background: never;
+    color: never;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly size: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], "" | "default" | "small" | "large", number, "", boolean>;
+    readonly shape: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "circle" | "square", unknown, "circle", boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly alt: StringConstructor;
+    readonly srcSet: StringConstructor;
+    readonly fit: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ObjectFitProperty & {}) | (() => ObjectFitProperty) | ((new (...args: any[]) => ObjectFitProperty & {}) | (() => ObjectFitProperty))[], unknown, unknown, "cover", boolean>;
+} & {
+    background: never;
+    color: never;
+}>> & Readonly<{}>, {
+    readonly size: import("element-plus/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], "" | "small" | "default" | "large", number>;
+    readonly shape: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "circle" | "square", unknown>;
+    readonly src: string;
+    readonly fit: any;
+}, {}, {
+    ElAvatar: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly size: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], "" | "default" | "small" | "large", number, "", boolean>;
+        readonly shape: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "circle" | "square", unknown, "circle", boolean>;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly alt: StringConstructor;
+        readonly srcSet: StringConstructor;
+        readonly fit: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty) | ((new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty))[], unknown, unknown, "cover", boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly size: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], "" | "default" | "small" | "large", number, "", boolean>;
+            readonly shape: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "circle" | "square", unknown, "circle", boolean>;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly alt: StringConstructor;
+            readonly srcSet: StringConstructor;
+            readonly fit: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty) | ((new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty))[], unknown, unknown, "cover", boolean>;
+        }>> & {
+            onError?: ((evt: Event) => any) | undefined;
+        }>>;
+        emit: (event: "error", evt: Event) => void;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        hasLoadError: import("vue").Ref<boolean>;
+        avatarClass: import("vue").ComputedRef<string[]>;
+        sizeStyle: import("vue").ComputedRef<import("vue").CSSProperties | undefined>;
+        fitStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+        handleError: (e: Event) => void;
+        ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(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;
+            };
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(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;
+                };
+            }>> & {
+                [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            style: import("vue").ComputedRef<import("vue").CSSProperties>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(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;
+            };
+        }>>, {}>> & Record<string, any>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        error: (evt: Event) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly size: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], "" | "default" | "small" | "large", number, "", boolean>;
+        readonly shape: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "circle" | "square", unknown, "circle", boolean>;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly src: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly alt: StringConstructor;
+        readonly srcSet: StringConstructor;
+        readonly fit: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty) | ((new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty))[], unknown, unknown, "cover", boolean>;
+    }>> & {
+        onError?: ((evt: Event) => any) | undefined;
+    }, {
+        readonly size: import("element-plus/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], "" | "default" | "small" | "large", number>;
+        readonly shape: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "circle" | "square", unknown>;
+        readonly src: string;
+        readonly fit: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty) | ((new (...args: any[]) => import("csstype").ObjectFitProperty & {}) | (() => import("csstype").ObjectFitProperty))[], unknown, unknown>;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/avatar/src/types.d.ts

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