bkui-vue 2.1.0-dev-beta.10 → 2.1.0-dev-beta.12

package/lib/cascader/index.js

@@ -1725,7 +1725,9 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
             // 只展开，不需要重复触发
             var expandNode = function expandNode(node) {
               var _node$children;
-              if (!node || node !== null && node !== void 0 && node.isDisabled) return;
+              if (!node || node !== null && node !== void 0 && node.isDisabled) {
+                return;
+              }
               var level = node.level;
               // 确保面板只更新到当前节点层级
               menus.list = menus.list.slice(0, level);
@@ -1773,7 +1775,9 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
     /** node点击展开回调 */
     var nodeExpandHandler = function nodeExpandHandler(node) {
       var _node$children2;
-      if (!node || node !== null && node !== void 0 && node.isDisabled) return;
+      if (!node || node !== null && node !== void 0 && node.isDisabled) {
+        return;
+      }
       menus.list = menus.list.slice(0, node.level);
       activePath.value = activePath.value.slice(0, node.level - 1);
       /** 如果所点击的node具有children元素，则直接展开
@@ -1953,6 +1957,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
         "class": [_this.resolveClassName('cascader-panel'), _this.resolveClassName('scroll-y')]
       }, [_this.suggestions.map(function (node) {
         return (0,external_vue_.createVNode)("li", (0,external_vue_.mergeProps)({
+          "key": node.id,
           "class": [_this.resolveClassName('cascader-node'), {
             'is-selected': _this.isNodeInPath(node)
           }, {
@@ -1971,8 +1976,9 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
     return (0,external_vue_.createVNode)("div", {
       "class": this.resolveClassName('cascader-panel-wrapper')
     }, [this.isFiltering ? searchPanelRender() : this.menus.list.map(function (menu, index) {
-      var _this$$slots$panel, _this$$slots;
+      var _this$activePath$id, _this$activePath, _this$$slots$panel, _this$$slots;
       return (0,external_vue_.createVNode)("ul", {
+        "key": index === 0 ? '__root__' : (_this$activePath$id = (_this$activePath = _this.activePath[index - 1]) === null || _this$activePath === void 0 ? void 0 : _this$activePath.id) !== null && _this$activePath$id !== void 0 ? _this$activePath$id : "__level_".concat(index, "__"),
         "style": {
           height: _this.panelHeight,
           width: _this.panelWidth
@@ -1985,6 +1991,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
       }), menu.length ? menu.map(function (node) {
         var _this$$slots$default, _this$$slots2;
         return (0,external_vue_.createVNode)("li", (0,external_vue_.mergeProps)({
+          "key": node.id,
           "class": [_this.resolveClassName('cascader-node'), {
             'is-selected': _this.isNodeInPath(node)
           }, {
@@ -2506,7 +2513,7 @@ var Store = /*#__PURE__*/function () {
     var isFocus = (0,external_vue_.ref)(false);
     // 定义isShowPanel变量，用于标致面板显示
     var isShowPanel = (0,external_vue_.ref)(false);
-    // 用computed定义checkedValue变量，用于监听modelValue的变化
+    // 定义checkedValue变量，用于监听modelValue的变化
     var checkedValue = (0,external_vue_.computed)({
       get: function get() {
         return modelValue.value;
@@ -2658,7 +2665,6 @@ var Store = /*#__PURE__*/function () {
       }
       // 开始过滤
       isFiltering.value = true;
-      isFiltering.value = true;
       // 筛选方法，如果props中存在filterMethod，则使用props中的方法，否则使用默认方法
       var filterMethod = props.filterMethod ? props.filterMethod : function (node) {
         if (props.checkAnyLevel) {

package/lib/code-diff/index.js

@@ -3282,7 +3282,46 @@ function hasOnlyWinLineEndings(string) {
 function hasOnlyUnixLineEndings(string) {
     return !string.includes('\r\n') && string.includes('\n');
 }
-function trailingWs(string) {
+/**
+ * Split a string into segments using a word segmenter, merging consecutive
+ * segments if they are both whitespace segments. Whitespace segments can
+ * appear adjacent to one another for two reasons:
+ * - newlines always get their own segment
+ * - where a diacritic is attached to a whitespace character in the text, the
+ *   segment ends after the diacritic, so e.g. " \u0300 " becomes two segments.
+ * This function therefore runs the segmenter's .segment() method and then
+ * merges consecutive segments of whitespace into a single part.
+ */
+function segment(string, segmenter) {
+    const parts = [];
+    for (const segmentObj of Array.from(segmenter.segment(string))) {
+        const segment = segmentObj.segment;
+        if (parts.length && (/\s/).test(parts[parts.length - 1]) && (/\s/).test(segment)) {
+            parts[parts.length - 1] += segment;
+        }
+        else {
+            parts.push(segment);
+        }
+    }
+    return parts;
+}
+// The functions below take a `segmenter` argument so that, when called from
+// diffWords when it is using a segmenter, they can use a notion of what
+// constitutes "whitespace" that is consistent with the segmenter.
+//
+// USUALLY this will be identical to the result of the non-segmenter-based
+// logic, but it differs in at least one case: when whitespace characters are
+// modified by diacritics. A word segmenter considers these diacritics to be
+// part of the whitespace, whereas our non-segmenter-based logic does not.
+//
+// Because the segmenter-based approach necessarily requires segmenting the
+// entire string, we offer a leadingAndTrailingWs function to allow getting the
+// whitespace prefix AND whitespace suffix with a single call to the segmenter,
+// for efficiency's sake.
+function trailingWs(string, segmenter) {
+    if (segmenter) {
+        return leadingAndTrailingWs(string, segmenter)[1];
+    }
     // Yes, this looks overcomplicated and dumb - why not replace the whole function with
     //     return string.match(/\s*$/)[0]
     // you ask? Because:
@@ -3302,11 +3341,28 @@ function trailingWs(string) {
     }
     return string.substring(i + 1);
 }
-function leadingWs(string) {
+function leadingWs(string, segmenter) {
+    if (segmenter) {
+        return leadingAndTrailingWs(string, segmenter)[0];
+    }
     // Thankfully the annoying considerations described in trailingWs don't apply here:
     const match = string.match(/^\s*/);
     return match ? match[0] : '';
 }
+function leadingAndTrailingWs(string, segmenter) {
+    if (!segmenter) {
+        return [leadingWs(string), trailingWs(string)];
+    }
+    if (segmenter.resolvedOptions().granularity != 'word') {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+    }
+    const segments = segment(string, segmenter);
+    const firstSeg = segments[0];
+    const lastSeg = segments[segments.length - 1];
+    const head = (/\s/).test(firstSeg) ? firstSeg : '';
+    const tail = (/\s/).test(lastSeg) ? lastSeg : '';
+    return [head, tail];
+}
 
 ;// CONCATENATED MODULE: ../../node_modules/diff2html/node_modules/diff/libesm/diff/word.js
 
@@ -3375,22 +3431,9 @@ class WordDiff extends base_Diff {
             // We want `parts` to be an array whose elements alternate between being
             // pure whitespace and being pure non-whitespace. This is ALMOST what the
             // segments returned by a word-based Intl.Segmenter already look like,
-            // and therefore we can ALMOST get what we want by simply doing...
-            //     parts = Array.from(segmenter.segment(value), segment => segment.segment);
-            // ... but not QUITE, because there's of one annoying special case: every
-            // newline character gets its own segment, instead of sharing a segment
-            // with other surrounding whitespace. We therefore need to manually merge
-            // consecutive segments of whitespace into a single part:
-            parts = [];
-            for (const segmentObj of Array.from(segmenter.segment(value))) {
-                const segment = segmentObj.segment;
-                if (parts.length && (/\s/).test(parts[parts.length - 1]) && (/\s/).test(segment)) {
-                    parts[parts.length - 1] += segment;
-                }
-                else {
-                    parts.push(segment);
-                }
-            }
+            // but not quite - see explanation in the docs of our custom segment()
+            // function.
+            parts = segment(value, segmenter);
         }
         else {
             parts = value.match(tokenizeIncludingWhitespace) || [];
@@ -3454,7 +3497,7 @@ class WordDiff extends base_Diff {
             }
             else {
                 if (insertion || deletion) { // May be false at start of text
-                    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+                    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
                 }
                 lastKeep = change;
                 insertion = null;
@@ -3462,7 +3505,7 @@ class WordDiff extends base_Diff {
             }
         });
         if (insertion || deletion) {
-            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
+            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
         }
         return changes;
     }
@@ -3478,7 +3521,7 @@ function word_diffWords(oldStr, newStr, options) {
     }
     return word_wordDiff.diff(oldStr, newStr, options);
 }
-function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
     // Before returning, we tidy up the leading and trailing whitespace of the
     // change objects to eliminate cases where trailing whitespace in one object
     // is repeated as leading whitespace in the next.
@@ -3521,10 +3564,8 @@ function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep
     // * Just a "delete"
     // We handle the three cases separately.
     if (deletion && insertion) {
-        const oldWsPrefix = leadingWs(deletion.value);
-        const oldWsSuffix = trailingWs(deletion.value);
-        const newWsPrefix = leadingWs(insertion.value);
-        const newWsSuffix = trailingWs(insertion.value);
+        const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter);
+        const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
         if (startKeep) {
             const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
             startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
@@ -3546,17 +3587,17 @@ function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep
         // whitespace and deleting duplicate leading whitespace where
         // present.
         if (startKeep) {
-            const ws = leadingWs(insertion.value);
+            const ws = leadingWs(insertion.value, segmenter);
             insertion.value = insertion.value.substring(ws.length);
         }
         if (endKeep) {
-            const ws = leadingWs(endKeep.value);
+            const ws = leadingWs(endKeep.value, segmenter);
             endKeep.value = endKeep.value.substring(ws.length);
         }
         // otherwise we've got a deletion and no insertion
     }
     else if (startKeep && endKeep) {
-        const newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
+        const newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter);
         // Any whitespace that comes straight after startKeep in both the old and
         // new texts, assign to startKeep and remove from the deletion.
         const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
@@ -3575,8 +3616,8 @@ function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep
         // We are at the start of the text. Preserve all the whitespace on
         // endKeep, and just remove whitespace from the end of deletion to the
         // extent that it overlaps with the start of endKeep.
-        const endKeepWsPrefix = leadingWs(endKeep.value);
-        const deletionWsSuffix = trailingWs(deletion.value);
+        const endKeepWsPrefix = leadingWs(endKeep.value, segmenter);
+        const deletionWsSuffix = trailingWs(deletion.value, segmenter);
         const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
         deletion.value = removeSuffix(deletion.value, overlap);
     }
@@ -3584,8 +3625,8 @@ function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep
         // We are at the END of the text. Preserve all the whitespace on
         // startKeep, and just remove whitespace from the start of deletion to
         // the extent that it overlaps with the end of startKeep.
-        const startKeepWsSuffix = trailingWs(startKeep.value);
-        const deletionWsPrefix = leadingWs(deletion.value);
+        const startKeepWsSuffix = trailingWs(startKeep.value, segmenter);
+        const deletionWsPrefix = leadingWs(deletion.value, segmenter);
         const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
         deletion.value = removePrefix(deletion.value, overlap);
     }

package/lib/index.js

@@ -3,5 +3,5 @@ export * from './hooks';
 export { default } from './preset';
 export * from './config-provider';
 export * from './directives';
-export const version = "2.1.0-dev-beta.10";
+export const version = "2.1.0-dev-beta.12";
 window.__bkui_vue_version__ = version;

package/lib/input/index.d.ts

@@ -33,12 +33,18 @@ declare const BkInput: {
         };
         step: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
+        } & {
+            default: number;
         };
         max: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
+        } & {
+            default: number;
         };
         min: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
+        } & {
+            default: number;
         };
         maxlength: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
@@ -111,13 +117,15 @@ declare const BkInput: {
         } & {
             default: boolean;
         };
+        allowEmptyValue: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
     }>> & Readonly<{
         onBlur?: (evt: FocusEvent) => any;
         onChange?: (_value: any, _evt: KeyboardEvent) => any;
         onClear?: () => any;
-        onCompositionend?: (evt: CompositionEvent) => any;
-        onCompositionstart?: (evt: CompositionEvent) => any;
-        onCompositionupdate?: (evt: CompositionEvent) => any;
         onEnter?: (_value: any, _evt: KeyboardEvent) => any;
         onFocus?: (evt: FocusEvent) => any;
         onInput?: (_value: any, _evt: KeyboardEvent) => any;
@@ -139,9 +147,6 @@ declare const BkInput: {
         keyup: (_value: any, _evt: KeyboardEvent) => any;
         enter: (_value: any, _evt: KeyboardEvent) => any;
         paste: (_value: any, _e: ClipboardEvent) => boolean;
-        compositionstart: (evt: CompositionEvent) => CompositionEvent;
-        compositionupdate: (evt: CompositionEvent) => CompositionEvent;
-        compositionend: (evt: CompositionEvent) => CompositionEvent;
         search: (evt: Event) => Event;
     }, import("vue").PublicProps, {
         type: string;
@@ -172,6 +177,7 @@ declare const BkInput: {
         showOverflowTooltips: boolean;
         tooltipsOptions: Partial<import("../../bkui-vue").IOptions>;
         autosize: boolean | import("./input").InputAutoSize;
+        allowEmptyValue: boolean;
     }, true, {}, {}, import("vue").GlobalComponents, {
         bkTooltips: import("vue").ObjectDirective<any, any, string, any>;
     } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
@@ -215,12 +221,18 @@ declare const BkInput: {
         };
         step: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
+        } & {
+            default: number;
         };
         max: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
+        } & {
+            default: number;
         };
         min: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
+        } & {
+            default: number;
         };
         maxlength: import("vue-types").VueTypeValidableDef<number> & {
             default: number;
@@ -293,13 +305,15 @@ declare const BkInput: {
         } & {
             default: boolean;
         };
+        allowEmptyValue: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
     }>> & Readonly<{
         onBlur?: (evt: FocusEvent) => any;
         onChange?: (_value: any, _evt: KeyboardEvent) => any;
         onClear?: () => any;
-        onCompositionend?: (evt: CompositionEvent) => any;
-        onCompositionstart?: (evt: CompositionEvent) => any;
-        onCompositionupdate?: (evt: CompositionEvent) => any;
         onEnter?: (_value: any, _evt: KeyboardEvent) => any;
         onFocus?: (evt: FocusEvent) => any;
         onInput?: (_value: any, _evt: KeyboardEvent) => any;
@@ -338,6 +352,7 @@ declare const BkInput: {
         showOverflowTooltips: boolean;
         tooltipsOptions: Partial<import("../../bkui-vue").IOptions>;
         autosize: boolean | import("./input").InputAutoSize;
+        allowEmptyValue: boolean;
     }>;
     __isFragment?: never;
     __isTeleport?: never;
@@ -376,12 +391,18 @@ declare const BkInput: {
     };
     step: import("vue-types").VueTypeValidableDef<number> & {
         default: number;
+    } & {
+        default: number;
     };
     max: import("vue-types").VueTypeValidableDef<number> & {
         default: number;
+    } & {
+        default: number;
     };
     min: import("vue-types").VueTypeValidableDef<number> & {
         default: number;
+    } & {
+        default: number;
     };
     maxlength: import("vue-types").VueTypeValidableDef<number> & {
         default: number;
@@ -454,13 +475,15 @@ declare const BkInput: {
     } & {
         default: boolean;
     };
+    allowEmptyValue: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
 }>> & Readonly<{
     onBlur?: (evt: FocusEvent) => any;
     onChange?: (_value: any, _evt: KeyboardEvent) => any;
     onClear?: () => any;
-    onCompositionend?: (evt: CompositionEvent) => any;
-    onCompositionstart?: (evt: CompositionEvent) => any;
-    onCompositionupdate?: (evt: CompositionEvent) => any;
     onEnter?: (_value: any, _evt: KeyboardEvent) => any;
     onFocus?: (evt: FocusEvent) => any;
     onInput?: (_value: any, _evt: KeyboardEvent) => any;
@@ -482,9 +505,6 @@ declare const BkInput: {
     keyup: (_value: any, _evt: KeyboardEvent) => any;
     enter: (_value: any, _evt: KeyboardEvent) => any;
     paste: (_value: any, _e: ClipboardEvent) => boolean;
-    compositionstart: (evt: CompositionEvent) => CompositionEvent;
-    compositionupdate: (evt: CompositionEvent) => CompositionEvent;
-    compositionend: (evt: CompositionEvent) => CompositionEvent;
     search: (evt: Event) => Event;
 }, string, {
     type: string;
@@ -515,6 +535,7 @@ declare const BkInput: {
     showOverflowTooltips: boolean;
     tooltipsOptions: Partial<import("../../bkui-vue").IOptions>;
     autosize: boolean | import("./input").InputAutoSize;
+    allowEmptyValue: boolean;
 }, {}, string, {}, import("vue").GlobalComponents, {
     bkTooltips: import("vue").ObjectDirective<any, any, string, any>;
 } & import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[], any[]>;