select next item #9

Author: codingedgar

package.json

@@ -1,6 +1,6 @@
 {
   "name": "macos-multi-select",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "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

@@ -1,4 +1,4 @@
-import { difference, head, take, union, without } from "ramda";
+import { difference, head, last, take, union, without } from "ramda";
 import { findAdjacentToPivotInSortedArray, findNextPivot } from "./arrayUtils";
 
 export type Context = {
@@ -12,6 +12,7 @@ type Command =
   | { type: "TOGGLE SELECTION", id: string }
   | { type: "DESELECT ALL" }
   | { type: "SELECT ADJACENT", id: string }
+  | { type: "SELECT NEXT" }
 
 function listIncludesAndIsNotEmpty(list: string[], item: string) {
   return list.length > 0 && list.includes(item)
@@ -108,6 +109,44 @@ export function multiselect(context: Context, command: Command): Context {
       ...context,
       selected: union(without(toRemove, context.selected), nextSelection)
     }
+  } else if(
+    command.type === "SELECT NEXT" &&
+    context.list.length &&
+    context.adjacentPivot === undefined
+  ) {
+    return {
+      ...context,
+      selected: [context.list[0]],
+      adjacentPivot: context.list[0],
+    }
+  } else if (
+    command.type === "SELECT NEXT" &&
+    context.list.length &&
+    context.adjacentPivot !== undefined
+    ) {
+    const pivotIndex = context.list.indexOf(context.adjacentPivot)
+
+    if (pivotIndex < context.list.length - 1) {
+      const nextItem = context.list[pivotIndex + 1];
+      return {
+        ...context,
+        selected: [nextItem],
+        adjacentPivot: nextItem
+      }
+    } else if (
+      !context.selected.length ||
+      !(
+        context.selected.length === 1 &&
+        last(context.selected) === last(context.list)
+      )
+    ) {
+      return {
+        ...context,
+        selected: [context.list[pivotIndex]],
+      }
+    } else {
+      return context;
+    }
   } else {
     return context;
   }

src/spec/arbitraries.ts

@@ -0,0 +1,17 @@
+import fc from 'fast-check';
+
+export function subsequentSubarray(arr: string[]) {
+  return fc.tuple(fc.nat(arr.length), fc.nat(arr.length))
+  .map(([a, b]) => a < b ? [a, b] : [b, a])
+  .map(([from, to]) => arr.slice(from, to));
+}
+
+export function nonEmptySubsequentSubarray(nonEmptyArray: string[]) {
+  return fc.tuple(fc.nat(nonEmptyArray.length), fc.nat(nonEmptyArray.length))
+  .map(([a, b]) => a < b ? [a, b + 1] : [b, a + 1])
+  .map(([from, to]) => nonEmptyArray.slice(from, to));
+}
+
+export function list() {
+  return fc.set(fc.string())
+}

src/spec/selectAdjacent.spec.ts

@@ -114,7 +114,7 @@ describe('Select Adjacent', () => {
     );
   });
 
-  test.only('should perform a minus between the old and new selection', () => {
+  test('should perform a minus between the old and new selection', () => {
     fc.assert(
       fc.property(
         fc.tuple(

src/spec/selectNext.spec.ts

@@ -0,0 +1,103 @@
+import fc from 'fast-check';
+import { last } from 'ramda';
+import { Context, multiselect } from '../index';
+import { nonEmptySubsequentSubarray } from './arbitraries';
+
+describe('Select Next Item', () => {
+  test('should do nothing if no items', () => {
+    const initialContext: Context = {
+      adjacentPivot: undefined,
+      list: [],
+      selected: []
+    };
+
+    expect(multiselect(initialContext, {
+      type: "SELECT NEXT",
+    }))
+      .toEqual(initialContext)
+
+  });
+
+  test('should start from the top', () => {
+
+    fc.assert(
+      fc.property(
+        fc.set(fc.string(), { minLength: 1 }),
+        (list) => {
+          expect(multiselect({
+            adjacentPivot: undefined,
+            list,
+            selected: []
+          }, {
+            type: "SELECT NEXT",
+          }))
+            .toEqual({
+              list,
+              selected: [list[0]],
+              adjacentPivot: list[0],
+            })
+        }
+      )
+    )
+
+  });
+
+  test('should never select beyond last item', () => {
+    fc.assert(
+      fc.property(
+        fc.tuple(
+          fc.integer(1, 20),
+          fc.set(
+            fc.string(), { minLength: 1 }
+          )
+        )
+        .chain(([extra, list]) =>
+          nonEmptySubsequentSubarray(list)
+          .map(selected => ({
+            list,
+            selected,
+            adjacentPivot: last(selected),
+            extra
+          }))
+        )
+        ,
+        ({
+          adjacentPivot,
+          list,
+          selected,
+          extra
+        }) => {
+
+          let prevContext: Context = {
+            adjacentPivot,
+            list,
+            selected
+          }
+
+          const startOn = list.indexOf(last(selected)!) + 1
+
+          for (let index = startOn; index < list.length + extra; index++) {
+            
+            const nextContext = multiselect(prevContext, {
+              type: "SELECT NEXT",
+            });
+
+            const selected = [index < list.length - 1 ? list[index]: last(list)];
+
+            expect(nextContext)
+            .toEqual({
+              list,
+              selected,
+              adjacentPivot: last(selected),
+            })
+            
+            prevContext = nextContext;
+            
+          }
+
+        }
+      )
+    )
+  })
+
+})

src/spec/selectOne.spec.ts

@@ -8,9 +8,9 @@ describe('Select One Item', () => {
     fc.assert(
       fc.property(
         fc.set(
-          fc.string()
+          fc.string(),
+          { minLength: 1 }
         )
-        .filter(list => list.length > 0)
         .chain(list =>
           fc.record({
             list: fc.constant(list),
@@ -49,9 +49,9 @@ describe('Select One Item', () => {
     fc.assert(
       fc.property(
         fc.set(
-          fc.string()
+          fc.string(),
+          { minLength: 2 }
         )
-        .filter(list => list.length > 1)
         .chain(list =>
           fc.record({
             list: fc.constant(list),

tsconfig.json

@@ -79,6 +79,7 @@
     "src"
   ],
   "exclude": [
-    "src/**/*.spec.ts"
+    "src/**/*.spec.ts",
+    "src/spec"
   ]
 }