@vunk/form 1.1.80 → 1.1.82

package/components/date-picker-range/index.mjs

@@ -72,8 +72,8 @@ var _sfc_main = defineComponent({
     const modelValue = computed({
       get: () => [props2.startValue, props2.endValue],
       set: (val) => {
-        emit("update:startValue", val[0]);
-        emit("update:endValue", val[1]);
+        emit("update:startValue", val?.[0]);
+        emit("update:endValue", val?.[1]);
       }
     });
     const prop = computed(() => {

package/components/esri-input-geojson/index.mjs

@@ -1004,7 +1004,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         createVNode(_component_ViewerVue, {
           view: _ctx.view,
           "view-component": _ctx.viewComponent,
-          viewComponentAttrs: _ctx.viewComponentAttrs
+          "view-component-attrs": _ctx.viewComponentAttrs
         }, {
           default: withCtx(() => [
             createVNode(_component_VaGraphicsLayer, {
@@ -1021,9 +1021,9 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
                   multiple: _ctx.multiple,
                   "available-creature-tools": _ctx.availableCreatureTools,
                   "model-value": _ctx.sketchValue,
+                  "visible-elements": _ctx.visibleElements,
                   "onUpdate:modelValue": _ctx.handleUpdateSketchValue,
-                  onLoad: _ctx.sketchLoad,
-                  visibleElements: _ctx.visibleElements
+                  onLoad: _ctx.sketchLoad
                 }, {
                   default: withCtx(() => [
                     !_ctx.skipSave && _ctx.shetchPanel ? (openBlock(), createBlock(_component_VkAsyncTeleport, {
@@ -1048,7 +1048,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
                   ]),
                   _: 1
                   /* STABLE */
-                }, 8, ["view-model-active-fill-symbol", "view-model-active-line-symbol", "view-model-active-point-symbol", "multiple", "available-creature-tools", "model-value", "onUpdate:modelValue", "onLoad", "visibleElements"])) : createCommentVNode("v-if", true)
+                }, 8, ["view-model-active-fill-symbol", "view-model-active-line-symbol", "view-model-active-point-symbol", "multiple", "available-creature-tools", "model-value", "visible-elements", "onUpdate:modelValue", "onLoad"])) : createCommentVNode("v-if", true)
               ]),
               _: 1
               /* STABLE */
@@ -1056,7 +1056,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
           ]),
           _: 1
           /* STABLE */
-        }, 8, ["view", "view-component", "viewComponentAttrs"])
+        }, 8, ["view", "view-component", "view-component-attrs"])
       ]),
       _: 1
       /* STABLE */

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.mjs

@@ -1,58 +1,308 @@
 import Vditor from 'vditor';
-import { defineComponent, ref, onMounted, provide, openBlock, createElementBlock } from 'vue';
+import { inject, unref, ref, watch, defineComponent, nextTick, shallowRef, provide, onMounted, resolveComponent, openBlock, createElementBlock, Fragment, createElementVNode, createBlock, withCtx, normalizeClass, renderSlot, createCommentVNode } from 'vue';
 import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+import { VkAsyncTeleport } from '@vunk/core';
 
 const props = {
   modelValue: {
-    type: Object,
-    default: () => ({})
+    type: String,
+    default: ""
   },
   defaultOptions: {
     type: Object,
     default: () => ({})
+  },
+  placeholder: {
+    type: String,
+    default: "\u95EE\u6211\u4EFB\u4F55\u95EE\u9898...(Crtl + Enter \u53D1\u9001)"
+  },
+  toolbar: {
+    type: Array,
+    default: () => [
+      "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 emits = {
-  load: (e) => e
+  load: (e) => e,
+  "update:modelValue": (e) => e,
+  ctrlEnter: (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("vkfVditorRef", null);
+  if (!core) {
+    throw new Error("useVditor must be used after VditorProvider");
+  }
+  return unref(core);
+};
+const useVditorMitter = () => {
+  const core = inject("vkfVditorMitter", null);
+  if (!core) {
+    throw new Error("useVditorMitter must be used after VditorProvider");
+  }
+  return core;
+};
+
+var _a;
+const isClient = typeof window !== "undefined";
+isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
+
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    filter(() => fn.apply(this, args), { fn, thisArg: this, args });
+  }
+  return wrapper;
+}
+const bypassFilter = (invoke) => {
+  return invoke();
+};
+function pausableFilter(extendFilter = bypassFilter) {
+  const isActive = ref(true);
+  function pause() {
+    isActive.value = false;
+  }
+  function resume() {
+    isActive.value = true;
+  }
+  const eventFilter = (...args) => {
+    if (isActive.value)
+      extendFilter(...args);
+  };
+  return { isActive, pause, resume, eventFilter };
+}
+
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function watchWithFilter(source, cb, options = {}) {
+  const _a = options, {
+    eventFilter = bypassFilter
+  } = _a, watchOptions = __objRest$5(_a, [
+    "eventFilter"
+  ]);
+  return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
 };
+function watchPausable(source, cb, options = {}) {
+  const _a = options, {
+    eventFilter: filter
+  } = _a, watchOptions = __objRest$1(_a, [
+    "eventFilter"
+  ]);
+  const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
+  const stop = watchWithFilter(source, cb, __spreadProps$2(__spreadValues$2({}, watchOptions), {
+    eventFilter
+  }));
+  return { stop, pause, resume, isActive };
+}
+
+var _sfc_main$1 = 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$1, [["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/vditor/src/handle-value.vue"]]);
 
 var _sfc_main = defineComponent({
   name: "VkfVditor",
-  emits,
+  components: {
+    HandleValue,
+    VkAsyncTeleport
+  },
   props,
+  emits,
   setup(props2, { emit }) {
     const vditorNode = ref();
     const ready = ref(false);
+    const mitter = mitt();
+    const vditorRef = shallowRef();
+    const isTextareaFocus = ref(false);
+    provide("vkfVditorMitter", mitter);
+    provide("vkfVditorRef", vditorRef);
     onMounted(() => {
       const vditor = new Vditor(vditorNode.value, {
         ...props2.defaultOptions,
+        placeholder: props2.placeholder,
         cache: {
           enable: true,
           id: "VkfVditorCache",
           ...props2.defaultOptions.cache || {}
         },
         after() {
+          vditorRef.value = vditor;
           ready.value = true;
           emit("load", vditor);
-          provide("vkfVditor", vditor);
           props2.defaultOptions.after?.();
-        }
+        },
+        input(value) {
+          mitter.emit("input", value);
+          props2.defaultOptions.input?.(value);
+        },
+        ctrlEnter(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
+      vditorNode,
+      isTextareaFocus,
+      ready
     };
   }
 });
 
-const _hoisted_1 = { ref: "vditorNode" };
+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");
   return openBlock(), createElementBlock(
-    "div",
-    _hoisted_1,
+    Fragment,
     null,
-    512
-    /* NEED_PATCH */
+    [
+      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 ? renderSlot(_ctx.$slots, "default", { key: 2 }) : createCommentVNode("v-if", true)
+    ],
+    64
+    /* STABLE_FRAGMENT */
   );
 }
 var VkfVditor = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/vditor/src/index.vue"]]);
@@ -62,7 +312,7 @@ var types = /*#__PURE__*/Object.freeze({
 });
 
 VkfVditor.install = (app) => {
-  app.component(VkfVditor.name, VkfVditor);
+  app.component(VkfVditor.name || "VkfVditor", VkfVditor);
 };
 
 export { VkfVditor, types as __VkfVditor, VkfVditor as default };

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

@@ -3,14 +3,24 @@ import { DefaultOptions } from './types';
 import Vditor from 'vditor';
 export declare const props: {
     modelValue: {
-        type: PropType<unknown>;
-        default: () => {};
+        type: StringConstructor;
+        default: string;
     };
     defaultOptions: {
         type: PropType<DefaultOptions>;
         default: () => IOptions;
     };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
 };
 export declare const emits: {
     load: (e: Vditor) => Vditor;
+    'update:modelValue': (e: string) => string;
+    ctrlEnter: (e: string) => string;
 };

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

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

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

@@ -2,30 +2,54 @@ import Vditor from 'vditor';
 import { Ref } from 'vue';
 declare const _default: import("vue").DefineComponent<{
     modelValue: {
-        type: import("vue").PropType<unknown>;
-        default: () => {};
+        type: StringConstructor;
+        default: string;
     };
     defaultOptions: {
         type: import("vue").PropType<import("./types").DefaultOptions>;
         default: () => IOptions;
     };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
 }, {
     vditorNode: Ref<HTMLDivElement>;
+    isTextareaFocus: Ref<boolean>;
+    ready: Ref<boolean>;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     load: (e: Vditor) => Vditor;
+    'update:modelValue': (e: string) => string;
+    ctrlEnter: (e: string) => string;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     modelValue: {
-        type: import("vue").PropType<unknown>;
-        default: () => {};
+        type: StringConstructor;
+        default: string;
     };
     defaultOptions: {
         type: import("vue").PropType<import("./types").DefaultOptions>;
         default: () => IOptions;
     };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    toolbar: {
+        type: import("vue").PropType<string[]>;
+        default: () => string[];
+    };
 }>> & {
+    "onUpdate:modelValue"?: (e: string) => any;
     onLoad?: (e: Vditor) => any;
+    onCtrlEnter?: (e: string) => any;
 }, {
-    modelValue: {};
+    placeholder: string;
+    modelValue: string;
     defaultOptions: IOptions;
+    toolbar: string[];
 }, {}>;
 export default _default;

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

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

@@ -439,3 +439,16 @@
   padding-left: var(--date-picker-title-padding);
   padding-right: var(--date-picker-title-padding);
 }
+
+.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/form",
-  "version": "1.1.80",
+  "version": "1.1.82",
   "description": "",
   "main": "index.esm.js",
   "scripts": {
@@ -213,6 +213,9 @@
     "./index.css": {
       "import": "./index.css"
     },
+    "./components/vditor/index.css": {
+      "import": "./components/vditor/index.css"
+    },
     "./components/var-datetime-picker/index.css": {
       "import": "./components/var-datetime-picker/index.css"
     },