@rn-tools/navigation 2.3.0 → 3.0.2

package/src/navigation-reducer.ts

@@ -1,487 +0,0 @@
-import * as React from "react";
-import { ScreenProps as RNScreenProps } from "react-native-screens";
-
-import type {
-  NavigationState,
-  PushScreenOptions,
-  RenderCharts,
-  StackItem,
-  ScreenItem,
-  TabItem,
-} from "./types";
-import {
-  generateScreenId,
-  generateStackId,
-  generateTabId,
-  serializeTabIndexKey,
-} from "./utils";
-
-export let DEFAULT_SLOT_NAME = "DEFAULT_SLOT";
-
-function getInitialState(): NavigationState {
-  return {
-    stacks: {
-      ids: [],
-      lookup: {},
-    },
-    screens: {
-      ids: [],
-      lookup: {},
-    },
-    tabs: {
-      ids: [],
-      lookup: {},
-    },
-    debugModeEnabled: false,
-  };
-}
-
-export let initialState = getInitialState();
-
-export let initialRenderCharts: RenderCharts = {
-  stacksByDepth: {},
-  tabsByDepth: {},
-  tabParentsById: {},
-  stackParentsById: {},
-  stacksByTabIndex: {},
-};
-
-type CreateStackAction = {
-  type: "CREATE_STACK_INSTANCE";
-  stackId?: string;
-  defaultSlotName?: string;
-};
-
-type RegisterStackAction = {
-  type: "REGISTER_STACK";
-  depth: number;
-  isActive: boolean;
-  stackId: string;
-  parentStackId: string;
-  parentTabId: string;
-  tabIndex: number;
-};
-
-type UnregisterStackAction = {
-  type: "UNREGISTER_STACK";
-  stackId: string;
-};
-
-type PushScreenStackAction = PushScreenOptions & {
-  type: "PUSH_SCREEN";
-  element: React.ReactElement<RNScreenProps>;
-};
-
-type PopScreenByCountAction = {
-  type: "POP_SCREEN_BY_COUNT";
-  count: number;
-  stackId: string;
-};
-
-type PopScreenByKeyAction = {
-  type: "POP_SCREEN_BY_KEY";
-  key: string;
-};
-
-type StackActions =
-  | CreateStackAction
-  | RegisterStackAction
-  | UnregisterStackAction
-  | PushScreenStackAction
-  | PopScreenByCountAction
-  | PopScreenByKeyAction;
-
-type CreateTabAction = {
-  type: "CREATE_TAB_INSTANCE";
-  tabId?: string;
-  initialActiveIndex?: number;
-};
-
-type SetTabIndexAction = {
-  type: "SET_TAB_INDEX";
-  index: number;
-  tabId: string;
-};
-
-type PopActiveTabAction = {
-  type: "POP_ACTIVE_TAB";
-  tabId: string;
-  index: number;
-};
-
-type RegisterTabAction = {
-  type: "REGISTER_TAB";
-  depth: number;
-  tabId: string;
-  isActive: boolean;
-  parentTabId?: string;
-};
-
-type UnregisterTabAction = {
-  type: "UNREGISTER_TAB";
-  tabId: string;
-};
-
-type TabBackAction = {
-  type: "TAB_BACK";
-  tabId: string;
-};
-
-type TabActions =
-  | CreateTabAction
-  | SetTabIndexAction
-  | RegisterTabAction
-  | UnregisterTabAction
-  | TabBackAction
-  | PopActiveTabAction;
-
-type SetDebugModeAction = {
-  type: "SET_DEBUG_MODE";
-  enabled: boolean;
-};
-
-type DebugActions = SetDebugModeAction;
-
-type ResetNavigationAction = {
-  type: "RESET_NAVIGATION";
-};
-
-export type NavigationAction =
-  | StackActions
-  | TabActions
-  | DebugActions
-  | ResetNavigationAction;
-
-export function reducer(
-  state: NavigationState,
-  action: NavigationAction,
-  context: { renderCharts: RenderCharts }
-): NavigationState {
-  switch (action.type) {
-    case "CREATE_STACK_INSTANCE": {
-      action.stackId = action.stackId || generateStackId();
-
-      let initialStack: StackItem = {
-        id: action.stackId,
-        defaultSlotName: action.defaultSlotName || DEFAULT_SLOT_NAME,
-        screens: [],
-      };
-
-      let nextState = Object.assign({}, state);
-      nextState.stacks.ids = nextState.stacks.ids
-        .filter((id) => id !== initialStack.id)
-        .concat(initialStack.id);
-
-      nextState.stacks.lookup[action.stackId] = initialStack;
-      return nextState;
-    }
-
-    case "REGISTER_STACK": {
-      let { depth, isActive, stackId, parentStackId, parentTabId, tabIndex } =
-        action;
-      let { renderCharts } = context;
-
-      renderCharts.stacksByDepth[depth] =
-        renderCharts.stacksByDepth[depth] || [];
-
-      Object.keys(renderCharts.stacksByDepth).forEach((depth) => {
-        renderCharts.stacksByDepth[depth] = renderCharts.stacksByDepth[
-          depth
-        ].filter((id) => id !== stackId);
-      });
-
-      if (isActive && !renderCharts.stacksByDepth[depth].includes(stackId)) {
-        renderCharts.stacksByDepth[depth].push(stackId);
-      }
-
-      if (parentStackId) {
-        renderCharts.stackParentsById[stackId] = parentStackId;
-      }
-
-      if (parentTabId) {
-        let tabIndexKey = serializeTabIndexKey(parentTabId, tabIndex);
-        renderCharts.stacksByTabIndex[tabIndexKey] =
-          renderCharts.stacksByTabIndex[tabIndexKey] || [];
-
-        if (!renderCharts.stacksByTabIndex[tabIndexKey].includes(stackId)) {
-          renderCharts.stacksByTabIndex[tabIndexKey].push(stackId);
-        }
-      }
-
-      return state;
-    }
-
-    case "UNREGISTER_STACK": {
-      let { stackId } = action;
-      let { renderCharts } = context;
-
-      let nextState = Object.assign({}, state);
-
-      for (let depth in renderCharts.stacksByDepth) {
-        renderCharts.stacksByDepth[depth] = renderCharts.stacksByDepth[
-          depth
-        ].filter((id) => id !== stackId);
-      }
-
-      let stack = state.stacks.lookup[stackId];
-
-      if (stack && renderCharts.stackParentsById[stackId] != null) {
-        stack.screens.forEach((screenId) => {
-          delete nextState.screens.lookup[screenId];
-          nextState.screens.ids = nextState.screens.ids.filter(
-            (id) => id !== screenId
-          );
-        });
-
-        nextState.stacks.ids = nextState.stacks.ids.filter(
-          (id) => id !== stackId
-        );
-        delete nextState.stacks.lookup[stackId];
-      }
-
-      return nextState;
-    }
-
-    case "PUSH_SCREEN": {
-      let { element, stackId, screenId, slotName } = action;
-      let stack = state.stacks.lookup[stackId];
-
-      if (!stack) {
-        if (state.debugModeEnabled) {
-          console.warn("Stack not found: ", stackId);
-        }
-        return state;
-      }
-
-      if (screenId && state.screens.lookup[screenId] != null) {
-        return state;
-      }
-
-      let nextState = Object.assign({}, state);
-
-      let screenItem: ScreenItem = {
-        element,
-        slotName: slotName || stack.defaultSlotName,
-        id: screenId || generateScreenId(),
-        stackId: stack.id,
-      };
-
-      nextState.screens.ids = nextState.screens.ids.concat(screenItem.id);
-      nextState.screens.lookup[screenItem.id] = screenItem;
-
-      nextState.stacks.lookup[stackId] = Object.assign(stack, {
-        screens: stack.screens
-          .filter((id) => id !== screenItem.id)
-          .concat(screenItem.id),
-      });
-
-      return nextState;
-    }
-
-    case "POP_SCREEN_BY_COUNT": {
-      let { count, stackId } = action;
-      let stack = state.stacks.lookup[stackId];
-
-      if (!stack) {
-        if (state.debugModeEnabled) {
-          console.warn("Stack not found: ", stackId);
-        }
-        return state;
-      }
-
-      if (count === -1) {
-        count = stack.screens.length;
-      }
-
-      let nextState = Object.assign({}, state);
-      let poppedScreenIds = nextState.stacks.lookup[stackId].screens.splice(
-        -count,
-        count
-      );
-
-      poppedScreenIds.forEach((screenId) => {
-        delete nextState.screens.lookup[screenId];
-        nextState.screens.ids = nextState.screens.ids.filter(
-          (id) => id !== screenId
-        );
-      });
-
-      return nextState;
-    }
-
-    case "POP_SCREEN_BY_KEY": {
-      let { key } = action;
-
-      let stackId = state.screens.lookup[key]?.stackId;
-      let stack = state.stacks.lookup[stackId];
-
-      if (!stack) {
-        if (state.debugModeEnabled) {
-          console.warn("Stack not found: ", stackId);
-        }
-
-        return state;
-      }
-
-      let nextState = Object.assign({}, state);
-
-      nextState.stacks.lookup[stackId] = Object.assign(stack, {
-        screens: stack.screens.filter((screenId) => screenId !== key),
-      });
-
-      delete nextState.screens.lookup[key];
-
-      nextState.screens = {
-        ids: nextState.screens.ids.filter((id) => id !== key),
-        lookup: nextState.screens.lookup,
-      };
-
-      return nextState;
-    }
-
-    case "CREATE_TAB_INSTANCE": {
-      let { tabId, initialActiveIndex = 0 } = action;
-
-      let initialTabs: TabItem = {
-        id: tabId || generateTabId(),
-        activeIndex: initialActiveIndex,
-        history: [],
-      };
-
-      let nextState = Object.assign({}, state);
-
-      nextState.tabs.lookup[initialTabs.id] = initialTabs;
-      nextState.tabs.ids = nextState.tabs.ids
-        .filter((id) => id !== initialTabs.id)
-        .concat(initialTabs.id);
-
-      return nextState;
-    }
-
-    case "SET_TAB_INDEX": {
-      let { tabId, index } = action;
-      let { renderCharts } = context;
-
-      let tab = state.tabs.lookup[tabId];
-      if (!tab) {
-        if (state.debugModeEnabled) {
-          console.warn("Tab not found: ", tabId);
-        }
-
-        return state;
-      }
-
-      let nextState: NavigationState = Object.assign({}, state);
-      let currentIndex = tab.activeIndex;
-      nextState.tabs.lookup[tabId] = Object.assign(
-        {},
-        {
-          ...nextState.tabs.lookup[tabId],
-          activeIndex: index,
-          history: tab.history.filter((i) => i !== index).concat(currentIndex),
-        }
-      );
-
-      return nextState;
-    }
-
-    case "POP_ACTIVE_TAB": {
-      let { tabId, index } = action;
-      let { renderCharts } = context;
-
-      let tabKey = serializeTabIndexKey(tabId, index);
-      let stackIds = renderCharts.stacksByTabIndex[tabKey];
-
-      let nextState: NavigationState = Object.assign({}, state);
-
-      if (stackIds?.length > 0) {
-        stackIds.forEach((stackId) => {
-          let stack = nextState.stacks.lookup[stackId];
-          let screenIdsToRemove = stack.screens;
-
-          let nextScreensLookup = Object.assign({}, nextState.screens.lookup);
-
-          screenIdsToRemove.forEach((id) => {
-            delete nextScreensLookup[id];
-          });
-
-          nextState.stacks.lookup[stackId].screens = [];
-          nextState.screens.ids = nextState.screens.ids.filter(
-            (id) => !screenIdsToRemove.includes(id)
-          );
-          nextState.screens.lookup = nextScreensLookup;
-        });
-      }
-
-      return nextState;
-    }
-
-    case "REGISTER_TAB": {
-      let { depth, tabId, parentTabId, isActive } = action;
-      let { renderCharts } = context;
-      renderCharts.tabsByDepth[depth] = renderCharts.tabsByDepth[depth] || [];
-
-      Object.keys(renderCharts.tabsByDepth).forEach((depth) => {
-        renderCharts.tabsByDepth[depth] = renderCharts.tabsByDepth[
-          depth
-        ].filter((id) => id !== tabId);
-      });
-
-      renderCharts.tabParentsById[tabId] = parentTabId ?? "";
-
-      if (isActive) {
-        renderCharts.tabsByDepth[depth]?.push(tabId);
-      }
-      return state;
-    }
-
-    case "UNREGISTER_TAB": {
-      let { tabId } = action;
-      let { renderCharts } = context;
-      for (let depth in renderCharts.tabsByDepth) {
-        renderCharts.tabsByDepth[depth] = renderCharts.tabsByDepth[
-          depth
-        ].filter((id) => id !== tabId);
-      }
-
-      let nextState: NavigationState = Object.assign({}, state);
-
-      nextState.tabs.ids = state.tabs.ids.filter((id) => id !== tabId);
-      delete nextState.tabs.lookup[tabId];
-
-      return nextState;
-    }
-
-    case "TAB_BACK": {
-      let { tabId } = action;
-      let nextState: NavigationState = Object.assign({}, state);
-
-      let tab = nextState.tabs.lookup[tabId];
-
-      let lastActiveIndex = tab.history[tab.history.length - 1];
-
-      nextState.tabs.lookup = Object.assign({}, nextState.tabs.lookup, {
-        [tabId]: Object.assign({}, nextState.tabs.lookup[tabId], {
-          activeIndex: lastActiveIndex,
-          history: tab.history.filter((i) => i !== lastActiveIndex),
-        }),
-      });
-
-      return nextState;
-    }
-
-    case "SET_DEBUG_MODE": {
-      let { enabled } = action;
-      return Object.assign(state, { debugModeEnabled: enabled });
-    }
-
-    case "RESET_NAVIGATION": {
-      context.renderCharts = initialRenderCharts;
-      return getInitialState();
-    }
-
-    default: {
-      return state;
-    }
-  }
-}

package/src/navigation-store.ts

@@ -1,58 +0,0 @@
-import * as React from "react";
-import { createStore, useStore as useStoreContext } from "zustand";
-import { devtools, redux } from "zustand/middleware";
-
-import {
-  initialRenderCharts,
-  initialState,
-  reducer as navigationReducer,
-  type NavigationAction,
-} from "./navigation-reducer";
-import type { NavigationState } from "./types";
-
-export type NavigationStore = ReturnType<typeof createNavigationStore>;
-
-export function createNavigationStore() {
-  let renderCharts = Object.assign({}, initialRenderCharts);
-
-  let reducer = (state: NavigationState, action: NavigationAction) => {
-    let nextState = navigationReducer(state, action, { renderCharts });
-    if (nextState.debugModeEnabled) {
-      console.debug(
-        `[@rntoolkit/navigation] action: ${action.type}`,
-        state,
-        nextState
-      );
-    }
-    return { ...nextState };
-  };
-
-  let store = createStore(devtools(redux(reducer, initialState)));
-
-  return {
-    store: store,
-    dispatch: store.dispatch,
-    renderCharts,
-  };
-}
-
-export let rootStore = createNavigationStore();
-export let NavigationStateContext = React.createContext(rootStore.store);
-export let NavigationDispatchContext = React.createContext(rootStore.dispatch);
-
-export function useNavigationState<T>(
-  selector?: (state: NavigationState) => T
-) {
-  let context = React.useContext(NavigationStateContext);
-  return useStoreContext(context, selector);
-}
-
-export function useNavigationDispatch() {
-  let dispatch = React.useContext(NavigationDispatchContext);
-  return dispatch;
-}
-
-export function useGetNavigationStore() {
-  let context = React.useContext(NavigationStateContext);
-  return context.getState
-}

package/src/types.ts

@@ -1,48 +0,0 @@
-export type PushScreenOptions = {
-  stackId?: string;
-  slotName?: string;
-  screenId?: string;
-};
-
-export type StackItem = {
-  id: string;
-  defaultSlotName?: string;
-  screens: string[];
-};
-
-export type ScreenItem = {
-  id: string;
-  stackId: string;
-  element: React.ReactElement<unknown>;
-  slotName?: string;
-};
-
-export type TabItem = {
-  id: string;
-  activeIndex: number;
-  history: number[];
-};
-
-export type NavigationState = {
-  stacks: {
-    lookup: Record<string, StackItem>;
-    ids: string[];
-  };
-  tabs: {
-    lookup: Record<string, TabItem>;
-    ids: string[];
-  };
-  screens: {
-    lookup: Record<string, ScreenItem>;
-    ids: string[];
-  };
-  debugModeEnabled: boolean;
-};
-
-export type RenderCharts = {
-  stacksByDepth: Record<string, string[]>;
-  tabsByDepth: Record<string, string[]>;
-  tabParentsById: Record<string, string>;
-  stackParentsById: Record<string, string>;
-  stacksByTabIndex: Record<string, string[]>;
-};

package/src/utils.ts

@@ -1,40 +0,0 @@
-import { Platform } from 'react-native';
-
-export let generateStackId = createIdGenerator("stack");
-export let generateScreenId = createIdGenerator("screen");
-export let generateTabId = createIdGenerator("tab");
-
-function createIdGenerator(name: string) {
-  let counter = 0;
-
-  return function generateId() {
-    return name + "-" + counter++;
-  };
-}
-
-export let serializeTabIndexKey = (tabId: string, index: number) =>
-  `${tabId}-${index}`;
-
-
-
-
-let baseInsets = {
-  top: Platform.OS === "ios" ? 59 : 49,
-  bottom: Platform.OS === "ios" ? 34 : 0,
-  right: 0,
-  left: 0,
-};
-
-export function useSafeAreaInsetsSafe() {
-  let insets = baseInsets;
-
-  try {
-    // Linter thinks this is conditional but it seems fine
-    // eslint-disable-next-line
-    insets = baseInsets;
-  } catch (error) {
-    console.warn("`react-native-safe-area-context` missing - Please install and wrap your app in a SafeAreaProvider");
-  }
-
-  return insets;
-}