Support latest version of Slate

lib/changes/decreaseItemDepth.js

@@ -46,29 +46,28 @@ function decreaseItemDepth(opts: Options, change: Change): Change {
             data: currentList.data
         });
         // Add the sublist
-        change.insertNodeByKey(
-            currentItem.key,
-            currentItem.nodes.size,
-            sublist,
-            { normalize: false }
-        );
-
-        change.moveNodeByKey(
-            currentItem.key,
-            parentList.key,
-            parentList.nodes.indexOf(parentItem) + 1,
-            { normalize: false }
-        );
+        change.withoutNormalizing(() => {
+            change.insertNodeByKey(
+                currentItem.key,
+                currentItem.nodes.size,
+                sublist
+            );
 
-        // Move the followingItems to the sublist
-        followingItems.forEach((item, index) =>
             change.moveNodeByKey(
-                item.key,
-                sublist.key,
-                sublist.nodes.size + index,
-                { normalize: false }
-            )
-        );
+                currentItem.key,
+                parentList.key,
+                parentList.nodes.indexOf(parentItem) + 1
+            );
+
+            // Move the followingItems to the sublist
+            followingItems.forEach((item, index) =>
+                change.moveNodeByKey(
+                    item.key,
+                    sublist.key,
+                    sublist.nodes.size + index
+                )
+            );
+        });
     } else {
         change.moveNodeByKey(
             currentItem.key,

lib/changes/increaseItemDepth.js

@@ -67,11 +67,10 @@ function moveAsSubItem(
         data: currentList.data
     });
 
-    change.insertNodeByKey(destKey, lastIndex, newSublist, {
-        normalize: false
+    return change.withoutNormalizing(() => {
+        change.insertNodeByKey(destKey, lastIndex, newSublist);
+        change.moveNodeByKey(item.key, newSublist.key, 0);
     });
-
-    return change.moveNodeByKey(item.key, newSublist.key, 0);
 }
 
 export default increaseItemDepth;

lib/changes/splitListItem.js

@@ -14,11 +14,12 @@ function splitListItem(opts: Options, change: Change): Change {
         return change;
     }
 
-    const splitOffset = value.startOffset;
+    const { start } = value.selection;
+    const splitOffset = start.offset;
 
     return change.splitDescendantsByKey(
         currentItem.key,
-        value.startKey,
+        start.key,
         splitOffset
     );
 }

lib/changes/unwrapList.js

@@ -14,33 +14,29 @@ function unwrapList(opts: Options, change: Change): Change {
         return change;
     }
 
-    // Unwrap the items from their list
-    items.forEach(item =>
-        change.unwrapNodeByKey(item.key, { normalize: false })
-    );
-
-    // Parent of the list of the items
-    const firstItem = items.first();
-    const parent = change.value.document.getParent(firstItem.key);
-
-    let index = parent.nodes.findIndex(node => node.key === firstItem.key);
-
-    // Unwrap the items' children
-    items.forEach(item => {
-        item.nodes.forEach(node => {
-            change.moveNodeByKey(node.key, parent.key, index, {
-                normalize: false
-            });
-            index += 1;
-        });
-    });
+    return change.withoutNormalizing(() => {
+        // Unwrap the items from their list
+        items.forEach(item => change.unwrapNodeByKey(item.key));
+
+        // Parent of the list of the items
+        const firstItem = items.first();
+        const parent = change.value.document.getParent(firstItem.key);
+
+        let index = parent.nodes.findIndex(node => node.key === firstItem.key);
 
-    // Finally, remove the now empty items
-    items.forEach(item =>
-        change.removeNodeByKey(item.key, { normalize: false })
-    );
+        // Unwrap the items' children
+        items.forEach(item =>
+            item.nodes.forEach(node => {
+                change.moveNodeByKey(node.key, parent.key, index);
+                index += 1;
+            })
+        );
 
-    return change;
+        // Finally, remove the now empty items
+        items.forEach(item => change.removeNodeByKey(item.key));
+
+        return change;
+    });
 }
 
 export default unwrapList;

lib/changes/wrapInList.js

@@ -18,27 +18,22 @@ function wrapInList(
     const selectedBlocks = getHighestSelectedBlocks(change.value);
     type = type || opts.types[0];
 
-    // Wrap in container
-    change.wrapBlock(
-        {
+    change.withoutNormalizing(() => {
+        // Wrap in container
+        change.wrapBlock({
             type,
             data: Data.create(data)
-        },
-        { normalize: false }
-    );
-
-    // Wrap in list items
-    selectedBlocks.forEach(node => {
-        if (isList(opts, node)) {
-            // Merge its items with the created list
-            node.nodes.forEach(({ key }) =>
-                change.unwrapNodeByKey(key, { normalize: false })
-            );
-        } else {
-            change.wrapBlockByKey(node.key, opts.typeItem, {
-                normalize: false
-            });
-        }
+        });
+
+        // Wrap in list items
+        selectedBlocks.forEach(node => {
+            if (isList(opts, node)) {
+                // Merge its items with the created list
+                node.nodes.forEach(({ key }) => change.unwrapNodeByKey(key));
+            } else {
+                change.wrapBlockByKey(node.key, opts.typeItem);
+            }
+        });
     });
 
     return change.normalize();
@@ -51,8 +46,8 @@ function getHighestSelectedBlocks(value: Value): List<Block> {
     const range = value.selection;
     const { document } = value;
 
-    const startBlock = document.getClosestBlock(range.startKey);
-    const endBlock = document.getClosestBlock(range.endKey);
+    const startBlock = document.getClosestBlock(range.start.key);
+    const endBlock = document.getClosestBlock(range.end.key);
 
     if (startBlock === endBlock) {
         return List([startBlock]);
@@ -61,7 +56,7 @@ function getHighestSelectedBlocks(value: Value): List<Block> {
     const startPath = ancestor.getPath(startBlock.key);
     const endPath = ancestor.getPath(endBlock.key);
 
-    return ancestor.nodes.slice(startPath[0], endPath[0] + 1);
+    return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);
 }
 
 export default wrapInList;

lib/core.js

@@ -1,6 +1,6 @@
 // @flow
 import Options, { type OptionsFormat } from './options';
-import { schema, validateNode } from './validation';
+import { schema, normalizeNode } from './validation';
 import {
     wrapInList,
     unwrapList,
@@ -33,7 +33,7 @@ function core(
 
     return {
         schema: schema(opts),
-        validateNode: validateNode(opts),
+        normalizeNode: normalizeNode(opts),
 
         utils: {
             getCurrentItem: getCurrentItem.bind(null, opts),

lib/handlers/onBackspace.js

@@ -15,16 +15,17 @@ function onBackspace(
     opts: Options
 ): void | any {
     const { value } = change;
-    const { startOffset, selection } = value;
+    const { selection } = value;
+    const { start, isCollapsed, isExpanded } = selection;
 
     // Only unwrap...
     // ... with a collapsed selection
-    if (selection.isExpanded) {
+    if (isExpanded) {
         return undefined;
     }
 
     // ... when at the beginning of nodes
-    if (startOffset > 0) {
+    if (start.offset > 0) {
         return undefined;
     }
     // ... in a list
@@ -33,7 +34,7 @@ function onBackspace(
         return undefined;
     }
     // ... more precisely at the beginning of the current item
-    if (!selection.isAtStartOf(currentItem)) {
+    if (!isCollapsed || !start.isAtStartOfNode(currentItem)) {
         return undefined;
     }
 

lib/handlers/onEnter.js

@@ -35,11 +35,11 @@ function onEnter(
     event.preventDefault();
 
     // If expanded, delete first.
-    if (value.isExpanded) {
+    if (value.selection.isExpanded) {
         change.delete();
     }
 
-    if (currentItem.isEmpty) {
+    if (!value.schema.isVoid(currentItem) && currentItem.text === '') {
         // Block is empty, we exit the list
         if (getItemDepth(opts, value) > 1) {
             return decreaseItemDepth(opts, change);

lib/handlers/onTab.js

@@ -12,22 +12,20 @@ import { getCurrentItem } from '../utils';
  */
 function onTab(event: *, change: Change, editor: *, opts: Options): void | any {
     const { value } = change;
-    const { isCollapsed } = value;
+    const { isCollapsed } = value.selection;
 
     if (!isCollapsed || !getCurrentItem(opts, value)) {
         return undefined;
     }
 
+    event.preventDefault();
+
     // Shift+tab reduce depth
     if (event.shiftKey) {
-        event.preventDefault();
-
         return decreaseItemDepth(opts, change);
     }
 
     // Tab increases depth
-    event.preventDefault();
-
     return increaseItemDepth(opts, change);
 }
 

lib/index.js

@@ -19,7 +19,6 @@ function EditList(
 
     return {
         ...corePlugin,
-
         onKeyDown: onKeyDown.bind(null, opts)
     };
 }

lib/options.js

@@ -20,10 +20,13 @@ class Options extends Record({
 }) {
     // The possibles types for list containers
     types: string[];
+
     // The type of list items
     typeItem: string;
+
     // The type of default block in items
     typeDefault: string;
+
     // You can control here the automatic merging of adjacent lists
     canMerge: (listA: Node, listB: Node) => boolean;
 }

lib/utils/getCurrentItem.js

@@ -9,7 +9,7 @@ function getCurrentItem(opts: Options, value: Value, block?: Block): ?Block {
     const { document } = value;
 
     if (!block) {
-        if (!value.selection.startKey) return null;
+        if (!value.selection.start.key) return null;
         block = value.startBlock;
     }
 

lib/utils/getItemsAtRange.js

@@ -19,14 +19,14 @@ function getItemsAtRange(
 ): List<Block> {
     range = range || value.selection;
 
-    if (!range.startKey) {
+    if (!range.start.key) {
         return List();
     }
 
     const { document } = value;
 
-    const startBlock = document.getClosestBlock(range.startKey);
-    const endBlock = document.getClosestBlock(range.endKey);
+    const startBlock = document.getClosestBlock(range.start.key);
+    const endBlock = document.getClosestBlock(range.end.key);
 
     if (startBlock === endBlock) {
         const item = getCurrentItem(opts, value, startBlock);
@@ -39,11 +39,14 @@ function getItemsAtRange(
         const startPath = ancestor.getPath(startBlock.key);
         const endPath = ancestor.getPath(endBlock.key);
 
-        return ancestor.nodes.slice(startPath[0], endPath[0] + 1);
-    } else if (ancestor.type === opts.typeItem) {
+        return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);
+    }
+
+    if (ancestor.type === opts.typeItem) {
         // The ancestor is the highest list item that covers the range
         return List([ancestor]);
     }
+
     // No list of items can cover the range
     return List();
 }

lib/validation/index.js

@@ -1,4 +1,4 @@
 import schema from './schema';
-import validateNode from './validateNode';
+import normalizeNode from './normalizeNode';
 
-export { schema, validateNode };
+export { schema, normalizeNode };