Simplified prop destruction to avoid type casts

Author: PatrickShaw

src/controllers/memory-router/index.tsx

@@ -1,67 +1,72 @@
 import React, { useRef } from 'react';
 
-import { createMemoryHistory, MemoryHistoryBuildOptions } from 'history';
+import { createMemoryHistory } from 'history';
 
 import { Router } from '../router';
-import { RouterProps } from '../router/types';
 
 import { MemoryRouterProps } from '../../common/types';
 
-const getRouterProps = (memoryRouterProps: MemoryRouterProps) => {
-  const {
-    isStatic = false,
-    isGlobal = true,
-    basePath,
-    routes,
-    resourceData,
-    resourceContext,
-  } = memoryRouterProps;
-  let routerProps: Partial<RouterProps> = {
-    basePath,
-    routes,
-    isStatic,
-    isGlobal,
-  };
+const lazy = <T extends any>(callback: () => T) => {
+  let firstCall = true;
+  let current: T | undefined = undefined;
 
-  if (resourceData) {
-    routerProps = { ...routerProps, resourceData };
-  }
+  return () => {
+    if (firstCall) {
+      current = callback();
+      firstCall = false;
+    }
 
-  if (resourceContext) {
-    routerProps = { ...routerProps, resourceContext };
-  }
-
-  return routerProps;
+    return current;
+  };
 };
 
-/**
- * Ensures the router store uses memory history.
- *
- */
-export const MemoryRouter = (props: MemoryRouterProps) => {
-  const { location, children } = props;
-
-  const newGetHistory = () =>
+const useMemoryHistory = (location: string | undefined) => {
+  const newGetHistory = lazy(() =>
     createMemoryHistory({
       initialEntries: location !== undefined ? [location] : undefined,
-    });
+    })
+  );
 
-  const historyState = useRef({
+  const historyStateCandidate = {
     getHistory: newGetHistory,
     location,
-  });
+  };
+
+  const historyState = useRef(historyStateCandidate);
 
-  if (historyState.current.location !== location) {
-    historyState.current.getHistory = newGetHistory;
+  if (historyState.current.location !== historyStateCandidate.location) {
+    historyState.current = historyStateCandidate;
   }
 
-  const routerProps = getRouterProps(props);
+  return historyState.current.getHistory();
+};
+
+/**
+ * Ensures the router store uses memory history.
+ *
+ */
+export const MemoryRouter = ({
+  isStatic = false,
+  isGlobal = true,
+  location,
+  children,
+  basePath,
+  routes,
+  resourceData,
+  resourceContext,
+}: MemoryRouterProps) => {
+  const history = useMemoryHistory(location);
 
   return (
     // @ts-ignore suppress history will be overwritten warning
     <Router
-      history={historyState.current.getHistory()}
-      {...(routerProps as RouterProps)}
+      isStatic={isStatic}
+      isGlobal={isGlobal}
+      history={history}
+      basePath={basePath}
+      routes={routes}
+      resourceData={resourceData}
+      resourceContext={resourceContext}
     >
       {children}
     </Router>