@amazon-devices/react-navigation__routers 8.0.9000000000 → 8.0.9000000002

package/lib/module/TabRouter.js

@@ -1,328 +0,0 @@
-"use strict";
-
-import { nanoid } from 'nanoid/non-secure';
-import { BaseRouter } from "./BaseRouter.js";
-import { createParamsFromAction } from "./createParamsFromAction.js";
-const TYPE_ROUTE = 'route';
-export const TabActions = {
-  jumpTo(name, params) {
-    return {
-      type: 'JUMP_TO',
-      payload: {
-        name,
-        params
-      }
-    };
-  }
-};
-const getRouteHistory = (routes, index, backBehavior, initialRouteName) => {
-  const history = [{
-    type: TYPE_ROUTE,
-    key: routes[index].key
-  }];
-  let initialRouteIndex;
-  switch (backBehavior) {
-    case 'order':
-      for (let i = index; i > 0; i--) {
-        history.unshift({
-          type: TYPE_ROUTE,
-          key: routes[i - 1].key
-        });
-      }
-      break;
-    case 'firstRoute':
-      if (index !== 0) {
-        history.unshift({
-          type: TYPE_ROUTE,
-          key: routes[0].key
-        });
-      }
-      break;
-    case 'initialRoute':
-      initialRouteIndex = routes.findIndex(route => route.name === initialRouteName);
-      initialRouteIndex = initialRouteIndex === -1 ? 0 : initialRouteIndex;
-      if (index !== initialRouteIndex) {
-        history.unshift({
-          type: TYPE_ROUTE,
-          key: routes[initialRouteIndex].key
-        });
-      }
-      break;
-    case 'history':
-    case 'fullHistory':
-      // The history will fill up on navigation
-      break;
-  }
-  return history;
-};
-const changeIndex = (state, index, backBehavior, initialRouteName) => {
-  let history = state.history;
-  if (backBehavior === 'history' || backBehavior === 'fullHistory') {
-    const currentRoute = state.routes[index];
-    if (backBehavior === 'history') {
-      // Remove the existing key from the history to de-duplicate it
-      history = history.filter(it => it.type === 'route' ? it.key !== currentRoute.key : false);
-    } else if (backBehavior === 'fullHistory') {
-      const lastHistoryRouteItemIndex = history.findLastIndex(item => item.type === 'route');
-      if (currentRoute.key === history[lastHistoryRouteItemIndex]?.key) {
-        // For full-history, only remove if it matches the last route
-        // Useful for drawer, if current route was in history, then drawer state changed
-        // Then we only need to move the route to the front
-        history = [...history.slice(0, lastHistoryRouteItemIndex), ...history.slice(lastHistoryRouteItemIndex + 1)];
-      }
-    }
-    history = history.concat({
-      type: TYPE_ROUTE,
-      key: currentRoute.key,
-      params: backBehavior === 'fullHistory' ? currentRoute.params : undefined
-    });
-  } else {
-    history = getRouteHistory(state.routes, index, backBehavior, initialRouteName);
-  }
-  return {
-    ...state,
-    index,
-    history
-  };
-};
-export function TabRouter({
-  initialRouteName,
-  backBehavior = 'firstRoute'
-}) {
-  const router = {
-    ...BaseRouter,
-    type: 'tab',
-    getInitialState({
-      routeNames,
-      routeParamList
-    }) {
-      const index = initialRouteName !== undefined && routeNames.includes(initialRouteName) ? routeNames.indexOf(initialRouteName) : 0;
-      const routes = routeNames.map(name => ({
-        name,
-        key: `${name}-${nanoid()}`,
-        params: routeParamList[name]
-      }));
-      const history = getRouteHistory(routes, index, backBehavior, initialRouteName);
-      return {
-        stale: false,
-        type: 'tab',
-        key: `tab-${nanoid()}`,
-        index,
-        routeNames,
-        history,
-        routes,
-        preloadedRouteKeys: []
-      };
-    },
-    getRehydratedState(partialState, {
-      routeNames,
-      routeParamList
-    }) {
-      const state = partialState;
-      if (state.stale === false) {
-        return state;
-      }
-      const routes = routeNames.map(name => {
-        const route = state.routes.find(r => r.name === name);
-        return {
-          ...route,
-          name,
-          key: route && route.name === name && route.key ? route.key : `${name}-${nanoid()}`,
-          params: routeParamList[name] !== undefined ? {
-            ...routeParamList[name],
-            ...(route ? route.params : undefined)
-          } : route ? route.params : undefined
-        };
-      });
-      const index = Math.min(Math.max(routeNames.indexOf(state.routes[state?.index ?? 0]?.name), 0), routes.length - 1);
-      const routeKeys = routes.map(route => route.key);
-      const history = state.history?.filter(it => routeKeys.includes(it.key)) ?? [];
-      return changeIndex({
-        stale: false,
-        type: 'tab',
-        key: `tab-${nanoid()}`,
-        index,
-        routeNames,
-        history,
-        routes,
-        preloadedRouteKeys: state.preloadedRouteKeys?.filter(key => routeKeys.includes(key)) ?? []
-      }, index, backBehavior, initialRouteName);
-    },
-    getStateForRouteNamesChange(state, {
-      routeNames,
-      routeParamList,
-      routeKeyChanges
-    }) {
-      const routes = routeNames.map(name => state.routes.find(r => r.name === name && !routeKeyChanges.includes(r.name)) || {
-        name,
-        key: `${name}-${nanoid()}`,
-        params: routeParamList[name]
-      });
-      const index = Math.max(0, routeNames.indexOf(state.routes[state.index].name));
-      let history = state.history.filter(
-      // Type will always be 'route' for tabs, but could be different in a router extending this (e.g. drawer)
-      it => it.type !== 'route' || routes.find(r => r.key === it.key));
-      if (!history.length) {
-        history = getRouteHistory(routes, index, backBehavior, initialRouteName);
-      }
-      return {
-        ...state,
-        history,
-        routeNames,
-        routes,
-        index
-      };
-    },
-    getStateForRouteFocus(state, key) {
-      const index = state.routes.findIndex(r => r.key === key);
-      if (index === -1 || index === state.index) {
-        return state;
-      }
-      return changeIndex(state, index, backBehavior, initialRouteName);
-    },
-    getStateForAction(state, action, {
-      routeParamList,
-      routeGetIdList
-    }) {
-      switch (action.type) {
-        case 'JUMP_TO':
-        case 'NAVIGATE':
-        case 'NAVIGATE_DEPRECATED':
-          {
-            const index = state.routes.findIndex(route => route.name === action.payload.name);
-            if (index === -1) {
-              return null;
-            }
-            const updatedState = changeIndex({
-              ...state,
-              routes: state.routes.map(route => {
-                if (route.name !== action.payload.name) {
-                  return route;
-                }
-                const getId = routeGetIdList[route.name];
-                const currentId = getId?.({
-                  params: route.params
-                });
-                const nextId = getId?.({
-                  params: action.payload.params
-                });
-                const key = currentId === nextId ? route.key : `${route.name}-${nanoid()}`;
-                let params;
-                if ((action.type === 'NAVIGATE' || action.type === 'NAVIGATE_DEPRECATED') && action.payload.merge && currentId === nextId) {
-                  params = action.payload.params !== undefined || routeParamList[route.name] !== undefined ? {
-                    ...routeParamList[route.name],
-                    ...route.params,
-                    ...action.payload.params
-                  } : route.params;
-                } else {
-                  params = createParamsFromAction({
-                    action,
-                    routeParamList
-                  });
-                }
-                const path = action.type === 'NAVIGATE' && action.payload.path != null ? action.payload.path : route.path;
-                return params !== route.params || path !== route.path ? {
-                  ...route,
-                  key,
-                  path,
-                  params
-                } : route;
-              })
-            }, index, backBehavior, initialRouteName);
-            return {
-              ...updatedState,
-              preloadedRouteKeys: updatedState.preloadedRouteKeys.filter(key => key !== state.routes[updatedState.index].key)
-            };
-          }
-        case 'SET_PARAMS':
-        case 'REPLACE_PARAMS':
-          {
-            const nextState = BaseRouter.getStateForAction(state, action);
-            if (nextState !== null) {
-              const index = nextState.index;
-              if (index != null) {
-                const focusedRoute = nextState.routes[index];
-                const historyItemIndex = state.history.findLastIndex(item => item.key === focusedRoute.key);
-                let updatedHistory = state.history;
-                if (historyItemIndex !== -1) {
-                  updatedHistory = [...state.history];
-                  updatedHistory[historyItemIndex] = {
-                    ...updatedHistory[historyItemIndex],
-                    params: focusedRoute.params
-                  };
-                }
-                return {
-                  ...nextState,
-                  history: updatedHistory
-                };
-              }
-            }
-            return nextState;
-          }
-        case 'GO_BACK':
-          {
-            if (state.history.length === 1) {
-              return null;
-            }
-            const previousHistoryItem = state.history[state.history.length - 2];
-            const previousKey = previousHistoryItem?.key;
-            const index = state.routes.findLastIndex(route => route.key === previousKey);
-            if (index === -1) {
-              return null;
-            }
-            let routes = state.routes;
-            if (backBehavior === 'fullHistory' && routes[index].params !== previousHistoryItem.params) {
-              routes = [...state.routes];
-              routes[index] = {
-                ...routes[index],
-                params: previousHistoryItem.params
-              };
-            }
-            return {
-              ...state,
-              routes,
-              preloadedRouteKeys: state.preloadedRouteKeys.filter(key => key !== state.routes[index].key),
-              history: state.history.slice(0, -1),
-              index
-            };
-          }
-        case 'PRELOAD':
-          {
-            const routeIndex = state.routes.findIndex(route => route.name === action.payload.name);
-            if (routeIndex === -1) {
-              return null;
-            }
-            const route = state.routes[routeIndex];
-            const getId = routeGetIdList[route.name];
-            const currentId = getId?.({
-              params: route.params
-            });
-            const nextId = getId?.({
-              params: action.payload.params
-            });
-            const key = currentId === nextId ? route.key : `${route.name}-${nanoid()}`;
-            const params = createParamsFromAction({
-              action,
-              routeParamList
-            });
-            const newRoute = params !== route.params ? {
-              ...route,
-              key,
-              params
-            } : route;
-            return {
-              ...state,
-              preloadedRouteKeys: state.preloadedRouteKeys.filter(key => key !== route.key).concat(newRoute.key),
-              routes: state.routes.map((route, index) => index === routeIndex ? newRoute : route),
-              history: key === route.key ? state.history : state.history.filter(record => record.key !== route.key)
-            };
-          }
-        default:
-          return BaseRouter.getStateForAction(state, action);
-      }
-    },
-    actionCreators: TabActions
-  };
-  return router;
-}
-//# sourceMappingURL=TabRouter.js.map

package/lib/module/createParamsFromAction.js

@@ -1,16 +0,0 @@
-"use strict";
-
-export function createParamsFromAction({
-  action,
-  routeParamList
-}) {
-  const {
-    name,
-    params
-  } = action.payload;
-  return routeParamList[name] !== undefined ? {
-    ...routeParamList[name],
-    ...params
-  } : params;
-}
-//# sourceMappingURL=createParamsFromAction.js.map

package/lib/module/createRouteFromAction.js

@@ -1,21 +0,0 @@
-"use strict";
-
-import { nanoid } from 'nanoid/non-secure';
-import { createParamsFromAction } from "./createParamsFromAction.js";
-export function createRouteFromAction({
-  action,
-  routeParamList
-}) {
-  const {
-    name
-  } = action.payload;
-  return {
-    key: `${name}-${nanoid()}`,
-    name,
-    params: createParamsFromAction({
-      action,
-      routeParamList
-    })
-  };
-}
-//# sourceMappingURL=createRouteFromAction.js.map

package/lib/module/types.js

@@ -1,4 +0,0 @@
-"use strict";
-
-export {};
-//# sourceMappingURL=types.js.map

package/src/BaseRouter.tsx

@@ -1,86 +0,0 @@
-import { nanoid } from 'nanoid/non-secure';
-
-import type {
-  CommonNavigationAction,
-  NavigationState,
-  PartialState,
-} from './types';
-
-/**
- * Base router object that can be used when writing custom routers.
- * This provides few helper methods to handle common actions such as `RESET`.
- */
-export const BaseRouter = {
-  getStateForAction<State extends NavigationState>(
-    state: State,
-    action: CommonNavigationAction
-  ): State | PartialState<State> | null {
-    switch (action.type) {
-      case 'SET_PARAMS':
-      case 'REPLACE_PARAMS': {
-        const index = action.source
-          ? state.routes.findIndex((r) => r.key === action.source)
-          : state.index;
-
-        if (index === -1) {
-          return null;
-        }
-
-        return {
-          ...state,
-          routes: state.routes.map((r, i) =>
-            i === index
-              ? {
-                  ...r,
-                  params:
-                    action.type === 'REPLACE_PARAMS'
-                      ? action.payload.params
-                      : { ...r.params, ...action.payload.params },
-                }
-              : r
-          ),
-        };
-      }
-
-      case 'RESET': {
-        const nextState = action.payload as State | PartialState<State>;
-
-        if (
-          nextState.routes.length === 0 ||
-          nextState.routes.some(
-            (route: { name: string }) => !state.routeNames.includes(route.name)
-          )
-        ) {
-          return null;
-        }
-
-        if (nextState.stale === false) {
-          if (
-            state.routeNames.length !== nextState.routeNames.length ||
-            nextState.routeNames.some(
-              (name) => !state.routeNames.includes(name)
-            )
-          ) {
-            return null;
-          }
-
-          return {
-            ...nextState,
-            routes: nextState.routes.map((route) =>
-              route.key ? route : { ...route, key: `${route.name}-${nanoid()}` }
-            ),
-          };
-        }
-
-        return nextState;
-      }
-
-      default:
-        return null;
-    }
-  },
-
-  shouldActionChangeFocus(action: CommonNavigationAction) {
-    return action.type === 'NAVIGATE' || action.type === 'NAVIGATE_DEPRECATED';
-  },
-};

package/src/CommonActions.tsx

@@ -1,180 +0,0 @@
-import type { NavigationState, PartialState, Route } from './types';
-
-type ResetState =
-  | PartialState<NavigationState>
-  | NavigationState
-  | (Omit<NavigationState, 'routes'> & {
-      routes: Omit<Route<string>, 'key'>[];
-    });
-
-type GoBackAction = {
-  type: 'GO_BACK';
-  source?: string;
-  target?: string;
-};
-
-type NavigateAction = {
-  type: 'NAVIGATE';
-  payload: {
-    name: string;
-    params?: object;
-    path?: string;
-    merge?: boolean;
-    pop?: boolean;
-  };
-  source?: string;
-  target?: string;
-};
-
-type NavigateDeprecatedAction = {
-  type: 'NAVIGATE_DEPRECATED';
-  payload: {
-    name: string;
-    params?: object;
-    merge?: boolean;
-  };
-  source?: string;
-  target?: string;
-};
-
-type ResetAction = {
-  type: 'RESET';
-  payload: ResetState | undefined;
-  source?: string;
-  target?: string;
-};
-
-type SetParamsAction = {
-  type: 'SET_PARAMS';
-  payload: { params?: object };
-  source?: string;
-  target?: string;
-};
-
-type ReplaceParamsAction = {
-  type: 'REPLACE_PARAMS';
-  payload: { params?: object };
-  source?: string;
-  target?: string;
-};
-
-type PreloadAction = {
-  type: 'PRELOAD';
-  payload: {
-    name: string;
-    params?: object;
-  };
-  source?: string;
-  target?: string;
-};
-
-export type Action =
-  | GoBackAction
-  | NavigateAction
-  | NavigateDeprecatedAction
-  | ResetAction
-  | SetParamsAction
-  | ReplaceParamsAction
-  | PreloadAction;
-
-export function goBack(): Action {
-  return { type: 'GO_BACK' };
-}
-
-export function navigate(
-  name: string,
-  params?: object,
-  options?: {
-    merge?: boolean;
-    pop?: boolean;
-  }
-): Action;
-
-export function navigate(options: {
-  name: string;
-  params?: object;
-  path?: string;
-  merge?: boolean;
-  pop?: boolean;
-}): Action;
-
-export function navigate(...args: any): Action {
-  if (typeof args[0] === 'string') {
-    const [name, params, options] = args;
-
-    if (typeof options === 'boolean') {
-      console.warn(
-        `Passing a boolean as the third argument to 'navigate' is deprecated. Pass '{ merge: true }' instead.`
-      );
-    }
-
-    return {
-      type: 'NAVIGATE',
-      payload: {
-        name,
-        params,
-        merge: typeof options === 'boolean' ? options : options?.merge,
-        pop: options?.pop,
-      },
-    };
-  } else {
-    const payload = args[0] || {};
-
-    if (!('name' in payload)) {
-      throw new Error(
-        'You need to specify a name when calling navigate with an object as the argument. See https://reactnavigation.org/docs/navigation-actions#navigate for usage.'
-      );
-    }
-
-    return { type: 'NAVIGATE', payload };
-  }
-}
-
-export function navigateDeprecated(
-  ...args:
-    | [name: string]
-    | [name: string, params: object | undefined]
-    | [options: { name: string; params?: object }]
-): Action {
-  if (typeof args[0] === 'string') {
-    return {
-      type: 'NAVIGATE_DEPRECATED',
-      payload: { name: args[0], params: args[1] },
-    };
-  } else {
-    const payload = args[0] || {};
-
-    if (!('name' in payload)) {
-      throw new Error(
-        'You need to specify a name when calling navigateDeprecated with an object as the argument. See https://reactnavigation.org/docs/navigation-actions#navigatelegacy for usage.'
-      );
-    }
-
-    return { type: 'NAVIGATE_DEPRECATED', payload };
-  }
-}
-
-export function reset(state: ResetState | undefined) {
-  return { type: 'RESET', payload: state } as const satisfies ResetAction;
-}
-
-export function setParams(params: object) {
-  return {
-    type: 'SET_PARAMS',
-    payload: { params },
-  } as const satisfies SetParamsAction;
-}
-
-export function replaceParams(params: object) {
-  return {
-    type: 'REPLACE_PARAMS',
-    payload: { params },
-  } as const satisfies ReplaceParamsAction;
-}
-
-export function preload(name: string, params?: object) {
-  return {
-    type: 'PRELOAD',
-    payload: { name, params },
-  } as const satisfies PreloadAction;
-}