@vunk/plus 0.0.0-alpha.4 → 0.0.2

package/components/lottie-animation/index.mjs

@@ -22,14 +22,13 @@ var _sfc_main = defineComponent({
       const animation = lottie.loadAnimation({
         container: lottieNode.value,
         renderer: "svg",
-        loop: false,
-        autoplay: false,
+        loop: true,
+        autoplay: true,
         path: props2.path
       });
       animation.addEventListener("complete", () => {
         emit("load", { animation });
       });
-      animation.goToAndPlay(50 * animation.totalFrames / 100);
     });
     return {
       lottieNode
@@ -59,7 +58,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     /* 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 VkLottieAnimation = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/lottie-animation/src/index.vue"]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null

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

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

package/components/monaco-editor/index.mjs

@@ -70,7 +70,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     /* 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 VkMonacoEditor = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/monaco-editor/src/index.vue"]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null

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

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

package/components/monaco-environment/index.mjs

@@ -33,7 +33,7 @@ var _sfc_main = defineComponent({
 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 VkMonacoEnvironment = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/monaco-environment/src/index.vue"]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null

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

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

package/components/typing-markdown/index.mjs

@@ -30,14 +30,16 @@ const emits = {
   typing: null
 };
 
+const highlightPromise = highlight({
+  dark: "github-dark",
+  light: "github-light"
+}, {}, {
+  warn: noop
+});
 const createMarkdownIt = async () => {
+  const highlight2 = await highlightPromise;
   const md = new MarkdownIt({
-    highlight: await highlight({
-      dark: "github-dark",
-      light: "github-light"
-    }, {}, {
-      warn: noop
-    })
+    highlight: highlight2
   });
   md.core.ruler.after("inline", "add-is-last-class", (state) => {
     const tokens = state.tokens;
@@ -122,7 +124,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     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 VkTypingMarkdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/typing-markdown/src/index.vue"]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null

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

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

package/components/vditor/index.css

@@ -0,0 +1,12 @@
+.vkf-vditor ul li {
+  list-style: initial;
+}
+.vkf-vditor ol li {
+  list-style: decimal;
+}
+.vkf-vditor.vditor{
+  --textarea-background-color: var(--el-fill-color-extra-light);
+}
+.vkf-vditor-footer.is-textarea-focus{
+  background-color:  var(--textarea-background-color);
+}

package/components/vditor/index.d.ts

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

package/components/vditor/index.mjs

@@ -0,0 +1,279 @@
+import Vditor from 'vditor';
+import { inject, unref, defineComponent, nextTick, ref, watch, shallowRef, provide, onMounted, resolveComponent, openBlock, createElementBlock, Fragment, createElementVNode, createBlock, withCtx, normalizeClass, renderSlot, createCommentVNode } from 'vue';
+import { watchPausable, useMutationObserver } from '@vueuse/core';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+import { VkAsyncTeleport } from '@vunk/core';
+
+const defaultToolbar = [
+  "headings",
+  "bold",
+  "italic",
+  "strike",
+  "link",
+  "|",
+  "list",
+  "ordered-list",
+  "outdent",
+  "indent",
+  "|",
+  "line",
+  "code",
+  "inline-code",
+  "insert-before",
+  "insert-after",
+  "|",
+  "table",
+  "|",
+  "undo",
+  "redo",
+  "|",
+  "fullscreen",
+  "outline",
+  "export",
+  "|"
+];
+const props = {
+  modelValue: {
+    type: String,
+    default: ""
+  },
+  defaultOptions: {
+    type: Object,
+    default: () => ({})
+  },
+  placeholder: {
+    type: String,
+    default: "Crtl + Enter \u53D1\u9001; Enter \u6362\u884C"
+  },
+  toolbar: {
+    type: Array,
+    default: () => defaultToolbar
+  },
+  fullscreen: {
+    type: Boolean,
+    default: false
+  }
+};
+const emits = {
+  load: (e) => e,
+  "update:modelValue": (e) => e,
+  ctrlEnter: (e) => e,
+  "update:fullscreen": (e) => e
+};
+
+function mitt(n){return {all:n=n||new Map,on:function(t,e){var i=n.get(t);i?i.push(e):n.set(t,[e]);},off:function(t,e){var i=n.get(t);i&&(e?i.splice(i.indexOf(e)>>>0,1):n.set(t,[]));},emit:function(t,e){var i=n.get(t);i&&i.slice().map(function(n){n(e);}),(i=n.get("*"))&&i.slice().map(function(n){n(t,e);});}}}
+
+const useVditor = () => {
+  const core = inject("vkVditorRef", null);
+  if (!core) {
+    throw new Error("useVditor must be used after VditorProvider");
+  }
+  return unref(core);
+};
+const useVditorMitter = () => {
+  const core = inject("vkVditorMitter", null);
+  if (!core) {
+    throw new Error("useVditorMitter must be used after VditorProvider");
+  }
+  return core;
+};
+
+var _sfc_main$2 = defineComponent({
+  props: {
+    modelValue: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: {
+    "update:modelValue": null
+  },
+  setup(props, { emit }) {
+    const vditor = useVditor();
+    const mitter = useVditorMitter();
+    if (props.modelValue) {
+      vditor.setValue(props.modelValue, true);
+    }
+    const { pause, resume } = watchPausable(() => props.modelValue, (value) => {
+      vditor.setValue(value, true);
+    });
+    mitter.on("input", (value) => {
+      pause();
+      emit("update:modelValue", value);
+      nextTick(resume);
+    });
+    return () => null;
+  }
+});
+
+var HandleValue = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/vditor/src/handle-value.vue"]]);
+
+var _sfc_main$1 = defineComponent({
+  props: {
+    fullscreen: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: {
+    "update:fullscreen": null
+  },
+  setup(props, { emit }) {
+    const vditor = useVditor();
+    const el = vditor.vditor.element;
+    const domFullscreen = ref(false);
+    useMutationObserver(el, () => {
+      if (el.classList.contains("vditor--fullscreen")) {
+        domFullscreen.value = true;
+      } else {
+        domFullscreen.value = false;
+      }
+    }, {
+      attributes: true
+    });
+    watch(() => props.fullscreen, (value) => {
+      if (value !== domFullscreen.value) {
+        const ir = vditor.vditor.ir?.element;
+        if (!ir) return;
+        ir.dispatchEvent(new KeyboardEvent("keydown", {
+          key: "'",
+          ctrlKey: true
+        }));
+      }
+    }, { immediate: true });
+    watch(() => domFullscreen.value, (value) => {
+      emit("update:fullscreen", value);
+    });
+    return () => null;
+  }
+});
+
+var HandleFullscreen = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/vditor/src/handle-fullscreen.vue"]]);
+
+var _sfc_main = defineComponent({
+  name: "VkVditor",
+  components: {
+    HandleValue,
+    HandleFullscreen,
+    VkAsyncTeleport
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const vditorNode = ref();
+    const ready = ref(false);
+    const mitter = mitt();
+    const vditorRef = shallowRef();
+    const isTextareaFocus = ref(false);
+    provide("vkVditorMitter", mitter);
+    provide("vkVditorRef", vditorRef);
+    onMounted(() => {
+      const vditor = new Vditor(vditorNode.value, {
+        ...props2.defaultOptions,
+        placeholder: props2.placeholder,
+        cache: {
+          enable: true,
+          id: "VkVditorCache",
+          ...props2.defaultOptions.cache || {}
+        },
+        after() {
+          vditorRef.value = vditor;
+          ready.value = true;
+          emit("load", vditor);
+          props2.defaultOptions.after?.();
+        },
+        input(value) {
+          mitter.emit("input", value);
+          props2.defaultOptions.input?.(value);
+        },
+        ctrlEnter(value) {
+          emit("update:modelValue", value);
+          emit("ctrlEnter", value);
+        },
+        focus(v) {
+          isTextareaFocus.value = true;
+          props2.defaultOptions.focus?.(v);
+        },
+        blur(v) {
+          isTextareaFocus.value = false;
+          props2.defaultOptions.blur?.(v);
+        },
+        toolbar: props2.toolbar
+      });
+    });
+    return {
+      vditorNode,
+      isTextareaFocus,
+      ready
+    };
+  }
+});
+
+const _hoisted_1 = {
+  ref: "vditorNode",
+  class: "vkf-vditor"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkAsyncTeleport = resolveComponent("VkAsyncTeleport");
+  const _component_HandleValue = resolveComponent("HandleValue");
+  const _component_HandleFullscreen = resolveComponent("HandleFullscreen");
+  return openBlock(), createElementBlock(
+    Fragment,
+    null,
+    [
+      createElementVNode(
+        "div",
+        _hoisted_1,
+        null,
+        512
+        /* NEED_PATCH */
+      ),
+      _ctx.ready ? (openBlock(), createBlock(_component_VkAsyncTeleport, {
+        key: 0,
+        to: _ctx.vditorNode
+      }, {
+        default: withCtx(() => [
+          createElementVNode(
+            "div",
+            {
+              class: normalizeClass(["vkf-vditor-footer", {
+                "is-textarea-focus": _ctx.isTextareaFocus
+              }])
+            },
+            [
+              renderSlot(_ctx.$slots, "footer")
+            ],
+            2
+            /* CLASS */
+          )
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["to"])) : createCommentVNode("v-if", true),
+      _ctx.ready ? (openBlock(), createBlock(_component_HandleValue, {
+        key: 1,
+        "model-value": _ctx.modelValue,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.$emit("update:modelValue", $event))
+      }, null, 8, ["model-value"])) : createCommentVNode("v-if", true),
+      _ctx.ready ? (openBlock(), createBlock(_component_HandleFullscreen, {
+        key: 2,
+        fullscreen: _ctx.fullscreen,
+        "onUpdate:fullscreen": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("update:fullscreen", $event))
+      }, null, 8, ["fullscreen"])) : createCommentVNode("v-if", true),
+      _ctx.ready ? renderSlot(_ctx.$slots, "default", { key: 3 }) : createCommentVNode("v-if", true)
+    ],
+    64
+    /* STABLE_FRAGMENT */
+  );
+}
+var VkVditor = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/vditor/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkVditor.install = (app) => {
+  app.component(VkVditor.name || "VkVditor", VkVditor);
+};
+
+export { VkVditor, types as __VkVditor, VkVditor as default };

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

@@ -0,0 +1,30 @@
+import { PropType } from 'vue';
+import Vditor from 'vditor';
+export declare const props: {
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: PropType<IOptions>;
+        default: () => IOptions;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare const emits: {
+    load: (e: Vditor) => Vditor;
+    'update:modelValue': (e: string) => string;
+    ctrlEnter: (e: string) => string;
+    'update:fullscreen': (e: boolean) => boolean;
+};

package/components/vditor/src/handle-fullscreen.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:fullscreen': any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:fullscreen"?: (...args: any[] | unknown[]) => any;
+}>, {
+    fullscreen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/vditor/src/handle-value.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
+}>, {
+    modelValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,144 @@
+/// <reference types="./types" />
+import Vditor from 'vditor';
+import { Ref } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: import("vue").PropType<IOptions>;
+        default: () => IOptions;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    vditorNode: Ref<HTMLDivElement, HTMLDivElement>;
+    isTextareaFocus: Ref<boolean, boolean>;
+    ready: Ref<boolean, boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: (e: Vditor) => Vditor;
+    'update:modelValue': (e: string) => string;
+    ctrlEnter: (e: string) => string;
+    'update:fullscreen': (e: boolean) => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: import("vue").PropType<IOptions>;
+        default: () => IOptions;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
+    fullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onLoad?: (e: Vditor) => any;
+    "onUpdate:modelValue"?: (e: string) => any;
+    "onUpdate:fullscreen"?: (e: boolean) => any;
+    onCtrlEnter?: (e: string) => any;
+}>, {
+    modelValue: string;
+    defaultOptions: IOptions;
+    placeholder: string;
+    toolbar: string[];
+    fullscreen: boolean;
+}, {}, {
+    HandleValue: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': any;
+    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
+    }>, {
+        modelValue: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    HandleFullscreen: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        fullscreen: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:fullscreen': any;
+    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        fullscreen: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onUpdate:fullscreen"?: (...args: any[] | unknown[]) => any;
+    }>, {
+        fullscreen: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    VkAsyncTeleport: import("vue").DefineComponent<{
+        to: {
+            type: import("vue").PropType<string | import("vue").RendererElement>;
+            default: any;
+        };
+        sleep: {
+            type: NumberConstructor;
+            default: number;
+        };
+        await: {
+            type: PromiseConstructor;
+            default: any;
+        };
+        teleport: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }, {
+        ready: Ref<boolean, boolean>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        to: {
+            type: import("vue").PropType<string | import("vue").RendererElement>;
+            default: any;
+        };
+        sleep: {
+            type: NumberConstructor;
+            default: number;
+        };
+        await: {
+            type: PromiseConstructor;
+            default: any;
+        };
+        teleport: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>>, {
+        to: any;
+        sleep: number;
+        await: Promise<unknown>;
+        teleport: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { NonVoidable } from '@vunk/core';
+import Vditor from 'vditor';
+import { Emitter } from 'mitt';
+export type DefaultOptions = NonVoidable<ConstructorParameters<typeof Vditor>[1]>;
+export type Toolbar = DefaultOptions['toolbar'];
+export type Mitter = Emitter<{
+    input: string;
+}>;
+export {};

package/components/vditor/src/use.d.ts

@@ -0,0 +1,4 @@
+import Vditor from 'vditor';
+import { Mitter } from './types';
+export declare const useVditor: () => Vditor;
+export declare const useVditorMitter: () => Mitter;

package/index.css

@@ -20,3 +20,16 @@
     opacity: 0;
 }
 }
+
+.vkf-vditor ul li {
+  list-style: initial;
+}
+.vkf-vditor ol li {
+  list-style: decimal;
+}
+.vkf-vditor.vditor{
+  --textarea-background-color: var(--el-fill-color-extra-light);
+}
+.vkf-vditor-footer.is-textarea-focus{
+  background-color:  var(--textarea-background-color);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vunk/plus",
-  "version": "0.0.0-alpha.4",
+  "version": "0.0.2",
   "description": "",
   "main": "index.esm.js",
   "scripts": {
@@ -55,6 +55,10 @@
       "import": "./composables/index.mjs",
       "types": "./composables/index.d.ts"
     },
+    "./components/vditor": {
+      "import": "./components/vditor/index.mjs",
+      "types": "./components/vditor/index.d.ts"
+    },
     "./components/typing-markdown": {
       "import": "./components/typing-markdown/index.mjs",
       "types": "./components/typing-markdown/index.d.ts"
@@ -82,6 +86,9 @@
     "./index.css": {
       "import": "./index.css"
     },
+    "./components/vditor/index.css": {
+      "import": "./components/vditor/index.css"
+    },
     "./components/typing-markdown/index.css": {
       "import": "./components/typing-markdown/index.css"
     },