Fix templates directory structure to produce correct nupkg output

templates/Microsoft.DotNet.Web.Spa.ProjectTemplates/redux/ClientApp/store/Counter.ts

@@ -0,0 +1,48 @@
+import { Action, Reducer } from 'redux';
+
+// -----------------
+// STATE - This defines the type of data maintained in the Redux store.
+
+export interface CounterState {
+    count: number;
+}
+
+// -----------------
+// ACTIONS - These are serializable (hence replayable) descriptions of state transitions.
+// They do not themselves have any side-effects; they just describe something that is going to happen.
+// Use @typeName and isActionType for type detection that works even after serialization/deserialization.
+
+interface IncrementCountAction { type: 'INCREMENT_COUNT' }
+interface DecrementCountAction { type: 'DECREMENT_COUNT' }
+
+// Declare a 'discriminated union' type. This guarantees that all references to 'type' properties contain one of the
+// declared type strings (and not any other arbitrary string).
+type KnownAction = IncrementCountAction | DecrementCountAction;
+
+// ----------------
+// ACTION CREATORS - These are functions exposed to UI components that will trigger a state transition.
+// They don't directly mutate state, but they can have external side-effects (such as loading data).
+
+export const actionCreators = {
+    increment: () => <IncrementCountAction>{ type: 'INCREMENT_COUNT' },
+    decrement: () => <DecrementCountAction>{ type: 'DECREMENT_COUNT' }
+};
+
+// ----------------
+// REDUCER - For a given state and action, returns the new state. To support time travel, this must not mutate the old state.
+
+export const reducer: Reducer<CounterState> = (state: CounterState, action: KnownAction) => {
+    switch (action.type) {
+        case 'INCREMENT_COUNT':
+            return { count: state.count + 1 };
+        case 'DECREMENT_COUNT':
+            return { count: state.count - 1 };
+        default:
+            // The following line guarantees that every action in the KnownAction union has been covered by a case above
+            const exhaustiveCheck: never = action;
+    }
+
+    // For unrecognized actions (or in cases where actions have no effect), must return the existing state
+    //  (or default initial state if none was supplied)
+    return state || { count: 0 };
+};

templates/Microsoft.DotNet.Web.Spa.ProjectTemplates/redux/ClientApp/store/WeatherForecasts.ts

@@ -0,0 +1,91 @@
+import { fetch, addTask } from 'domain-task';
+import { Action, Reducer, ActionCreator } from 'redux';
+import { AppThunkAction } from './';
+
+// -----------------
+// STATE - This defines the type of data maintained in the Redux store.
+
+export interface WeatherForecastsState {
+    isLoading: boolean;
+    startDateIndex?: number;
+    forecasts: WeatherForecast[];
+}
+
+export interface WeatherForecast {
+    dateFormatted: string;
+    temperatureC: number;
+    temperatureF: number;
+    summary: string;
+}
+
+// -----------------
+// ACTIONS - These are serializable (hence replayable) descriptions of state transitions.
+// They do not themselves have any side-effects; they just describe something that is going to happen.
+
+interface RequestWeatherForecastsAction {
+    type: 'REQUEST_WEATHER_FORECASTS';
+    startDateIndex: number;
+}
+
+interface ReceiveWeatherForecastsAction {
+    type: 'RECEIVE_WEATHER_FORECASTS';
+    startDateIndex: number;
+    forecasts: WeatherForecast[];
+}
+
+// Declare a 'discriminated union' type. This guarantees that all references to 'type' properties contain one of the
+// declared type strings (and not any other arbitrary string).
+type KnownAction = RequestWeatherForecastsAction | ReceiveWeatherForecastsAction;
+
+// ----------------
+// ACTION CREATORS - These are functions exposed to UI components that will trigger a state transition.
+// They don't directly mutate state, but they can have external side-effects (such as loading data).
+
+export const actionCreators = {
+    requestWeatherForecasts: (startDateIndex: number): AppThunkAction<KnownAction> => (dispatch, getState) => {
+        // Only load data if it's something we don't already have (and are not already loading)
+        if (startDateIndex !== getState().weatherForecasts.startDateIndex) {
+            let fetchTask = fetch(`api/SampleData/WeatherForecasts?startDateIndex=${ startDateIndex }`)
+                .then(response => response.json() as Promise<WeatherForecast[]>)
+                .then(data => {
+                    dispatch({ type: 'RECEIVE_WEATHER_FORECASTS', startDateIndex: startDateIndex, forecasts: data });
+                });
+
+            addTask(fetchTask); // Ensure server-side prerendering waits for this to complete
+            dispatch({ type: 'REQUEST_WEATHER_FORECASTS', startDateIndex: startDateIndex });
+        }
+    }
+};
+
+// ----------------
+// REDUCER - For a given state and action, returns the new state. To support time travel, this must not mutate the old state.
+
+const unloadedState: WeatherForecastsState = { forecasts: [], isLoading: false };
+
+export const reducer: Reducer<WeatherForecastsState> = (state: WeatherForecastsState, incomingAction: Action) => {
+    const action = incomingAction as KnownAction;
+    switch (action.type) {
+        case 'REQUEST_WEATHER_FORECASTS':
+            return {
+                startDateIndex: action.startDateIndex,
+                forecasts: state.forecasts,
+                isLoading: true
+            };
+        case 'RECEIVE_WEATHER_FORECASTS':
+            // Only accept the incoming data if it matches the most recent request. This ensures we correctly
+            // handle out-of-order responses.
+            if (action.startDateIndex === state.startDateIndex) {
+                return {
+                    startDateIndex: action.startDateIndex,
+                    forecasts: action.forecasts,
+                    isLoading: false
+                };
+            }
+            break;
+        default:
+            // The following line guarantees that every action in the KnownAction union has been covered by a case above
+            const exhaustiveCheck: never = action;
+    }
+
+    return state || unloadedState;
+};

templates/Microsoft.DotNet.Web.Spa.ProjectTemplates/redux/ClientApp/store/index.ts

@@ -0,0 +1,22 @@
+import * as WeatherForecasts from './WeatherForecasts';
+import * as Counter from './Counter';
+
+// The top-level state object
+export interface ApplicationState {
+    counter: Counter.CounterState;
+    weatherForecasts: WeatherForecasts.WeatherForecastsState;
+}
+
+// Whenever an action is dispatched, Redux will update each top-level application state property using
+// the reducer with the matching name. It's important that the names match exactly, and that the reducer
+// acts on the corresponding ApplicationState property type.
+export const reducers = {
+    counter: Counter.reducer,
+    weatherForecasts: WeatherForecasts.reducer
+};
+
+// This type can be used as a hint on action creators so that its 'dispatch' and 'getState' params are
+// correctly typed to match your store.
+export interface AppThunkAction<TAction> {
+    (dispatch: (action: TAction) => void, getState: () => ApplicationState): void;
+}