select previous item #10

edge case of select next #9

Author: codingedgar

package.json

@@ -1,6 +1,6 @@
 {
   "name": "macos-multi-select",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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.",
   "main": "dist/index.js",
   "repository": "[email protected]:codingedgar/macos-multi-select.git",

src/index.ts

@@ -13,6 +13,7 @@ type Command =
   | { type: "DESELECT ALL" }
   | { type: "SELECT ADJACENT", id: string }
   | { type: "SELECT NEXT" }
+  | { type: "SELECT PREVIOUS" }
 
 function listIncludesAndIsNotEmpty(list: string[], item: string) {
   return list.length > 0 && list.includes(item)
@@ -35,11 +36,10 @@ export function multiselect(context: Context, command: Command): Context {
       context.selected.includes(command.id) &&
       context.selected.length === 1
   ) {
-    const index = context.selected.indexOf(command.id)
     return {
       ...context,
       selected: [],
-      adjacentPivot: head(context.list)!,
+      adjacentPivot: head(context.list),
     };
   } else if (
       command.type === 'TOGGLE SELECTION' &&
@@ -112,7 +112,7 @@ export function multiselect(context: Context, command: Command): Context {
   } else if(
     command.type === "SELECT NEXT" &&
     context.list.length &&
-    context.adjacentPivot === undefined
+    context.selected.length === 0
   ) {
     return {
       ...context,
@@ -134,7 +134,6 @@ export function multiselect(context: Context, command: Command): Context {
         adjacentPivot: nextItem
       }
     } else if (
-      !context.selected.length ||
       !(
         context.selected.length === 1 &&
         last(context.selected) === last(context.list)
@@ -147,6 +146,46 @@ export function multiselect(context: Context, command: Command): Context {
     } else {
       return context;
     }
+  } else if (
+    command.type === "SELECT PREVIOUS" &&
+    context.list.length &&
+    context.selected.length === 0
+  ) {
+    const pivot = last(context.list)!;
+    return {
+      ...context,
+      selected: [pivot],
+      adjacentPivot: pivot,
+    }
+  } else if (
+    command.type === "SELECT PREVIOUS" &&
+    context.list.length &&
+    context.adjacentPivot !== undefined
+  ) {
+    const pivotIndex = context.list.indexOf(context.adjacentPivot)
+
+    if (pivotIndex > 0) {
+      const prevItem = context.list[pivotIndex - 1];
+      return {
+        ...context,
+        selected: [prevItem],
+        adjacentPivot: prevItem
+      }
+    } else if (
+      !(
+        context.selected.length === 1 &&
+        context.selected[0] === head(context.list)
+      )
+    ) {
+      const pivot = head(context.list)!;
+      return {
+        ...context,
+        selected: [pivot],
+        adjacentPivot: pivot
+      }
+    } else {
+      return context;
+    }
   } else {
     return context;
   }

src/spec/selectNext.spec.ts

@@ -1,5 +1,5 @@
 import fc from 'fast-check';
-import { last } from 'ramda';
+import { head, last } from 'ramda';
 import { Context, multiselect } from '../index';
 import { nonEmptySubsequentSubarray } from './arbitraries';
 
@@ -22,10 +22,13 @@ describe('Select Next Item', () => {
 
     fc.assert(
       fc.property(
-        fc.set(fc.string(), { minLength: 1 }),
-        (list) => {
+        fc.tuple(
+          fc.set(fc.string(), { minLength: 1 }),
+          fc.boolean()
+        ),
+        ([list, undefOrTop]) => {
           expect(multiselect({
-            adjacentPivot: undefined,
+            adjacentPivot: undefOrTop ? undefined : head(list),
             list,
             selected: []
           }, {
@@ -98,6 +101,6 @@ describe('Select Next Item', () => {
         }
       )
     )
-  })
+  });
 
 })

src/spec/selectPrevious.spec.ts

@@ -0,0 +1,113 @@
+import fc from 'fast-check';
+import { head, last } from 'ramda';
+import { Context, multiselect } from '../index';
+
+describe('Select Previous Item', () => {
+  test('should do nothing if the list is empty', () => {
+
+    const initialContext: Context = {
+      adjacentPivot: undefined,
+      list: [],
+      selected: []
+    };
+
+    expect(multiselect(initialContext, {
+      type: "SELECT PREVIOUS",
+    }))
+      .toEqual(initialContext)
+
+  });
+
+  test('should start from the bottom', () => {
+
+    fc.assert(
+      fc.property(
+        fc.tuple(
+          fc.set(fc.string(), { minLength: 1 }),
+          fc.boolean()
+        )
+        .map(([list, undefOrTop]) => ({
+          list,
+          adjacentPivot: undefOrTop ? undefined : head(list),
+          selected: [],
+        })),
+        (initialContext) => {
+          const nextAdjacentPivot = last(initialContext.list)!;
+          
+          expect(multiselect(initialContext, {
+            type: "SELECT PREVIOUS",
+          }))
+            .toEqual({
+              list: initialContext.list,
+              selected: [nextAdjacentPivot],
+              adjacentPivot: nextAdjacentPivot,
+            })
+        }
+      )
+    )
+
+  });
+
+
+  test('should never select beyond first item', () => {
+    fc.assert(
+      fc.property(
+        fc.tuple(
+          fc.integer(1, 20),
+          fc.set(
+            fc.string(), { minLength: 1 }
+          )
+        )
+        .chain(([extra, list]) =>
+          fc.shuffledSubarray(list)
+          .map(selected => ({
+            list,
+            selected,
+            adjacentPivot: last(selected),
+            extra
+          }))
+        )
+        ,
+        ({
+          adjacentPivot,
+          list,
+          selected,
+          extra
+        }) => {
+
+          let prevContext: Context = {
+            adjacentPivot,
+            list,
+            selected
+          }
+
+          const lastSelected = last(selected);
+          const startOn = lastSelected !== undefined
+            ? list.indexOf(lastSelected) - 1
+            : list.length - 1
+
+          for (let index = startOn; index > -list.length - extra; index--) {
+            
+            const nextContext = multiselect(prevContext, {
+              type: "SELECT PREVIOUS",
+            });
+            
+            const pivot = index >= 0 ? list[index]: head(list);
+            
+            expect(nextContext)
+            .toEqual({
+              list,
+              selected: [pivot],
+              adjacentPivot: pivot,
+            })
+            
+            prevContext = nextContext;
+            
+          }
+
+        }
+      )
+    )
+  })
+
+});