chore: Updated dev dependencies. Fixed types. Fixed jest config.

jest.config.js

@@ -8,12 +8,4 @@ export default {
   roots: fastGlob.sync(['packages/*/src'], { onlyDirectories: true }),
   collectCoverageFrom: ['packages/*/src/**/{!(index|testUtils),}.ts'],
   preset: 'ts-jest',
-  globals: {
-    'ts-jest': {
-      tsconfig: {
-        module: 'commonjs',
-        jsx: 'react',
-      },
-    },
-  },
 };

package.json

@@ -29,31 +29,31 @@
     "lerna-publish": "lerna publish from-git"
   },
   "devDependencies": {
-    "@types/jest": "28.1.4",
+    "@types/jest": "29.2.4",
     "@types/shelljs": "0.8.11",
-    "@typescript-eslint/eslint-plugin": "5.30.3",
-    "@typescript-eslint/parser": "5.30.3",
+    "@typescript-eslint/eslint-plugin": "5.46.0",
+    "@typescript-eslint/parser": "5.46.0",
     "ditox": "2.2.0",
     "ditox-react": "2.2.0",
-    "eslint": "8.19.0",
+    "eslint": "8.29.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-eslint-comments": "3.2.0",
     "eslint-plugin-import": "2.26.0",
-    "eslint-plugin-jest": "26.5.3",
+    "eslint-plugin-jest": "27.1.6",
     "eslint-plugin-react-hooks": "4.6.0",
-    "fast-glob": "3.2.11",
-    "husky": "8.0.1",
-    "jest": "28.1.2",
-    "lerna": "5.1.6",
-    "lint-staged": "13.0.3",
+    "fast-glob": "3.2.12",
+    "husky": "8.0.2",
+    "jest": "29.3.1",
+    "lerna": "6.1.0",
+    "lint-staged": "13.1.0",
     "markdown-toc": "1.2.0",
-    "prettier": "2.7.1",
-    "rxjs": "7.5.5",
+    "prettier": "2.8.1",
+    "rxjs": "7.6.0",
     "shelljs": "0.8.5",
-    "ts-jest": "28.0.5",
-    "typedoc": "0.23.4",
-    "typedoc-plugin-markdown": "3.13.2",
-    "typescript": "4.7.4"
+    "ts-jest": "29.0.3",
+    "typedoc": "0.23.21",
+    "typedoc-plugin-markdown": "3.14.0",
+    "typescript": "4.9.4"
   },
   "attributions": [
     {

packages/rx-effects-react/src/mvc.tsx

@@ -18,17 +18,20 @@ export function useInjectableController<Result extends Record<string, unknown>>(
 
 export const useViewController = useInjectableController;
 
-export function useControllerFactory<Args extends unknown[], Result>(
-  factoryDeclaration: (...args: Args) => ControllerFactory<Controller<Result>>,
+export function useControllerFactory<
+  Args extends unknown[],
+  Service extends AnyObject,
+>(
+  factoryDeclaration: (...args: Args) => ControllerFactory<Controller<Service>>,
   ...args: Args
-): Controller<Result> {
+): Controller<Service> {
   const controllerFactory = useMemo(
     () => factoryDeclaration(...args),
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [factoryDeclaration, ...args],
   );
 
-  return useInjectableController<Controller<Result>>(controllerFactory);
+  return useInjectableController<Controller<Service>>(controllerFactory);
 }
 
 export function createViewControllerContainer<T extends AnyObject>(

packages/rx-effects-react/src/useConst.test.ts

@@ -28,7 +28,7 @@ describe('useConst()', () => {
     rerender({ factory: factory2 });
     expect(result.current).toBe(1);
 
-    expect(factory1).toBeCalledTimes(1);
-    expect(factory2).toBeCalledTimes(0);
+    expect(factory1).toHaveBeenCalledTimes(1);
+    expect(factory2).toHaveBeenCalledTimes(0);
   });
 });

packages/rx-effects-react/src/useController.test.ts

@@ -21,10 +21,10 @@ describe('useController()', () => {
     expect(result.current.value).toBe(1);
 
     result.current.action();
-    expect(action).toBeCalledTimes(1);
+    expect(action).toHaveBeenCalledTimes(1);
 
     unmount();
-    expect(destroy).toBeCalledTimes(1);
+    expect(destroy).toHaveBeenCalledTimes(1);
   });
 
   it('should not recreate the controller with empty dependencies after rerendering', () => {
@@ -43,7 +43,7 @@ describe('useController()', () => {
     expect(controller1 === controller2).toBe(true);
 
     unmount();
-    expect(destroy).toBeCalledTimes(1);
+    expect(destroy).toHaveBeenCalledTimes(1);
   });
 
   it('should recreate the controller if a dependency is changed', () => {
@@ -70,6 +70,6 @@ describe('useController()', () => {
     expect(controller3.value).toBe(2);
 
     unmount();
-    expect(destroy).toBeCalledTimes(2);
+    expect(destroy).toHaveBeenCalledTimes(2);
   });
 });

packages/rx-effects-react/src/useObserver.test.ts

@@ -10,7 +10,7 @@ describe('useObserver()', () => {
     renderHook(() => useObserver(source$, listener));
 
     source$.next(1);
-    expect(listener).nthCalledWith(1, 1);
+    expect(listener).toHaveBeenNthCalledWith(1, 1);
   });
 
   it('should subscribe an observer', () => {
@@ -24,8 +24,8 @@ describe('useObserver()', () => {
     source$.next(1);
     source$.complete();
 
-    expect(observer.next).toBeCalledWith(1);
-    expect(observer.complete).toBeCalled();
+    expect(observer.next).toHaveBeenCalledWith(1);
+    expect(observer.complete).toHaveBeenCalled();
   });
 
   it('should resubscribe if a source or listener is changed', () => {
@@ -41,9 +41,9 @@ describe('useObserver()', () => {
     rerender({ source$: source2$, listener: listener1 });
     rerender({ source$: source2$, listener: listener2 });
 
-    expect(listener1).nthCalledWith(1, 1);
-    expect(listener1).nthCalledWith(2, 2);
-    expect(listener2).nthCalledWith(1, 2);
+    expect(listener1).toHaveBeenNthCalledWith(1, 1);
+    expect(listener1).toHaveBeenNthCalledWith(2, 2);
+    expect(listener2).toHaveBeenNthCalledWith(1, 2);
   });
 
   it('should return a subscription', () => {
@@ -55,8 +55,8 @@ describe('useObserver()', () => {
     result.current.unsubscribe();
     source$.next(2);
 
-    expect(listener).toBeCalledTimes(1);
-    expect(listener).toBeCalledWith(1);
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toHaveBeenCalledWith(1);
   });
 
   it('should unsubscribe on unmount', () => {
@@ -70,8 +70,8 @@ describe('useObserver()', () => {
     unmount();
     source$.next(2);
 
-    expect(listener).toBeCalledTimes(1);
-    expect(listener).toBeCalledWith(1);
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toHaveBeenCalledWith(1);
     expect(result.current.closed).toBe(true);
   });
 
@@ -89,9 +89,9 @@ describe('useObserver()', () => {
     rerender({ listener: listener2 });
     source$.next(2);
 
-    expect(listener1).toBeCalledTimes(1);
-    expect(listener1).toBeCalledWith(1);
+    expect(listener1).toHaveBeenCalledTimes(1);
+    expect(listener1).toHaveBeenCalledWith(1);
 
-    expect(listener2).toBeCalledTimes(0);
+    expect(listener2).toHaveBeenCalledTimes(0);
   });
 });

packages/rx-effects/src/controller.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-types */
 
+import { AnyObject, EmptyObject } from './utils';
+
 /**
  * Effects and business logic controller.
  *
@@ -13,9 +15,10 @@
  * }>;
  * ```
  */
-export type Controller<ControllerProps extends {} = {}> = Readonly<
-  {
-    /** Dispose the controller and clean its resources */
-    destroy: () => void;
-  } & ControllerProps
->;
+export type Controller<ControllerProps extends AnyObject = EmptyObject> =
+  Readonly<
+    ControllerProps & {
+      /** Dispose the controller and clean its resources */
+      destroy: () => void;
+    }
+  >;

packages/rx-effects/src/effect.test.ts

@@ -137,7 +137,7 @@ describe('Effect', () => {
   describe('handle()', () => {
     it('should fail in case the source is not observable, action or query', () => {
       const effect = createEffect(() => undefined);
-      expect(() => effect.handle('invalid-value' as any)).toThrowError(
+      expect(() => effect.handle('invalid-value' as any)).toThrow(
         new TypeError('Unexpected source type'),
       );
     });
@@ -205,9 +205,7 @@ describe('Effect', () => {
 
       const theError = new Error('test error');
 
-      expect(() =>
-        effect.handle(throwError(() => theError)),
-      ).not.toThrowError();
+      expect(() => effect.handle(throwError(() => theError))).not.toThrow();
 
       await expect(errorPromise).resolves.toEqual({
         origin: 'source',
@@ -227,7 +225,10 @@ describe('Effect', () => {
       effect.error$.subscribe(({ error }) => onSourceFailed(error));
       effect.handle(throwError(() => new Error('test error')));
 
-      expect(onSourceFailed).nthCalledWith(1, new Error('test error'));
+      expect(onSourceFailed).toHaveBeenNthCalledWith(
+        1,
+        new Error('test error'),
+      );
     });
 
     it('should execute an observable in case the handler returns it', async () => {
@@ -288,9 +289,9 @@ describe('Effect', () => {
       effect.destroy();
       action(3);
 
-      expect(listener).toBeCalledTimes(2);
-      expect(listener).nthCalledWith(1, 1);
-      expect(listener).nthCalledWith(2, 2);
+      expect(listener).toHaveBeenCalledTimes(2);
+      expect(listener).toHaveBeenNthCalledWith(1, 1);
+      expect(listener).toHaveBeenNthCalledWith(2, 2);
     });
 
     it('should completes result observables', async () => {
@@ -400,7 +401,7 @@ describe('GLOBAL_EFFECT_UNHANDLED_ERROR$', () => {
 
     effect.handle(of(1));
 
-    expect(consoleError).toBeCalledWith('Uncaught error in Effect', {
+    expect(consoleError).toHaveBeenCalledWith('Uncaught error in Effect', {
       origin: 'handler',
       event: 1,
       error: 'test error',

packages/rx-effects/src/mvc.ts

@@ -1,10 +1,11 @@
 import { Container, injectable, Token } from 'ditox';
 import { Controller } from './controller';
 import { createScope, Scope } from './scope';
+import { AnyObject } from './utils';
 
-export function createController<T>(
-  factory: (scope: Scope) => T & { destroy?: () => void },
-): Controller<T> {
+export function createController<Service extends AnyObject>(
+  factory: (scope: Scope) => Service & { destroy?: () => void },
+): Controller<Service> {
   const scope = createScope();
 
   const controller = factory(scope);
@@ -19,9 +20,9 @@ export function createController<T>(
   };
 }
 
-export type ControllerFactory<Result> = (
+export type ControllerFactory<Service extends AnyObject> = (
   container: Container,
-) => Controller<Result>;
+) => Controller<Service>;
 
 export type InferredService<Factory> = Factory extends ControllerFactory<
   infer Service
@@ -36,10 +37,13 @@ declare type TokenProps<Props extends ValuesProps> = {
   [K in keyof Props]: Token<Props[K]>;
 };
 
-export function createInjectableController<Props extends ValuesProps, Result>(
+export function createInjectableController<
+  Props extends ValuesProps,
+  Service extends AnyObject,
+>(
   tokens: TokenProps<Props>,
-  factory: (scope: Scope, props: Props) => Result,
-): ControllerFactory<Result> {
+  factory: (scope: Scope, props: Props) => Service,
+): ControllerFactory<Service> {
   return injectable(
     (props) => createController((scope) => factory(scope, props as Props)),
     tokens,
@@ -48,8 +52,11 @@ export function createInjectableController<Props extends ValuesProps, Result>(
 
 export const createViewController = createInjectableController;
 
-export function declareControllerFactory<Result, Args extends unknown[]>(
-  factory: (...args: Args) => ControllerFactory<Result>,
-): (...args: Args) => ControllerFactory<Result> {
+export function declareControllerFactory<
+  Service extends AnyObject,
+  Args extends unknown[],
+>(
+  factory: (...args: Args) => ControllerFactory<Service>,
+): (...args: Args) => ControllerFactory<Service> {
   return factory;
 }