@vunk/plus 1.7.4 → 1.8.0

package/components/scrollbar/index.mjs

@@ -0,0 +1,595 @@
+import { defineComponent, inject, ref, computed, onBeforeUnmount, toRef, openBlock, createBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, withModifiers, normalizeStyle, vShow, createElementBlock, Fragment, createVNode, watch, nextTick, provide, reactive, onActivated, onMounted, onUpdated, resolveDynamicComponent, renderSlot, createCommentVNode } from 'vue';
+import { useEventListener, isClient, useResizeObserver, isObject } from '@vueuse/core';
+import { VkAsyncTeleport } from '@vunk/core/components/async-teleport';
+import { scrollbarContextKey, useNamespace, BAR_MAP, renderThumbStyle, GAP, SCOPE, scrollbarProps, scrollbarEmits } from 'element-plus';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const barProps = {
+  always: {
+    type: Boolean,
+    default: true
+  },
+  minSize: {
+    type: Number,
+    required: true
+  }
+};
+
+const thumbProps = {
+  vertical: Boolean,
+  size: String,
+  move: Number,
+  ratio: {
+    type: Number,
+    required: true
+  },
+  always: Boolean
+};
+
+var _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "thumb",
+  props: thumbProps,
+  setup(__props, { expose: __expose }) {
+    __expose();
+    const props = __props;
+    const scrollbar = inject(scrollbarContextKey);
+    const ns = useNamespace("scrollbar");
+    const instance = ref();
+    const thumb = ref();
+    const thumbState = ref({});
+    const visible = ref(false);
+    let cursorDown = false;
+    let cursorLeave = false;
+    let baseScrollHeight = 0;
+    let baseScrollWidth = 0;
+    let originalOnSelectStart = isClient ? document.onselectstart : null;
+    const bar = computed(() => BAR_MAP[props.vertical ? "vertical" : "horizontal"]);
+    const thumbStyle = computed(
+      () => renderThumbStyle({
+        size: props.size,
+        move: props.move,
+        bar: bar.value
+      })
+    );
+    const offsetRatio = computed(
+      () => (
+        // offsetRatioX = original width of thumb / current width of thumb / ratioX
+        // offsetRatioY = original height of thumb / current height of thumb / ratioY
+        // instance height = wrap height - GAP
+        instance.value[bar.value.offset] ** 2 / scrollbar.wrapElement[bar.value.scrollSize] / props.ratio / thumb.value[bar.value.offset]
+      )
+    );
+    function clickThumbHandler(e) {
+      e.stopPropagation();
+      if (e.ctrlKey || [1, 2].includes(e.button))
+        return;
+      window.getSelection()?.removeAllRanges();
+      startDrag(e);
+      const el = e.currentTarget;
+      if (!el)
+        return;
+      thumbState.value[bar.value.axis] = el[bar.value.offset] - (e[bar.value.client] - el.getBoundingClientRect()[bar.value.direction]);
+    }
+    function clickTrackHandler(e) {
+      if (!thumb.value || !instance.value || !scrollbar.wrapElement)
+        return;
+      const offset = Math.abs(
+        e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]
+      );
+      const thumbHalf = thumb.value[bar.value.offset] / 2;
+      const thumbPositionPercentage = (offset - thumbHalf) * 100 * offsetRatio.value / instance.value[bar.value.offset];
+      scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize] / 100;
+    }
+    function startDrag(e) {
+      e.stopImmediatePropagation();
+      cursorDown = true;
+      baseScrollHeight = scrollbar.wrapElement.scrollHeight;
+      baseScrollWidth = scrollbar.wrapElement.scrollWidth;
+      document.addEventListener("mousemove", mouseMoveDocumentHandler);
+      document.addEventListener("mouseup", mouseUpDocumentHandler);
+      originalOnSelectStart = document.onselectstart;
+      document.onselectstart = () => false;
+    }
+    function mouseMoveDocumentHandler(e) {
+      if (!instance.value || !thumb.value)
+        return;
+      if (cursorDown === false)
+        return;
+      const prevPage = thumbState.value[bar.value.axis];
+      if (!prevPage)
+        return;
+      const offset = (instance.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
+      const thumbClickPosition = thumb.value[bar.value.offset] - prevPage;
+      const thumbPositionPercentage = (offset - thumbClickPosition) * 100 * offsetRatio.value / instance.value[bar.value.offset];
+      if (bar.value.scroll === "scrollLeft") {
+        scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * baseScrollWidth / 100;
+      } else {
+        scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * baseScrollHeight / 100;
+      }
+    }
+    function mouseUpDocumentHandler() {
+      cursorDown = false;
+      thumbState.value[bar.value.axis] = 0;
+      document.removeEventListener("mousemove", mouseMoveDocumentHandler);
+      document.removeEventListener("mouseup", mouseUpDocumentHandler);
+      restoreOnselectstart();
+      if (cursorLeave)
+        visible.value = false;
+    }
+    function mouseMoveScrollbarHandler() {
+      cursorLeave = false;
+      visible.value = !!props.size;
+    }
+    function mouseLeaveScrollbarHandler() {
+      cursorLeave = true;
+      visible.value = cursorDown;
+    }
+    onBeforeUnmount(() => {
+      restoreOnselectstart();
+      document.removeEventListener("mouseup", mouseUpDocumentHandler);
+    });
+    function restoreOnselectstart() {
+      if (document.onselectstart !== originalOnSelectStart)
+        document.onselectstart = originalOnSelectStart;
+    }
+    useEventListener(
+      toRef(scrollbar, "scrollbarElement"),
+      "mousemove",
+      mouseMoveScrollbarHandler
+    );
+    useEventListener(
+      toRef(scrollbar, "scrollbarElement"),
+      "mouseleave",
+      mouseLeaveScrollbarHandler
+    );
+    const __returned__ = { props, scrollbar, ns, instance, thumb, thumbState, visible, get cursorDown() {
+      return cursorDown;
+    }, set cursorDown(v) {
+      cursorDown = v;
+    }, get cursorLeave() {
+      return cursorLeave;
+    }, set cursorLeave(v) {
+      cursorLeave = v;
+    }, get baseScrollHeight() {
+      return baseScrollHeight;
+    }, set baseScrollHeight(v) {
+      baseScrollHeight = v;
+    }, get baseScrollWidth() {
+      return baseScrollWidth;
+    }, set baseScrollWidth(v) {
+      baseScrollWidth = v;
+    }, get originalOnSelectStart() {
+      return originalOnSelectStart;
+    }, set originalOnSelectStart(v) {
+      originalOnSelectStart = v;
+    }, bar, thumbStyle, offsetRatio, clickThumbHandler, clickTrackHandler, startDrag, mouseMoveDocumentHandler, mouseUpDocumentHandler, mouseMoveScrollbarHandler, mouseLeaveScrollbarHandler, restoreOnselectstart };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createBlock(Transition, {
+    name: $setup.ns.b("fade"),
+    persisted: ""
+  }, {
+    default: withCtx(() => [
+      withDirectives(createElementVNode(
+        "div",
+        {
+          ref: "instance",
+          class: normalizeClass([$setup.ns.e("bar"), $setup.ns.is($setup.bar.key)]),
+          onMousedown: $setup.clickTrackHandler,
+          onClick: _cache[0] || (_cache[0] = withModifiers(() => {
+          }, ["stop"]))
+        },
+        [
+          createElementVNode(
+            "div",
+            {
+              ref: "thumb",
+              class: normalizeClass($setup.ns.e("thumb")),
+              style: normalizeStyle($setup.thumbStyle),
+              onMousedown: $setup.clickThumbHandler
+            },
+            null,
+            38
+            /* CLASS, STYLE, NEED_HYDRATION */
+          )
+        ],
+        34
+        /* CLASS, NEED_HYDRATION */
+      ), [
+        [vShow, _ctx.always || $setup.visible]
+      ])
+    ]),
+    _: 1
+    /* STABLE */
+  }, 8, ["name"]);
+}
+var Thumb = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/scrollbar/src/thumb.vue"]]);
+
+var _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "bar",
+  props: barProps,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const scrollbar = inject(scrollbarContextKey);
+    const moveX = ref(0);
+    const moveY = ref(0);
+    const sizeWidth = ref("");
+    const sizeHeight = ref("");
+    const ratioY = ref(1);
+    const ratioX = ref(1);
+    function handleScroll(wrap) {
+      if (wrap) {
+        const offsetHeight = wrap.offsetHeight - GAP;
+        const offsetWidth = wrap.offsetWidth - GAP;
+        moveY.value = wrap.scrollTop * 100 / offsetHeight * ratioY.value;
+        moveX.value = wrap.scrollLeft * 100 / offsetWidth * ratioX.value;
+      }
+    }
+    function update() {
+      const wrap = scrollbar?.wrapElement;
+      if (!wrap)
+        return;
+      const offsetHeight = wrap.offsetHeight - GAP;
+      const offsetWidth = wrap.offsetWidth - GAP;
+      const originalHeight = offsetHeight ** 2 / wrap.scrollHeight;
+      const originalWidth = offsetWidth ** 2 / wrap.scrollWidth;
+      const height = Math.max(originalHeight, props.minSize);
+      const width = Math.max(originalWidth, props.minSize);
+      ratioY.value = originalHeight / (offsetHeight - originalHeight) / (height / (offsetHeight - height));
+      ratioX.value = originalWidth / (offsetWidth - originalWidth) / (width / (offsetWidth - width));
+      sizeHeight.value = height + GAP < offsetHeight ? `${height}px` : "";
+      sizeWidth.value = width + GAP < offsetWidth ? `${width}px` : "";
+    }
+    __expose({
+      handleScroll,
+      update
+    });
+    const __returned__ = { props, scrollbar, moveX, moveY, sizeWidth, sizeHeight, ratioY, ratioX, handleScroll, update, Thumb };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock(
+    Fragment,
+    null,
+    [
+      createVNode($setup["Thumb"], {
+        move: $setup.moveX,
+        ratio: $setup.ratioX,
+        size: $setup.sizeWidth,
+        always: _ctx.always
+      }, null, 8, ["move", "ratio", "size", "always"]),
+      createVNode($setup["Thumb"], {
+        move: $setup.moveY,
+        ratio: $setup.ratioY,
+        size: $setup.sizeHeight,
+        vertical: "",
+        always: _ctx.always
+      }, null, 8, ["move", "ratio", "size", "always"])
+    ],
+    64
+    /* STABLE_FRAGMENT */
+  );
+}
+var Bar = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/scrollbar/src/bar.vue"]]);
+
+/**
+* @vue/shared v3.5.13
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+
+
+
+!!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+!!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+const isString = (val) => typeof val === "string";
+
+const isNumber = (val) => typeof val === "number";
+function isStringNumber(val) {
+  if (!isString(val)) {
+    return false;
+  }
+  return !Number.isNaN(Number(val));
+}
+function addUnit(value, defaultUnit = "px") {
+  if (!value)
+    return "";
+  if (isNumber(value) || isStringNumber(value)) {
+    return `${value}${defaultUnit}`;
+  } else if (isString(value)) {
+    return value;
+  }
+  console.warn(SCOPE, "binding value must be a string or number");
+}
+
+const COMPONENT_NAME = "ElScrollbar";
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: {
+    ...scrollbarProps,
+    appendTo: null
+  },
+  emits: scrollbarEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const ns = useNamespace("scrollbar");
+    let stopResizeObserver;
+    let stopWrapResizeObserver;
+    let stopResizeListener;
+    let wrapScrollTop = 0;
+    let wrapScrollLeft = 0;
+    let direction = "";
+    const distanceScrollState = {
+      bottom: false,
+      top: false,
+      right: false,
+      left: false
+    };
+    const scrollbarRef = ref();
+    const wrapRef = ref();
+    const resizeRef = ref();
+    const barRef = ref();
+    const wrapStyle = computed(() => {
+      const style = {};
+      if (props.height)
+        style.height = addUnit(props.height);
+      if (props.maxHeight)
+        style.maxHeight = addUnit(props.maxHeight);
+      return [props.wrapStyle, style];
+    });
+    const wrapKls = computed(() => {
+      return [
+        props.wrapClass,
+        ns.e("wrap"),
+        { [ns.em("wrap", "hidden-default")]: !props.native }
+      ];
+    });
+    const resizeKls = computed(() => {
+      return [ns.e("view"), props.viewClass];
+    });
+    function shouldSkipDirection(direction2) {
+      return distanceScrollState[direction2] ?? false;
+    }
+    const DIRECTION_PAIRS = {
+      top: "bottom",
+      bottom: "top",
+      left: "right",
+      right: "left"
+    };
+    function updateTriggerStatus(arrivedStates) {
+      const oppositeDirection = DIRECTION_PAIRS[direction];
+      if (!oppositeDirection)
+        return;
+      const arrived = arrivedStates[direction];
+      const oppositeArrived = arrivedStates[oppositeDirection];
+      if (arrived && !distanceScrollState[direction]) {
+        distanceScrollState[direction] = true;
+      }
+      if (!oppositeArrived && distanceScrollState[oppositeDirection]) {
+        distanceScrollState[oppositeDirection] = false;
+      }
+    }
+    function handleScroll() {
+      if (wrapRef.value) {
+        barRef.value?.handleScroll(wrapRef.value);
+        const prevTop = wrapScrollTop;
+        const prevLeft = wrapScrollLeft;
+        wrapScrollTop = wrapRef.value.scrollTop;
+        wrapScrollLeft = wrapRef.value.scrollLeft;
+        const arrivedStates = {
+          bottom: wrapScrollTop + wrapRef.value.clientHeight >= wrapRef.value.scrollHeight - props.distance,
+          top: wrapScrollTop <= props.distance && prevTop !== 0,
+          right: wrapScrollLeft + wrapRef.value.clientWidth >= wrapRef.value.scrollWidth - props.distance && prevLeft !== wrapScrollLeft,
+          left: wrapScrollLeft <= props.distance && prevLeft !== 0
+        };
+        emit("scroll", {
+          scrollTop: wrapScrollTop,
+          scrollLeft: wrapScrollLeft
+        });
+        if (prevTop !== wrapScrollTop) {
+          direction = wrapScrollTop > prevTop ? "bottom" : "top";
+        }
+        if (prevLeft !== wrapScrollLeft) {
+          direction = wrapScrollLeft > prevLeft ? "right" : "left";
+        }
+        if (props.distance > 0) {
+          if (shouldSkipDirection(direction)) {
+            return;
+          }
+          updateTriggerStatus(arrivedStates);
+        }
+        if (arrivedStates[direction])
+          emit("end-reached", direction);
+      }
+    }
+    function scrollTo(arg1, arg2) {
+      if (isObject(arg1)) {
+        wrapRef.value.scrollTo(arg1);
+      } else if (isNumber(arg1) && isNumber(arg2)) {
+        wrapRef.value.scrollTo(arg1, arg2);
+      }
+    }
+    function setScrollTop(value) {
+      if (!isNumber(value)) {
+        console.warn(COMPONENT_NAME, "value must be a number");
+        return;
+      }
+      wrapRef.value.scrollTop = value;
+    }
+    function setScrollLeft(value) {
+      if (!isNumber(value)) {
+        console.warn(COMPONENT_NAME, "value must be a number");
+        return;
+      }
+      wrapRef.value.scrollLeft = value;
+    }
+    function update() {
+      barRef.value?.update();
+      distanceScrollState[direction] = false;
+    }
+    watch(
+      () => props.noresize,
+      (noresize) => {
+        if (noresize) {
+          stopResizeObserver?.();
+          stopWrapResizeObserver?.();
+          stopResizeListener?.();
+        } else {
+          ({ stop: stopResizeObserver } = useResizeObserver(resizeRef, update));
+          ({ stop: stopWrapResizeObserver } = useResizeObserver(wrapRef, update));
+          stopResizeListener = useEventListener("resize", update);
+        }
+      },
+      { immediate: true }
+    );
+    watch(
+      () => [props.maxHeight, props.height],
+      () => {
+        if (!props.native) {
+          nextTick(() => {
+            update();
+            if (wrapRef.value) {
+              barRef.value?.handleScroll(wrapRef.value);
+            }
+          });
+        }
+      }
+    );
+    provide(
+      scrollbarContextKey,
+      reactive({
+        scrollbarElement: scrollbarRef,
+        wrapElement: wrapRef
+      })
+    );
+    onActivated(() => {
+      if (wrapRef.value) {
+        wrapRef.value.scrollTop = wrapScrollTop;
+        wrapRef.value.scrollLeft = wrapScrollLeft;
+      }
+    });
+    onMounted(() => {
+      if (!props.native) {
+        nextTick(() => {
+          update();
+        });
+      }
+    });
+    onUpdated(() => update());
+    __expose({
+      /** @description scrollbar wrap ref */
+      wrapRef,
+      /** @description update scrollbar state manually */
+      update,
+      /** @description scrolls to a particular set of coordinates */
+      scrollTo,
+      /** @description set distance to scroll top */
+      setScrollTop,
+      /** @description set distance to scroll left */
+      setScrollLeft,
+      /** @description handle scroll event */
+      handleScroll
+    });
+    const __returned__ = { props, emit, COMPONENT_NAME, ns, get stopResizeObserver() {
+      return stopResizeObserver;
+    }, set stopResizeObserver(v) {
+      stopResizeObserver = v;
+    }, get stopWrapResizeObserver() {
+      return stopWrapResizeObserver;
+    }, set stopWrapResizeObserver(v) {
+      stopWrapResizeObserver = v;
+    }, get stopResizeListener() {
+      return stopResizeListener;
+    }, set stopResizeListener(v) {
+      stopResizeListener = v;
+    }, get wrapScrollTop() {
+      return wrapScrollTop;
+    }, set wrapScrollTop(v) {
+      wrapScrollTop = v;
+    }, get wrapScrollLeft() {
+      return wrapScrollLeft;
+    }, set wrapScrollLeft(v) {
+      wrapScrollLeft = v;
+    }, get direction() {
+      return direction;
+    }, set direction(v) {
+      direction = v;
+    }, distanceScrollState, scrollbarRef, wrapRef, resizeRef, barRef, wrapStyle, wrapKls, resizeKls, shouldSkipDirection, DIRECTION_PAIRS, updateTriggerStatus, handleScroll, scrollTo, setScrollTop, setScrollLeft, update, get VkAsyncTeleport() {
+      return VkAsyncTeleport;
+    }, Bar };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+const _hoisted_1 = ["tabindex"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock(
+    "div",
+    {
+      ref: "scrollbarRef",
+      class: normalizeClass($setup.ns.b())
+    },
+    [
+      createElementVNode("div", {
+        ref: "wrapRef",
+        class: normalizeClass($setup.wrapKls),
+        style: normalizeStyle($setup.wrapStyle),
+        tabindex: _ctx.tabindex,
+        onScroll: $setup.handleScroll
+      }, [
+        (openBlock(), createBlock(resolveDynamicComponent(_ctx.tag), {
+          id: _ctx.id,
+          ref: "resizeRef",
+          class: normalizeClass($setup.resizeKls),
+          style: normalizeStyle(_ctx.viewStyle),
+          role: _ctx.role,
+          "aria-label": _ctx.ariaLabel,
+          "aria-orientation": _ctx.ariaOrientation
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "default")
+          ]),
+          _: 3
+          /* FORWARDED */
+        }, 8, ["id", "class", "style", "role", "aria-label", "aria-orientation"]))
+      ], 46, _hoisted_1),
+      !_ctx.native ? (openBlock(), createBlock($setup["VkAsyncTeleport"], {
+        key: 0,
+        disabled: !$props.appendTo,
+        to: $props.appendTo
+      }, {
+        default: withCtx(() => [
+          createVNode($setup["Bar"], {
+            ref: "barRef",
+            always: _ctx.always,
+            "min-size": _ctx.minSize
+          }, null, 8, ["always", "min-size"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["disabled", "to"])) : createCommentVNode("v-if", true)
+    ],
+    2
+    /* CLASS */
+  );
+}
+var VkScrollbar = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/scrollbar/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkScrollbar.install = (app) => {
+  app.component(VkScrollbar.name || "VkScrollbar", VkScrollbar);
+};
+
+export { VkScrollbar, types as __VkScrollbar, VkScrollbar as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vunk/plus",
-  "version": "1.7.4",
+  "version": "1.8.0",
   "description": "",
   "author": "",
   "license": "ISC",
@@ -103,6 +103,10 @@
       "import": "./components/sender/index.mjs",
       "types": "./components/sender/index.d.ts"
     },
+    "./components/scrollbar": {
+      "import": "./components/scrollbar/index.mjs",
+      "types": "./components/scrollbar/index.d.ts"
+    },
     "./components/routes-menu-content": {
       "import": "./components/routes-menu-content/index.mjs",
       "types": "./components/routes-menu-content/index.d.ts"

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

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

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

@@ -1,29 +0,0 @@
-export interface MessageView {
-    content: string;
-    type: string;
-    updating: boolean;
-}
-export declare class MessageViewManager {
-    private views;
-    getViews(): MessageView[];
-    createView(view: MessageView): void;
-    /**
-     * @description 创建或更新最后一个 view
-     */
-    upsertView(data: MessageView, callbacks?: {
-        onCreate?: (view: MessageView) => void;
-        onUpdate?: (view: MessageView) => void;
-    }): MessageView;
-    /**
-     * @description 获取当前view 的上一个 view
-     */
-    getPrevView(view: MessageView): MessageView | undefined;
-    /**
-     * @description 获取最后一个正在更新的 view
-     */
-    getLastUpdatingView(type: string): MessageView | undefined;
-    /**
-     * @description 所有 view 更新结束
-     */
-    allViewUpdated(): void;
-}

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

@@ -1,3 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,22 +0,0 @@
-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;