Removed boilerplate

package.json

@@ -3,6 +3,7 @@
   "private": true,
   "version": "0.0.0",
   "type": "module",
+  "description": "",
   "scripts": {
     "dev": "vite",
     "start": "vite",
@@ -16,7 +17,14 @@
     "test": "vitest",
     "format": "prettier --write .",
     "lint": "eslint .",
-    "type-check": "tsc"
+    "type-check": "tsc",
+    "sm:add": "git submodule add",
+    "sm:update": "git submodule update --remote --merge",
+    "sm:init": "git submodule init && git submodule update",
+    "sm:status": "git submodule status",
+    "sm:push": "git submodule foreach 'git push origin main'",
+    "sm:pull": "git submodule foreach 'git pull origin main'",
+    "sm:sync": "git submodule sync && git submodule update --init --recursive"
   },
   "dependencies": {
     "@reduxjs/toolkit": "^1.8.1",
@@ -40,6 +48,7 @@
     "eslint-config-react-app": "^7.0.1",
     "eslint-plugin-prettier": "^4.2.1",
     "jsdom": "^21.1.0",
+    "lerna": "^8.1.8",
     "plop": "^3.1.2",
     "prettier": "^2.7.1",
     "prettier-config-nick": "^1.0.2",

src/app/pages/Home/Home.module.scss

@@ -1,3 +0,0 @@
-.c-Home {
-  
-}

src/app/pages/Home/Home.slice.ts

@@ -1,18 +0,0 @@
-import { createSlice } from "@reduxjs/toolkit"
-
-export interface HomeState {}
-
-const initialState: HomeState = {}
-
-export const homeSlice = createSlice({
-  name: "home",
-  initialState,
-  reducers: {
-    increment: (state) => {},
-  },
-  extraReducers: (builder) => {},
-})
-
-export const { increment } = homeSlice.actions
-
-export default homeSlice.reducer

src/app/pages/Home/Home.test.ts

@@ -1,8 +0,0 @@
-import React from "react"
-import Home from "./Home"
-
-describe("Home", () => {
-   it("renders without error", () => {
-
-   })
-})

src/app/pages/Home/Home.tsx

@@ -1,14 +0,0 @@
-import React from "react"
-import "./Home.module.scss"
-
-interface HomeProps {}
-
-const Home = props => {
-  return (
-    <div className="c-Home">
-      In Page Home
-    </div>
-  )
-}
-
-export default Home

src/app/pages/Home/index.ts

@@ -1,3 +0,0 @@
-import Home from "./Home.jsx"
-
-export default Home

src/app/pages/index.ts

@@ -1,7 +1,3 @@
 /* PLOP_INJECT_IMPORT */
-import Home from "./Home"
 
-export {
-  /* PLOP_INJECT_EXPORT */
-	Home,
-}
+export /* PLOP_INJECT_EXPORT */ {}

src/features/counter/Counter.tsx

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

src/features/counter/counterAPI.ts

@@ -1,6 +0,0 @@
-// 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/counterSlice.spec.ts

@@ -1,34 +0,0 @@
-import counterReducer, {
-  CounterState,
-  increment,
-  decrement,
-  incrementByAmount,
-} from "./counterSlice"
-
-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("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/counterSlice.ts

@@ -1,84 +0,0 @@
-import { createAsyncThunk, createSlice, PayloadAction } from "@reduxjs/toolkit"
-import { RootState, AppThunk } from "../../app/store"
-import { fetchCount } from "./counterAPI"
-
-export interface CounterState {
-  value: number
-  status: "idle" | "loading" | "failed"
-}
-
-const initialState: CounterState = {
-  value: 0,
-  status: "idle",
-}
-
-// 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
-  },
-)
-
-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 contents 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
-
-// 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