@douyinfe/semi-foundation 2.70.1 → 2.71.0-alpha.3

package/lib/cjs/tree/tree.css

@@ -107,6 +107,7 @@
 .semi-tree-option-list .semi-tree-option-highlight {
   font-weight: 600;
   color: var(--semi-color-primary);
+  background-color: inherit;
 }
 .semi-tree-option-list .semi-tree-option-hidden {
   display: none;

package/lib/cjs/tree/tree.scss

@@ -137,6 +137,8 @@ $module: #{$prefix}-tree;
         &-highlight {
             font-weight: $font-tree_option_hightlight-fontWeight;
             color: $color-tree_option_hightlight-text;
+            // set inherit to override highlight component default bgc
+            background-color: inherit;
         }
 
         &-hidden {

package/lib/es/cascader/constants.d.ts

@@ -14,6 +14,8 @@ declare const strings: {
     readonly NONE_MERGE_TYPE: "none";
     readonly SEARCH_POSITION_TRIGGER: "trigger";
     readonly SEARCH_POSITION_CUSTOM: "custom";
+    readonly RELATED: "related";
+    readonly UN_RELATED: "unRelated";
 };
 declare const numbers: {};
 export { cssClasses, strings, numbers };

package/lib/es/cascader/constants.js

@@ -15,7 +15,9 @@ const strings = {
   AUTO_MERGE_VALUE_MERGE_TYPE: 'autoMergeValue',
   NONE_MERGE_TYPE: 'none',
   SEARCH_POSITION_TRIGGER: 'trigger',
-  SEARCH_POSITION_CUSTOM: 'custom'
+  SEARCH_POSITION_CUSTOM: 'custom',
+  RELATED: 'related',
+  UN_RELATED: 'unRelated'
 };
 const numbers = {};
 export { cssClasses, strings, numbers };

package/lib/es/cascader/foundation.d.ts

@@ -112,6 +112,7 @@ export interface BasicCascaderProps {
     enableLeafClick?: boolean;
     preventScroll?: boolean;
     virtualizeInSearch?: Virtualize;
+    checkRelation?: string;
     onClear?: () => void;
     triggerRender?: (props: BasicTriggerRenderProps) => any;
     onListScroll?: (e: any, panel: BasicScrollPanelProps) => void;
@@ -228,6 +229,8 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
     notifyIfLoadData(item: BasicEntity | BasicData): void;
     handleSingleSelect(e: any, item: BasicEntity | BasicData): void;
     _handleMultipleSelect(item: BasicEntity | BasicData): void;
+    _handleRelatedMultipleSelect(item: BasicEntity | BasicData): void;
+    _handleUnRelatedMultipleSelect(item: BasicEntity | BasicData): void;
     calcNonDisabledCheckedKeys(eventKey: string, targetStatus: boolean): {
         checkedKeys: Set<string>;
         halfCheckedKeys: Set<any>;

package/lib/es/cascader/foundation.js

@@ -595,6 +595,19 @@ export default class CascaderFoundation extends BaseFoundation {
     }
   }
   _handleMultipleSelect(item) {
+    const {
+      checkRelation
+    } = this.getProps();
+    if (checkRelation === strings.RELATED) {
+      this._handleRelatedMultipleSelect(item);
+    } else if (checkRelation === 'unRelated') {
+      this._handleUnRelatedMultipleSelect(item);
+    }
+    this._adapter.updateStates({
+      inputValue: ''
+    });
+  }
+  _handleRelatedMultipleSelect(item) {
     const {
       key
     } = item;
@@ -659,9 +672,48 @@ export default class CascaderFoundation extends BaseFoundation {
     if (curCheckedStatus) {
       this._notifySelect(curRealCheckedKeys);
     }
-    this._adapter.updateStates({
-      inputValue: ''
-    });
+  }
+  _handleUnRelatedMultipleSelect(item) {
+    const {
+      key
+    } = item;
+    const {
+      checkedKeys,
+      keyEntities
+    } = this.getStates();
+    const {
+      max
+    } = this.getProps();
+    const newCheckedKeys = new Set(checkedKeys);
+    let targetStatus;
+    const prevCheckedStatus = checkedKeys.has(key);
+    if (prevCheckedStatus) {
+      newCheckedKeys.delete(key);
+      targetStatus = false;
+    } else {
+      // 查看是否超出 max
+      if (_isNumber(max)) {
+        if (checkedKeys.size >= max) {
+          const checkedEntities = [];
+          checkedKeys.forEach(itemKey => {
+            checkedEntities.push(keyEntities[itemKey]);
+          });
+          this._adapter.notifyOnExceed(checkedEntities);
+          return;
+        }
+      }
+      newCheckedKeys.add(key);
+      targetStatus = true;
+    }
+    if (!this._isControlledComponent()) {
+      this._adapter.updateStates({
+        checkedKeys: newCheckedKeys
+      });
+    }
+    this._notifyChange(newCheckedKeys);
+    if (targetStatus) {
+      this._notifySelect(newCheckedKeys);
+    }
   }
   calcNonDisabledCheckedKeys(eventKey, targetStatus) {
     const {

package/lib/es/dragMove/foundation.d.ts

@@ -0,0 +1,45 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export declare function clampValueInRange(value: number, min: number, max: number): number;
+export interface DragMoveAdapter<P = Record<string, any>, S = Record<string, any>> extends DefaultAdapter<P, S> {
+    getDragElement: () => HTMLElement;
+    getConstrainer: () => HTMLElement | null;
+    getHandler: () => HTMLElement;
+    notifyMouseDown?: (e: MouseEvent) => void;
+    notifyMouseMove?: (e: MouseEvent) => void;
+    notifyMouseUp?: (e: MouseEvent) => void;
+    notifyTouchStart?: (e: TouchEvent) => void;
+    notifyTouchMove?: (e: TouchEvent) => void;
+    notifyTouchEnd?: (e: TouchEvent) => void;
+    notifyTouchCancel?: (e: TouchEvent) => void;
+}
+export default class DragMoveFoundation<P = Record<string, any>, S = Record<string, any>> extends BaseFoundation<DragMoveAdapter<P, S>, P, S> {
+    element: HTMLElement;
+    xMax: number;
+    xMin: number;
+    yMax: number;
+    yMin: number;
+    startOffsetX: number;
+    startOffsetY: number;
+    get constrainer(): HTMLElement;
+    get handler(): HTMLElement;
+    constructor(adapter: DragMoveAdapter<P, S>);
+    init(): void;
+    destroy(): void;
+    _registerDocMouseEvent: () => void;
+    _unRegisterDocMouseEvent: () => void;
+    _registerDocTouchEvent: () => void;
+    _unRegisterDocTouchEvent: () => void;
+    _unRegisterEvent(): void;
+    _calcMoveRange(): void;
+    _allowMove(e: MouseEvent | TouchEvent): any;
+    _calcOffset: (e: Touch | MouseEvent) => void;
+    _preventDefault: (e: MouseEvent | TouchEvent) => void;
+    onMouseDown: (e: MouseEvent) => void;
+    onTouchStart: (e: TouchEvent) => void;
+    _changePos: (e: Touch | MouseEvent) => void;
+    _onMouseMove: (e: MouseEvent) => void;
+    _onTouchMove: (e: TouchEvent) => void;
+    _onMouseUp: (e: MouseEvent) => void;
+    _onTouchEnd: (e: TouchEvent) => void;
+    _onTouchCancel: (e: TouchEvent) => void;
+}

package/lib/es/dragMove/foundation.js

@@ -0,0 +1,153 @@
+import BaseFoundation from '../base/foundation';
+export function clampValueInRange(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+export default class DragMoveFoundation extends BaseFoundation {
+  get constrainer() {
+    return this._adapter.getConstrainer();
+  }
+  get handler() {
+    return this._adapter.getHandler();
+  }
+  constructor(adapter) {
+    super(Object.assign({}, adapter));
+    this._registerDocMouseEvent = () => {
+      document.addEventListener('mousemove', this._onMouseMove);
+      document.addEventListener('mouseup', this._onMouseUp);
+    };
+    this._unRegisterDocMouseEvent = () => {
+      document.removeEventListener('mousemove', this._onMouseMove);
+      document.removeEventListener('mouseup', this._onMouseUp);
+    };
+    this._registerDocTouchEvent = () => {
+      document.addEventListener('touchend', this._onTouchEnd);
+      document.addEventListener('touchmove', this._onTouchMove);
+      document.addEventListener('touchcancel', this._onTouchCancel);
+    };
+    this._unRegisterDocTouchEvent = () => {
+      document.removeEventListener('touchend', this._onTouchEnd);
+      document.removeEventListener('touchmove', this._onTouchMove);
+      document.removeEventListener('touchcancel', this._onTouchCancel);
+    };
+    this._calcOffset = e => {
+      this.startOffsetX = e.clientX - this.element.offsetLeft;
+      this.startOffsetY = e.clientY - this.element.offsetTop;
+    };
+    this._preventDefault = e => {
+      // prevent default behavior, avoid other element(like img, text) be selected
+      e.preventDefault();
+    };
+    this.onMouseDown = e => {
+      this._calcMoveRange();
+      this._adapter.notifyMouseDown(e);
+      if (!this._allowMove(e)) {
+        return;
+      }
+      this._registerDocMouseEvent();
+      // store origin offset
+      this._calcOffset(e);
+      this._preventDefault(e);
+    };
+    this.onTouchStart = e => {
+      this._calcMoveRange();
+      this._adapter.notifyTouchStart(e);
+      if (!this._allowMove(e)) {
+        return;
+      }
+      this._registerDocTouchEvent();
+      const touch = e.targetTouches[0];
+      this._calcOffset(touch);
+      this._preventDefault(e);
+    };
+    this._changePos = e => {
+      const {
+        customMove
+      } = this.getProps();
+      let newLeft = e.clientX - this.startOffsetX;
+      let newTop = e.clientY - this.startOffsetY;
+      if (this.constrainer) {
+        newLeft = clampValueInRange(newLeft, this.xMin, this.xMax);
+        newTop = clampValueInRange(newTop, this.yMin, this.yMax);
+      }
+      requestAnimationFrame(() => {
+        if (customMove) {
+          customMove(this.element, newTop, newLeft);
+          return;
+        }
+        this.element.style.top = newTop + 'px';
+        this.element.style.left = newLeft + 'px';
+      });
+    };
+    this._onMouseMove = e => {
+      this._adapter.notifyMouseMove(e);
+      this._changePos(e);
+    };
+    this._onTouchMove = e => {
+      this._adapter.notifyTouchMove(e);
+      const touch = e.targetTouches[0];
+      this._changePos(touch);
+    };
+    this._onMouseUp = e => {
+      this._adapter.notifyMouseUp(e);
+      this._unRegisterDocMouseEvent();
+    };
+    this._onTouchEnd = e => {
+      this._adapter.notifyTouchEnd(e);
+      this._unRegisterDocTouchEvent();
+    };
+    this._onTouchCancel = e => {
+      this._adapter.notifyTouchCancel(e);
+      this._unRegisterDocTouchEvent();
+    };
+  }
+  init() {
+    const element = this._adapter.getDragElement();
+    if (!element) {
+      throw new Error('drag element must be a valid element');
+    }
+    this.element = element;
+    this.element.style.position = 'absolute';
+    this.handler.style.cursor = 'move';
+  }
+  destroy() {
+    this._unRegisterEvent();
+  }
+  _unRegisterEvent() {
+    this._unRegisterDocMouseEvent();
+    this._unRegisterDocTouchEvent();
+  }
+  _calcMoveRange() {
+    // Calculate the range within which an element can move
+    if (this.constrainer) {
+      let node = this.element.offsetParent;
+      let startX = 0;
+      let startY = 0;
+      while (node !== this.constrainer && node !== null) {
+        startX -= node.offsetLeft;
+        startY -= node.offsetTop;
+        node = node.offsetParent;
+      }
+      this.xMin = startX;
+      this.xMax = startX + this.constrainer.offsetWidth - this.element.offsetWidth;
+      this.yMin = startY;
+      this.yMax = startY + this.constrainer.offsetHeight - this.element.offsetHeight;
+    }
+  }
+  _allowMove(e) {
+    const {
+      allowMove,
+      allowInputDrag
+    } = this.getProps();
+    // When the clicked object is an input or textarea, clicking should be allowed but dragging should not be allowed.
+    if (!allowInputDrag) {
+      let target = e.target.tagName.toLowerCase();
+      if (target === 'input' || target === 'textarea') {
+        return;
+      }
+    }
+    if (allowMove) {
+      return allowMove(e, this.element);
+    }
+    return true;
+  }
+}

package/lib/es/highlight/foundation.d.ts

@@ -0,0 +1,84 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+interface HighlightAdapter extends Partial<DefaultAdapter> {
+}
+interface ChunkQuery {
+    autoEscape?: boolean;
+    caseSensitive?: boolean;
+    searchWords: SearchWords;
+    sourceString: string;
+}
+export interface Chunk {
+    start: number;
+    end: number;
+    highlight: boolean;
+    className: string;
+    style: Record<string, string>;
+}
+export interface ComplexSearchWord {
+    text: string;
+    className?: string;
+    style?: Record<string, string>;
+}
+export type SearchWord = string | ComplexSearchWord | undefined;
+export type SearchWords = SearchWord[];
+export default class HighlightFoundation extends BaseFoundation<HighlightAdapter> {
+    constructor(adapter?: HighlightAdapter);
+    /**
+     * Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word.
+     *
+        findAll ['z'], 'aaazaaazaaa'
+            result #=> [
+                { start: 0, end: 3, highlight: false }
+                { start: 3, end: 4, highlight: true }
+                { start: 4, end: 7, highlight: false }
+                { start: 7, end: 8, highlight: true }
+                { start: 8, end: 11, highlight: false }
+            ]
+
+        findAll ['do', 'dollar'], 'aaa do dollar aaa'
+            #=> chunks: [
+                    { start: 4, end: 6 },
+                    { start: 7, end: 9 },
+                    { start: 7, end: 13 },
+                ]
+            #=> chunksToHight: [
+                    { start: 4, end: 6 },
+                    { start: 7, end: 13 },
+                ]
+            #=> result: [
+                    { start: 0, end: 4, highlight: false },
+                    { start: 4, end: 6, highlight: true },
+                    { start: 6, end: 7, highlight: false },
+                    { start: 7, end: 13, highlight: true },
+                    { start: 13, end: 17, highlight: false },
+                ]
+
+    * @return Array of "chunks" (where a Chunk is { start:number, end:number, highlight:boolean })
+    */
+    findAll: ({ autoEscape, caseSensitive, searchWords, sourceString }: ChunkQuery) => Chunk[];
+    /**
+        * Examine text for any matches.
+        * If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}).
+        * @return { start:number, end:number }[]
+    */
+    findChunks: ({ autoEscape, caseSensitive, searchWords, sourceString }: ChunkQuery) => Chunk[];
+    /**
+   * Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks.
+   * @return {start:number, end:number}[]
+   */
+    combineChunks: ({ chunks }: {
+        chunks: Chunk[];
+    }) => Chunk[];
+    /**
+   * Given a set of chunks to highlight, create an additional set of chunks
+   * to represent the bits of text between the highlighted text.
+   * @param chunksToHighlight {start:number, end:number}[]
+   * @param totalLength number
+   * @return {start:number, end:number, highlight:boolean}[]
+   */
+    fillInChunks: ({ chunksToHighlight, totalLength }: {
+        chunksToHighlight: Chunk[];
+        totalLength: number;
+    }) => Chunk[];
+}
+export {};

package/lib/es/highlight/foundation.js

@@ -0,0 +1,174 @@
+import _isString from "lodash/isString"; // Modified version based on 'highlight-words-core'
+import BaseFoundation from '../base/foundation';
+const escapeRegExpFn = string => string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+export default class HighlightFoundation extends BaseFoundation {
+  constructor(adapter) {
+    super(Object.assign({}, adapter));
+    /**
+     * Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word.
+     *
+        findAll ['z'], 'aaazaaazaaa'
+            result #=> [
+                { start: 0, end: 3, highlight: false }
+                { start: 3, end: 4, highlight: true }
+                { start: 4, end: 7, highlight: false }
+                { start: 7, end: 8, highlight: true }
+                { start: 8, end: 11, highlight: false }
+            ]
+             findAll ['do', 'dollar'], 'aaa do dollar aaa'
+            #=> chunks: [
+                    { start: 4, end: 6 },
+                    { start: 7, end: 9 },
+                    { start: 7, end: 13 },
+                ]
+            #=> chunksToHight: [
+                    { start: 4, end: 6 },
+                    { start: 7, end: 13 },
+                ]
+            #=> result: [
+                    { start: 0, end: 4, highlight: false },
+                    { start: 4, end: 6, highlight: true },
+                    { start: 6, end: 7, highlight: false },
+                    { start: 7, end: 13, highlight: true },
+                    { start: 13, end: 17, highlight: false },
+                ]
+         * @return Array of "chunks" (where a Chunk is { start:number, end:number, highlight:boolean })
+    */
+    this.findAll = _ref => {
+      let {
+        autoEscape = true,
+        caseSensitive = false,
+        searchWords,
+        sourceString
+      } = _ref;
+      if (_isString(searchWords)) {
+        searchWords = [searchWords];
+      }
+      const chunks = this.findChunks({
+        autoEscape,
+        caseSensitive,
+        searchWords,
+        sourceString
+      });
+      const chunksToHighlight = this.combineChunks({
+        chunks
+      });
+      const result = this.fillInChunks({
+        chunksToHighlight,
+        totalLength: sourceString ? sourceString.length : 0
+      });
+      return result;
+    };
+    /**
+        * Examine text for any matches.
+        * If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}).
+        * @return { start:number, end:number }[]
+    */
+    this.findChunks = _ref2 => {
+      let {
+        autoEscape,
+        caseSensitive,
+        searchWords,
+        sourceString
+      } = _ref2;
+      return searchWords.map(searchWord => typeof searchWord === 'string' ? {
+        text: searchWord
+      } : searchWord).filter(searchWord => searchWord.text) // Remove empty words
+      .reduce((chunks, searchWord) => {
+        let searchText = searchWord.text;
+        if (autoEscape) {
+          searchText = escapeRegExpFn(searchText);
+        }
+        const regex = new RegExp(searchText, caseSensitive ? 'g' : 'gi');
+        let match;
+        while (match = regex.exec(sourceString)) {
+          const start = match.index;
+          const end = regex.lastIndex;
+          if (end > start) {
+            chunks.push({
+              highlight: true,
+              start,
+              end,
+              className: searchWord.className,
+              style: searchWord.style
+            });
+          }
+          if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+          }
+        }
+        return chunks;
+      }, []);
+    };
+    /**
+    * Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks.
+    * @return {start:number, end:number}[]
+    */
+    this.combineChunks = _ref3 => {
+      let {
+        chunks
+      } = _ref3;
+      return chunks.sort((first, second) => first.start - second.start).reduce((processedChunks, nextChunk) => {
+        // First chunk just goes straight in the array...
+        if (processedChunks.length === 0) {
+          return [nextChunk];
+        } else {
+          // ... subsequent chunks get checked to see if they overlap...
+          const prevChunk = processedChunks.pop();
+          if (nextChunk.start <= prevChunk.end) {
+            // It may be the case that prevChunk completely surrounds nextChunk, so take the
+            // largest of the end indeces.
+            const endIndex = Math.max(prevChunk.end, nextChunk.end);
+            processedChunks.push({
+              highlight: true,
+              start: prevChunk.start,
+              end: endIndex,
+              className: prevChunk.className || nextChunk.className,
+              style: Object.assign(Object.assign({}, prevChunk.style), nextChunk.style)
+            });
+          } else {
+            processedChunks.push(prevChunk, nextChunk);
+          }
+          return processedChunks;
+        }
+      }, []);
+    };
+    /**
+    * Given a set of chunks to highlight, create an additional set of chunks
+    * to represent the bits of text between the highlighted text.
+    * @param chunksToHighlight {start:number, end:number}[]
+    * @param totalLength number
+    * @return {start:number, end:number, highlight:boolean}[]
+    */
+    this.fillInChunks = _ref4 => {
+      let {
+        chunksToHighlight,
+        totalLength
+      } = _ref4;
+      const allChunks = [];
+      const append = (start, end, highlight, className, style) => {
+        if (end - start > 0) {
+          allChunks.push({
+            start,
+            end,
+            highlight,
+            className,
+            style
+          });
+        }
+      };
+      if (chunksToHighlight.length === 0) {
+        append(0, totalLength, false);
+      } else {
+        let lastIndex = 0;
+        chunksToHighlight.forEach(chunk => {
+          append(lastIndex, chunk.start, false);
+          append(chunk.start, chunk.end, true, chunk.className, chunk.style);
+          lastIndex = chunk.end;
+        });
+        append(lastIndex, totalLength, false);
+      }
+      return allChunks;
+    };
+  }
+}

package/lib/es/jsonViewer/constants.d.ts

@@ -0,0 +1,4 @@
+declare const cssClasses: {
+    readonly PREFIX: "semi-json-viewer";
+};
+export { cssClasses };

package/lib/es/jsonViewer/constants.js

@@ -0,0 +1,5 @@
+import { BASE_CLASS_PREFIX } from "../base/constants";
+const cssClasses = {
+  PREFIX: `${BASE_CLASS_PREFIX}-json-viewer`
+};
+export { cssClasses };

package/lib/es/jsonViewer/foundation.d.ts

@@ -0,0 +1,24 @@
+import { JsonViewer, JsonViewerOptions } from '@douyinfe/semi-json-viewer-core';
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export type { JsonViewerOptions };
+export interface JsonViewerAdapter<P = Record<string, any>, S = Record<string, any>> extends DefaultAdapter<P, S> {
+    getEditorRef: () => HTMLElement;
+    getSearchRef: () => HTMLInputElement;
+    notifyChange: (value: string) => void;
+    notifyHover: (value: string, el: HTMLElement) => HTMLElement | undefined;
+    setSearchOptions: (key: string) => void;
+    showSearchBar: () => void;
+}
+declare class JsonViewerFoundation extends BaseFoundation<JsonViewerAdapter> {
+    constructor(adapter: JsonViewerAdapter);
+    jsonViewer: JsonViewer | null;
+    init(): void;
+    search(searchText: string): void;
+    prevSearch(): void;
+    nextSearch(): void;
+    replace(replaceText: string): void;
+    replaceAll(replaceText: string): void;
+    setSearchOptions(key: string): void;
+    showSearchBar(): void;
+}
+export default JsonViewerFoundation;

package/lib/es/jsonViewer/foundation.js

@@ -0,0 +1,62 @@
+import { JsonViewer } from '@douyinfe/semi-json-viewer-core';
+import BaseFoundation from '../base/foundation';
+class JsonViewerFoundation extends BaseFoundation {
+  constructor(adapter) {
+    super(Object.assign(Object.assign({}, JsonViewerFoundation), adapter));
+    this.jsonViewer = null;
+  }
+  init() {
+    const props = this.getProps();
+    const editorRef = this._adapter.getEditorRef();
+    this.jsonViewer = new JsonViewer(editorRef, props.value, props.options);
+    this.jsonViewer.layout();
+    this.jsonViewer.emitter.on('contentChanged', e => {
+      var _a;
+      this._adapter.notifyChange((_a = this.jsonViewer) === null || _a === void 0 ? void 0 : _a.getModel().getValue());
+      if (this.getState('showSearchBar')) {
+        this.search(this._adapter.getSearchRef().value);
+      }
+    });
+    this.jsonViewer.emitter.on('hoverNode', e => {
+      const el = this._adapter.notifyHover(e.value, e.target);
+      if (el) {
+        this.jsonViewer.emitter.emit('renderHoverNode', {
+          el
+        });
+      }
+    });
+  }
+  search(searchText) {
+    var _a;
+    const state = this.getState('searchOptions');
+    const {
+      caseSensitive,
+      wholeWord,
+      regex
+    } = state;
+    (_a = this.jsonViewer) === null || _a === void 0 ? void 0 : _a.getSearchWidget().search(searchText, caseSensitive, wholeWord, regex);
+  }
+  prevSearch() {
+    var _a;
+    (_a = this.jsonViewer) === null || _a === void 0 ? void 0 : _a.getSearchWidget().navigateResults(-1);
+  }
+  nextSearch() {
+    var _a;
+    (_a = this.jsonViewer) === null || _a === void 0 ? void 0 : _a.getSearchWidget().navigateResults(1);
+  }
+  replace(replaceText) {
+    var _a;
+    (_a = this.jsonViewer) === null || _a === void 0 ? void 0 : _a.getSearchWidget().replace(replaceText);
+  }
+  replaceAll(replaceText) {
+    var _a;
+    (_a = this.jsonViewer) === null || _a === void 0 ? void 0 : _a.getSearchWidget().replaceAll(replaceText);
+  }
+  setSearchOptions(key) {
+    this._adapter.setSearchOptions(key);
+  }
+  showSearchBar() {
+    this._adapter.showSearchBar();
+  }
+}
+export default JsonViewerFoundation;