Upload folder using huggingface_hub

1e92f2d verified over 1 year ago

18.2 kB

import React from 'react'
import {
  DecoratedRange,
  Node,
  NodeEntry,
  Path,
  createEditor as slateCreateEditor,
  Editor,
  Text,
  Transforms,
} from 'slate'
import { act, render } from '@testing-library/react'
import {
  Slate,
  withReact,
  Editable,
  RenderLeafProps,
  ReactEditor,
} from '../src'

const renderLeaf = ({ leaf, attributes, children }: RenderLeafProps) => {
  const decorations = Object.keys(Node.extractProps(leaf)).sort()

  return (
    <span {...attributes} data-decorations={JSON.stringify(decorations)}>
      {children}
    </span>
  )
}

interface DecorateConfig {
  path: Path
  decorations: (node: Node) => (DecoratedRange & Record<string, unknown>)[]
}

const decoratePaths =
  (editor: ReactEditor, configs: DecorateConfig[]) =>
  ([node, path]: NodeEntry): DecoratedRange[] => {
    // Validate that decorate was called with a node matching the path
    if (Node.get(editor, path) !== node) {
      throw new Error('decorate was called with an incorrect node entry')
    }

    const matchingConfig = configs.find(({ path: p }) => Path.equals(path, p))
    if (!matchingConfig) return []

    return matchingConfig.decorations(node)
  }

const getDecoratedLeaves = (
  editor: ReactEditor,
  path: Path
): { text: string; decorations: string[] }[] => {
  const text = ReactEditor.toDOMNode(editor, Node.leaf(editor, path))
  const leaves = Array.from(text.children) as HTMLElement[]

  return leaves.map(leaf => ({
    text: leaf.textContent!,
    decorations: JSON.parse(leaf.dataset.decorations!),
  }))
}

// Pad children arrays with additional nodes to test whether decorations work
// correctly on chunked children
const otherNodes = () =>
  Array.from({ length: 7 }, () => ({ children: [{ text: '' }] }))

describe('decorations', () => {
  const withChunking = (chunking: boolean) => {
    const createEditor = () => {
      const editor = withReact(slateCreateEditor())

      if (chunking) {
        editor.getChunkSize = () => 2
      }

      return editor
    }

    describe('decorating initial value', () => {
      it('decorates part of a single text node', () => {
        const editor = createEditor()

        const initialValue = [
          { children: [{ text: 'Hello world!' }] },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [0, 0],
            decorations: () => [
              {
                anchor: { path: [0, 0], offset: 6 },
                focus: { path: [0, 0], offset: 11 },
                bold: true,
              },
            ],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'Hello ', decorations: [] },
          { text: 'world', decorations: ['bold'] },
          { text: '!', decorations: [] },
        ])
      })

      it('decorates an entire text node', () => {
        const editor = createEditor()

        const initialValue = [
          {
            children: [{ text: 'before' }, { text: 'bold' }, { text: 'after' }],
          },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [0, 1],
            decorations: () => [
              {
                ...Editor.range(editor, [0, 1]),
                bold: true,
              },
            ],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'before', decorations: [] },
        ])

        expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
          { text: 'bold', decorations: ['bold'] },
        ])

        expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
          { text: 'after', decorations: [] },
        ])
      })

      it('applies multiple overlapping decorations in a single text node', () => {
        const editor = createEditor()

        const initialValue = [
          { children: [{ text: 'Hello world!' }] },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [0, 0],
            decorations: () => [
              {
                anchor: { path: [0, 0], offset: 0 },
                focus: { path: [0, 0], offset: 11 },
                bold: true,
              },
              {
                anchor: { path: [0, 0], offset: 6 },
                focus: { path: [0, 0], offset: 12 },
                italic: true,
              },
            ],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'Hello ', decorations: ['bold'] },
          { text: 'world', decorations: ['bold', 'italic'] },
          { text: '!', decorations: ['italic'] },
        ])
      })

      it('passes down decorations from the parent element', () => {
        const editor = createEditor()

        const initialValue = [
          {
            children: [
              { text: 'before' },
              { text: 'middle' },
              { text: 'after' },
            ],
          },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [0],
            decorations: () => [
              {
                anchor: { path: [0, 0], offset: 2 },
                focus: { path: [0, 2], offset: 2 },
                bold: true,
              },
            ],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'be', decorations: [] },
          { text: 'fore', decorations: ['bold'] },
        ])

        expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
          { text: 'middle', decorations: ['bold'] },
        ])

        expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
          { text: 'af', decorations: ['bold'] },
          { text: 'ter', decorations: [] },
        ])
      })

      it('passes decorations down from the editor', () => {
        const editor = createEditor()

        const initialValue = [
          {
            children: [{ text: '0.0' }, { text: '0.1' }, { text: '0.2' }],
          },
          {
            children: [{ text: '1.0' }],
          },
          {
            children: [{ text: '2.0' }],
          },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [],
            decorations: () => [
              {
                anchor: { path: [0, 1], offset: 0 },
                focus: { path: [1, 0], offset: 3 },
                bold: true,
              },
            ],
          },
          {
            path: [0],
            decorations: () => [
              {
                ...Editor.range(editor, [0, 2]),
                italic: true,
              },
            ],
          },
          {
            path: [1, 0],
            decorations: () => [
              {
                ...Editor.range(editor, [1, 0]),
                underline: true,
              },
            ],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: '0.0', decorations: [] },
        ])

        expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
          { text: '0.1', decorations: ['bold'] },
        ])

        expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
          { text: '0.2', decorations: ['bold', 'italic'] },
        ])

        expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
          { text: '1.0', decorations: ['bold', 'underline'] },
        ])

        expect(getDecoratedLeaves(editor, [2, 0])).toEqual([
          { text: '2.0', decorations: [] },
        ])
      })
    })

    describe('redecorating', () => {
      it('redecorates all nodes when the decorate function changes', () => {
        const editor = createEditor()

        const initialValue = [
          {
            children: [{ text: '0.0' }, { text: '0.1' }, { text: '0.2' }],
          },
          {
            children: [{ text: '1.0' }, { text: '1.1' }, { text: '1.2' }],
          },
          ...otherNodes(),
        ]

        const decorate1 = decoratePaths(editor, [
          {
            path: [],
            decorations: () => [
              {
                ...Editor.range(editor, [0, 0]),
                bold: true,
              },
              {
                ...Editor.range(editor, [0, 1]),
                italic: true,
              },
            ],
          },
          {
            path: [1, 0],
            decorations: () => [
              {
                ...Editor.range(editor, [1, 0]),
                bold: true,
              },
            ],
          },
          {
            path: [1, 1],
            decorations: () => [
              {
                ...Editor.range(editor, [1, 1]),
                italic: true,
              },
            ],
          },
        ])

        const decorate2 = decoratePaths(editor, [
          {
            path: [0],
            decorations: () => [
              {
                ...Editor.range(editor, [0, 1]),
                underline: true,
              },
              {
                ...Editor.range(editor, [0, 2]),
                bold: true,
              },
            ],
          },
          {
            path: [1, 1],
            decorations: () => [
              {
                ...Editor.range(editor, [1, 1]),
                underline: true,
              },
            ],
          },
          {
            path: [1, 2],
            decorations: () => [
              {
                ...Editor.range(editor, [1, 2]),
                bold: true,
              },
            ],
          },
        ])

        const { rerender } = render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate1} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: '0.0', decorations: ['bold'] },
        ])

        expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
          { text: '0.1', decorations: ['italic'] },
        ])

        expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
          { text: '0.2', decorations: [] },
        ])

        expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
          { text: '1.0', decorations: ['bold'] },
        ])

        expect(getDecoratedLeaves(editor, [1, 1])).toEqual([
          { text: '1.1', decorations: ['italic'] },
        ])

        expect(getDecoratedLeaves(editor, [1, 2])).toEqual([
          { text: '1.2', decorations: [] },
        ])

        rerender(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate2} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: '0.0', decorations: [] },
        ])

        expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
          { text: '0.1', decorations: ['underline'] },
        ])

        expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
          { text: '0.2', decorations: ['bold'] },
        ])

        expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
          { text: '1.0', decorations: [] },
        ])

        expect(getDecoratedLeaves(editor, [1, 1])).toEqual([
          { text: '1.1', decorations: ['underline'] },
        ])

        expect(getDecoratedLeaves(editor, [1, 2])).toEqual([
          { text: '1.2', decorations: ['bold'] },
        ])
      })

      it('redecorates undecorated nodes when they change', async () => {
        const editor = createEditor()

        const initialValue = [
          { children: [{ text: 'The quick brown fox' }] },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [0, 0],
            decorations: node =>
              Text.isText(node) && node.text.includes('box')
                ? [
                    {
                      ...Editor.range(editor, [0, 0]),
                      bold: true,
                    },
                  ]
                : [],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'The quick brown fox', decorations: [] },
        ])

        await act(async () => {
          Transforms.insertText(editor, 'b', {
            at: {
              anchor: { path: [0, 0], offset: 16 },
              focus: { path: [0, 0], offset: 17 },
            },
          })
        })

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'The quick brown box', decorations: ['bold'] },
        ])
      })

      it('redecorates decorated nodes when they change', async () => {
        const editor = createEditor()

        const initialValue = [
          { children: [{ text: 'The quick brown box' }] },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [0, 0],
            decorations: node =>
              Text.isText(node) && node.text.includes('box')
                ? [
                    {
                      ...Editor.range(editor, [0, 0]),
                      bold: true,
                    },
                  ]
                : [],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'The quick brown box', decorations: ['bold'] },
        ])

        await act(async () => {
          Transforms.insertText(editor, 'f', {
            at: {
              anchor: { path: [0, 0], offset: 16 },
              focus: { path: [0, 0], offset: 17 },
            },
          })
        })

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'The quick brown fox', decorations: [] },
        ])
      })

      it('passes down new decorations from changed ancestors', async () => {
        const editor = createEditor()

        const initialValue = [
          {
            children: [
              { children: [{ text: 'Hello world!' }] },
              ...otherNodes(),
            ],
          },
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [0],
            decorations: node =>
              'bold' in node
                ? [
                    {
                      ...Editor.range(editor, [0, 0, 0]),
                      bold: true,
                    },
                  ]
                : [],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0, 0])).toEqual([
          { text: 'Hello world!', decorations: [] },
        ])

        await act(async () => {
          Transforms.setNodes(editor, { bold: true } as any, {
            at: [0],
          })
        })

        expect(getDecoratedLeaves(editor, [0, 0, 0])).toEqual([
          { text: 'Hello world!', decorations: ['bold'] },
        ])
      })

      it('does not redecorate unchanged nodes when their paths change', async () => {
        const editor = createEditor()

        const initialValue = [
          { children: [{ text: 'A' }] },
          { children: [{ text: 'B' }] },
          ...otherNodes(),
        ]

        const decorate = decoratePaths(editor, [
          {
            path: [1, 0],
            decorations: () => [
              {
                ...Editor.range(editor, [1, 0]),
                bold: true,
              },
            ],
          },
        ])

        render(
          <Slate editor={editor} initialValue={initialValue}>
            <Editable decorate={decorate} renderLeaf={renderLeaf} />
          </Slate>
        )

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: 'A', decorations: [] },
        ])

        expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
          { text: 'B', decorations: ['bold'] },
        ])

        await act(async () => {
          Transforms.insertNodes(
            editor,
            { children: [{ text: '0' }] },
            {
              at: [0],
            }
          )
        })

        expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
          { text: '0', decorations: [] },
        ])

        // A does not become bold even though it now matches the decoration
        expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
          { text: 'A', decorations: [] },
        ])

        // B remains bold even though it no longer matches the decoration
        expect(getDecoratedLeaves(editor, [2, 0])).toEqual([
          { text: 'B', decorations: ['bold'] },
        ])
      })
    })
  }

  describe('without chunking', () => {
    withChunking(false)
  })

  describe('with chunking', () => {
    withChunking(true)
  })
})

	import React from 'react'
	import {
	DecoratedRange,
	Node,
	NodeEntry,
	Path,
	createEditor as slateCreateEditor,
	Editor,
	Text,
	Transforms,
	} from 'slate'
	import { act, render } from '@testing-library/react'
	import {
	Slate,
	withReact,
	Editable,
	RenderLeafProps,
	ReactEditor,
	} from '../src'

	const renderLeaf = ({ leaf, attributes, children }: RenderLeafProps) => {
	const decorations = Object.keys(Node.extractProps(leaf)).sort()

	return (
	<span {...attributes} data-decorations={JSON.stringify(decorations)}>
	{children}
	</span>
	)
	}

	interface DecorateConfig {
	path: Path
	decorations: (node: Node) => (DecoratedRange & Record<string, unknown>)[]
	}

	const decoratePaths =
	(editor: ReactEditor, configs: DecorateConfig[]) =>
	([node, path]: NodeEntry): DecoratedRange[] => {
	// Validate that decorate was called with a node matching the path
	if (Node.get(editor, path) !== node) {
	throw new Error('decorate was called with an incorrect node entry')
	}

	const matchingConfig = configs.find(({ path: p }) => Path.equals(path, p))
	if (!matchingConfig) return []

	return matchingConfig.decorations(node)
	}

	const getDecoratedLeaves = (
	editor: ReactEditor,
	path: Path
	): { text: string; decorations: string[] }[] => {
	const text = ReactEditor.toDOMNode(editor, Node.leaf(editor, path))
	const leaves = Array.from(text.children) as HTMLElement[]

	return leaves.map(leaf => ({
	text: leaf.textContent!,
	decorations: JSON.parse(leaf.dataset.decorations!),
	}))
	}

	// Pad children arrays with additional nodes to test whether decorations work
	// correctly on chunked children
	const otherNodes = () =>
	Array.from({ length: 7 }, () => ({ children: [{ text: '' }] }))

	describe('decorations', () => {
	const withChunking = (chunking: boolean) => {
	const createEditor = () => {
	const editor = withReact(slateCreateEditor())

	if (chunking) {
	editor.getChunkSize = () => 2
	}

	return editor
	}

	describe('decorating initial value', () => {
	it('decorates part of a single text node', () => {
	const editor = createEditor()

	const initialValue = [
	{ children: [{ text: 'Hello world!' }] },
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [0, 0],
	decorations: () => [
	{
	anchor: { path: [0, 0], offset: 6 },
	focus: { path: [0, 0], offset: 11 },
	bold: true,
	},
	],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'Hello ', decorations: [] },
	{ text: 'world', decorations: ['bold'] },
	{ text: '!', decorations: [] },
	])
	})

	it('decorates an entire text node', () => {
	const editor = createEditor()

	const initialValue = [
	{
	children: [{ text: 'before' }, { text: 'bold' }, { text: 'after' }],
	},
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [0, 1],
	decorations: () => [
	{
	...Editor.range(editor, [0, 1]),
	bold: true,
	},
	],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'before', decorations: [] },
	])

	expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
	{ text: 'bold', decorations: ['bold'] },
	])

	expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
	{ text: 'after', decorations: [] },
	])
	})

	it('applies multiple overlapping decorations in a single text node', () => {
	const editor = createEditor()

	const initialValue = [
	{ children: [{ text: 'Hello world!' }] },
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [0, 0],
	decorations: () => [
	{
	anchor: { path: [0, 0], offset: 0 },
	focus: { path: [0, 0], offset: 11 },
	bold: true,
	},
	{
	anchor: { path: [0, 0], offset: 6 },
	focus: { path: [0, 0], offset: 12 },
	italic: true,
	},
	],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'Hello ', decorations: ['bold'] },
	{ text: 'world', decorations: ['bold', 'italic'] },
	{ text: '!', decorations: ['italic'] },
	])
	})

	it('passes down decorations from the parent element', () => {
	const editor = createEditor()

	const initialValue = [
	{
	children: [
	{ text: 'before' },
	{ text: 'middle' },
	{ text: 'after' },
	],
	},
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [0],
	decorations: () => [
	{
	anchor: { path: [0, 0], offset: 2 },
	focus: { path: [0, 2], offset: 2 },
	bold: true,
	},
	],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'be', decorations: [] },
	{ text: 'fore', decorations: ['bold'] },
	])

	expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
	{ text: 'middle', decorations: ['bold'] },
	])

	expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
	{ text: 'af', decorations: ['bold'] },
	{ text: 'ter', decorations: [] },
	])
	})

	it('passes decorations down from the editor', () => {
	const editor = createEditor()

	const initialValue = [
	{
	children: [{ text: '0.0' }, { text: '0.1' }, { text: '0.2' }],
	},
	{
	children: [{ text: '1.0' }],
	},
	{
	children: [{ text: '2.0' }],
	},
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [],
	decorations: () => [
	{
	anchor: { path: [0, 1], offset: 0 },
	focus: { path: [1, 0], offset: 3 },
	bold: true,
	},
	],
	},
	{
	path: [0],
	decorations: () => [
	{
	...Editor.range(editor, [0, 2]),
	italic: true,
	},
	],
	},
	{
	path: [1, 0],
	decorations: () => [
	{
	...Editor.range(editor, [1, 0]),
	underline: true,
	},
	],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: '0.0', decorations: [] },
	])

	expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
	{ text: '0.1', decorations: ['bold'] },
	])

	expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
	{ text: '0.2', decorations: ['bold', 'italic'] },
	])

	expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
	{ text: '1.0', decorations: ['bold', 'underline'] },
	])

	expect(getDecoratedLeaves(editor, [2, 0])).toEqual([
	{ text: '2.0', decorations: [] },
	])
	})
	})

	describe('redecorating', () => {
	it('redecorates all nodes when the decorate function changes', () => {
	const editor = createEditor()

	const initialValue = [
	{
	children: [{ text: '0.0' }, { text: '0.1' }, { text: '0.2' }],
	},
	{
	children: [{ text: '1.0' }, { text: '1.1' }, { text: '1.2' }],
	},
	...otherNodes(),
	]

	const decorate1 = decoratePaths(editor, [
	{
	path: [],
	decorations: () => [
	{
	...Editor.range(editor, [0, 0]),
	bold: true,
	},
	{
	...Editor.range(editor, [0, 1]),
	italic: true,
	},
	],
	},
	{
	path: [1, 0],
	decorations: () => [
	{
	...Editor.range(editor, [1, 0]),
	bold: true,
	},
	],
	},
	{
	path: [1, 1],
	decorations: () => [
	{
	...Editor.range(editor, [1, 1]),
	italic: true,
	},
	],
	},
	])

	const decorate2 = decoratePaths(editor, [
	{
	path: [0],
	decorations: () => [
	{
	...Editor.range(editor, [0, 1]),
	underline: true,
	},
	{
	...Editor.range(editor, [0, 2]),
	bold: true,
	},
	],
	},
	{
	path: [1, 1],
	decorations: () => [
	{
	...Editor.range(editor, [1, 1]),
	underline: true,
	},
	],
	},
	{
	path: [1, 2],
	decorations: () => [
	{
	...Editor.range(editor, [1, 2]),
	bold: true,
	},
	],
	},
	])

	const { rerender } = render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate1} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: '0.0', decorations: ['bold'] },
	])

	expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
	{ text: '0.1', decorations: ['italic'] },
	])

	expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
	{ text: '0.2', decorations: [] },
	])

	expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
	{ text: '1.0', decorations: ['bold'] },
	])

	expect(getDecoratedLeaves(editor, [1, 1])).toEqual([
	{ text: '1.1', decorations: ['italic'] },
	])

	expect(getDecoratedLeaves(editor, [1, 2])).toEqual([
	{ text: '1.2', decorations: [] },
	])

	rerender(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate2} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: '0.0', decorations: [] },
	])

	expect(getDecoratedLeaves(editor, [0, 1])).toEqual([
	{ text: '0.1', decorations: ['underline'] },
	])

	expect(getDecoratedLeaves(editor, [0, 2])).toEqual([
	{ text: '0.2', decorations: ['bold'] },
	])

	expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
	{ text: '1.0', decorations: [] },
	])

	expect(getDecoratedLeaves(editor, [1, 1])).toEqual([
	{ text: '1.1', decorations: ['underline'] },
	])

	expect(getDecoratedLeaves(editor, [1, 2])).toEqual([
	{ text: '1.2', decorations: ['bold'] },
	])
	})

	it('redecorates undecorated nodes when they change', async () => {
	const editor = createEditor()

	const initialValue = [
	{ children: [{ text: 'The quick brown fox' }] },
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [0, 0],
	decorations: node =>
	Text.isText(node) && node.text.includes('box')
	? [
	{
	...Editor.range(editor, [0, 0]),
	bold: true,
	},
	]
	: [],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'The quick brown fox', decorations: [] },
	])

	await act(async () => {
	Transforms.insertText(editor, 'b', {
	at: {
	anchor: { path: [0, 0], offset: 16 },
	focus: { path: [0, 0], offset: 17 },
	},
	})
	})

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'The quick brown box', decorations: ['bold'] },
	])
	})

	it('redecorates decorated nodes when they change', async () => {
	const editor = createEditor()

	const initialValue = [
	{ children: [{ text: 'The quick brown box' }] },
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [0, 0],
	decorations: node =>
	Text.isText(node) && node.text.includes('box')
	? [
	{
	...Editor.range(editor, [0, 0]),
	bold: true,
	},
	]
	: [],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'The quick brown box', decorations: ['bold'] },
	])

	await act(async () => {
	Transforms.insertText(editor, 'f', {
	at: {
	anchor: { path: [0, 0], offset: 16 },
	focus: { path: [0, 0], offset: 17 },
	},
	})
	})

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'The quick brown fox', decorations: [] },
	])
	})

	it('passes down new decorations from changed ancestors', async () => {
	const editor = createEditor()

	const initialValue = [
	{
	children: [
	{ children: [{ text: 'Hello world!' }] },
	...otherNodes(),
	],
	},
	]

	const decorate = decoratePaths(editor, [
	{
	path: [0],
	decorations: node =>
	'bold' in node
	? [
	{
	...Editor.range(editor, [0, 0, 0]),
	bold: true,
	},
	]
	: [],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0, 0])).toEqual([
	{ text: 'Hello world!', decorations: [] },
	])

	await act(async () => {
	Transforms.setNodes(editor, { bold: true } as any, {
	at: [0],
	})
	})

	expect(getDecoratedLeaves(editor, [0, 0, 0])).toEqual([
	{ text: 'Hello world!', decorations: ['bold'] },
	])
	})

	it('does not redecorate unchanged nodes when their paths change', async () => {
	const editor = createEditor()

	const initialValue = [
	{ children: [{ text: 'A' }] },
	{ children: [{ text: 'B' }] },
	...otherNodes(),
	]

	const decorate = decoratePaths(editor, [
	{
	path: [1, 0],
	decorations: () => [
	{
	...Editor.range(editor, [1, 0]),
	bold: true,
	},
	],
	},
	])

	render(
	<Slate editor={editor} initialValue={initialValue}>
	<Editable decorate={decorate} renderLeaf={renderLeaf} />
	</Slate>
	)

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: 'A', decorations: [] },
	])

	expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
	{ text: 'B', decorations: ['bold'] },
	])

	await act(async () => {
	Transforms.insertNodes(
	editor,
	{ children: [{ text: '0' }] },
	{
	at: [0],
	}
	)
	})

	expect(getDecoratedLeaves(editor, [0, 0])).toEqual([
	{ text: '0', decorations: [] },
	])

	// A does not become bold even though it now matches the decoration
	expect(getDecoratedLeaves(editor, [1, 0])).toEqual([
	{ text: 'A', decorations: [] },
	])

	// B remains bold even though it no longer matches the decoration
	expect(getDecoratedLeaves(editor, [2, 0])).toEqual([
	{ text: 'B', decorations: ['bold'] },
	])
	})
	})
	}

	describe('without chunking', () => {
	withChunking(false)
	})

	describe('with chunking', () => {
	withChunking(true)
	})
	})