make the context properties more semantic #21

Author: codingedgar

README.md

@@ -1,5 +1,5 @@
 # macos-multi-select
 
-Given a list of ids, and an action, return a list of selected items with the same behaviour of macOS finder list view selection.
+Given an Index, and an Action, return an array of selected keys with the same behaviour of macOS finder list view selection.
 
 🌟 [List of Features Known](documentation/features.md)

documentation/features.md

@@ -36,7 +36,7 @@
 # Toggle Key Selection
 
 ## Scenarios
-### Should be able to add and remove a selection one item in a non empty index
+### Should be able to add and remove a selection one key in a non empty index
 
 |  |  |
 | --- | ---|
@@ -133,7 +133,7 @@
 
 # Select Next
 # Scenarios
-### Should do nothing if no items
+### Should do nothing if no keys
 |  |  |
 | --- | ---|
 | Implemented | ✅ |
@@ -151,7 +151,7 @@
 
 ![demo](./images/select_next_key_scenario_2.gif)
 
-### Should never select beyond last item
+### Should never select beyond last key
 
 |  |  |
 | --- | ---|
@@ -202,7 +202,7 @@
 | Hot Key | `Arrow Up` |
 
 ![demo](./images/select_previous_key_scenario_2.gif)
-### Should never select beyond first item
+### Should never select beyond first key
 
 |  |  |
 | --- | ---|

package.json

@@ -1,7 +1,7 @@
 {
   "name": "macos-multi-select",
-  "version": "0.1.9",
-  "description": "Given a list of ids, and an action, return a list of selected items with the same behaviour of macOS finder list view selection.",
+  "version": "0.2.0-rc.0",
+  "description": "Given an Index, and an Action, return an array of selected keys with the same behaviour of macOS finder list view selection.",
   "main": "dist/index.js",
   "repository": "[email protected]:codingedgar/macos-multi-select.git",
   "author": "codingedgar <[email protected]>",

src/arrayUtils.ts

@@ -1,61 +1,61 @@
 import { head } from "ramda";
 
 export function findNextPivot(
-  sortedArray: string[],
+  sortedIndex: string[],
   subarray: string[],
   previousPivot: string
 ): string {
-    const previousIndex = sortedArray.indexOf(previousPivot);
-    let nextIndex = previousIndex + 1;
+    const previous = sortedIndex.indexOf(previousPivot);
+    let next = previous + 1;
 
-    while (nextIndex <= sortedArray.length - 1) {
-      const nextItem = sortedArray[nextIndex];
-      if (subarray.includes(nextItem)){
-        return nextItem;
+    while (next <= sortedIndex.length - 1) {
+      const nextKey = sortedIndex[next];
+      if (subarray.includes(nextKey)){
+        return nextKey;
       };
-      nextIndex++;
+      next++;
     }
 
-    nextIndex = previousIndex - 1;
+    next = previous - 1;
 
-    while (nextIndex >= 0) {
-      const prevItem = sortedArray[nextIndex];
-      if (subarray.includes(prevItem)) {
-        return prevItem;
+    while (next >= 0) {
+      const prevKey = sortedIndex[next];
+      if (subarray.includes(prevKey)) {
+        return prevKey;
       }
-      nextIndex--;
+      next--;
     }
 
-  return head(sortedArray)!
+  return head(sortedIndex)!
 }
 
 export function findAdjacentToPivotInSortedArray(
-  sortedArray: string[],
+  sortedIndex: string[],
   subarray: string[],
-  item: string
+  key: string
 ): string[] {
-    const indexOfItem = sortedArray.indexOf(item);
-    let leftIndex = indexOfItem;
-    let rightIndex = indexOfItem;
+    const indexOfKey = sortedIndex.indexOf(key);
+    let leftIndex = indexOfKey;
+    let rightIndex = indexOfKey;
     let hasLeftAdjacent = leftIndex > 0;
-    let hasRightAdjacent = rightIndex < sortedArray.length - 1;
+    let hasRightAdjacent = rightIndex < sortedIndex.length - 1;
     while ((hasLeftAdjacent || hasRightAdjacent)) {
       if (leftIndex > 0) {
-        const nextLeft = sortedArray[leftIndex - 1];
+        const nextLeft = sortedIndex[leftIndex - 1];
         hasLeftAdjacent = subarray.includes(nextLeft);
         leftIndex = hasLeftAdjacent ? leftIndex - 1 : leftIndex;
       } else {
         hasLeftAdjacent = false
       }
 
-      if (rightIndex < sortedArray.length - 1) {
-        const nextRight = sortedArray[rightIndex + 1];
+      if (rightIndex < sortedIndex.length - 1) {
+        const nextRight = sortedIndex[rightIndex + 1];
         hasRightAdjacent = subarray.includes(nextRight);
         rightIndex = hasRightAdjacent ? rightIndex + 1 : rightIndex;
       } else {
         hasRightAdjacent = false
       }
     }
 
-  return sortedArray.slice(leftIndex, rightIndex + 1);
+  return sortedIndex.slice(leftIndex, rightIndex + 1);
 }

src/index.ts

@@ -1,8 +1,8 @@
-import { difference, head, last, take, union, without } from "ramda";
+import { head, last, take, union, without } from "ramda";
 import { findAdjacentToPivotInSortedArray, findNextPivot } from "./arrayUtils";
 
 export type Context = {
-  list: string[],
+  index: string[],
   selected: string[],
   adjacentPivot: string | undefined,
 }
@@ -15,15 +15,15 @@ export type Command =
   | { type: "SELECT NEXT" }
   | { type: "SELECT PREVIOUS" }
 
-function listIncludesAndIsNotEmpty(list: string[], item: string) {
-  return list.length > 0 && list.includes(item)
+function listIncludesAndIsNotEmpty(index: string[], key: string) {
+  return index.length > 0 && index.includes(key)
 }
 
 export function multiselect(context: Context, command: Command): Context {
 
   if (
     command.type === "SELECT ONE" &&
-    listIncludesAndIsNotEmpty(context.list, command.id)
+    listIncludesAndIsNotEmpty(context.index, command.id)
   ) {
     return {
       ...context,
@@ -32,23 +32,23 @@ export function multiselect(context: Context, command: Command): Context {
     };
   } else if (
       command.type === 'TOGGLE SELECTION' &&
-      listIncludesAndIsNotEmpty(context.list, command.id) &&
+      listIncludesAndIsNotEmpty(context.index, command.id) &&
       context.selected.includes(command.id) &&
       context.selected.length === 1
   ) {
     return {
       ...context,
       selected: [],
-      adjacentPivot: head(context.list),
+      adjacentPivot: head(context.index),
     };
   } else if (
       command.type === 'TOGGLE SELECTION' &&
-      listIncludesAndIsNotEmpty(context.list, command.id) &&
+      listIncludesAndIsNotEmpty(context.index, command.id) &&
       context.selected.includes(command.id)
   ) {
     const selected = context.selected.filter(x => x !== command.id);
     const adjacentPivot = findNextPivot(
-      context.list,
+      context.index,
       selected,
       command.id
     );
@@ -60,7 +60,7 @@ export function multiselect(context: Context, command: Command): Context {
     };
   } else if (
     command.type === 'TOGGLE SELECTION' &&
-    context.list.includes(command.id)
+    context.index.includes(command.id)
   ) {
     return {
       ...context,
@@ -71,41 +71,41 @@ export function multiselect(context: Context, command: Command): Context {
     return {
       ...context,
       selected: [],
-      adjacentPivot: head(context.list)!,
+      adjacentPivot: head(context.index)!,
     }
   } else if (
     command.type === "SELECT ADJACENT" &&
-    listIncludesAndIsNotEmpty(context.list, command.id) &&
+    listIncludesAndIsNotEmpty(context.index, command.id) &&
     context.selected.length === 0
   ) {
-    const n = context.list.indexOf(command.id) + 1;
+    const n = context.index.indexOf(command.id) + 1;
     return {
       ...context,
-      selected: take(n, context.list),
-      adjacentPivot: head(context.list),
+      selected: take(n, context.index),
+      adjacentPivot: head(context.index),
     }
   } else if (
     command.type === "SELECT ADJACENT" &&
-    listIncludesAndIsNotEmpty(context.list, command.id)  &&
+    listIncludesAndIsNotEmpty(context.index, command.id)  &&
     context.adjacentPivot !== undefined
   ) {
 
-    const pivotIndex = context.list.indexOf(context.adjacentPivot);
-    const selectionIndex = context.list.indexOf(command.id);
+    const pivotIndex = context.index.indexOf(context.adjacentPivot);
+    const selectionIndex = context.index.indexOf(command.id);
 
     const adjacentToStart = findAdjacentToPivotInSortedArray(
-      context.list,
+      context.index,
       context.selected,
       context.adjacentPivot
     );
 
     const adjacentToEnd = findAdjacentToPivotInSortedArray(
-      context.list,
+      context.index,
       context.selected,
       command.id,
     );
 
-    const nextSelection = context.list.slice(
+    const nextSelection = context.index.slice(
       Math.min(pivotIndex, selectionIndex),
       Math.max(pivotIndex, selectionIndex) + 1
     );
@@ -122,36 +122,36 @@ export function multiselect(context: Context, command: Command): Context {
     }
   } else if(
     command.type === "SELECT NEXT" &&
-    context.list.length &&
+    context.index.length &&
     context.selected.length === 0
   ) {
     return {
       ...context,
-      selected: [context.list[0]],
-      adjacentPivot: context.list[0],
+      selected: [context.index[0]],
+      adjacentPivot: context.index[0],
     }
   } else if (
     command.type === "SELECT NEXT" &&
-    context.list.length &&
+    context.index.length &&
     context.selected.length
   ) {
-    const pivotIndex = context.list.indexOf(last(context.selected)!)
+    const pivotIndex = context.index.indexOf(last(context.selected)!)
 
-    if (pivotIndex < context.list.length - 1) {
-      const nextItem = context.list[pivotIndex + 1];
+    if (pivotIndex < context.index.length - 1) {
+      const nextKey = context.index[pivotIndex + 1];
 
       return {
         ...context,
-        selected: [nextItem],
-        adjacentPivot: nextItem
+        selected: [nextKey],
+        adjacentPivot: nextKey
       }
     } else if (
       !(
         context.selected.length === 1 &&
-        context.selected[0] === last(context.list)
+        context.selected[0] === last(context.index)
       )
     ) {
-      const pivot = context.list[pivotIndex];
+      const pivot = context.index[pivotIndex];
       return {
         ...context,
         selected: [pivot],
@@ -162,36 +162,36 @@ export function multiselect(context: Context, command: Command): Context {
     }
   } else if (
     command.type === "SELECT PREVIOUS" &&
-    context.list.length &&
+    context.index.length &&
     context.selected.length === 0
   ) {
-    const pivot = last(context.list)!;
+    const pivot = last(context.index)!;
     return {
       ...context,
       selected: [pivot],
       adjacentPivot: pivot,
     }
   } else if (
     command.type === "SELECT PREVIOUS" &&
-    context.list.length &&
+    context.index.length &&
     context.selected.length
   ) {
-    const pivotIndex = context.list.indexOf(last(context.selected)!)
+    const pivotIndex = context.index.indexOf(last(context.selected)!)
 
     if (pivotIndex > 0) {
-      const prevItem = context.list[pivotIndex - 1];
+      const prevKey = context.index[pivotIndex - 1];
       return {
         ...context,
-        selected: [prevItem],
-        adjacentPivot: prevItem
+        selected: [prevKey],
+        adjacentPivot: prevKey
       }
     } else if (
       !(
         context.selected.length === 1 &&
-        context.selected[0] === head(context.list)
+        context.selected[0] === head(context.index)
       )
     ) {
-      const pivot = head(context.list)!;
+      const pivot = head(context.index)!;
       return {
         ...context,
         selected: [pivot],