@vunk/plus 1.2.2 → 1.3.1

package/components/typing-markdown/index.mjs

@@ -1,9 +1,133 @@
-import { defineComponent, ref, computed, watch, openBlock, createElementBlock, normalizeClass } from 'vue';
 import { noop, computedAsync, debouncedRef } from '@vueuse/core';
-import MarkdownIt from 'markdown-it';
+import { noop as noop$1 } from '@vunk/shared/function';
+import { defineComponent, ref, computed, watch, createElementBlock, openBlock, normalizeClass } from 'vue';
 import { highlight } from '@vunk/shared/markdown/shiki';
+import markdownIt from 'markdown-it';
 import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 
+const placeholder = (id, code) => `<pre><!--::markdown-it-async::${id}::--><code>${code}</code></pre>`;
+const placeholderRe = /<pre><!--::markdown-it-async::(\w+)::--><code>[\s\S]*?<\/code><\/pre>/g;
+function randStr() {
+  return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+class MarkdownItAsync extends markdownIt {
+  placeholderMap;
+  disableWarn = false;
+  constructor(...args) {
+    const map = /* @__PURE__ */ new Map();
+    const options = args.length === 2 ? args[1] : args[0];
+    if (options && "highlight" in options)
+      options.highlight = wrapHightlight(options.highlight, map);
+    super(...args);
+    this.placeholderMap = map;
+  }
+  // implementation
+  use(plugin, ...params) {
+    return super.use(plugin, ...params);
+  }
+  render(src, env) {
+    if (this.options.warnOnSyncRender && !this.disableWarn) {
+      console.warn("[markdown-it-async] Please use `md.renderAsync` instead of `md.render`");
+    }
+    return super.render(src, env);
+  }
+  async renderAsync(src, env) {
+    this.options.highlight = wrapHightlight(this.options.highlight, this.placeholderMap);
+    this.disableWarn = true;
+    const result = this.render(src, env);
+    this.disableWarn = false;
+    return replaceAsync(result, placeholderRe, async (match, id) => {
+      if (!this.placeholderMap.has(id))
+        throw new Error(`Unknown highlight placeholder id: ${id}`);
+      const [promise, _str, lang, _attrs] = this.placeholderMap.get(id);
+      const result2 = await promise || "";
+      this.placeholderMap.delete(id);
+      if (result2.startsWith("<pre"))
+        return result2;
+      else
+        return `<pre><code class="language-${lang}">${result2}</code></pre>`;
+    });
+  }
+}
+function createMarkdownItAsync(...args) {
+  return new MarkdownItAsync(...args);
+}
+function replaceAsync(string, searchValue, replacer) {
+  try {
+    if (typeof replacer === "function") {
+      const values = [];
+      String.prototype.replace.call(string, searchValue, (...args) => {
+        values.push(replacer(...args));
+        return "";
+      });
+      return Promise.all(values).then((resolvedValues) => {
+        return String.prototype.replace.call(string, searchValue, () => {
+          return resolvedValues.shift() || "";
+        });
+      });
+    } else {
+      return Promise.resolve(
+        String.prototype.replace.call(string, searchValue, replacer)
+      );
+    }
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+const wrappedSet = /* @__PURE__ */ new WeakSet();
+function escapeHtml(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function wrapHightlight(highlight, map) {
+  if (!highlight)
+    return void 0;
+  if (wrappedSet.has(highlight))
+    return highlight;
+  const wrapped = (str, lang, attrs) => {
+    const promise = highlight(str, lang, attrs);
+    if (typeof promise === "string")
+      return promise;
+    const id = randStr();
+    map.set(id, [promise, str, lang, attrs]);
+    let code = str;
+    if (code.endsWith("\n"))
+      code = code.slice(0, -1);
+    code = escapeHtml(code);
+    return placeholder(id, code);
+  };
+  wrappedSet.add(wrapped);
+  return wrapped;
+}
+
+const highlightInfo = highlight({
+  dark: "github-dark",
+  light: "github-light"
+}, {}, {
+  warn: noop
+});
+async function createMarkdownIt() {
+  const [highlight] = await highlightInfo;
+  const md = createMarkdownItAsync({
+    highlight
+  });
+  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;
+}
+const markdownItPromise = createMarkdownIt();
+
 const props = {
   source: {
     type: String,
@@ -37,35 +161,6 @@ 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: highlight2
-  });
-  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;
-};
-const markdownItPromise = createMarkdownIt();
-
 var _sfc_main = defineComponent({
   name: "VkTypingMarkdown",
   props,
@@ -83,7 +178,7 @@ var _sfc_main = defineComponent({
       return md;
     });
     const htmlText = computedAsync(async () => {
-      currentText.value;
+      noop$1(currentText.value);
       const md = await theMarkdownIt;
       return md.render(currentText.value);
     }, "");
@@ -135,7 +230,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", "/home/runner/work/vunk-plus/vunk-plus/packages/components/typing-markdown/src/index.vue"]]);
+var VkTypingMarkdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null

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

@@ -1,3 +1,2 @@
-import MarkdownIt from 'markdown-it';
-export declare const createMarkdownIt: () => Promise<MarkdownIt>;
-export declare const markdownItPromise: Promise<MarkdownIt>;
+export declare function createMarkdownIt(): Promise<import("markdown-it-async").MarkdownItAsync>;
+export declare const markdownItPromise: Promise<import("markdown-it-async").MarkdownItAsync>;

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

@@ -1,5 +1,5 @@
-import type MarkdownIt from "markdown-it";
-import { PropType } from "vue";
+import type { MarkdownItAsync } from 'markdown-it-async';
+import type { PropType } from 'vue';
 export declare const props: {
     source: {
         type: StringConstructor;
@@ -24,10 +24,10 @@ export declare const props: {
      *  @description markdown-it 配置
      */
     markdownItSetup: {
-        type: PropType<(md: MarkdownIt) => void>;
-        default: any;
+        type: PropType<(md: MarkdownItAsync) => void>;
+        default: null;
     };
 };
 export declare const emits: {
-    typing: any;
+    typing: null;
 };

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

@@ -16,14 +16,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: boolean;
     };
     markdownItSetup: {
-        type: import("vue").PropType<(md: import("markdown-it")) => void>;
-        default: any;
+        type: import("vue").PropType<(md: import("markdown-it-async").MarkdownItAsync) => void>;
+        default: null;
     };
 }>, {
     htmlText: import("vue").Ref<string, string>;
     isDebouncedTyping: Readonly<import("vue").Ref<boolean, boolean>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    typing: any;
+    typing: null;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     source: {
         type: StringConstructor;
@@ -42,16 +42,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: boolean;
     };
     markdownItSetup: {
-        type: import("vue").PropType<(md: import("markdown-it")) => void>;
-        default: any;
+        type: import("vue").PropType<(md: import("markdown-it-async").MarkdownItAsync) => void>;
+        default: null;
     };
 }>> & Readonly<{
-    onTyping?: (...args: any[] | unknown[]) => any;
+    onTyping?: ((...args: any[]) => any) | undefined;
 }>, {
-    disabled: boolean;
     source: string;
-    pause: boolean;
     delay: number;
-    markdownItSetup: (md: import("markdown-it")) => void;
+    pause: boolean;
+    disabled: boolean;
+    markdownItSetup: (md: import("markdown-it-async").MarkdownItAsync) => void;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/components/vditor/index.mjs

@@ -1,9 +1,9 @@
 import Vditor from 'vditor';
 import { bindPropsFactory, onEmitsFactory } from '@vunk/core/shared/utils-vue';
-import { inject, unref, defineComponent, nextTick, ref, watch, shallowRef, provide, onMounted, resolveComponent, openBlock, createElementBlock, Fragment, createElementVNode, createBlock, withCtx, normalizeClass, renderSlot, createCommentVNode } from 'vue';
+import { inject, unref, defineComponent, nextTick, ref, watch, shallowRef, provide, onMounted, resolveComponent, createElementBlock, openBlock, Fragment, createElementVNode, createBlock, createCommentVNode, renderSlot, withCtx, normalizeClass } from 'vue';
 import { watchPausable, useMutationObserver } from '@vueuse/core';
-import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 import { VkAsyncTeleport } from '@vunk/core';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 
 const defaultToolbar = [
   "headings",
@@ -117,8 +117,6 @@ var _sfc_main$2 = defineComponent({
   }
 });
 
-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: {
@@ -159,13 +157,11 @@ var _sfc_main$1 = defineComponent({
   }
 });
 
-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,
+    HandleValue: _sfc_main$2,
+    HandleFullscreen: _sfc_main$1,
     VkAsyncTeleport
   },
   props,
@@ -277,7 +273,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     /* 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 VkVditor = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 
 var types = /*#__PURE__*/Object.freeze({
   __proto__: null

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

@@ -22,14 +22,14 @@ export declare const props: {
         default: boolean;
     };
 };
-export declare const createBindProps: <T2 extends import("@vunk/core").NormalObject, EX extends (Extract<"modelValue", keyof T2> | Extract<"defaultOptions", keyof T2> | Extract<"placeholder", keyof T2> | Extract<"toolbar", keyof T2> | Extract<"fullscreen", keyof T2>)[]>(propsArg: T2, excludes?: EX) => import("vue").ComputedRef<{ [P in EX extends (infer KE)[] ? Exclude<Extract<"modelValue", keyof T2>, KE> | Exclude<Extract<"defaultOptions", keyof T2>, KE> | Exclude<Extract<"placeholder", keyof T2>, KE> | Exclude<Extract<"toolbar", keyof T2>, KE> | Exclude<Extract<"fullscreen", keyof T2>, KE> : Extract<"modelValue", keyof T2> | Extract<"defaultOptions", keyof T2> | Extract<"placeholder", keyof T2> | Extract<"toolbar", keyof T2> | Extract<"fullscreen", keyof T2>]: { [k in Extract<"modelValue", keyof T2> | Extract<"defaultOptions", keyof T2> | Extract<"placeholder", keyof T2> | Extract<"toolbar", keyof T2> | Extract<"fullscreen", keyof T2>]: T2[k]; }[P]; }>;
+export declare const createBindProps: <T2 extends import("@vunk/core").NormalObject, EX extends (Extract<"modelValue", keyof T2> | Extract<"placeholder", keyof T2> | Extract<"defaultOptions", keyof T2> | Extract<"toolbar", keyof T2> | Extract<"fullscreen", keyof T2>)[]>(propsArg: T2, excludes?: EX | undefined) => import("vue").ComputedRef<{ [P in EX extends (infer KE)[] ? Exclude<Extract<"modelValue", keyof T2>, KE> | Exclude<Extract<"placeholder", keyof T2>, KE> | Exclude<Extract<"defaultOptions", keyof T2>, KE> | Exclude<Extract<"toolbar", keyof T2>, KE> | Exclude<Extract<"fullscreen", keyof T2>, KE> : Extract<"modelValue", keyof T2> | Extract<"placeholder", keyof T2> | Extract<"defaultOptions", keyof T2> | Extract<"toolbar", keyof T2> | Extract<"fullscreen", keyof T2>]: { [k in Extract<"modelValue", keyof T2> | Extract<"placeholder", keyof T2> | Extract<"defaultOptions", keyof T2> | Extract<"toolbar", keyof T2> | Extract<"fullscreen", keyof T2>]: T2[k]; }[P]; }>;
 export declare const emits: {
     load: (e: Vditor) => Vditor;
     'update:modelValue': (e: string) => string;
     ctrlEnter: (e: string) => string;
     'update:fullscreen': (e: boolean) => boolean;
 };
-export declare const createOnEmits: <T2 extends import("@vunk/core").AnyFunc, EX extends ("load" | "update:modelValue" | "update:fullscreen" | "ctrlEnter")[]>(emit: T2, excludes?: EX) => { [P in EX extends (infer KE)[] ? Exclude<"load", KE> | Exclude<"update:modelValue", KE> | Exclude<"update:fullscreen", KE> | Exclude<"ctrlEnter", KE> : "load" | "update:modelValue" | "update:fullscreen" | "ctrlEnter"]: {
+export declare const createOnEmits: <T2 extends import("@vunk/core").AnyFunc, EX extends ("load" | "update:modelValue" | "update:fullscreen" | "ctrlEnter")[]>(emit: T2, excludes?: EX | undefined) => { [P in EX extends (infer KE)[] ? Exclude<"load", KE> | Exclude<"update:modelValue", KE> | Exclude<"update:fullscreen", KE> | Exclude<"ctrlEnter", KE> : "load" | "update:modelValue" | "update:fullscreen" | "ctrlEnter"]: {
     load: (...e: import("@vunk/core").RestParameters<T2>) => void;
     'update:modelValue': (...e: import("@vunk/core").RestParameters<T2>) => void;
     ctrlEnter: (...e: import("@vunk/core").RestParameters<T2>) => void;

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

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

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

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

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

@@ -53,14 +53,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: boolean;
     };
 }>> & Readonly<{
-    onLoad?: (e: Vditor) => any;
-    "onUpdate:modelValue"?: (e: string) => any;
-    "onUpdate:fullscreen"?: (e: boolean) => any;
-    onCtrlEnter?: (e: string) => any;
+    onLoad?: ((e: Vditor) => any) | undefined;
+    "onUpdate:modelValue"?: ((e: string) => any) | undefined;
+    "onUpdate:fullscreen"?: ((e: boolean) => any) | undefined;
+    onCtrlEnter?: ((e: string) => any) | undefined;
 }>, {
     modelValue: string;
-    defaultOptions: IOptions;
     placeholder: string;
+    defaultOptions: IOptions;
     toolbar: string[];
     fullscreen: boolean;
 }, {}, {
@@ -69,15 +69,15 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: StringConstructor;
             default: string;
         };
-    }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        'update:modelValue': any;
+    }>, () => null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': null;
     }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
         modelValue: {
             type: StringConstructor;
             default: string;
         };
     }>> & Readonly<{
-        "onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     }>, {
         modelValue: string;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
@@ -86,15 +86,15 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: BooleanConstructor;
             default: boolean;
         };
-    }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        'update:fullscreen': any;
+    }>, () => null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:fullscreen': null;
     }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
         fullscreen: {
             type: BooleanConstructor;
             default: boolean;
         };
     }>> & Readonly<{
-        "onUpdate:fullscreen"?: (...args: any[] | unknown[]) => any;
+        "onUpdate:fullscreen"?: ((...args: any[]) => any) | undefined;
     }>, {
         fullscreen: boolean;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/composables/el-breakpoints/index.d.ts

@@ -11,7 +11,7 @@ export declare const useElBreakpoints: () => {
         isSmallerOrEqual(k: import("@vueuse/shared").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl">): boolean;
         isInBetween(a: import("@vueuse/shared").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl">, b: import("@vueuse/shared").MaybeRefOrGetter<"sm" | "md" | "lg" | "xl">): boolean;
         current: () => import("vue").ComputedRef<string[]>;
-        active(): import("vue").ComputedRef<string>;
+        active(): import("vue").ComputedRef<string | undefined>;
     };
     isMobile: import("vue").Ref<boolean, boolean>;
     isDesktop: import("vue").Ref<boolean, boolean>;