chore: remove 1.52kb of optional chaining (#9248)

* chore: remove 1.52kb of optional chaining

* chore: add jacob-ebey to contributors

Author: jacob-ebey

contributors.yml

@@ -84,3 +84,4 @@
 - KostiantynPopovych
 - CanRau
 - dokeet
+- jacob-ebey

packages/router/history.ts

@@ -325,8 +325,8 @@ export function createBrowserHistory(
       "",
       { pathname, search, hash },
       // state defaults to `null` because `window.history.state` does
-      globalHistory.state?.usr || null,
-      globalHistory.state?.key || "default"
+      (globalHistory.state && globalHistory.state.usr) || null,
+      (globalHistory.state && globalHistory.state.key) || "default"
     );
   }
 
@@ -386,8 +386,8 @@ export function createHashHistory(
       "",
       { pathname, search, hash },
       // state defaults to `null` because `window.history.state` does
-      globalHistory.state?.usr || null,
-      globalHistory.state?.key || "default"
+      (globalHistory.state && globalHistory.state.usr) || null,
+      (globalHistory.state && globalHistory.state.key) || "default"
     );
   }
 
@@ -476,7 +476,7 @@ export function createLocation(
     // full Locations now and avoid the need to run through this flow at all
     // But that's a pretty big refactor to the current test suite so going to
     // keep as is for the time being and just let any incoming keys take precedence
-    key: (to as Location)?.key || key || createKey(),
+    key: (to && (to as Location).key) || key || createKey(),
   };
   return location;
 }
@@ -551,7 +551,7 @@ function getUrlBasedHistory(
   function push(to: To, state?: any) {
     action = Action.Push;
     let location = createLocation(history.location, to, state);
-    validateLocation?.(location, to);
+    if (validateLocation) validateLocation(location, to);
 
     let historyState = getHistoryState(location);
     let url = history.createHref(location);
@@ -573,7 +573,7 @@ function getUrlBasedHistory(
   function replace(to: To, state?: any) {
     action = Action.Replace;
     let location = createLocation(history.location, to, state);
-    validateLocation?.(location, to);
+    if (validateLocation) validateLocation(location, to);
 
     let historyState = getHistoryState(location);
     let url = history.createHref(location);

packages/router/router.ts

@@ -555,9 +555,9 @@ export function createRouter(init: RouterInit): Router {
     restoreScrollPosition: null,
     preventScrollReset: false,
     revalidation: "idle",
-    loaderData: init.hydrationData?.loaderData || {},
-    actionData: init.hydrationData?.actionData || null,
-    errors: init.hydrationData?.errors || initialErrors,
+    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},
+    actionData: (init.hydrationData && init.hydrationData.actionData) || null,
+    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,
     fetchers: new Map(),
   };
 
@@ -628,7 +628,7 @@ export function createRouter(init: RouterInit): Router {
       unlistenHistory();
     }
     subscribers.clear();
-    pendingNavigationController?.abort();
+    pendingNavigationController && pendingNavigationController.abort();
     state.fetchers.forEach((_, key) => deleteFetcher(key));
   }
 
@@ -731,9 +731,9 @@ export function createRouter(init: RouterInit): Router {
 
     let { path, submission, error } = normalizeNavigateOptions(to, opts);
 
-    let location = createLocation(state.location, path, opts?.state);
+    let location = createLocation(state.location, path, opts && opts.state);
     let historyAction =
-      opts?.replace === true || submission != null
+      (opts && opts.replace) === true || submission != null
         ? HistoryAction.Replace
         : HistoryAction.Push;
     let preventScrollReset =
@@ -747,7 +747,7 @@ export function createRouter(init: RouterInit): Router {
       // render at the right error boundary after we match routes
       pendingError: error,
       preventScrollReset,
-      replace: opts?.replace,
+      replace: opts && opts.replace,
     });
   }
 
@@ -802,17 +802,18 @@ export function createRouter(init: RouterInit): Router {
     // Abort any in-progress navigations and start a new one. Unset any ongoing
     // uninterrupted revalidations unless told otherwise, since we want this
     // new navigation to update history normally
-    pendingNavigationController?.abort();
+    pendingNavigationController && pendingNavigationController.abort();
     pendingNavigationController = null;
     pendingAction = historyAction;
-    isUninterruptedRevalidation = opts?.startUninterruptedRevalidation === true;
+    isUninterruptedRevalidation =
+      (opts && opts.startUninterruptedRevalidation) === true;
 
     // Save the current scroll position every time we start a new navigation,
     // and track whether we should reset scroll on completion
     saveScrollPosition(state.location, state.matches);
-    pendingPreventScrollReset = opts?.preventScrollReset === true;
+    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
 
-    let loadingNavigation = opts?.overrideNavigation;
+    let loadingNavigation = opts && opts.overrideNavigation;
     let matches = matchRoutes(dataRoutes, location, init.basename);
 
     // Short circuit with a 404 on the root error boundary if we match nothing
@@ -845,20 +846,20 @@ export function createRouter(init: RouterInit): Router {
     let request = createRequest(
       location,
       pendingNavigationController.signal,
-      opts?.submission
+      opts && opts.submission
     );
     let pendingActionData: RouteData | undefined;
     let pendingError: RouteData | undefined;
 
-    if (opts?.pendingError) {
+    if (opts && opts.pendingError) {
       // If we have a pendingError, it means the user attempted a GET submission
       // with binary FormData so assign here and skip to handleLoaders.  That
       // way we handle calling loaders above the boundary etc.  It's not really
       // different from an actionError in that sense.
       pendingError = {
         [findNearestBoundary(matches).route.id]: opts.pendingError,
       };
-    } else if (opts?.submission) {
+    } else if (opts && opts.submission) {
       // Call action if we received an action submission
       let actionOutput = await handleAction(
         request,
@@ -889,8 +890,8 @@ export function createRouter(init: RouterInit): Router {
       location,
       matches,
       loadingNavigation,
-      opts?.submission,
-      opts?.replace,
+      opts && opts.submission,
+      opts && opts.replace,
       pendingActionData,
       pendingError
     );
@@ -950,7 +951,11 @@ export function createRouter(init: RouterInit): Router {
         location: createLocation(state.location, result.location),
         ...submission,
       };
-      await startRedirectNavigation(result, redirectNavigation, opts?.replace);
+      await startRedirectNavigation(
+        result,
+        redirectNavigation,
+        opts && opts.replace
+      );
       return { shortCircuited: true };
     }
 
@@ -963,7 +968,7 @@ export function createRouter(init: RouterInit): Router {
       // action threw an error that'll be rendered in an errorElement, we fall
       // back to PUSH so that the user can use the back button to get back to
       // the pre-submission form location to try again
-      if (opts?.replace !== true) {
+      if ((opts && opts.replace) !== true) {
         pendingAction = HistoryAction.Push;
       }
 
@@ -1025,8 +1030,8 @@ export function createRouter(init: RouterInit): Router {
     // already cancelled all pending deferreds so this would be a no-op
     cancelActiveDeferreds(
       (routeId) =>
-        !matches?.some((m) => m.route.id === routeId) ||
-        matchesToLoad?.some((m) => m.route.id === routeId)
+        !(matches && matches.some((m) => m.route.id === routeId)) ||
+        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))
     );
 
     // Short circuit if we have no loaders to run
@@ -1047,9 +1052,10 @@ export function createRouter(init: RouterInit): Router {
     // a revalidation interrupting an actionReload)
     if (!isUninterruptedRevalidation) {
       revalidatingFetchers.forEach(([key]) => {
+        const fetcher = state.fetchers.get(key);
         let revalidatingFetcher: FetcherStates["Loading"] = {
           state: "loading",
-          data: state.fetchers.get(key)?.data,
+          data: fetcher && fetcher.data,
           formMethod: undefined,
           formAction: undefined,
           formEncType: undefined,
@@ -1192,10 +1198,11 @@ export function createRouter(init: RouterInit): Router {
     }
 
     // Put this fetcher into it's submitting state
+    let existingFetcher = state.fetchers.get(key);
     let fetcher: FetcherStates["Submitting"] = {
       state: "submitting",
       ...submission,
-      data: state.fetchers.get(key)?.data || undefined,
+      data: existingFetcher && existingFetcher.data,
     };
     state.fetchers.set(key, fetcher);
     updateState({ fetchers: new Map(state.fetchers) });
@@ -1289,9 +1296,10 @@ export function createRouter(init: RouterInit): Router {
     revalidatingFetchers
       .filter(([staleKey]) => staleKey !== key)
       .forEach(([staleKey]) => {
+        let existingFetcher = state.fetchers.get(staleKey);
         let revalidatingFetcher: FetcherStates["Loading"] = {
           state: "loading",
-          data: state.fetchers.get(staleKey)?.data,
+          data: existingFetcher && existingFetcher.data,
           formMethod: undefined,
           formAction: undefined,
           formEncType: undefined,
@@ -1360,7 +1368,7 @@ export function createRouter(init: RouterInit): Router {
       loadId > pendingNavigationLoadId
     ) {
       invariant(pendingAction, "Expected pending action");
-      pendingNavigationController?.abort();
+      pendingNavigationController && pendingNavigationController.abort();
 
       completeNavigation(state.navigation.location, {
         matches,
@@ -1388,14 +1396,15 @@ export function createRouter(init: RouterInit): Router {
     path: string,
     match: AgnosticDataRouteMatch
   ) {
+    let existingFetcher = state.fetchers.get(key);
     // Put this fetcher into it's loading state
     let loadingFetcher: FetcherStates["Loading"] = {
       state: "loading",
       formMethod: undefined,
       formAction: undefined,
       formEncType: undefined,
       formData: undefined,
-      data: state.fetchers.get(key)?.data || undefined,
+      data: existingFetcher && existingFetcher.data,
     };
     state.fetchers.set(key, loadingFetcher);
     updateState({ fetchers: new Map(state.fetchers) });
@@ -2109,7 +2118,8 @@ function normalizeNavigateOptions(
       submission: {
         formMethod: opts.formMethod,
         formAction: createHref(parsePath(path)),
-        formEncType: opts?.formEncType || "application/x-www-form-urlencoded",
+        formEncType:
+          (opts && opts.formEncType) || "application/x-www-form-urlencoded",
         formData: opts.formData,
       },
     };
@@ -2211,25 +2221,26 @@ function getMatchesToLoad(
 
   // Pick fetcher.loads that need to be revalidated
   let revalidatingFetchers: RevalidatingFetcher[] = [];
-  fetchLoadMatches?.forEach(([href, match], key) => {
-    // This fetcher was cancelled from a prior action submission - force reload
-    if (cancelledFetcherLoads.includes(key)) {
-      revalidatingFetchers.push([key, href, match]);
-    } else if (isRevalidationRequired) {
-      let shouldRevalidate = shouldRevalidateLoader(
-        href,
-        match,
-        submission,
-        href,
-        match,
-        isRevalidationRequired,
-        actionResult
-      );
-      if (shouldRevalidate) {
+  fetchLoadMatches &&
+    fetchLoadMatches.forEach(([href, match], key) => {
+      // This fetcher was cancelled from a prior action submission - force reload
+      if (cancelledFetcherLoads.includes(key)) {
         revalidatingFetchers.push([key, href, match]);
+      } else if (isRevalidationRequired) {
+        let shouldRevalidate = shouldRevalidateLoader(
+          href,
+          match,
+          submission,
+          href,
+          match,
+          isRevalidationRequired,
+          actionResult
+        );
+        if (shouldRevalidate) {
+          revalidatingFetchers.push([key, href, match]);
+        }
       }
-    }
-  });
+    });
 
   return [navigationMatches, revalidatingFetchers];
 }
@@ -2257,12 +2268,14 @@ function isNewRouteInstance(
   currentMatch: AgnosticDataRouteMatch,
   match: AgnosticDataRouteMatch
 ) {
+  let currentPath = currentMatch.route.path;
   return (
     // param change for this match, /users/123 -> /users/456
     currentMatch.pathname !== match.pathname ||
     // splat param changed, which is not present in match.path
     // e.g. /files/images/avatar.jpg -> files/finances.xls
-    (currentMatch.route.path?.endsWith("*") &&
+    (currentPath &&
+      currentPath.endsWith("*") &&
       currentMatch.params["*"] !== match.params["*"])
   );
 }
@@ -2375,7 +2388,8 @@ async function callLoaderOrAction(
     }
 
     let data: any;
-    if (result.headers.get("Content-Type")?.startsWith("application/json")) {
+    let contentType = result.headers.get("Content-Type");
+    if (contentType && contentType.startsWith("application/json")) {
       data = await result.json();
     } else {
       data = await result.text();
@@ -2497,7 +2511,7 @@ function processRouteLoaderData(
         loaderHeaders[id] = result.headers;
       }
     } else if (isDeferredResult(result)) {
-      activeDeferreds?.set(id, result.deferredData);
+      activeDeferreds && activeDeferreds.set(id, result.deferredData);
       loaderData[id] = result.deferredData.data;
       // TODO: Add statusCode/headers once we wire up streaming in Remix
     } else {
@@ -2560,7 +2574,7 @@ function processLoaderData(
     // Process fetcher non-redirect errors
     if (isErrorResult(result)) {
       let boundaryMatch = findNearestBoundary(state.matches, match.route.id);
-      if (!errors?.[boundaryMatch.route.id]) {
+      if (!(errors && errors[boundaryMatch.route.id])) {
         errors = {
           ...errors,
           [boundaryMatch.route.id]: result.error,
@@ -2695,7 +2709,7 @@ function isErrorResult(result: DataResult): result is ErrorResult {
 }
 
 function isRedirectResult(result?: DataResult): result is RedirectResult {
-  return result?.type === ResultType.redirect;
+  return (result && result.type) === ResultType.redirect;
 }
 
 async function resolveDeferredResults(
@@ -2715,7 +2729,7 @@ async function resolveDeferredResults(
     let isRevalidatingLoader =
       currentMatch != null &&
       !isNewRouteInstance(currentMatch, match) &&
-      currentLoaderData?.[match.route.id] !== undefined;
+      (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
 
     if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {
       // Note: we do not have to touch activeDeferreds here since we race them

packages/router/utils.ts

@@ -986,14 +986,15 @@ export class DeferredData {
       this.unlistenAbortSignal();
     }
 
+    const subscriber = this.subscriber;
     if (error) {
       Object.defineProperty(promise, "_error", { get: () => error });
-      this.subscriber?.(false);
+      subscriber && subscriber(false);
       return Promise.reject(error);
     }
 
     Object.defineProperty(promise, "_data", { get: () => data });
-    this.subscriber?.(false);
+    subscriber && subscriber(false);
     return data;
   }
 
@@ -1004,7 +1005,8 @@ export class DeferredData {
   cancel() {
     this.controller.abort();
     this.pendingKeys.forEach((v, k) => this.pendingKeys.delete(k));
-    this.subscriber?.(true);
+    let subscriber = this.subscriber;
+    subscriber && subscriber(true);
   }
 
   async resolveData(signal: AbortSignal) {