TypeScript EditorState.acceptSelection方法代码示例

 (start, end) => {
     editorState = EditorState.acceptSelection(editorState, selection.merge({
         isBackward: false,
         anchorOffset: start,
         focusOffset: end,
     }));
     editorState = addHighlight(editorState, type, data, single);
     editorState = EditorState.push(editorState, editorState.getCurrentContent(), 'change-block-data');
     editorState = EditorState.acceptSelection(editorState, selection);
 });

export function changeEditorSelection(editorState, startOffset, endOffset, force) {
    const selection = editorState.getSelection();
    const {block: startBlock, newOffset: newStartOffset} = getBlockAndOffset(
        editorState, selection, startOffset, false);
    const {block: endBlock, newOffset: newEndOffset} = getBlockAndOffset(
        editorState, selection, endOffset, true);

    if (startBlock == null || endBlock == null) {
        return editorState;
    }

    const newSelection = selection.merge({
        anchorOffset: newStartOffset,
        anchorKey: startBlock.getKey(),
        focusOffset: newEndOffset,
        focusKey: endBlock.getKey(),
        isBackward: false,
    });

    if (force) {
        return EditorState.forceSelection(editorState, newSelection);
    }

    return EditorState.acceptSelection(editorState, newSelection);
}

    it("Knows if selection focus is in last character of block", () => {
      // Set the selection to end of last block
      const newSelection = editorState.getSelection().merge({
        anchorOffset: lastBlock.getLength(),
      })
      editorState = Draft.EditorState.acceptSelection(
        editorState,
        newSelection as any
      )

      const selection = getSelectionDetails(editorState)
      expect(selection.isLastCharacter).toBe(true)
      expect(selection.isFirstCharacter).toBe(false)
      expect(selection.anchorOffset).toBe(lastBlock.getLength())
    })

export const applySelectionToEditorState = (
  editorState,
  anchorOffset: number = 0
) => {
  const startSelection = editorState.getSelection()
  const startEditorState = editorState.getCurrentContent()
  const { key, text } = startEditorState.getFirstBlock()
  const selection = startSelection.merge({
    anchorKey: key,
    anchorOffset,
    focusKey: key,
    focusOffset: text.length,
  })
  const newEditorState = Draft.EditorState.acceptSelection(
    editorState,
    selection
  )
  return newEditorState
}

export function getSuggestionData(editorState, styleName) {
    const type = getHighlightType(styleName);
    const {selection, highlightedText} = getRangeAndTextForStyle(editorState, styleName);

    const data = {
        ...getHighlightData(editorState, styleName),
        suggestionText: highlightedText,
        selection: selection,
        styleName: styleName,
    };

    if (changeSuggestionsTypes.indexOf(type) === -1) {
        return data;
    }

    let peerStyleName = getHighlightStyleAtOffset(editorState, changeSuggestionsTypes, selection, 0, true);
    let afterPeer = true;

    if (!isPeerHighlight(editorState, peerStyleName, type, data.author)) {
        peerStyleName = getHighlightStyleAtOffset(editorState, changeSuggestionsTypes, selection, -1, false);
        if (!isPeerHighlight(editorState, peerStyleName, type, data.author)) {
            return data;
        }
        afterPeer = false;
    }

    const beforeSelection = selection.merge({
        anchorOffset: selection.getStartOffset(),
        anchorKey: selection.getStartKey(),
        focusOffset: selection.getStartOffset(),
        focusKey: selection.getStartKey(),
        isBackward: false,
    });
    const afterSelection = selection.merge({
        anchorOffset: selection.getEndOffset(),
        anchorKey: selection.getEndKey(),
        focusOffset: selection.getEndOffset(),
        focusKey: selection.getEndKey(),
        isBackward: false,
    });
    const beforeEditorState = EditorState.acceptSelection(editorState, beforeSelection);
    const afterEditorState = EditorState.acceptSelection(editorState, afterSelection);

    const peerRangeAndText = getRangeAndTextForStyle(afterPeer ? afterEditorState : beforeEditorState, peerStyleName);

    const suggestionSelection = selection.merge({
        anchorOffset: afterPeer ? selection.getStartOffset() : peerRangeAndText.selection.getStartOffset(),
        anchorKey: afterPeer ? selection.getStartKey() : peerRangeAndText.selection.getStartKey(),
        focusOffset: afterPeer ? peerRangeAndText.selection.getEndOffset() : selection.getEndOffset(),
        focusKey: afterPeer ? peerRangeAndText.selection.getEndKey() : selection.getEndKey(),
        isBackward: false,
    });

    if (type === 'ADD_SUGGESTION') {
        return {
            ...data,
            type: 'REPLACE_SUGGESTION',
            oldText: peerRangeAndText.highlightedText,
            selection: suggestionSelection,
        };
    }

    return {
        ...data,
        type: 'REPLACE_SUGGESTION',
        suggestionText: peerRangeAndText.highlightedText,
        oldText: data.suggestionText,
        selection: suggestionSelection,
    };
}