File size: 3,602 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
import { createContext, useCallback, useContext, useMemo, useRef } from 'react'
import { Editor } from 'slate'
import { useIsomorphicLayoutEffect } from './use-isomorphic-layout-effect'
import { useSlateStatic } from './use-slate-static'
import { useGenericSelector } from './use-generic-selector'
type Callback = () => void
export interface SlateSelectorOptions {
/**
* If true, defer calling the selector function until after `Editable` has
* finished rendering. This ensures that `ReactEditor.findPath` won't return
* an outdated path if called inside the selector.
*/
deferred?: boolean
}
/**
* A React context for sharing the editor selector context in a way to control
* re-renders.
*/
export const SlateSelectorContext = createContext<{
addEventListener: (
callback: Callback,
options?: SlateSelectorOptions
) => () => void
flushDeferred: () => void
}>({} as any)
const refEquality = (a: any, b: any) => a === b
/**
* Use redux style selectors to prevent re-rendering on every keystroke.
*
* Bear in mind re-rendering can only prevented if the returned value is a value
* type or for reference types (e.g. objects and arrays) add a custom equality
* function.
*
* If `selector` is memoized using `useCallback`, then it will only be called
* when it or the editor state changes. Otherwise, `selector` will be called
* every time the component renders.
*
* @example
* const isSelectionActive = useSlateSelector(editor => Boolean(editor.selection))
*/
export function useSlateSelector<T>(
selector: (editor: Editor) => T,
equalityFn: (a: T | null, b: T) => boolean = refEquality,
{ deferred }: SlateSelectorOptions = {}
): T {
const context = useContext(SlateSelectorContext)
if (!context) {
throw new Error(
`The \`useSlateSelector\` hook must be used inside the <Slate> component's context.`
)
}
const { addEventListener } = context
const editor = useSlateStatic()
const genericSelector = useCallback(
() => selector(editor),
[editor, selector]
)
const [selectedState, update] = useGenericSelector(
genericSelector,
equalityFn
)
useIsomorphicLayoutEffect(() => {
const unsubscribe = addEventListener(update, { deferred })
update()
return unsubscribe
}, [addEventListener, update, deferred])
return selectedState
}
/**
* Create selector context with editor updating on every editor change
*/
export function useSelectorContext() {
const eventListeners = useRef(new Set<Callback>())
const deferredEventListeners = useRef(new Set<Callback>())
const onChange = useCallback(() => {
eventListeners.current.forEach(listener => listener())
}, [])
const flushDeferred = useCallback(() => {
deferredEventListeners.current.forEach(listener => listener())
deferredEventListeners.current.clear()
}, [])
const addEventListener = useCallback(
(
callbackProp: Callback,
{ deferred = false }: SlateSelectorOptions = {}
) => {
const callback = deferred
? () => deferredEventListeners.current.add(callbackProp)
: callbackProp
eventListeners.current.add(callback)
return () => {
eventListeners.current.delete(callback)
}
},
[]
)
const selectorContext = useMemo(
() => ({
addEventListener,
flushDeferred,
}),
[addEventListener, flushDeferred]
)
return { selectorContext, onChange }
}
export function useFlushDeferredSelectorsOnRender() {
const { flushDeferred } = useContext(SlateSelectorContext)
useIsomorphicLayoutEffect(flushDeferred)
}
|