@vunk/plus 0.0.0-alpha.2

package/api/index.mjs

@@ -0,0 +1 @@
+

package/api/user/index.d.ts

@@ -0,0 +1,3 @@
+import { User } from './types';
+export type * from './types';
+export declare const rUsers: () => Promise<User[]>;

package/api/user/index.mjs

@@ -0,0 +1,18 @@
+const rUsers = () => {
+  return new Promise((resolve) => {
+    resolve([
+      {
+        id: "1",
+        name: "John Doe",
+        email: "xxxxxx"
+      },
+      {
+        id: "2",
+        name: "Jane Doe",
+        email: "xxxxxx"
+      }
+    ]);
+  });
+};
+
+export { rUsers };

package/api/user/types.d.ts

@@ -0,0 +1,5 @@
+export interface User {
+    id: string;
+    name: string;
+    email: string;
+}

package/components/_plugin-vue_export-helper.mjs

@@ -0,0 +1,9 @@
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+export { _export_sfc as _ };

package/components/lottie-animation/index.css

@@ -0,0 +1,4 @@
+.vk-lottie-animation {
+  width: 100%;
+  height: 100%;
+}

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

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

package/components/lottie-animation/index.mjs

@@ -0,0 +1,72 @@
+import { defineComponent, ref, onMounted, openBlock, createElementBlock, Fragment, createElementVNode, renderSlot } from 'vue';
+import lottie from 'lottie-web';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const props = {
+  path: {
+    type: String,
+    default: ""
+  }
+};
+const emits = {
+  load: (e) => e
+};
+
+var _sfc_main = defineComponent({
+  name: "VkLottieAnimation",
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const lottieNode = ref();
+    onMounted(() => {
+      const animation = lottie.loadAnimation({
+        container: lottieNode.value,
+        renderer: "svg",
+        loop: false,
+        autoplay: false,
+        path: props2.path
+      });
+      animation.addEventListener("complete", () => {
+        emit("load", { animation });
+      });
+      animation.goToAndPlay(50 * animation.totalFrames / 100);
+    });
+    return {
+      lottieNode
+    };
+  }
+});
+
+const _hoisted_1 = {
+  ref: "lottieNode",
+  class: "vk-lottie-animation"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock(
+    Fragment,
+    null,
+    [
+      createElementVNode(
+        "div",
+        _hoisted_1,
+        null,
+        512
+        /* NEED_PATCH */
+      ),
+      renderSlot(_ctx.$slots, "default")
+    ],
+    64
+    /* STABLE_FRAGMENT */
+  );
+}
+var VkLottieAnimation = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "D:\\labCode\\vunk-plus\\packages\\components\\lottie-animation\\src\\index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkLottieAnimation.install = (app) => {
+  app.component(VkLottieAnimation.name || "VkLottieAnimation", VkLottieAnimation);
+};
+
+export { VkLottieAnimation, types as __VkLottieAnimation, VkLottieAnimation as default };

package/components/lottie-animation/src/ctx.d.ts

@@ -0,0 +1,10 @@
+import { LoadEvent } from './types';
+export declare const props: {
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export declare const emits: {
+    load: (e: LoadEvent) => LoadEvent;
+};

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

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    lottieNode: Ref<HTMLDivElement>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: (e: import("./types").LoadEvent) => import("./types").LoadEvent;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onLoad?: (e: import("./types").LoadEvent) => any;
+}, {
+    path: string;
+}, {}>;
+export default _default;

package/components/lottie-animation/src/types.d.ts

@@ -0,0 +1,4 @@
+import { AnimationItem } from 'lottie-web';
+export interface LoadEvent {
+    animation: AnimationItem;
+}

package/components/monaco-editor/index.css

@@ -0,0 +1,4 @@
+.vk-monaco-editor {
+  width: 100%;
+  height: 100%;
+}

package/components/monaco-editor/index.d.ts

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

package/components/monaco-editor/index.mjs

@@ -0,0 +1,83 @@
+import { defineComponent, ref, onMounted, nextTick, watchEffect, openBlock, createElementBlock } from 'vue';
+import { editor } from 'monaco-editor';
+import { watchPausable } from '@vueuse/core';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const props = {
+  modelValue: {
+    type: String,
+    default: ""
+  },
+  defaultOptions: {
+    type: Object,
+    default: () => ({})
+  },
+  readOnly: {
+    type: Boolean,
+    default: false
+  }
+};
+const emits = {
+  "update:modelValue": null
+};
+
+var _sfc_main = defineComponent({
+  name: "VkMonacoEditor",
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const editorNode = ref();
+    onMounted(() => {
+      const editor$1 = editor.create(editorNode.value, props2.defaultOptions);
+      const subjectModelValueWatcher = watchPausable(
+        () => props2.modelValue,
+        (v) => {
+          editor$1.setValue(v);
+        },
+        {
+          immediate: true
+        }
+      );
+      editor$1.onDidChangeModelContent(() => {
+        subjectModelValueWatcher.pause();
+        emit("update:modelValue", editor$1.getValue());
+        nextTick(() => {
+          subjectModelValueWatcher.resume();
+        });
+      });
+      watchEffect(() => {
+        editor$1.updateOptions({
+          readOnly: props2.readOnly
+        });
+      });
+    });
+    return {
+      editorNode
+    };
+  }
+});
+
+const _hoisted_1 = {
+  ref: "editorNode",
+  class: "vk-monaco-editor"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock(
+    "div",
+    _hoisted_1,
+    null,
+    512
+    /* NEED_PATCH */
+  );
+}
+var VkMonacoEditor = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "D:\\labCode\\vunk-plus\\packages\\components\\monaco-editor\\src\\index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkMonacoEditor.install = (app) => {
+  app.component(VkMonacoEditor.name || "VkMonacoEditor", VkMonacoEditor);
+};
+
+export { VkMonacoEditor, types as __VkMonacoEditor, VkMonacoEditor as default };

package/components/monaco-editor/src/ctx.d.ts

@@ -0,0 +1,19 @@
+import { PropType } from 'vue';
+import { editor } from 'monaco-editor';
+export declare const props: {
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: PropType<editor.IStandaloneEditorConstructionOptions>;
+        default: () => {};
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare const emits: {
+    'update:modelValue': any;
+};

package/components/monaco-editor/src/index.vue.d.ts

@@ -0,0 +1,40 @@
+import { Ref } from 'vue';
+import { editor as mEditor } from 'monaco-editor';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: import("vue").PropType<mEditor.IStandaloneEditorConstructionOptions>;
+        default: () => {};
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    editorNode: Ref<HTMLDivElement>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: import("vue").PropType<mEditor.IStandaloneEditorConstructionOptions>;
+        default: () => {};
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
+}, {
+    modelValue: string;
+    defaultOptions: {};
+    readOnly: boolean;
+}, {}>;
+export default _default;

package/components/monaco-editor/src/types.d.ts

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

package/components/monaco-environment/index.d.ts

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

package/components/monaco-environment/index.mjs

@@ -0,0 +1,46 @@
+import { defineComponent, renderSlot } from 'vue';
+import jsonWorker from 'monaco-editor/esm/vs/language/json/json.worker?worker';
+import cssWorker from 'monaco-editor/esm/vs/language/css/css.worker?worker';
+import htmlWorker from 'monaco-editor/esm/vs/language/html/html.worker?worker';
+import tsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker';
+import EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+var _sfc_main = defineComponent({
+  name: "VkMonacoEnvironment",
+  setup() {
+    self.MonacoEnvironment = {
+      getWorker(_, label) {
+        if (label === "json") {
+          return new jsonWorker();
+        }
+        if (label === "css" || label === "scss" || label === "less") {
+          return new cssWorker();
+        }
+        if (label === "html" || label === "handlebars" || label === "razor") {
+          return new htmlWorker();
+        }
+        if (["typescript", "javascript"].includes(label)) {
+          return new tsWorker();
+        }
+        return new EditorWorker();
+      }
+    };
+    return {};
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return renderSlot(_ctx.$slots, "default");
+}
+var VkMonacoEnvironment = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "D:\\labCode\\vunk-plus\\packages\\components\\monaco-environment\\src\\index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkMonacoEnvironment.install = (app) => {
+  app.component(VkMonacoEnvironment.name || "VkMonacoEnvironment", VkMonacoEnvironment);
+};
+
+export { VkMonacoEnvironment, types as __VkMonacoEnvironment, VkMonacoEnvironment as default };

package/components/monaco-environment/src/ctx.d.ts

@@ -0,0 +1,8 @@
+import { PropType } from 'vue';
+export declare const props: {
+    modelValue: {
+        type: PropType<unknown>;
+        default: () => {};
+    };
+};
+export declare const emits: {};

package/components/monaco-environment/src/index.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/components/monaco-environment/src/types.d.ts

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

package/components/typing-markdown/index.css

@@ -0,0 +1,12 @@
+.vk-typing-markdown.is-typing .is-last::after{
+  animation: blink 0.7s infinite;
+  content: '|';
+}
+@keyframes blink {
+0%, 100% {
+    opacity: 1;
+}
+50% {
+    opacity: 0;
+}
+}

package/components/typing-markdown/index.d.ts

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

package/components/typing-markdown/index.mjs

@@ -0,0 +1,135 @@
+import { defineComponent, ref, computed, watch, openBlock, createElementBlock, normalizeClass } from 'vue';
+import { noop, computedAsync, debouncedRef } from '@vueuse/core';
+import MarkdownIt from 'markdown-it';
+import { highlight } from '@vunk/shared/markdown/shiki';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const props = {
+  source: {
+    type: String,
+    default: ""
+  },
+  delay: {
+    type: Number,
+    default: 60
+  },
+  // 暂停
+  pause: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * 禁用typing
+   */
+  disabled: {
+    type: Boolean,
+    default: false
+  }
+};
+const emits = {
+  typing: null
+};
+
+const createMarkdownIt = async () => {
+  const md = new MarkdownIt({
+    highlight: await highlight({
+      dark: "github-dark",
+      light: "github-light"
+    }, {}, {
+      warn: noop
+    })
+  });
+  md.core.ruler.after("inline", "add-is-last-class", (state) => {
+    const tokens = state.tokens;
+    let lastTagIndex = -1;
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      const token = tokens[i];
+      if (token.nesting === 1 && !token.hidden) {
+        lastTagIndex = i;
+        break;
+      }
+    }
+    if (lastTagIndex !== -1) {
+      tokens[lastTagIndex].attrSet("class", "is-last");
+    }
+  });
+  return md;
+};
+
+var _sfc_main = defineComponent({
+  name: "VkTypingMarkdown",
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const currentIndex = ref(0);
+    const currentText = computed(() => {
+      if (props2.disabled) {
+        return props2.source;
+      }
+      return props2.source.substring(0, currentIndex.value);
+    });
+    const markdownItPromise = createMarkdownIt();
+    const htmlText = computedAsync(async () => {
+      currentText.value;
+      const md = await markdownItPromise;
+      return md.render(currentText.value);
+    }, "");
+    const isTyping = computed(() => {
+      return !props2.pause && !props2.disabled && currentIndex.value !== props2.source.length;
+    });
+    const isDebouncedTyping = debouncedRef(isTyping, 100);
+    const isFinished = ref(false);
+    function typeWriter() {
+      if (props2.pause || props2.disabled) {
+        return;
+      }
+      if (currentIndex.value < props2.source.length) {
+        currentIndex.value++;
+        emit("typing");
+        setTimeout(typeWriter, props2.delay);
+      } else {
+        isFinished.value = true;
+      }
+    }
+    watch(() => props2.pause || props2.disabled, (v) => {
+      if (!v) {
+        typeWriter();
+      }
+    }, {
+      flush: "post",
+      immediate: true
+    });
+    watch(
+      () => isFinished.value && currentIndex.value < props2.source.length,
+      () => {
+        isFinished.value = false;
+        typeWriter();
+      }
+    );
+    return {
+      htmlText,
+      isDebouncedTyping
+    };
+  }
+});
+
+const _hoisted_1 = ["innerHTML"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(["vk-typing-markdown", {
+      "is-typing": _ctx.isDebouncedTyping
+    }]),
+    innerHTML: _ctx.htmlText
+  }, null, 10, _hoisted_1);
+}
+var VkTypingMarkdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "D:\\labCode\\vunk-plus\\packages\\components\\typing-markdown\\src\\index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkTypingMarkdown.install = (app) => {
+  app.component(VkTypingMarkdown.name || "VkTypingMarkdown", VkTypingMarkdown);
+};
+
+export { VkTypingMarkdown, types as __VkTypingMarkdown, VkTypingMarkdown as default };

package/components/typing-markdown/src/core.d.ts

@@ -0,0 +1,2 @@
+import MarkdownIt from 'markdown-it';
+export declare const createMarkdownIt: () => Promise<MarkdownIt>;

package/components/typing-markdown/src/ctx.d.ts

@@ -0,0 +1,24 @@
+export declare const props: {
+    source: {
+        type: StringConstructor;
+        default: string;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    pause: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * 禁用typing
+     */
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare const emits: {
+    typing: any;
+};

package/components/typing-markdown/src/index.vue.d.ts

@@ -0,0 +1,48 @@
+declare const _default: import("vue").DefineComponent<{
+    source: {
+        type: StringConstructor;
+        default: string;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    pause: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    htmlText: import("vue").Ref<string>;
+    isDebouncedTyping: Readonly<import("vue").Ref<boolean>>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    typing: any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        default: string;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    pause: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onTyping?: (...args: any[] | unknown[]) => any;
+}, {
+    source: string;
+    delay: number;
+    pause: boolean;
+    disabled: boolean;
+}, {}>;
+export default _default;

package/components/typing-markdown/src/types.d.ts

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

package/composables/index.mjs

@@ -0,0 +1 @@
+

package/index.css

@@ -0,0 +1,22 @@
+.vk-lottie-animation {
+  width: 100%;
+  height: 100%;
+}
+
+.vk-monaco-editor {
+  width: 100%;
+  height: 100%;
+}
+
+.vk-typing-markdown.is-typing .is-last::after{
+  animation: blink 0.7s infinite;
+  content: '|';
+}
+@keyframes blink {
+0%, 100% {
+    opacity: 1;
+}
+50% {
+    opacity: 0;
+}
+}

package/index.esm.js

@@ -0,0 +1 @@
+export * from '@vunk/plus/shared';

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@vunk/plus",
+  "version": "0.0.0-alpha.2",
+  "description": "",
+  "main": "index.esm.js",
+  "scripts": {
+    "build": "gulp -f gulpfile.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "module": "index.esm.js",
+  "exports": {
+    ".": {
+      "import": "./index.esm.js",
+      "types": "./index.d.ts"
+    },
+    "./theme": {
+      "import": "./theme/index.mjs",
+      "types": "./theme/index.d.ts"
+    },
+    "./stores": {
+      "import": "./stores/index.mjs",
+      "types": "./stores/index.d.ts"
+    },
+    "./shared": {
+      "import": "./shared/index.mjs",
+      "types": "./shared/index.d.ts"
+    },
+    "./shared/fetch/ssr": {
+      "import": "./shared/fetch/ssr/index.mjs",
+      "types": "./shared/fetch/ssr/index.d.ts"
+    },
+    "./shared/fetch/base": {
+      "import": "./shared/fetch/base/index.mjs",
+      "types": "./shared/fetch/base/index.d.ts"
+    },
+    "./shared/chatgpt": {
+      "import": "./shared/chatgpt/index.mjs",
+      "types": "./shared/chatgpt/index.d.ts"
+    },
+    "./shared/chatgpt/response": {
+      "import": "./shared/chatgpt/response/index.mjs",
+      "types": "./shared/chatgpt/response/index.d.ts"
+    },
+    "./shared/chatgpt/response/sse": {
+      "import": "./shared/chatgpt/response/sse/index.mjs",
+      "types": "./shared/chatgpt/response/sse/index.d.ts"
+    },
+    "./shared/chatgpt/response/sse/message": {
+      "import": "./shared/chatgpt/response/sse/message/index.mjs",
+      "types": "./shared/chatgpt/response/sse/message/index.d.ts"
+    },
+    "./composables": {
+      "import": "./composables/index.mjs",
+      "types": "./composables/index.d.ts"
+    },
+    "./components/typing-markdown": {
+      "import": "./components/typing-markdown/index.mjs",
+      "types": "./components/typing-markdown/index.d.ts"
+    },
+    "./components/monaco-environment": {
+      "import": "./components/monaco-environment/index.mjs",
+      "types": "./components/monaco-environment/index.d.ts"
+    },
+    "./components/monaco-editor": {
+      "import": "./components/monaco-editor/index.mjs",
+      "types": "./components/monaco-editor/index.d.ts"
+    },
+    "./components/lottie-animation": {
+      "import": "./components/lottie-animation/index.mjs",
+      "types": "./components/lottie-animation/index.d.ts"
+    },
+    "./api": {
+      "import": "./api/index.mjs",
+      "types": "./api/index.d.ts"
+    },
+    "./api/user": {
+      "import": "./api/user/index.mjs",
+      "types": "./api/user/index.d.ts"
+    },
+    "./index.css": {
+      "import": "./index.css"
+    },
+    "./components/typing-markdown/index.css": {
+      "import": "./components/typing-markdown/index.css"
+    },
+    "./components/monaco-editor/index.css": {
+      "import": "./components/monaco-editor/index.css"
+    },
+    "./components/lottie-animation/index.css": {
+      "import": "./components/lottie-animation/index.css"
+    }
+  }
+}

package/shared/chatgpt/index.d.ts

@@ -0,0 +1 @@
+export * from './response';

package/shared/chatgpt/index.mjs

@@ -0,0 +1,3 @@
+export { SpecialResponse, isChatgptSSEResponse, isDoneResponse } from './response/index.mjs';
+export { isContentMessage, isConversationDetailMetadataMessage } from './response/sse/message/index.mjs';
+import '@vunk/shared/object';

package/shared/chatgpt/response/enum.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 特殊的回复类型
+ */
+export declare enum SpecialResponse {
+    done = "[DONE]"
+}

package/shared/chatgpt/response/index.d.ts

@@ -0,0 +1,6 @@
+import { ChatgptSSEResponse } from './sse';
+import { SpecialResponse } from './enum';
+export * from './sse';
+export * from './enum';
+export declare const isChatgptSSEResponse: (data: any) => data is ChatgptSSEResponse;
+export declare const isDoneResponse: (data: any) => data is SpecialResponse;

package/shared/chatgpt/response/index.mjs

@@ -0,0 +1,16 @@
+import { isPlainObject } from '@vunk/shared/object';
+export { isContentMessage, isConversationDetailMetadataMessage } from './sse/message/index.mjs';
+
+var SpecialResponse = /* @__PURE__ */ ((SpecialResponse2) => {
+  SpecialResponse2["done"] = "[DONE]";
+  return SpecialResponse2;
+})(SpecialResponse || {});
+
+const isChatgptSSEResponse = (data) => {
+  return isPlainObject(data) && !!data.conversation_id;
+};
+const isDoneResponse = (data) => {
+  return data === SpecialResponse.done;
+};
+
+export { SpecialResponse, isChatgptSSEResponse, isDoneResponse };

package/shared/chatgpt/response/sse/index.d.ts

@@ -0,0 +1,2 @@
+export * from './message';
+export * from './types';

package/shared/chatgpt/response/sse/index.mjs

@@ -0,0 +1 @@
+export { isContentMessage, isConversationDetailMetadataMessage } from './message/index.mjs';

package/shared/chatgpt/response/sse/message/index.d.ts

@@ -0,0 +1,4 @@
+import { ChatgptContentMessage, ChatgptConversationDetailMetadataMessage } from './types';
+export * from './types';
+export declare const isContentMessage: (message: any) => message is ChatgptContentMessage;
+export declare const isConversationDetailMetadataMessage: (message: any) => message is ChatgptConversationDetailMetadataMessage;

package/shared/chatgpt/response/sse/message/index.mjs

@@ -0,0 +1,8 @@
+const isContentMessage = (message) => {
+  return message?.id && message?.content;
+};
+const isConversationDetailMetadataMessage = (message) => {
+  return message?.type === "conversation_detail_metadata";
+};
+
+export { isContentMessage, isConversationDetailMetadataMessage };

package/shared/chatgpt/response/sse/message/types.d.ts

@@ -0,0 +1,15 @@
+export interface ChatgptConversationDetailMetadataMessage {
+    type: 'conversation_detail_metadata';
+    blocked_features: string[];
+    model_limits: string[];
+    default_model_slug: string;
+    conversation_id: string;
+}
+export interface ChatgptContentMessage {
+    id: string;
+    content: ChatgptContent;
+}
+export interface ChatgptContent {
+    content_type: 'text';
+    parts: string[];
+}

package/shared/chatgpt/response/sse/types.d.ts

@@ -0,0 +1,6 @@
+import { ChatgptContentMessage, ChatgptConversationDetailMetadataMessage } from './message/types';
+export interface ChatgptSSEResponse {
+    message: ChatgptContentMessage | ChatgptConversationDetailMetadataMessage;
+    conversation_id: string;
+    error?: string;
+}

package/shared/fetch/base/index.d.ts

@@ -0,0 +1,9 @@
+import { RestFetch } from '@vunk/skzz/shared/utils-fetch';
+export declare const restFetch: RestFetch;
+interface R<T> {
+    data: T;
+    code: number;
+    msg: string;
+}
+export declare const request: <T>(options: import("@vunk/skzz/shared").BaseFetchRequestOptions, initOptions?: import("@vunk/skzz/shared").RequestInitOptions, init?: RequestInit) => Promise<R<T>>;
+export {};

package/shared/fetch/base/index.mjs

@@ -0,0 +1,17 @@
+import { RestFetch } from '@vunk/skzz/shared/utils-fetch';
+
+const restFetch = new RestFetch({
+  baseURL: "",
+  DEV: true,
+  customOk(res) {
+    return res.code === 0;
+  },
+  onerror() {
+  }
+});
+const request = (...args) => {
+  const p = restFetch.request(...args);
+  return p;
+};
+
+export { request, restFetch };

package/shared/fetch/ssr/index.d.ts

@@ -0,0 +1,3 @@
+import { RestFetch } from '@vunk/core/shared/utils-fetch';
+export declare const restFetch: RestFetch;
+export declare const request: <T>(options: import("@vunk/skzz/shared").BaseFetchRequestOptions, initOptions?: import("@vunk/skzz/shared").RequestInitOptions, init?: RequestInit) => Promise<T>;

package/shared/fetch/ssr/index.mjs

@@ -0,0 +1,11 @@
+import { RestFetch } from '@vunk/core/shared/utils-fetch';
+
+const restFetch = new RestFetch({
+  baseURL: ""
+});
+const request = (...args) => {
+  const p = restFetch.request(...args);
+  return p;
+};
+
+export { request, restFetch };

package/shared/index.mjs

@@ -0,0 +1 @@
+

package/stores/index.mjs

@@ -0,0 +1 @@
+

package/theme/index.mjs

@@ -0,0 +1 @@
+