Enum actions

Author: Wawrzyn321

src/state/GitreeContext.tsx

@@ -8,10 +8,10 @@ import { fetchRepoNames, fetchBranches, fetchFiles } from "../api/api";
 import { TreeRenderer } from "../domain/TreeRenderer";
 
 import { GitreeContextType } from "./types";
-import { actions } from "./actions";
 import { reducer } from "./reducer";
 import { initialState } from "./initialState";
 import { storeOwner, storeToken } from "./storage";
+import { ActionTypes } from "./actions";
 
 export const GitreeContext = React.createContext<GitreeContextType | null>(
   null,
@@ -22,35 +22,35 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
   const value: GitreeContextType = {
     state,
     setOwnerFormCollapsed: (collapsed: boolean) => {
-      dispatch({ type: actions.SET_OWNER_FORM_COLLAPSED, collapsed });
+      dispatch({ type: ActionTypes.SET_OWNER_FORM_COLLAPSED, collapsed });
     },
     setOwner: (owner: string) => {
-      dispatch({ type: actions.SET_OWNER, owner });
+      dispatch({ type: ActionTypes.SET_OWNER, owner });
     },
     setToken: (token: string) => {
-      dispatch({ type: actions.SET_TOKEN, token });
+      dispatch({ type: ActionTypes.SET_TOKEN, token });
     },
     getRepos: async () => {
-      dispatch({ type: actions.FETCH_REPOS });
+      dispatch({ type: ActionTypes.FETCH_REPOS });
       const { owner, token } = state.ownerData;
       try {
         const repos = await fetchRepoNames(owner, token);
         if (!repos.length) {
           dispatch({
-            type: actions.SET_REPOS,
+            type: ActionTypes.SET_REPOS,
             error:
               "This user appears to have no repos. Why don't you try another one?",
             repos,
           });
         } else {
-          dispatch({ type: actions.SET_REPOS, error: null, repos });
+          dispatch({ type: ActionTypes.SET_REPOS, error: null, repos });
           storeOwner(owner);
           storeToken(token);
         }
       } catch (e) {
         if (e instanceof Error) {
           dispatch({
-            type: actions.SET_REPOS,
+            type: ActionTypes.SET_REPOS,
             error: `Can't fetch repos: ${e.message}.`,
             repos: [],
           });
@@ -61,13 +61,13 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
     },
 
     setRepoFormCollapsed: (collapsed: boolean) => {
-      dispatch({ type: actions.SET_REPO_FORM_COLLAPSED, collapsed });
+      dispatch({ type: ActionTypes.SET_REPO_FORM_COLLAPSED, collapsed });
     },
     setRepo: (repo: string) => {
-      dispatch({ type: actions.SET_REPO, repo });
+      dispatch({ type: ActionTypes.SET_REPO, repo });
     },
     getBranches: async () => {
-      dispatch({ type: actions.FETCH_BRANCHES });
+      dispatch({ type: ActionTypes.FETCH_BRANCHES });
       const { owner, token } = state.ownerData;
       const { repo } = state.repoData;
       try {
@@ -78,7 +78,7 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
         const branches = await fetchBranches(owner, token, repo);
         if (!branches.length) {
           dispatch({
-            type: actions.SET_BRANCHES,
+            type: ActionTypes.SET_BRANCHES,
             error:
               "This repo appears to have no branches. Why don't you try another one?",
             branches,
@@ -89,7 +89,7 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
             (b: Branch) => b.name === "master" || b.name === "main",
           );
           dispatch({
-            type: actions.SET_BRANCHES,
+            type: ActionTypes.SET_BRANCHES,
             error: null,
             branches,
             branch: masterBranch ?? null,
@@ -98,7 +98,7 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
       } catch (e) {
         if (e instanceof Error) {
           dispatch({
-            type: actions.SET_BRANCHES,
+            type: ActionTypes.SET_BRANCHES,
             error: `Can't fetch branches: ${e.message}.`,
             branches: [],
             branch: null,
@@ -110,13 +110,13 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
     },
 
     setBranchFormCollapsed: (collapsed: boolean) => {
-      dispatch({ type: actions.SET_BRANCH_FORM_COLLAPSED, collapsed });
+      dispatch({ type: ActionTypes.SET_BRANCH_FORM_COLLAPSED, collapsed });
     },
     setBranch: (branch: Branch) => {
-      dispatch({ type: actions.SET_BRANCH, branch });
+      dispatch({ type: ActionTypes.SET_BRANCH, branch });
     },
     buildTree: async () => {
-      dispatch({ type: actions.FETCH_FILES });
+      dispatch({ type: ActionTypes.FETCH_FILES });
       const { owner, token } = state.ownerData;
       const { repo } = state.repoData;
       const { branch } = state.branchData;
@@ -133,7 +133,7 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
         );
 
         dispatch({
-          type: actions.BUILD_TREE,
+          type: ActionTypes.BUILD_TREE,
           error: null,
           files,
           tree: buildTree(`${repo}@${branch!.name}`, files),
@@ -142,7 +142,7 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
       } catch (e) {
         if (e instanceof Error) {
           dispatch({
-            type: actions.BUILD_TREE,
+            type: ActionTypes.BUILD_TREE,
             error: `Can't fetch files: ${e.message}.`,
             files: [],
             tree: null,
@@ -155,13 +155,13 @@ export const GitreeProvider = ({ children }: { children: React.ReactNode }) => {
     },
 
     setRenderer: (renderer: TreeRenderer) => {
-      dispatch({ type: actions.SET_RENDERER, renderer });
+      dispatch({ type: ActionTypes.SET_RENDERER, renderer });
     },
     setHoveredNode: (hoveredNode: Node | null) => {
-      dispatch({ type: actions.SET_HOVERED_NODE, hoveredNode });
+      dispatch({ type: ActionTypes.SET_HOVERED_NODE, hoveredNode });
     },
     setMainNode: (mainNode: Node | null) => {
-      dispatch({ type: actions.SET_MAIN_NODE, mainNode });
+      dispatch({ type: ActionTypes.SET_MAIN_NODE, mainNode });
     },
   };
 

src/state/actions.ts

@@ -3,109 +3,109 @@ import { Branch } from "../types/Branch";
 import { FileList } from "../types/FileList";
 import { Node } from "../types/Node";
 
-export const actions = {
-  SET_OWNER_FORM_COLLAPSED: "SET_OWNER_FORM_COLLAPSED",
-  SET_OWNER: "SET_OWNER",
-  SET_TOKEN: "SET_TOKEN",
-  FETCH_REPOS: "FETCH_REPOS",
-  SET_REPOS: "SET_REPOS",
-
-  SET_REPO_FORM_COLLAPSED: "SET_REPO_FORM_COLLAPSED",
-  SET_REPO: "SET_REPO",
-  FETCH_BRANCHES: "FETCH_BRANCHES",
-  SET_BRANCHES: "SET_BRANCHES",
-
-  SET_BRANCH_FORM_COLLAPSED: "SET_BRANCH_FORM_COLLAPSED",
-  SET_BRANCH: "SET_BRANCH",
-  FETCH_FILES: "FETCH_FILES",
-  BUILD_TREE: "BUILD_TREE",
-
-  SET_RENDERER: "SET_RENDERER",
-  REDRAW: "REDRAW",
-  SET_HOVERED_NODE: "SET_HOVERED_NODE",
-  SET_MAIN_NODE: "SET_MAIN_NODE",
-} as const;
+export enum ActionTypes {
+  SET_OWNER_FORM_COLLAPSED,
+  SET_OWNER,
+  SET_TOKEN,
+  FETCH_REPOS,
+  SET_REPOS,
+
+  SET_REPO_FORM_COLLAPSED,
+  SET_REPO,
+  FETCH_BRANCHES,
+  SET_BRANCHES,
+
+  SET_BRANCH_FORM_COLLAPSED,
+  SET_BRANCH,
+  FETCH_FILES,
+  BUILD_TREE,
+
+  SET_RENDERER,
+  REDRAW,
+  SET_HOVERED_NODE,
+  SET_MAIN_NODE,
+}
 
 type SetOwnerFormCollapsedAction = {
-  type: "SET_OWNER_FORM_COLLAPSED";
+  type: ActionTypes.SET_OWNER_FORM_COLLAPSED;
   collapsed: boolean;
 };
 
 type SetOwnerAction = {
-  type: "SET_OWNER";
+  type: ActionTypes.SET_OWNER;
   owner: string;
 };
 
 type SetTokenAction = {
-  type: "SET_TOKEN";
+  type: ActionTypes.SET_TOKEN;
   token: string;
 };
 
 type FetchReposAction = {
-  type: "FETCH_REPOS";
+  type: ActionTypes.FETCH_REPOS;
 };
 
 type SetReposAction = {
-  type: "SET_REPOS";
+  type: ActionTypes.SET_REPOS;
   error: string | null;
   repos: string[] | null;
 };
 
 type SetRepoFormCollapsedAction = {
-  type: "SET_REPO_FORM_COLLAPSED";
+  type: ActionTypes.SET_REPO_FORM_COLLAPSED;
   collapsed: boolean;
 };
 
 type SetRepoAction = {
-  type: "SET_REPO";
+  type: ActionTypes.SET_REPO;
   repo: string;
 };
 
 type FetchBranchesAction = {
-  type: "FETCH_BRANCHES";
+  type: ActionTypes.FETCH_BRANCHES;
 };
 
 type SetBranchesAction = {
-  type: "SET_BRANCHES";
+  type: ActionTypes.SET_BRANCHES;
   error: string | null;
   branches: Branch[];
   branch: Branch | null;
 };
 
 type SetBranchCollapsedAction = {
-  type: "SET_BRANCH_FORM_COLLAPSED";
+  type: ActionTypes.SET_BRANCH_FORM_COLLAPSED;
   collapsed: boolean;
 };
 
 type SetBranchAction = {
-  type: "SET_BRANCH";
+  type: ActionTypes.SET_BRANCH;
   branch: Branch;
 };
 
 type FetchFilesAction = {
-  type: "FETCH_FILES";
+  type: ActionTypes.FETCH_FILES;
 };
 
 type BuildTreeAction = {
-  type: "BUILD_TREE";
+  type: ActionTypes.BUILD_TREE;
   tree: Node | null;
   files: FileList["files"];
   error: string | null;
   truncated: boolean;
 };
 
 type SetHoveredNodeAction = {
-  type: "SET_HOVERED_NODE";
+  type: ActionTypes.SET_HOVERED_NODE;
   hoveredNode: Node | null;
 };
 
 type SetMainNodeAction = {
-  type: "SET_MAIN_NODE";
+  type: ActionTypes.SET_MAIN_NODE;
   mainNode: Node | null;
 };
 
 type SetRendererAction = {
-  type: "SET_RENDERER";
+  type: ActionTypes.SET_RENDERER;
   renderer: TreeRenderer;
 };