change inference behaviour in old TS versions

Author: phryneas

src/createAction.ts

@@ -1,4 +1,5 @@
 import { Action } from 'redux'
+import { IsUnknownOrNonInferrable } from './tsHelpers';
 
 /**
  * An action with a string type and an associated payload. This is the
@@ -11,9 +12,9 @@ export type PayloadAction<
   P = any,
   T extends string = string,
   M = void
-> = Action<T> & {
-  payload: P
-} & ([M] extends [void] ? {} : { meta: M })
+  > = Action<T> & {
+    payload: P
+  } & ([M] extends [void] ? {} : { meta: M })
 
 export type Diff<T, U> = T extends U ? never : T
 
@@ -28,29 +29,30 @@ export type PayloadActionCreator<
   P = any,
   T extends string = string,
   PA extends PrepareAction<P> | void = void
-> = {
-  type: T
-} & (PA extends (...args: any[]) => any
-  ? (ReturnType<PA> extends { meta: infer M }
+  > = {
+    type: T
+  } & (PA extends (...args: any[]) => any
+    ? (ReturnType<PA> extends { meta: infer M }
       ? (...args: Parameters<PA>) => PayloadAction<P, T, M>
       : (...args: Parameters<PA>) => PayloadAction<P, T>)
-  : (/*
+    : (/*
      * The `P` generic is wrapped with a single-element tuple to prevent the
      * conditional from being checked distributively, thus preserving unions
      * of contra-variant types.
      */
-    [undefined] extends [P]
+      [undefined] extends [P]
       ? {
-          (payload?: undefined): PayloadAction<undefined, T>
-          <PT extends Diff<P, undefined>>(payload?: PT): PayloadAction<PT, T>
-        }
+        (payload?: undefined): PayloadAction<undefined, T>
+        <PT extends Diff<P, undefined>>(payload?: PT): PayloadAction<PT, T>
+      }
       : [void] extends [P]
-      ? {
-          (): PayloadAction<undefined, T>
-        }
-      : {
-          <PT extends P>(payload: PT): PayloadAction<PT, T>
-        }))
+      ? () => PayloadAction<undefined, T>
+      : IsUnknownOrNonInferrable<P,
+        // TS < 3.5 infers non-inferrable types to {}, which does not take `null`. This enforces `undefined` instead.
+        <PT extends unknown>(payload: PT) => PayloadAction<PT, T>,
+        // default behaviour
+        <PT extends P>(payload: PT) => PayloadAction<PT, T>
+      >))
 
 /**
  * A utility function to create an action creator for the given action type

src/tsHelpers.ts

@@ -0,0 +1,31 @@
+// taken from https://github.com/joonhocho/tsdef
+// return True if T is `any`, otherwise return False
+export type IsAny<T, True, False = never> = (
+  | True
+  | False) extends (T extends never ? True : False)
+  ? True
+  : False;
+
+// taken from https://github.com/joonhocho/tsdef
+// return True if T is `unknown`, otherwise return False
+export type IsUnknown<T, True, False = never> = unknown extends T
+  ? IsAny<T, False, True>
+  : False;
+
+export type IsEmptyObj<T, True, False = never> = 
+  T extends any 
+    ? {} extends T 
+      ? IsUnknown<T, False, IsAny<T, False, True>> 
+      : False 
+    : never;
+
+
+/** 
+ * returns True if TS version is above 3.5, False if below.
+ * uses feature detection to detect TS version >= 3.5
+ * * versions below 3.5 will return `{}` for unresolvable interference
+ * * versions above will return `unknown` 
+ * */
+export type AtLeastTS35<True, False> = IsUnknown<ReturnType<<T>() => T>, True, False>;
+
+export type IsUnknownOrNonInferrable<T, True, False> = AtLeastTS35<IsUnknown<T, True, False>, IsEmptyObj<T, True, False>>;

type-tests/files/createSlice.typetest.ts

@@ -153,10 +153,36 @@ function expectType<T>(t: T) {
   expectType<number>(counter.actions.concatMetaStrLen('test').meta)
 
   // typings:expect-error
-  expectType<string>(counter.actions.strLen('test').payload)
+  expectType<string>(counter.actions.incrementByStrLen('test').payload)
 
   // typings:expect-error
-  expectType<string>(counter.actions.strLenMeta('test').meta)
+  expectType<string>(counter.actions.concatMetaStrLen('test').meta)
+}
+
+/*
+ * Test: if no Payload Type is specified, accept any payload
+ * see https://github.com/reduxjs/redux-starter-kit/issues/165
+ */
+{
+  const initialState = {
+    name: null
+  };
+
+
+  const mySlice = createSlice({
+    initialState,
+    reducers: {
+      setName: (state, action) => {
+        state.name = action.payload;
+      }
+    }
+  });
+
+  const x = mySlice.actions.setName;
+
+  mySlice.actions.setName(null);
+  mySlice.actions.setName("asd");
+  mySlice.actions.setName(5);
 }
 
 /*