Optimize hooks a little

packages/leyden-react/src/hooks/useAreCoordinatesSelected.ts

@@ -0,0 +1,29 @@
+import { Coordinates, LeydenEditor } from 'leyden';
+import { useEffect, useState } from 'react';
+
+import { useLeydenStatic } from './useLeydenStatic';
+
+export const useAreCoordinatesSelected = (coords: Coordinates|null): boolean => {
+    const editor = useLeydenStatic();
+    const currentSelectedCoords = LeydenEditor.selectedCoords(editor);
+    const [coordinatesSelected, setCoordinatesSelected] = useState(
+        (coords && currentSelectedCoords) ?
+            Coordinates.equals(currentSelectedCoords, coords) :
+            false
+    );
+
+    useEffect(() => {
+        const unsubscribe = LeydenEditor.subscribeToSelectedCoordinatesByCoordinates(
+            editor,
+            setCoordinatesSelected,
+            {
+                at: coords
+            },
+        );
+        return () => {
+            unsubscribe();
+        };
+    }, []);
+
+    return coordinatesSelected;
+};

packages/leyden-react/src/hooks/useCellIsSelected.ts

@@ -1,21 +1,10 @@
-import { Coordinates } from 'leyden';
-import { useMemo } from 'react';
 import { Descendant } from 'slate';
 
 import { useCoordinates } from './useCoordinates';
-import { useSelectedCoordinates } from './useSelectedCoordinates';
+import { useAreCoordinatesSelected } from './useAreCoordinatesSelected';
 
 export const useCellIsSelected = (node: Descendant): boolean => {
     const ownCoords = useCoordinates(node);
-    const selectedCoords = useSelectedCoordinates();
 
-    const cellSelected = useMemo(() => {
-        return (
-            ownCoords !== null
-            && selectedCoords !== null
-            && Coordinates.equals(ownCoords, selectedCoords)
-        );
-    }, [ownCoords, selectedCoords]);
-
-    return cellSelected;
+    return useAreCoordinatesSelected(ownCoords);
 };

packages/leyden-react/src/hooks/useCoordinates.ts

@@ -23,15 +23,13 @@ export const useCoordinates = (node: Descendant): Coordinates|null => {
                 return;
             }
             // If not wrapped in `setTimeout`, this runs before the cell paths are updated
-            // and coordinate movement is never detected. 
-            setTimeout(() => {
-                const newCoords = ReactEditor.cellCoords(editor, node);
-                if ((newCoords === null || !Coordinates.equals(coordinates, newCoords))
-                    && !canceled
-                ) {
-                    setCoordinates(newCoords);
-                }
-            });
+            // and coordinate movement is never detected.
+            const newCoords = ReactEditor.cellCoords(editor, node);
+            if ((newCoords === null || !Coordinates.equals(coordinates, newCoords))
+                && !canceled
+            ) {
+                setCoordinates(newCoords);
+            }
         });
         return () => {
             canceled = true;

packages/leyden/src/interfaces/LeydenEditor.ts

@@ -11,10 +11,7 @@ import { Coordinates } from './Coordinates';
 import { Table } from './Table';
 import { ValidationFunc, Validator } from './Validator';
 import {
-    CellSubscriber,
-    OperationSubscriber,
-    SelectedCoordinatesSubscriber,
-    Unsubscriber,
+    CellSubscriber, CoordinateSelectedSubscriber, OperationSubscriber, SelectedCoordinatesSubscriber, Unsubscriber,
 } from '../utils/types';
 import { OPERATION_SUBSCRIBERS } from '../utils/weakMaps';
 
@@ -79,6 +76,13 @@ export interface LeydenEditorInterface {
         editor: Editor,
         subscriber: SelectedCoordinatesSubscriber
     ) => Unsubscriber;
+    subscribeToSelectedCoordinatesByCoordinates: (
+        editor: Editor,
+        subscriber: CoordinateSelectedSubscriber,
+        options: {
+            at: Coordinates | null,
+        }
+    ) => Unsubscriber;
     table: (editor: Editor) => Table;
     tablePath: () => Path;
 }
@@ -148,7 +152,7 @@ export const LeydenEditor: LeydenEditorInterface = {
     },
 
     /**
-     * Get the path to the nth cell in an editor. 
+     * Get the path to the nth cell in an editor.
      */
 
     nthCellPath(n: number): CellPath {
@@ -333,6 +337,34 @@ export const LeydenEditor: LeydenEditorInterface = {
         });
     },
 
+    /**
+     * Subscribe to the selected status of a cell at the specified coordinates.
+     */
+
+    subscribeToSelectedCoordinatesByCoordinates(
+        editor: Editor,
+        subscriber: CoordinateSelectedSubscriber,
+        options: {
+            at: Coordinates | null,
+        }
+    ): Unsubscriber {
+        const { at } = options;
+        if (!at) {
+            return () => subscriber(false);
+        }
+        const cellPath = LeydenEditor.cellPath(editor, { at });
+        return LeydenEditor.subscribeToOperations(editor, op => {
+            if (Operation.isSelectionOperation(op) &&
+                op.newProperties?.focus?.path &&
+                Path.equals(op.newProperties?.focus?.path.slice(0, 2), cellPath)
+            ) {
+                subscriber(true);
+            } else if (Operation.isSelectionOperation(op)) {
+                subscriber(false);
+            }
+        });
+    },
+
     /**
      * Get an editor's table.
      */

packages/leyden/src/utils/types.ts

@@ -39,21 +39,27 @@ export type CellSubscriber<T extends CellType> = (cell: Cell<T>) => void;
 export type SelectedCoordinatesSubscriber = (coords: Coordinates|null) => void;
 
 /**
- * A function which will end a subscription 
+ * A function fired when the current cell's coordinates become selected.
+ */
+
+export type CoordinateSelectedSubscriber = (selected: boolean) => void;
+
+/**
+ * A function which will end a subscription
  */
 
 export type Unsubscriber = () => void;
 
 /**
- * An option representing a leyden editor passed during editor initialization 
+ * An option representing a leyden editor passed during editor initialization
  */
 
 export interface EditorOption<T extends Editor> {
     editor: T,
 }
 
 /**
- * An option representing a validator set passed during editor initialization 
+ * An option representing a validator set passed during editor initialization
  */
 
 export interface ValidatorsOption {

packages/leyden/src/withLeyden.ts

@@ -35,13 +35,16 @@ export const withLeyden = <T extends Editor>({ editor, ...rest }: WithLeydenOpti
             }
         }
         apply(op);
+
         // Notify subscribers of operations after application
-        const opSubscribers = OPERATION_SUBSCRIBERS.get(e);
-        if (opSubscribers !== undefined) {
-            for (const opSubscriber of opSubscribers) {
-                opSubscriber(op);
+        setTimeout(() => {
+            const opSubscribers = OPERATION_SUBSCRIBERS.get(e);
+            if (opSubscribers !== undefined) {
+                for (const opSubscriber of opSubscribers) {
+                    opSubscriber(op);
+                }
             }
-        }
+        });
     };
 
     e.getValidationFunc = validator => (