Merge pull request #635 from kwonoj/bump-rxjs

Author: kwonoj

jest.config.js

@@ -1,40 +1,26 @@
 const isWallaby = !!process.env.WALLABY_ENV;
 
 module.exports = {
-  "preset": "ts-jest",
-  "testMatch": [
-    "**/spec/**/*-spec.ts"
-  ],
-  "globals": {
-    "ts-jest": {
-      "diagnostics": false
-    }
+  preset: 'ts-jest',
+  testMatch: ['**/spec/**/*-spec.ts'],
+  globals: {
+    'ts-jest': {
+      diagnostics: false,
+    },
   },
-  "bail": true,
-  "testEnvironment": "node",
-  "moduleFileExtensions": [
-    "js",
-    "jsx",
-    "json",
-    "ts",
-    "tsx"
-  ],
-  "testPathIgnorePatterns": [
-    "/.tmp/"
-  ],
-  "coverageReporters": [
-    "lcov"
-  ],
-  reporters: !isWallaby ? [ "jest-spin-reporter" ] : undefined,
-  "collectCoverageFrom": [
-    "src/**/*.{ts, tsx}",
-    "!**/*.d.ts"
+  resolver: '<rootDir>/spec/exportMapResolver.js',
+  bail: true,
+  testEnvironment: 'node',
+  moduleFileExtensions: ['js', 'jsx', 'json', 'ts', 'tsx'],
+  testPathIgnorePatterns: ['/.tmp/'],
+  coverageReporters: ['lcov'],
+  reporters: !isWallaby ? ['jest-spin-reporter'] : undefined,
+  collectCoverageFrom: ['src/**/*.{ts, tsx}', '!**/*.d.ts'],
+  coveragePathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '<rootDir>/spec/.*\\.(ts|js)$',
+    '<rootDir>/build/.*\\.(ts|js)$',
+    '<rootDir>/src/RxSandbox.ts',
+    '<rootDir>/src/RxSandboxInstance.ts',
   ],
-  "coveragePathIgnorePatterns": [
-    "<rootDir>/node_modules/",
-    "<rootDir>/spec/.*\\.(ts|js)$",
-    "<rootDir>/build/.*\\.(ts|js)$",
-    "<rootDir>/src/RxSandbox.ts",
-    "<rootDir>/src/RxSandboxInstance.ts"
-  ]
-}
+};

package-lock.json

@@ -47,26 +47,27 @@
   },
   "homepage": "https://github.com/kwonoj/rx-sandbox#readme",
   "devDependencies": {
-    "@commitlint/cli": "^11.0.0",
-    "@commitlint/config-angular": "^11.0.0",
-    "@types/jest": "^26.0.15",
-    "@types/node": "^14.14.6",
+    "@commitlint/cli": "^12.1.4",
+    "@commitlint/config-angular": "^12.1.4",
+    "@types/jest": "^26.0.23",
+    "@types/node": "^15.3.0",
     "conventional-changelog-cli": "^2.1.1",
     "cz-conventional-changelog": "^3.3.0",
+    "enhanced-resolve": "^5.8.2",
     "husky": "^3.1.0",
     "jest": "^26.6.3",
     "jest-spin-reporter": "^2.0.0",
-    "lint-staged": "^10.5.1",
+    "lint-staged": "^11.0.0",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.1.2",
-    "rxjs": "^7.0.0-beta.0",
+    "prettier": "^2.3.0",
+    "rxjs": "^7.0.1",
     "shx": "^0.3.3",
-    "ts-jest": "^26.4.3",
+    "ts-jest": "^26.5.6",
     "tslint": "^6.1.3",
-    "typescript": "^4.0.5"
+    "typescript": "^4.2.4"
   },
   "peerDependencies": {
-    "rxjs": "^7.0.0-beta.8"
+    "rxjs": "^7.0.1"
   },
   "dependencies": {
     "expect": "^26.6.2",

package.json

@@ -0,0 +1,9 @@
+// temporary workaround while we wait for https://github.com/facebook/jest/issues/9771
+const resolver = require('enhanced-resolve').create.sync({
+  conditionNames: ['require', 'node', 'default', 'import'],
+  extensions: ['.js', '.json', '.node', '.ts'],
+});
+
+module.exports = function (request, options) {
+  return resolver(options.basedir, request);
+};

spec/exportMapResolver.js

@@ -1,9 +1,9 @@
+import { ObservableNotification } from 'rxjs';
 import { complete, error, next, subscribe, TestMessageValue } from '../../src/message/TestMessage';
-import { COMPLETE_NOTIFICATION, errorNotification, nextNotification } from '../../src/utils/coreInternalImport';
 
 describe('TestMessageValue', () => {
   it('should create metadata', () => {
-    const notification = nextNotification('meh');
+    const notification = { kind: 'N', value: 'meh' } as ObservableNotification<string>;
 
     const message = new TestMessageValue(10, notification);
 
@@ -15,19 +15,19 @@ describe('TestMessageValue', () => {
     it('should create next', () => {
       const value = next(10, 'meh');
 
-      expect(value).toEqual(new TestMessageValue(10, nextNotification('meh')));
+      expect(value).toEqual(new TestMessageValue(10, { kind: 'N', value: 'meh' }));
     });
 
     it('should create error', () => {
       const errorValue = error(10, 'meh');
 
-      expect(errorValue).toEqual(new TestMessageValue(10, errorNotification('meh')));
+      expect(errorValue).toEqual(new TestMessageValue(10, { kind: 'E', error: 'meh' }));
     });
 
     it('should create complete', () => {
       const completeValue = complete(10);
 
-      expect(completeValue).toEqual(new TestMessageValue(10, COMPLETE_NOTIFICATION));
+      expect(completeValue).toEqual(new TestMessageValue(10, { kind: 'C' }));
     });
 
     it('should create subscription log', () => {

spec/message/TestMessage-spec.ts

@@ -1,10 +1,5 @@
 import { ObservableNotification } from 'rxjs';
-import {
-  COMPLETE_NOTIFICATION,
-  errorNotification,
-  nextNotification,
-  SubscriptionLog,
-} from '../utils/coreInternalImport';
+import { SubscriptionLog } from '../utils/coreInternalImport';
 
 /**
  * Represents interface for single metadata value emitted by HotObservable<T> or ColdObservable<T>
@@ -29,22 +24,21 @@ class TestMessageValue<T = string> implements TestMessage<T> {
  * @param value
  */
 
-const next = <T = string>(frame: number, value: T): TestMessage<T> =>
-  new TestMessageValue(frame, nextNotification(value));
+const next = <T = string>(frame: number, value: T): TestMessage<T> => new TestMessageValue(frame, { kind: 'N', value });
 
 /**
  * Utility function to generate TestMessage represents error for Observer::error()
  * @param frame virtual frame time when value will be emitted
  * @param value
  */
 const error = (frame: number, error: any = '#'): TestMessage<any> =>
-  new TestMessageValue<any>(frame, errorNotification(error));
+  new TestMessageValue<any>(frame, { kind: 'E', error });
 
 /**
  * Utility function to generate TestMessage represents completion for Observer::complete()
  * @param frame virtual frame time when value will be emitted
  */
-const complete = <T = void>(frame: number): TestMessage<T> => new TestMessageValue<T>(frame, COMPLETE_NOTIFICATION);
+const complete = <T = void>(frame: number): TestMessage<T> => new TestMessageValue<T>(frame, { kind: 'C' });
 
 const subscribe = (
   subscribedFrame: number = Number.POSITIVE_INFINITY,

src/message/TestMessage.ts

@@ -5,14 +5,7 @@ import { parseObservableMarble } from '../marbles/parseObservableMarble';
 import { SubscriptionMarbleToken } from '../marbles/SubscriptionMarbleToken';
 import { TestMessage } from '../message/TestMessage';
 import { TestMessageValue } from '../message/TestMessage';
-import {
-  AsyncAction,
-  ColdObservable,
-  COMPLETE_NOTIFICATION,
-  errorNotification,
-  HotObservable,
-  nextNotification,
-} from '../utils/coreInternalImport';
+import { AsyncAction, ColdObservable, HotObservable } from '../utils/coreInternalImport';
 import { calculateSubscriptionFrame } from './calculateSubscriptionFrame';
 
 /**
@@ -97,11 +90,17 @@ const getCreateHotObservable = (state: SandboxState) => {
  * As we don't inherit virtualtimescheduler anymore, only these functions should be
  * used to properly flush out actions. Calling `scheduler.flush()` will not do any work.
  */
-function getSchedulerFlushFunctions(state: SandboxState, flushWithAsyncTick: true): {
+function getSchedulerFlushFunctions(
+  state: SandboxState,
+  flushWithAsyncTick: true
+): {
   flushUntil: (toFrame?: number) => Promise<void>;
   advanceTo: (toFrame?: number) => Promise<void>;
 };
-function getSchedulerFlushFunctions(state: SandboxState, flushWithAsyncTick: false): {
+function getSchedulerFlushFunctions(
+  state: SandboxState,
+  flushWithAsyncTick: false
+): {
   flushUntil: (toFrame?: number) => void;
   advanceTo: (toFrame?: number) => void;
 };
@@ -131,9 +130,11 @@ function getSchedulerFlushFunctions(state: SandboxState, flushWithAsyncTick: boo
      * For synchronous loop, it'll use plain `while` loop. In case of flushing with tick, each action
      * will be scheduled into promise instead.
      */
-    function loopActions(loopState: SandboxState,
-                         condition: (loopState: SandboxState) => boolean,
-                         fn: (loopState: SandboxState) => Error | undefined): Promise<Error | undefined> | Error | undefined {
+    function loopActions(
+      loopState: SandboxState,
+      condition: (loopState: SandboxState) => boolean,
+      fn: (loopState: SandboxState) => Error | undefined
+    ): Promise<Error | undefined> | Error | undefined {
       if (!flushWithAsyncTick) {
         let fnResult;
         while (condition(loopState)) {
@@ -160,15 +161,19 @@ function getSchedulerFlushFunctions(state: SandboxState, flushWithAsyncTick: boo
 
     // flush actions via custom loop fn, as same as
     // https://github.com/kwonoj/rx-sandbox/blob/c2922e5c5e2503739c64af626f2861b1e1f38159/src/scheduler/TestScheduler.ts#L166-L173
-    const loopResult = loopActions(state, (flushState) => {
-      const action = flushState.scheduler.actions[0];
-      return !!action && action.delay <= toFrame;
-    }, (flushState) => {
-      const action = flushState.scheduler.actions.shift()!;
-      flushState.scheduler.frame = action.delay;
-
-      return action.execute(action.state, action.delay);
-    });
+    const loopResult = loopActions(
+      state,
+      (flushState) => {
+        const action = flushState.scheduler.actions[0];
+        return !!action && action.delay <= toFrame;
+      },
+      (flushState) => {
+        const action = flushState.scheduler.actions.shift()!;
+        flushState.scheduler.frame = action.delay;
+
+        return action.execute(action.state, action.delay);
+      }
+    );
 
     const tearDown = (error?: Error) => {
       state.flushing = false;
@@ -212,15 +217,20 @@ function getSchedulerFlushFunctions(state: SandboxState, flushWithAsyncTick: boo
     }
 
     const flushResult = flushUntil(toFrame);
-    const tearDown = () => { state.scheduler.frame = toFrame; };
+    const tearDown = () => {
+      state.scheduler.frame = toFrame;
+    };
     return isPromise(flushResult) ? flushResult.then(() => tearDown()) : tearDown();
   };
 
   return { flushUntil, advanceTo };
 }
 
 type getMessages = <T = string>(observable: Observable<T>, unsubscriptionMarbles?: string | null) => void;
-type getMessagesWithTick = <T = string>(observable: Observable<T>, unsubscriptionMarbles?: string | null) => Promise<void>;
+type getMessagesWithTick = <T = string>(
+  observable: Observable<T>,
+  unsubscriptionMarbles?: string | null
+) => Promise<void>;
 
 /**
  * create getMessages function. Depends on flush, this'll either work asynchronously or synchronously.
@@ -235,11 +245,11 @@ function createGetMessages(state: SandboxState, flush: Function): Function {
     const pushMetaData = (notification: ObservableNotification<T>) =>
       innerObservableMetadata.push(new TestMessageValue<T>(state.scheduler.frame - outerFrame, notification));
 
-    observable.subscribe(
-      (value) => pushMetaData(nextNotification(value)),
-      (err) => pushMetaData(errorNotification(err)),
-      () => pushMetaData(COMPLETE_NOTIFICATION)
-    );
+    observable.subscribe({
+      next: (value) => pushMetaData({ kind: 'N', value }),
+      error: (error) => pushMetaData({ kind: 'E', error }),
+      complete: () => pushMetaData({ kind: 'C' }),
+    });
 
     return innerObservableMetadata;
   };
@@ -257,16 +267,15 @@ function createGetMessages(state: SandboxState, flush: Function): Function {
 
     let subscription: Subscription | null = null;
     state.scheduler.schedule(() => {
-      subscription = observable.subscribe(
-        (value: T) =>
-          pushMetadata(
-            nextNotification(
-              value instanceof Observable ? materializeInnerObservable<T>(value, state.scheduler.frame) : value
-            )
-          ),
-        (err: any) => pushMetadata(errorNotification(err)),
-        () => pushMetadata(COMPLETE_NOTIFICATION)
-      );
+      subscription = observable.subscribe({
+        next: (value: T) =>
+          pushMetadata({
+            kind: 'N',
+            value: value instanceof Observable ? materializeInnerObservable<T>(value, state.scheduler.frame) : value,
+          }),
+        error: (error: any) => pushMetadata({ kind: 'E', error }),
+        complete: () => pushMetadata({ kind: 'C' }),
+      });
     }, subscribedFrame);
 
     if (unsubscribedFrame !== Number.POSITIVE_INFINITY) {
@@ -294,7 +303,7 @@ const initializeSandboxState = (autoFlush: boolean, frameTimeFactor: number, max
     maxFrame,
     frameTimeFactor,
     scheduler: new VirtualTimeScheduler(VirtualAction, Number.POSITIVE_INFINITY),
-    autoFlush
+    autoFlush,
   };
 };
 
@@ -337,8 +346,8 @@ interface SchedulerInstance extends BaseSchedulerInstance {
 
 interface AsyncSchedulerInstance extends BaseSchedulerInstance {
   /**
-     * Flush out currently scheduled observables, only until reaches frame specfied.
-     */
+   * Flush out currently scheduled observables, only until reaches frame specfied.
+   */
   advanceTo: ReturnTypeWithArgs<typeof getSchedulerFlushFunctions, [SandboxState, true]>['advanceTo'];
   /**
    * Flush out currently scheduled observables, fill values returned by `getMarbles`.
@@ -355,9 +364,24 @@ interface AsyncSchedulerInstance extends BaseSchedulerInstance {
 /**
  * Creates a new instance of virtualScheduler, along with utility functions for sandbox assertions.
  */
-function createTestScheduler(autoFlush: boolean, frameTimeFactor: number, maxFrameValue: number, flushWithAsyncTick: true): AsyncSchedulerInstance;
-function createTestScheduler(autoFlush: boolean, frameTimeFactor: number, maxFrameValue: number, flushWithAsyncTick: false): SchedulerInstance;
-function createTestScheduler(autoFlush: boolean, frameTimeFactor: number, maxFrameValue: number, flushWithAsyncTick: boolean): any {
+function createTestScheduler(
+  autoFlush: boolean,
+  frameTimeFactor: number,
+  maxFrameValue: number,
+  flushWithAsyncTick: true
+): AsyncSchedulerInstance;
+function createTestScheduler(
+  autoFlush: boolean,
+  frameTimeFactor: number,
+  maxFrameValue: number,
+  flushWithAsyncTick: false
+): SchedulerInstance;
+function createTestScheduler(
+  autoFlush: boolean,
+  frameTimeFactor: number,
+  maxFrameValue: number,
+  flushWithAsyncTick: boolean
+): any {
   const sandboxState = initializeSandboxState(autoFlush, frameTimeFactor, maxFrameValue);
 
   const { flushUntil, advanceTo } = getSchedulerFlushFunctions(sandboxState, flushWithAsyncTick as any);