TypeError: Cannot read property 'key' of null
./packages/slate-lists/src/commands/decrease-list-item-depth.js:8:49
   5 | 
   6 | const listItem = document.getParent(startBlock.key);
   7 | const list = document.getParent(listItem.key);
>  8 | const parentListItem = document.getParent(list.key);
   9 | if (parentListItem.type != blocks.list_item) return;
  10 | const parentList = document.getParent(parentListItem.key);
  11 | 

Not sure if we should be checking for whether the block is a list item in the event handler, or if that's something that we should guard against behind the scenes.

Perhaps this involves disabling indent/outdent buttons when on a non-list block in the example. #25 could help with this?

clicking the numbered list button just cancels the list. I assume the toggle needs to check the list type

Is it possible to change the order list to have multilevel numbering like:

That would be more user friendly and easy to read.

I'm following the example for slate-code but no highlighting occurs, and the following warnings are reported in the console:

As of [email protected], the `leaves` property of Text nodes has been removed. Instead, each text node contains a string of text and a unique set of marks and leaves are unnecessary.

As of [email protected] the `decoration.mark` property has been changed to `decoration.type` and `decoration.data` directly. 

Can't find anything in the docs restricting the plugin to a specific version of Slate, or am I missing something? I guess the API for Slate is still subject to sudden changes.

The whole table becomes a list item instead of the selection in the table cell.

Here is a CodeSandbox example: https://codesandbox.io/s/slate-1evfo

Perhaps I'm the only one using an online editor that allows editing of tables and lists inside of them :-O

If the container of the list is inside another block node, the behavior of wrapList seems incorrect. If, for example, your schema looks like section -> paragraph -> unordered-list. Calling wrapList when the cursor is in the paragraph will eliminate the entire section node.

This could be handled by a separate plugin, like an updated version of slate-when

Version: "^0.2.5"
We have recently adopted this lib for our editor. Here is the sample code that we have previously generated using default list

<ul><li><span><strong>A: </strong></span><span>content A</span></li><li><span><strong>B: </strong></span><span>content B</span></li><li><span><strong>C: </strong></span><span>Content C</span></li><li><span><strong>D: </strong></span><span>Content D</span></li></ul>

After the rendering with this plugin, some of the content were lost, the html becomes

<ul class="unordered-list" data-key="25"><li class="list-item" data-key="26"><div class="list-item-child" data-key="69"><span data-key="27"><span data-slate-leaf="true" data-offset-key="27:0"><span><strong><span data-slate-content="true">A: </span></strong></span></span></span></div></li><li class="list-item" data-key="29"><div class="list-item-child" data-key="68"><span data-key="30"><span data-slate-leaf="true" data-offset-key="30:0"><span><strong><span data-slate-content="true">B: </span></strong></span></span></span></div></li><li class="list-item" data-key="32"><div class="list-item-child" data-key="67"><span data-key="33"><span data-slate-leaf="true" data-offset-key="33:0"><span><strong><span data-slate-content="true">C: </span></strong></span></span></span></div></li><li class="list-item" data-key="35"><div class="list-item-child" data-key="66"><span data-key="36"><span data-slate-leaf="true" data-offset-key="36:0"><span><strong><span data-slate-content="true">D: </span></strong></span></span></span></div></li></ul>

All the Contents span are gone as show in screenshot:

If we add a div to each li element, it seems to be working. Below is an example:

<ul><li><div><span><strong>A: </strong></span><span>Content A</span></div></li><li><div><span><strong>B: </strong></span><span>Content B</span></div></li><li><div><span><strong>C: </strong></span><span>Content C</span></div></li><li><div><span><strong>D: </strong></span><span>Content D</span></div></li></ul>

@brendancarney
First, I want to thank you on the plugins, it's very helpful to see how others build their slate editor.
I'm interested in the implementation of the testing library. It would be great if you can expend that.

Thank you.

The example of blockquotes crashes after placing the cursor at the end of the only quote, and pressing enter:

This seems to happen while the loading of the page is not yet complete.

I'm running Chrome 78.0.3904.70 in Ubuntu 18.04

I just found your repo and I like the concept of slate-keymap. I looked at the code and have two comments:

• Would it not be better to map hotkeys to a canonical string, and use a map to match handlers? Now each keystroke performs a linear search.
• How about string handlers that just call an editor command? See https://docs.slatejs.org/guides/plugins#register-commands-and-queries - E.g. "ctrl+i": 'insertImage'

the onKeyDown example on slate-code's doc only return next() inside the ctrlKey check therefore some keys are not handled properly see https://slate-js.slack.com/archives/C1RH7AXSS/p1553824026021400

Hey! Thanks for this really cool plugin!
Would you accept a pr to export these functions as utils from the list package?

  const isListItem = block => block && block.type == blocks.list_item;

  const getListItem = (editor, block) => {
    const possibleListItem = editor.value.document.getParent(block.key);

    return isListItem(possibleListItem) ? possibleListItem : null;
  };

  const isList = block =>
    block &&
    (block.type == blocks.unordered_list || block.type == blocks.ordered_list);

  const getList = (editor, block) => {
    const possibleList = editor.value.document.getParent(block.key);
    return isList(possibleList) ? possibleList : null;
  };

I need these utils in order to be able to show an active status in my editor :)

Not sure if bug or not, i.e if we or this plugin should prevent Shift+Enter event..

If caret is in list-item-child which is not empty and you press Shift+Enter, new list-item-child with zero-width element is created and appended to same line and you need to press Shift+Enter again to make another list-item-child which finally appreas on next line.

I've found at least 3 bugs (and would probably find more) related to Shift+Enter and list-item-child which leads me to belive that Shift+Enter and multi-line list items are not intended features..

I tried the demo in documentation.

Awesome plugins by the way! I might use the list one if this issue gets resolved.

How to reproduce:

• Go to list docs
• Drop caret into either Subitem 2 or Item 2
• If Item 2, increasing depth deletes the item
• If Subitem 2, decrease depth and if then increased, item gets deleted

It also seems that if you repeat Subitem 2 steps for middle list item in a sub-list that has more than 2 items, all list items after that one get deleted after depth increase. Don't remember seeing this bug before.

Ubuntu, Chromium (can't test it on other platforms at the moment)

When deserializing some html so that it can be used with a slatejs editor inner list-items are lost. Using the following sample html:

<ol>
  <li>
    one
    <ol>
      <li>
         two
      </li>
    </ol>
  </li>
</ol>

Here, the ordered list within the list-item containing "one" will be lost as this seems to be part of the slate architecture.

Looking at the above sample code, wrapping the "one" in a div (as part of the deserialization process) will preserve the inner ordered list, but now the list slate-list-plugin will not work as intended - the plugin will not allow you to add or remove new list-items and does not seem to recognize the structure as a list because the inner list-item "two" will now also be wrapped in a div.

When loading some Value like the following into the editor, however, everything works as intended and the above issue is not encountered (like in the example):

{"object":"value","document":{"object":"document","data":{},"nodes":[{"object":"block","type":"ordered-list","data":{},"nodes":[{"object":"block","type":"list-item","data":{},"nodes":[{"object":"block","type":"list-item-child","data":{},"nodes":[{"object":"text","leaves":[{"object":"leaf","text":"one","marks":[]}]}]},{"object":"block","type":"ordered-list","data":{},"nodes":[{"object":"block","type":"list-item","data":{},"nodes":[{"object":"block","type":"list-item-child","data":{},"nodes":[{"object":"text","leaves":[{"object":"leaf","text":"two","marks":[]}]}]}]}]}]}]}]}}

Was looking through the codebase for a sample deserialization method but could not find one, but this seems to be an issue with deserialization.

I'm getting the following warning when using the lists plugin:

As of [email protected], the `getNodesAtRange` method has been renamed to `getDescendantsAtRange`.

I looked at fixing it but it seems doing so would be a breaking change for this library since it would change the Slate version, but I'm unsure.

This provides a few benefits:

• Can use React and convenient slate values in the same file
• No transpilation required to create a slate value
• Users don't need to use slate-hyperscript directly

Here's a potential API. The naming will almost surely change as I don't like it right now.

const structure = {
  blocks: {
    paragraph: "paragraph"
  },
  marks: {
    bold: "bold"
  }
}  

const { editor, html } = SlateTest({ plugins: Code() }, { structure });

const value = html`
  <paragraph>
    Some sample <bold>text</bold>
  </paragraph>
`

A few open questions:

• Should this be completely outside of the SlateTest function? In other words, should it be a separate import?
• The html name could be confusing, but it does automatically get you syntax highlighting depending on your editor setup.

Is there complete example around? Maybe codepen?

I was wondering if you wanted to add line count as well. I did on my project and thought it was worth asking if it's a feature you would want. If so I can send a PR for it, it's pretty small to be honest. Let me know!

I think there might be some missing normalization rules for slate-lists, but haven't had the time to dig into all of it yet. I know at the very least that by highlighting list items and dragging around, I can get my editor into weird states where list-item-child blocks don't have child text nodes.

Not sure what others are missing/leading to three bullets showing on the same line. A little gif tinkering with the documentation example for a couple seconds. The flash to white at the end is actually the page crashing with the exception below.

By current I mean the list item where caret is located when Delete is pressed.

I should also note that depth doesn't play any role with Delete, next or previous list items are literally visually next and previous, even if different depth (I don't have a problem with that).

Good cases:

• If current and next item have content, next item is deleted and its content is appended to current's
• If current has content and next is empty, next list item is just deleted
• If current is last item in list and has content, nothing happens after Delete

Bad cases:
Why bad? I personally don't care about Delete functionality at all but it would be nice if it worked properly if it's already there. From list documentation:

Delete or Backspace at the start of an item: remove the item

• If two empty list items are next to each other, pressing Delete moves caret to other empty item, this behavior repeats if Delete is pressed again, nothing gets removed
• If current is last and empty item in list, caret is moved to previous list item, last empty item only gets removed when Delete is pressed again (when caret is in previous item)
• If current is first and empty item in list, caret is moved off the list (previous block) and I get two list bullets side-by-side situation, few frames later, I get the following error:

These descriptions might get pretty cryptic, my apologies.

I found it counter-intuitive to use the " " for space event, what do you think about changing it to "Space"?

Select text as below:

Click decrease depth:

Is there going to be an upgrade to slate v0.5? Really hoping so. Cheers

Currently only building ES module builds

This is useful for e.g. button bars
Not sure what to call it, isList, hasList, inList?

	queries: {
		isList: editor => !!getListItem(editor, editor.value.startBlock)
	}

getListItem will then need a guard for undefined block

Hey @brendancarney thanks for this plugin! I'm fairly new to Slate and I was having a hard time understanding how to enable a block of code. I am having fun with Slate creating useful shortcuts, maybe it could be a good idea to expand the docs to instruct different ways of enabling code blocks when typing. Maybe that will be a simpler example than having a context menu. Once I have something working I might just send a PR your way if that's ok!

I mean after you get around how things come together in Slate it feels pretty straightforward, but an example with actual code wouldn't hurt.

After copy-pasting, sometimes the list structure is lost, and pressing Enter does not start a new list item bullet:
I suspect this is because copy-pasting introduces paragraphs, which are not dealt with in the normalization of slate-lists.

Expected behavior:

Should strip all paragraphs insidelist-item-child elements, so that the list structure behaviour is not affected.

Copy & paste a list item entry results to wrong indentation which leads to an error in schema. See