feat: Refactor ActionWithPayload/ActionWithoutPayload to be uniform

package.json

@@ -82,7 +82,7 @@
     "react": "18.2.0",
     "react-test-renderer": "18.2.0",
     "rimraf": "3.0.2",
-    "rxjs": "7.5.7",
+    "rxjs": "7.8.0",
     "rxjs-marbles": "7.0.1",
     "standard-version": "9.5.0",
     "typescript": "4.9.3"

src/action$.spec.ts

@@ -2,7 +2,7 @@ import { incrementMocks } from './internal/testing/mock';
 import { action$, dispatchAction } from './action$';
 import { take } from 'rxjs/operators';
 import { _namespaceAction } from './namespace';
-import { ActionWithoutPayload } from './types/Action';
+import { UnknownAction } from './internal';
 
 const actions = incrementMocks.marbles.actions;
 
@@ -13,7 +13,7 @@ afterEach(() => {
 });
 
 test('dispatchAction makes action$ emit', () => {
-  let lastAction: ActionWithoutPayload | undefined;
+  let lastAction: UnknownAction | undefined;
   const sub = action$.pipe(take(1)).subscribe((a) => (lastAction = a));
   cleanupFns.push(() => sub.unsubscribe());
 
@@ -22,7 +22,7 @@ test('dispatchAction makes action$ emit', () => {
 });
 
 test('dispatchAction does not remove existing namespace', () => {
-  let lastAction: ActionWithoutPayload | undefined;
+  let lastAction: UnknownAction | undefined;
   const sub = action$.pipe(take(1)).subscribe((a) => (lastAction = a));
   cleanupFns.push(() => sub.unsubscribe());
 

src/actionCreator.spec.ts

@@ -3,11 +3,12 @@ import {
   isActionOfType,
   isValidRxBeachAction,
 } from './actionCreator';
+import { ActionName } from './types/Action';
 
 type Payload = { num: number };
 const myAction = actionCreator<Payload>('[test] three');
 const action = myAction({ num: 3 }) as {
-  type: string;
+  type: ActionName;
   payload: Payload;
   meta: { namespace?: string };
 };
@@ -32,7 +33,7 @@ test('actionCreator should create action objects with the payload', () => {
 });
 test('actionCreator should create action objects with protected type', () => {
   expect(() => {
-    action.type = 'mock';
+    action.type = '[test] mock';
   }).toThrow(TypeError);
 });
 test('actionCreator should create action objects with protected meta', () => {

src/actionCreator.ts

@@ -1,15 +1,19 @@
-import type { Action, VoidPayload } from './types/Action';
-import type { ActionCreator, ActionCreatorFunc } from './types/ActionCreator';
+import type { Action, ActionName, VoidPayload } from './types/Action';
+import type { ActionCreator } from './types/ActionCreator';
 
 /**
- * Untyped `actionCreator`
+ * Create an action creator
  *
- * **You code should not hit this untyped overload**
- * If you see this message in your IDE, you should investigate why TS did not
- * recognize the generic, typed overload of this function.
+ * @param type A name for debugging purposes
+ * @template `Payload` - The payload type for the action
+ * @returns An action creator function that accepts a payload as input, and
+ *          returns a complete action object with that payload and a type unique
+ *          to this action creator
  */
-export const actionCreator: ActionCreatorFunc = (type: string) => {
-  const actionCreatorFn = (payload?: any) =>
+export const actionCreator = <Payload = void>(
+  type: ActionName
+): ActionCreator<Payload> => {
+  const actionCreatorFn = (payload: Payload) =>
     Object.freeze({
       type,
       payload,

src/actionCreator.tspec.ts

@@ -102,6 +102,27 @@ for (const [creatorFn, anAction] of actionPairs) {
 const action1 = actionCreatorWithoutPayload();
 if (isActionOfType(actionCreatorWithoutPayload, action1)) {
   // @ts-expect-error Assert that ActionWithoutPayload does not have a payload
-  // eslint-disable-next-line no-unused-expressions
-  action1.payload;
+  isNonNullish(action1.payload);
 }
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+const isNonNullish = (x: {}) => {
+  /* no-op */
+};
+
+const testIsActionOfType = (action: any) => {
+  if (!isValidRxBeachAction(action)) {
+    return;
+  }
+
+  if (isActionOfType(actionCreatorWithPayload, action)) {
+    return isNonNullish(action.payload);
+  }
+
+  if (isActionOfType(actionCreatorWithoutPayload, action)) {
+    // @ts-expect-error should not have payload
+    return isNonNullish(action.payload);
+  }
+
+  isNonNullish(action.type);
+};

src/internal/testing/utils.ts

@@ -1,8 +1,8 @@
-import { Action } from '../../types/Action';
+import type { Action, ActionName } from '../../types/Action';
 import { VoidPayload } from '../types';
 
 export const mockAction = <P = VoidPayload>(
-  type: string,
+  type: ActionName,
   namespace?: string,
   payload?: P
 ): Action<P> =>

src/internal/types.ts

@@ -1,5 +1,5 @@
 import { OperatorFunction } from 'rxjs';
-import { ActionWithPayload, ActionWithoutPayload } from '../types/Action';
+import { Action, ActionName, ActionWithPayload } from '../types/Action';
 
 export { VoidPayload } from '../types/Action';
 
@@ -10,10 +10,10 @@ export { VoidPayload } from '../types/Action';
  * want to extract a possible `payload` from an action you don't know anything
  * about.
  */
-export type UnknownAction = ActionWithoutPayload & { payload?: unknown };
+export type UnknownAction = Action<unknown>;
 
 export interface ActionCreatorCommon {
-  readonly type: string;
+  readonly type: ActionName;
 }
 
 /**

src/internal/types.tspec.ts

@@ -1,4 +1,3 @@
-import { AssertFalse, Has } from 'conditional-type-checks';
 import { ActionWithPayload, ActionWithoutPayload } from '../types/Action';
 import {
   ActionCreatorWithPayload,
@@ -24,11 +23,6 @@ let unknownActionCreator: UnknownActionCreator;
 unknownAction = actionWithoutPayload;
 unknownAction = actionWithPayload;
 
-type ActionCreatorWithoutPayload_is_not_assibleable_to_UnknownActionCreatorWithPayload =
-  AssertFalse<
-    Has<ActionCreatorWithoutPayload, UnknownActionCreatorWithPayload<unknown>>
-  >;
-
 // ActionCreatorWithPayload and UnkownActionCreatorWithPayload is assignable to each other
 unknownActionCreatorWithPayload = actionCreatorWithPayload;
 actionCreatorWithPayload = unknownActionCreatorWithPayload;

src/namespace.spec.ts

@@ -3,16 +3,17 @@ import { ActionDispatcher } from './types/helpers';
 import { UnknownAction } from './internal/types';
 import { _namespaceAction } from './namespace';
 import { mockAction } from './internal/testing/utils';
+import { ActionName } from './types/Action';
 
-const namespaced = _namespaceAction('namespace', mockAction('type')) as {
-  type: string;
+const namespaced = _namespaceAction('namespace', mockAction('[Mock] type')) as {
+  type: ActionName;
   meta: {
     namespace: string;
   };
 };
 test('_namespaceAction has unwritable type', () => {
   expect(() => {
-    namespaced.type = 'foo';
+    namespaced.type = '[Mock] foo';
   }).toThrow(TypeError);
 });
 
@@ -29,7 +30,7 @@ test('_namespaceAction has unwritable namespace', () => {
 });
 
 test('namespaceActionCreator should create actions with namespace', () => {
-  const type = 'action type';
+  const type: ActionName = '[Mock] action type';
   const namespace = 'new namespace';
   const actionCreator = (payload: number) =>
     mockAction(type, 'old namespace', payload);
@@ -55,7 +56,7 @@ test('namespaceActionDispatcher should invoke the parent dispatcher with namespa
     parentDispatcher
   );
 
-  const actionObject = mockAction('action', 'old namespace');
+  const actionObject = mockAction('[Mock] action', 'old namespace');
 
   childDispatcher(actionObject);
 

src/operators/operators.spec.ts

@@ -30,7 +30,7 @@ test.each`
   ({ payload }: { name: string; payload: unknown }) => {
     marbles((m) => {
       const source = m.hot<ActionWithPayload<any>>('aa', {
-        a: mockAction('', '', payload) as ActionWithPayload<any>,
+        a: mockAction('[Mock] a', '', payload),
       });
       const expected = m.hot('pp', {
         p: payload,

src/persistentDerivedStream.ts

@@ -1,4 +1,4 @@
-import { ObservableInput } from 'rxjs';
+import type { ObservableInput } from 'rxjs';
 import { ObservableState } from './observableState';
 import { stateStreamRegistry } from './stateStreamRegistry';
 

src/routines.spec.ts

@@ -1,7 +1,7 @@
 import { Subject } from 'rxjs';
 import { filter, map } from 'rxjs/operators';
 import { marbles } from 'rxjs-marbles/jest';
-import { ActionWithPayload } from './types/Action';
+import { Action } from './types/Action';
 import {
   Routine,
   collectRoutines,
@@ -18,55 +18,67 @@ beforeAll(() => {
   jest.useFakeTimers();
 });
 
-const actions = {
-  a: mockAction('alpha', undefined, { letter: 'A' }),
-  b: mockAction('bravo', undefined, { letter: 'B' }),
-  c: mockAction('charlie', undefined, { letter: 'C' }),
-  e: mockAction('error'),
+const marbleMap: Record<string, any> = {
+  a: mockAction('[Mock] alpha', undefined, { letter: 'A' }),
+  b: mockAction('[Mock] bravo', undefined, { letter: 'B' }),
+  c: mockAction('[Mock] charlie', undefined, { letter: 'C' }),
+  e: mockAction('[Mock] error'),
   f: mockAction('[Mock] action', undefined, { letter: 'F' }),
 };
-const letters = {
-  A: 'A',
-  B: 'B',
-  C: 'C',
-  F: 'F',
-};
-const lengths = {
-  ...letters,
-  '5': 5,
-  '7': 7,
-};
+
+// Add letter representations to marble map
+for (let i = 'A'.charCodeAt(0); i < 'Z'.charCodeAt(0); i++) {
+  const letter = String.fromCharCode(i);
+  marbleMap[letter] = letter;
+}
+// Add number representations to marble map
+for (let i = 0; i < 10; i++) {
+  // Create marble representations of the 10 first characters
+  // eg. { A: 'A', B: 'B', ...etc }
+  const charCodeA = 'A'.charCodeAt(0);
+  const letter = String.fromCharCode(charCodeA + i);
+  marbleMap[letter] = letter;
+  // Create marble representations of the 10 first numbers from 0
+  marbleMap[`${i}`] = i;
+}
+
 const errors = {
   e: 'error',
 };
 const actionMarbles1 = ' -a----b----c---';
 const letterMarbles = '  -A----B----C---';
-const combinedMarbles = '-(A5)-(B5)-(C7)';
+const combinedMarbles = '-(A0)-(B1)-(C2)';
 const actionMarbles2 = ' -a----e----a---';
 const errorMarbles = '   ------e';
 const errorSub1 = '      ^-----!';
 const errorSub2 = '      ------^--------';
 const singleActionMarble = '  -f---f';
 
 const errorRoutine: Routine<string> = map((a) => {
-  if (a.type === 'error') throw 'error';
+  if (a.type === '[Mock] error') throw 'error';
   return 'passed';
 });
 const lettersRoutine = routine(
-  filter(
-    (action: any): action is ActionWithPayload<{ letter: string }> =>
-      action.payload !== undefined
-  ),
+  filter((action: unknown): action is Action<{ letter: string }> => {
+    const { payload } = action as Action<{ letter: string }>;
+    return Boolean(payload.letter);
+  }),
   extractPayload(),
   map(({ letter }) => letter)
 );
-const lengthRoutine = routine(map(({ type }) => type.length));
+
+const letterToNumberRoutine = routine(
+  map((action) => {
+    const { payload } = action as Action<{ letter: string }>;
+    return payload.letter.charCodeAt(0) - 'A'.charCodeAt(0);
+  })
+);
 
 test(
   'routine pipes multiple operator functions',
   marbles((m) => {
-    const action$ = m.hot(actionMarbles1, actions);
-    const expected$ = m.hot(letterMarbles, letters);
+    const action$ = m.hot(actionMarbles1, marbleMap);
+    const expected$ = m.hot(letterMarbles, marbleMap);
 
     const actual$ = action$.pipe(lettersRoutine);
 
@@ -77,10 +89,10 @@ test(
 test(
   'collectRoutines runs all routines',
   marbles((m) => {
-    const action$ = m.hot(actionMarbles1, actions);
-    const expected$ = m.hot(combinedMarbles, lengths);
+    const action$ = m.hot(actionMarbles1, marbleMap);
+    const expected$ = m.hot(combinedMarbles, marbleMap);
     const actual$ = action$.pipe(
-      collectRoutines(lettersRoutine, lengthRoutine)
+      collectRoutines(lettersRoutine, letterToNumberRoutine)
     );
     m.expect(actual$).toBeObservable(expected$);
   })
@@ -89,7 +101,7 @@ test(
 test(
   'subscribeRoutine subscribes action$',
   marbles((m) => {
-    const action$ = m.hot(actionMarbles1, actions);
+    const action$ = m.hot(actionMarbles1, marbleMap);
     subscribeRoutine(action$, lettersRoutine);
 
     m.expect(action$).toHaveSubscriptions(['^']);
@@ -99,7 +111,7 @@ test(
 test(
   'subscribeRoutine resubscribes on errors',
   marbles((m) => {
-    const action$ = m.hot(actionMarbles2, actions);
+    const action$ = m.hot(actionMarbles2, marbleMap);
 
     subscribeRoutine(action$, errorRoutine);
 
@@ -110,7 +122,7 @@ test(
 test(
   'subscribeRoutine emits errors to error subject',
   marbles((m) => {
-    const action$ = m.hot(actionMarbles2, actions);
+    const action$ = m.hot(actionMarbles2, marbleMap);
     const error$ = new Subject<any>();
 
     subscribeRoutine(action$, errorRoutine, error$);
@@ -122,7 +134,7 @@ test(
 test(
   'tapRoutine register a routine',
   marbles((m) => {
-    const action$ = m.hot(singleActionMarble, actions);
+    const action$ = m.hot(singleActionMarble, marbleMap);
     const action = actionCreator<{ letter: string }>('[Mock] action');
     expect.assertions(2);
     const routineToSubscribe = tapRoutine(action, (payload) =>