patch(vest): Add isolate module for containing re-orders

package.json

@@ -4,7 +4,8 @@
     "test": "vx test",
     "release": "vx release",
     "lint": "eslint . --ignore-path .gitignore",
-    "prepare": "husky install"
+    "prepare": "husky install",
+    "dev": "vx dev"
   },
   "prettier": {
     "arrowParens": "avoid",

packages/n4s/src/rules/inside.ts

@@ -1,8 +1,10 @@
 import bindNot from 'bindNot';
 import { isStringValue as isString } from 'isStringValue';
 
+import { isArray } from 'isArrayValue';
+
 export function inside(value: unknown, arg1: string | unknown[]): boolean {
-  if (Array.isArray(arg1)) {
+  if (isArray(arg1)) {
     return arg1.indexOf(value) !== -1;
   }
 

packages/shared/src/nestedArray.ts

@@ -0,0 +1,70 @@
+import { isArray } from 'isArrayValue';
+import { isNotNull } from 'isNull';
+
+import asArray from 'asArray';
+import defaultTo from 'defaultTo';
+import last from 'last';
+
+export type NestedArray<T> = Array<NestedArray<T> | T>;
+
+// This is sort of a map/filter in one function.
+// Normally, behaves like a nested-array map
+// Returning `null` will drop the element from the array
+export function transform<T>(
+  array: NestedArray<T>,
+  cb: (value: T) => NestedArray<T> | T | null
+): NestedArray<T> {
+  const res = [];
+  for (const v of array) {
+    if (isArray(v)) {
+      res.push(transform(v, cb));
+    } else {
+      const output = cb(v);
+
+      if (isNotNull(output)) {
+        res.push(output);
+      }
+    }
+  }
+  return res as NestedArray<T>;
+}
+
+export function valueAtPath<T>(
+  array: NestedArray<T>,
+  path: number[]
+): T | NestedArray<T> {
+  return getCurrent(array, path)[last(path)];
+}
+
+export function setValueAtPath<T>(
+  array: NestedArray<T>,
+  path: number[],
+  value: NestedArray<T> | T
+): NestedArray<T> {
+  const current = getCurrent(array, path);
+
+  current[last(path)] = value;
+  return array;
+}
+
+export function flatten<T>(values: NestedArray<T> | T): T[] {
+  return asArray(values).reduce((acc, value) => {
+    if (isArray(value)) {
+      return (acc as NestedArray<T>).concat(flatten(value));
+    }
+
+    return asArray(acc).concat(value);
+  }, [] as T[]) as T[];
+}
+
+export function getCurrent<T>(
+  array: NestedArray<T>,
+  path: number[]
+): NestedArray<T> {
+  let current: NestedArray<T> = array;
+  for (const p of path.slice(0, -1)) {
+    current[p] = defaultTo(current[p], []);
+    current = current[p] as NestedArray<T>;
+  }
+  return current;
+}

packages/vast/src/vast.ts

@@ -44,15 +44,20 @@ export function createState(
   }
 
   function reset(): void {
+    const prev = current();
     state.references = [];
     registrations.forEach(([initialValue], index) =>
-      initKey(index, initialValue)
+      initKey(index, initialValue, prev[index])
     );
   }
 
-  function initKey<S>(key: number, initialState?: TStateInput<S>) {
+  function initKey<S>(
+    key: number,
+    initialState?: TStateInput<S>,
+    prevState?: S | undefined
+  ) {
     current().push();
-    set(key, optionalFunctionValue(initialState));
+    set(key, optionalFunctionValue(initialState, prevState));
 
     return function useStateKey(): TStateHandlerReturn<S> {
       return [
@@ -83,7 +88,7 @@ export function createState(
   }
 }
 
-type TStateInput<S> = S | (() => S);
+type TStateInput<S> = S | ((prevState?: S) => S);
 type TSetStateInput<S> = S | ((prevState: S) => S);
 
 export type TState = ReturnType<typeof createState>;