- Updated to React 18

- Updated for public release
  - Git was reset for privacy reasons

src/App.tsx

@@ -0,0 +1,29 @@
+import { BrowserRouter, Route, Routes } from "react-router-dom";
+import { AboutContainer } from "./features/about/About";
+import { CounterContainer } from "./features/counter/Counter";
+import { HomeContainer } from "./features/home/Home";
+import { Navbar } from "./infrastructure/navbar/Navbar";
+
+function App() {
+  return (
+    <BrowserRouter>
+      <div className="App">
+        <Navbar />
+        <Routes>
+          <Route path="/" element={<HomeContainer />} />
+          <Route path="/about" element={<AboutContainer />} />
+          <Route path="/counter" element={<CounterContainer />} />
+          {/* <Route index element={<Home />} /> */}
+          {/* <Route path="teams" element={<Teams />}>
+              <Route path=":teamId" element={<Team />} />
+              <Route path="new" element={<NewTeamForm />} />
+              <Route index element={<LeagueStandings />} />
+            </Route> */}
+          {/* </Route> */}
+        </Routes>
+      </div>
+    </BrowserRouter>
+  );
+}
+
+export default App;

src/app/hooks.ts

@@ -0,0 +1,6 @@
+import { TypedUseSelectorHook, useDispatch, useSelector } from 'react-redux';
+import type { RootState, AppDispatch } from './store';
+
+// Use throughout your app instead of plain `useDispatch` and `useSelector`
+export const useAppDispatch = () => useDispatch<AppDispatch>();
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;

src/app/store.ts

@@ -0,0 +1,17 @@
+import { configureStore, ThunkAction, Action } from "@reduxjs/toolkit";
+import counterReducer from "../features/counter/state/counterSlice";
+
+export const store = configureStore({
+  reducer: {
+    counter: counterReducer,
+  },
+});
+
+export type AppDispatch = typeof store.dispatch;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppThunk<ReturnType = void> = ThunkAction<
+  ReturnType,
+  RootState,
+  unknown,
+  Action<string>
+>;

src/features/about/About.spec.tsx

@@ -0,0 +1,10 @@
+import { render, screen } from "@testing-library/react";
+import { AboutContainer } from "./About";
+
+describe("About container", () => {
+  it("renders welcome to the about page", () => {
+    render(<AboutContainer />);
+
+    expect(screen.getByText(/Welcome to the about page/i)).toBeInTheDocument();
+  });
+});

src/features/about/About.tsx

@@ -0,0 +1,7 @@
+import { FunctionComponent } from "react";
+
+type Props = {};
+
+export const AboutContainer: FunctionComponent<Props> = () => {
+  return <h1>Welcome to the about page :)</h1>;
+};

src/features/counter/Counter.module.css

@@ -0,0 +1,79 @@
+.row {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.row > button {
+  margin-left: 4px;
+  margin-right: 8px;
+}
+
+.row:not(:last-child) {
+  margin-bottom: 16px;
+}
+
+.value {
+  font-size: 78px;
+  padding-left: 16px;
+  padding-right: 16px;
+  margin-top: 2px;
+  font-family: 'Courier New', Courier, monospace;
+}
+
+.button {
+  appearance: none;
+  background: none;
+  font-size: 32px;
+  padding-left: 12px;
+  padding-right: 12px;
+  outline: none;
+  border: 2px solid transparent;
+  color: rgb(112, 76, 182);
+  padding-bottom: 4px;
+  cursor: pointer;
+  background-color: rgba(112, 76, 182, 0.1);
+  border-radius: 2px;
+  transition: all 0.15s;
+}
+
+.textbox {
+  font-size: 32px;
+  padding: 2px;
+  width: 64px;
+  text-align: center;
+  margin-right: 4px;
+}
+
+.button:hover,
+.button:focus {
+  border: 2px solid rgba(112, 76, 182, 0.4);
+}
+
+.button:active {
+  background-color: rgba(112, 76, 182, 0.2);
+}
+
+.asyncButton {
+  composes: button;
+  position: relative;
+}
+
+.asyncButton:after {
+  content: '';
+  background-color: rgba(112, 76, 182, 0.15);
+  display: block;
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  left: 0;
+  top: 0;
+  opacity: 0;
+  transition: width 1s linear, opacity 0.5s ease 1s;
+}
+
+.asyncButton:active:after {
+  width: 0%;
+  opacity: 1;
+  transition: 0s;
+}

src/features/counter/Counter.tsx

@@ -0,0 +1,69 @@
+import { useState } from "react";
+
+import { useAppDispatch, useAppSelector } from "../../app/hooks";
+import styles from "./Counter.module.css";
+import { incrementAsync } from "./state/actions/incrementAsync";
+import {
+  decrement,
+  increment,
+  incrementByAmount,
+  incrementIfOdd,
+  selectCountAndStatus,
+} from "./state/counterSlice";
+
+export function CounterContainer() {
+  const { value, status } = useAppSelector(selectCountAndStatus);
+  const dispatch = useAppDispatch();
+  const [incrementAmount, setIncrementAmount] = useState("2");
+
+  const incrementValue = Number(incrementAmount) || 0;
+
+  return (
+    <div>
+      Status: {status}
+      <div className={styles.row}>
+        <button
+          className={styles.button}
+          aria-label="Decrement value"
+          onClick={() => dispatch(decrement())}
+        >
+          -
+        </button>
+        <span className={styles.value}>{value}</span>
+        <button
+          className={styles.button}
+          aria-label="Increment value"
+          onClick={() => dispatch(increment())}
+        >
+          +
+        </button>
+      </div>
+      <div className={styles.row}>
+        <input
+          className={styles.textbox}
+          aria-label="Set increment amount"
+          value={incrementAmount}
+          onChange={(e) => setIncrementAmount(e.target.value)}
+        />
+        <button
+          className={styles.button}
+          onClick={() => dispatch(incrementByAmount(incrementValue))}
+        >
+          Add Amount
+        </button>
+        <button
+          className={styles.asyncButton}
+          onClick={() => dispatch(incrementAsync(incrementValue))}
+        >
+          Add Async
+        </button>
+        <button
+          className={styles.button}
+          onClick={() => dispatch(incrementIfOdd(incrementValue))}
+        >
+          Add If Odd
+        </button>
+      </div>
+    </div>
+  );
+}

src/features/counter/models/CounterState.ts

@@ -0,0 +1,4 @@
+export interface CounterState {
+  value: number;
+  status: "idle" | "loading" | "failed";
+}

src/features/counter/services/counterAPI.ts

@@ -0,0 +1,4 @@
+// A mock function to mimic making an async request for data
+export function fetchCount(amount = 1) {
+  return new Promise<{ data: number }>((resolve) => setTimeout(() => resolve({ data: amount }), 500));
+}

src/features/counter/state/actions/incrementAsync.ts

@@ -0,0 +1,13 @@
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { fetchCount } from "../../services/counterAPI";
+
+// The function below is called a thunk and allows us to perform async logic. It
+// can be dispatched like a regular action: `dispatch(incrementAsync(10))`. This
+// will call the thunk with the `dispatch` function as the first argument. Async
+// code can then be executed and other actions can be dispatched. Thunks are
+// typically used to make async requests.
+export const incrementAsync = createAsyncThunk("counter/fetchCount", async (amount: number) => {
+  const response = await fetchCount(amount);
+  // The value we return becomes the `fulfilled` action payload
+  return response.data;
+});

src/features/counter/state/counterSlice.spec.ts

@@ -0,0 +1,34 @@
+import counterReducer, {
+  increment,
+  decrement,
+  incrementByAmount,
+} from "./counterSlice";
+import { CounterState } from "../models/CounterState";
+
+describe("counter reducer", () => {
+  const initialState: CounterState = {
+    value: 3,
+    status: "idle",
+  };
+  it("should handle initial state", () => {
+    expect(counterReducer(undefined, { type: "unknown" })).toEqual({
+      value: 0,
+      status: "idle",
+    });
+  });
+
+  it.only("should handle increment", () => {
+    const actual = counterReducer(initialState, increment());
+    expect(actual.value).toEqual(4);
+  });
+
+  it("should handle decrement", () => {
+    const actual = counterReducer(initialState, decrement());
+    expect(actual.value).toEqual(2);
+  });
+
+  it("should handle incrementByAmount", () => {
+    const actual = counterReducer(initialState, incrementByAmount(2));
+    expect(actual.value).toEqual(5);
+  });
+});

src/features/counter/state/counterSlice.ts

@@ -0,0 +1,73 @@
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+import { AppThunk, RootState } from "../../../app/store";
+import { CounterState } from "../models/CounterState";
+import { incrementAsync } from "./actions/incrementAsync";
+
+const initialState: CounterState = {
+  value: 0,
+  status: "idle",
+};
+
+export const counterSlice = createSlice({
+  name: "counter",
+  initialState,
+  // The `reducers` field lets us define reducers and generate associated actions
+  reducers: {
+    increment: (state) => {
+      // Redux Toolkit allows us to write "mutating" logic in reducers. It
+      // doesn't actually mutate the state because it uses the Immer library,
+      // which detects changes to a "draft state" and produces a brand new
+      // immutable state based off those changes
+      state.value += 1;
+    },
+    decrement: (state) => {
+      state.value -= 1;
+    },
+    // Use the PayloadAction type to declare the type of `action.payload`
+    incrementByAmount: (state, action: PayloadAction<number>) => {
+      state.value += action.payload;
+    },
+  },
+  // The `extraReducers` field lets the slice handle actions defined elsewhere,
+  // including actions generated by createAsyncThunk or in other slices.
+  extraReducers: (builder) => {
+    builder
+      .addCase(incrementAsync.pending, (state) => {
+        state.status = "loading";
+      })
+      .addCase(incrementAsync.fulfilled, (state, action) => {
+        state.status = "idle";
+        state.value += action.payload;
+      })
+      .addCase(incrementAsync.rejected, (state) => {
+        state.status = "failed";
+      });
+  },
+});
+
+export const { increment, decrement, incrementByAmount } = counterSlice.actions;
+
+// The function below is called a selector and allows us to select a value from
+// the state. Selectors can also be defined inline where they're used instead of
+// in the slice file. For example: `useSelector((state: RootState) => state.counter.value)`
+export const selectCount = (state: RootState) => state.counter.value;
+export const selectStatus = (state: RootState) => state.counter.status;
+
+// You can combine related items (such as nr of results + items)
+export const selectCountAndStatus = (state: RootState) => {
+  const { value, status } = state.counter;
+  return { value, status };
+};
+
+// We can also write thunks by hand, which may contain both sync and async logic.
+// Here's an example of conditionally dispatching actions based on current state.
+export const incrementIfOdd =
+  (amount: number): AppThunk =>
+  (dispatch, getState) => {
+    const currentValue = selectCount(getState());
+    if (currentValue % 2 === 1) {
+      dispatch(incrementByAmount(amount));
+    }
+  };
+
+export default counterSlice.reducer;

src/features/home/Home.spec.tsx

@@ -0,0 +1,10 @@
+import { render, screen } from "@testing-library/react";
+import { HomeContainer } from "./Home";
+
+describe("Home component", () => {
+  it("renders learn react link", () => {
+    render(<HomeContainer />);
+
+    expect(screen.getByText(/learn/i)).toBeInTheDocument();
+  });
+});

src/features/home/Home.tsx

@@ -0,0 +1,29 @@
+import { FunctionComponent } from "react";
+
+type Props = {};
+
+export const HomeContainer: FunctionComponent<Props> = () => {
+  return (
+    <header className="App-header">
+      <p>This is the react base app :)</p>
+      <span>
+        <span>Learn </span>
+        <a className="App-link" href="https://reactjs.org/" target="_blank" rel="noopener noreferrer">
+          React
+        </a>
+        <span>, </span>
+        <a className="App-link" href="https://redux.js.org/" target="_blank" rel="noopener noreferrer">
+          Redux
+        </a>
+        <span>, </span>
+        <a className="App-link" href="https://redux-toolkit.js.org/" target="_blank" rel="noopener noreferrer">
+          Redux Toolkit
+        </a>
+        ,<span> and </span>
+        <a className="App-link" href="https://react-redux.js.org/" target="_blank" rel="noopener noreferrer">
+          React Redux
+        </a>
+      </span>
+    </header>
+  );
+};

src/index.css

@@ -0,0 +1,11 @@
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans",
+    "Droid Sans", "Helvetica Neue", sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+code {
+  font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+}

src/index.tsx

@@ -0,0 +1,23 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { Provider } from "react-redux";
+import App from "./App";
+import { store } from "./app/store";
+import "./index.css";
+import reportWebVitals from "./reportWebVitals";
+
+const container = document.getElementById("root")!;
+const root = createRoot(container);
+
+root.render(
+  <React.StrictMode>
+    <Provider store={store}>
+      <App />
+    </Provider>
+  </React.StrictMode>,
+);
+
+// If you want to start measuring performance in your app, pass a function
+// to log results (for example: reportWebVitals(console.log))
+// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
+reportWebVitals();

src/infrastructure/config.ts

@@ -0,0 +1,5 @@
+type RunTimeConfig = {
+  version: number;
+};
+
+export const Config = (window as any).config as RunTimeConfig;

src/infrastructure/navbar/Navbar.css

@@ -0,0 +1,3 @@
+nav a {
+  padding-right: 10px;
+}

src/infrastructure/navbar/Navbar.spec.tsx

@@ -0,0 +1,15 @@
+import { render, screen } from "@testing-library/react";
+import { WithRouter } from "../wrappers/WithRouter";
+import { Navbar } from "./Navbar";
+
+describe("Navbar container", () => {
+  it("renders a navigation section identified by the nav test-id", () => {
+    render(
+      <WithRouter>
+        <Navbar />
+      </WithRouter>,
+    );
+
+    expect(screen.getAllByTestId("nav")?.length).toBeGreaterThan(0);
+  });
+});

src/infrastructure/navbar/Navbar.tsx

@@ -0,0 +1,19 @@
+import { FunctionComponent } from "react";
+import { Link } from "react-router-dom";
+import { Config } from "../config";
+import "./Navbar.css";
+type Props = {};
+
+export const Navbar: FunctionComponent<Props> = () => {
+  return (
+    <>
+      <h1>Our fancy header with navigation.</h1>
+      <p>App version: {JSON.stringify(Config.version)}</p>
+      <nav data-testid="nav">
+        <Link to="/">Home</Link> <Link to="/about">About</Link>
+        <Link to="/counter">Counter</Link>
+        <hr />
+      </nav>
+    </>
+  );
+};

src/infrastructure/wrappers/WithRouter.tsx

@@ -0,0 +1,8 @@
+import { FunctionComponent, ReactNode } from "react";
+import { BrowserRouter } from "react-router-dom";
+
+type Props = { children?: ReactNode };
+
+export const WithRouter: FunctionComponent<Props> = ({ children }) => {
+  return <BrowserRouter>{children}</BrowserRouter>;
+};

src/react-app-env.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+/// <reference types="react" />
+/// <reference types="react-dom" />
+
+declare namespace NodeJS {
+  interface ProcessEnv {
+    readonly NODE_ENV: 'development' | 'production' | 'test';
+    readonly PUBLIC_URL: string;
+  }
+}
+
+declare module '*.avif' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.bmp' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.gif' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.jpg' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.jpeg' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.png' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.webp' {
+    const src: string;
+    export default src;
+}
+
+declare module '*.svg' {
+  import * as React from 'react';
+
+  export const ReactComponent: React.FunctionComponent<React.SVGProps<
+    SVGSVGElement
+  > & { title?: string }>;
+
+  const src: string;
+  export default src;
+}
+
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}

src/reportWebVitals.ts

@@ -0,0 +1,15 @@
+import { ReportHandler } from 'web-vitals';
+
+const reportWebVitals = (onPerfEntry?: ReportHandler) => {
+  if (onPerfEntry && onPerfEntry instanceof Function) {
+    import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
+      getCLS(onPerfEntry);
+      getFID(onPerfEntry);
+      getFCP(onPerfEntry);
+      getLCP(onPerfEntry);
+      getTTFB(onPerfEntry);
+    });
+  }
+};
+
+export default reportWebVitals;

src/setupTests.ts

@@ -0,0 +1,7 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+import "@testing-library/jest-dom/extend-expect";
+
+(window as any).config = require("./../public/config");