@jscutlery/operators 2.1.4 → 3.0.0

package/CHANGELOG.md

@@ -1,3 +1,44 @@
+# 3.0.0 (2024-04-12)
+
+
+### 🚀 Features
+
+- **operator:** ✅ add supensify operator ([e7fc483](https://github.com/jscutlery/devkit/commit/e7fc483))
+
+- **operators:** ✨add esm support ([77b5470](https://github.com/jscutlery/devkit/commit/77b5470))
+
+- ⚠️  **operators:** ✨ drop support for suspensify's projector ([f4bf6dc](https://github.com/jscutlery/devkit/commit/f4bf6dc))
+
+- **operators:** add suspensify's strict mode ([f9dd789](https://github.com/jscutlery/devkit/commit/f9dd789))
+
+- **operators:** ✨ expose pending state constant ([caaea8e](https://github.com/jscutlery/devkit/commit/caaea8e))
+
+
+### 🩹 Fixes
+
+- 🐞 bump workspace ([127c808](https://github.com/jscutlery/devkit/commit/127c808))
+
+- **operators:** 🏷️ fix typing errors ([91c084c](https://github.com/jscutlery/devkit/commit/91c084c))
+
+- **operators:** 🐞 fix suspensify type to be strict by default too ([c5d424c](https://github.com/jscutlery/devkit/commit/c5d424c))
+
+- **operators:** 🐞 export missing types + pending const ([96eed66](https://github.com/jscutlery/devkit/commit/96eed66))
+
+
+#### ⚠️  Breaking Changes
+
+- **operators:** suspensify's operator "projector" function is not supported anymore
+
+### ❤️  Thank You
+
+- Edouard Bozon @edbzn
+- Julien Brun
+- Younes Jaaidi
+
+## 2.1.5 (2024-04-11)
+
+This was a version bump only for operators to align it with other projects, there were no code changes.
+
 ## 2.1.4 (2024-03-24)
 
 

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 jscutlery
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+
+function suspensify({
+  strict = true
+} = {}) {
+  return source$ => {
+    const strictSuspense$ = source$.pipe(_suspensify(), _coalesceFirstEmittedValue());
+    return strict ? strictSuspense$ : strictSuspense$.pipe(operators.map(strictSuspense => ({
+      error: undefined,
+      value: undefined,
+      ...strictSuspense
+    }))
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+  };
+}
+/**
+ * This is the initial state of the Suspense.
+ * It is exposed for convenience and edge cases where the initial state must be set initially.
+ * e.g. when using {@link suspensify} on inner observables.
+ * @example toSignal(source$.pipe(switchMap(() => fetchData().pipe(suspensify()))), {initialValue: pending});
+ */
+const pending = {
+  finalized: false,
+  hasError: false,
+  hasValue: false,
+  pending: true
+};
+function _coalesceFirstEmittedValue() {
+  return source$ => {
+    return new rxjs.Observable(observer => {
+      const isReadySubject = new rxjs.ReplaySubject(1);
+      const subscription = source$.pipe( /* Wait for all synchronous processing to be done. */
+      operators.debounce(() => isReadySubject)).subscribe(observer);
+      /* Sync emitted values have been processed now.
+       * Mark source as ready and emit last computed state. */
+      isReadySubject.next(undefined);
+      return () => subscription.unsubscribe();
+    });
+  };
+}
+/* Use values as types for better type checking. */
+const TRUE = true;
+const FALSE = false;
+function _suspensify() {
+  return source$ => {
+    return source$.pipe(operators.materialize(), operators.scan((state, notification) => {
+      switch (notification.kind) {
+        /* Value. */
+        case 'N':
+          return {
+            finalized: FALSE,
+            hasError: FALSE,
+            hasValue: TRUE,
+            value: notification.value,
+            pending: FALSE
+          };
+        /* Error. */
+        case 'E':
+          return {
+            finalized: TRUE,
+            hasError: TRUE,
+            hasValue: FALSE,
+            pending: FALSE,
+            error: notification.error
+          };
+        /* Complete. */
+        case 'C':
+          return {
+            ...state,
+            finalized: TRUE,
+            pending: FALSE
+          };
+      }
+    }, pending), operators.startWith(pending));
+  };
+}
+
+exports.pending = pending;
+exports.suspensify = suspensify;

package/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.esm.js

@@ -0,0 +1,80 @@
+import { Observable, ReplaySubject } from 'rxjs';
+import { map, debounce, materialize, scan, startWith } from 'rxjs/operators';
+
+function suspensify({
+  strict = true
+} = {}) {
+  return source$ => {
+    const strictSuspense$ = source$.pipe(_suspensify(), _coalesceFirstEmittedValue());
+    return strict ? strictSuspense$ : strictSuspense$.pipe(map(strictSuspense => ({
+      error: undefined,
+      value: undefined,
+      ...strictSuspense
+    }))
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+  };
+}
+/**
+ * This is the initial state of the Suspense.
+ * It is exposed for convenience and edge cases where the initial state must be set initially.
+ * e.g. when using {@link suspensify} on inner observables.
+ * @example toSignal(source$.pipe(switchMap(() => fetchData().pipe(suspensify()))), {initialValue: pending});
+ */
+const pending = {
+  finalized: false,
+  hasError: false,
+  hasValue: false,
+  pending: true
+};
+function _coalesceFirstEmittedValue() {
+  return source$ => {
+    return new Observable(observer => {
+      const isReadySubject = new ReplaySubject(1);
+      const subscription = source$.pipe( /* Wait for all synchronous processing to be done. */
+      debounce(() => isReadySubject)).subscribe(observer);
+      /* Sync emitted values have been processed now.
+       * Mark source as ready and emit last computed state. */
+      isReadySubject.next(undefined);
+      return () => subscription.unsubscribe();
+    });
+  };
+}
+/* Use values as types for better type checking. */
+const TRUE = true;
+const FALSE = false;
+function _suspensify() {
+  return source$ => {
+    return source$.pipe(materialize(), scan((state, notification) => {
+      switch (notification.kind) {
+        /* Value. */
+        case 'N':
+          return {
+            finalized: FALSE,
+            hasError: FALSE,
+            hasValue: TRUE,
+            value: notification.value,
+            pending: FALSE
+          };
+        /* Error. */
+        case 'E':
+          return {
+            finalized: TRUE,
+            hasError: TRUE,
+            hasValue: FALSE,
+            pending: FALSE,
+            error: notification.error
+          };
+        /* Complete. */
+        case 'C':
+          return {
+            ...state,
+            finalized: TRUE,
+            pending: FALSE
+          };
+      }
+    }, pending), startWith(pending));
+  };
+}
+
+export { pending, suspensify };

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@jscutlery/operators",
-  "version": "2.1.4",
+  "version": "3.0.0",
   "repository": {
     "url": "https://github.com/jscutlery/devkit"
   },
   "peerDependencies": {
     "rxjs": ">=6.0.0"
-  }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js"
 }

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export { pending, suspensify } from './lib/suspensify';
+export type { SuspenseLax, Suspense, SuspenseEmpty, SuspensePending, SuspenseWithError, SuspenseWithValue, SuspensifyOptions, } from './lib/suspensify';

package/src/lib/suspensify.d.ts

@@ -0,0 +1,59 @@
+import { OperatorFunction } from 'rxjs';
+export interface SuspenseLax<T> {
+    finalized: boolean;
+    hasError: boolean;
+    hasValue: boolean;
+    pending: boolean;
+    error: undefined | any;
+    value: undefined | T;
+}
+export interface SuspensePending {
+    finalized: false;
+    hasError: false;
+    hasValue: false;
+    pending: true;
+}
+export interface SuspenseWithValue<T> {
+    finalized: boolean;
+    hasError: false;
+    hasValue: true;
+    pending: false;
+    value: T;
+}
+export interface SuspenseWithError {
+    finalized: true;
+    hasError: true;
+    hasValue: false;
+    pending: false;
+    error: unknown;
+}
+export interface SuspenseEmpty {
+    finalized: true;
+    hasError: false;
+    hasValue: false;
+    pending: false;
+}
+export type Suspense<T> = SuspensePending | SuspenseWithValue<T> | SuspenseWithError | SuspenseEmpty;
+export interface SuspensifyOptions {
+    strict?: boolean;
+}
+/**
+ * @description creates a derivated state from the source observable.
+ *
+ * @example source$.pipe(suspensify())
+ *
+ * @returns Observable<SuspenseLax<T> | SuspenseStrict<T>>
+ */
+export declare function suspensify<T>(options: {
+    strict: false;
+}): OperatorFunction<T, SuspenseLax<T>>;
+export declare function suspensify<T>(options?: {
+    strict: true;
+}): OperatorFunction<T, Suspense<T>>;
+/**
+ * This is the initial state of the Suspense.
+ * It is exposed for convenience and edge cases where the initial state must be set initially.
+ * e.g. when using {@link suspensify} on inner observables.
+ * @example toSignal(source$.pipe(switchMap(() => fetchData().pipe(suspensify()))), {initialValue: pending});
+ */
+export declare const pending: SuspensePending;

package/src/lib/testing/observer.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+export declare function createObserver(): {
+    observe<T>(observable: Observable<T>): {
+        mockClear(): void;
+        mockReset(): void;
+        next: jest.MockInstance<void, [value: T], unknown> & ((value: T) => void);
+        error: jest.MockInstance<void, [err: any], unknown> & ((err: any) => void);
+        complete: jest.MockInstance<void, [], unknown> & (() => void);
+    };
+};

package/.babelrc

@@ -1,10 +0,0 @@
-{
-  "presets": [
-    [
-      "@nx/js/babel",
-      {
-        "useBuiltIns": "usage"
-      }
-    ]
-  ]
-}

package/.eslintrc.json

@@ -1,18 +0,0 @@
-{
-  "extends": ["../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    }
-  ]
-}

package/jest.config.ts

@@ -1,17 +0,0 @@
-/* eslint-disable */
-module.exports = {
-  displayName: 'operators',
-  preset: '../../jest.preset.js',
-  globals: {},
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]sx?$': [
-      'ts-jest',
-      {
-        tsconfig: '<rootDir>/tsconfig.spec.json',
-      },
-    ],
-  },
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
-  coverageDirectory: '../../coverage/packages/operators',
-};

package/project.json

@@ -1,57 +0,0 @@
-{
-  "name": "operators",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/operators/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "@nx/rollup:rollup",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "project": "packages/operators/package.json",
-        "outputPath": "dist/packages/operators",
-        "entryFile": "packages/operators/src/index.ts",
-        "tsConfig": "packages/operators/tsconfig.lib.json",
-        "main": "packages/operators/src/index.ts",
-        "format": ["cjs", "esm"],
-        "assets": [
-          {
-            "glob": "LICENSE",
-            "input": ".",
-            "output": "."
-          },
-          {
-            "glob": "*.md",
-            "input": "packages/operators",
-            "output": "."
-          }
-        ]
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"]
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/packages/operators"],
-      "options": {
-        "jestConfig": "packages/operators/jest.config.ts"
-      }
-    },
-    "github": {
-      "executor": "@jscutlery/semver:github",
-      "options": {
-        "notes": "{notes}",
-        "tag": "{tag}"
-      }
-    },
-    "npm": {
-      "executor": "ngx-deploy-npm:deploy",
-      "options": {
-        "access": "public"
-      }
-    }
-  },
-  "tags": []
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export { pending, suspensify } from './lib/suspensify';
-export type {
-  SuspenseLax,
-  Suspense,
-  SuspenseEmpty,
-  SuspensePending,
-  SuspenseWithError,
-  SuspenseWithValue,
-  SuspensifyOptions,
-} from './lib/suspensify';

package/src/lib/suspensify.spec.ts

@@ -1,223 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import {
-  EMPTY,
-  Observable,
-  Subject,
-  firstValueFrom,
-  of,
-  throwError,
-} from 'rxjs';
-import { suspensify } from './suspensify';
-import { createObserver } from './testing/observer';
-
-describe(suspensify.name, () => {
-  const { observe } = createObserver();
-
-  describe('strict mode', () => {
-    it('should always have pending, finalized, hasValue & hasError properties', async () => {
-      const suspense = await getFirstSuspenseValue();
-      suspense.pending;
-      suspense.finalized;
-      suspense.hasError;
-      suspense.hasValue;
-    });
-
-    it('should not have value or error before narrowing', async () => {
-      const suspense = await getFirstSuspenseValue();
-      // @ts-expect-error error property should not exist before narrowing
-      suspense.error;
-      // @ts-expect-error value property should not exist before narrowing
-      suspense.value;
-    });
-
-    it('should narrow value type', async () => {
-      const suspense = await getFirstSuspenseValue();
-      if (suspense.hasValue) {
-        suspense.value;
-        // @ts-expect-error error property should not exist on value type
-        suspense.error;
-      }
-    });
-
-    it('should narrow error type', async () => {
-      const suspense = await getFirstSuspenseValue();
-      if (suspense.hasError) {
-        suspense.error;
-        // @ts-expect-error value property should not exist on error type
-        suspense.value;
-      }
-    });
-
-    it('should emit pending', () => {
-      const { next } = setUpStrict(new Subject<'🍔'>());
-      expect(next).toBeCalledTimes(1);
-      expect(next).toBeCalledWith({
-        finalized: false,
-        hasError: false,
-        hasValue: false,
-        pending: true,
-      });
-    });
-
-    it('should emit value', () => {
-      /* Unfinished observable. */
-      const { next } = setUpStrict(
-        new Observable((observer) => observer.next('🍔'))
-      );
-
-      expect(next).lastCalledWith({
-        finalized: false,
-        hasError: false,
-        hasValue: true,
-        pending: false,
-        value: '🍔',
-      });
-    });
-
-    it('should emit once (not pending + value)', () => {
-      const { next } = setUpStrict(of('🍔'));
-      expect(next).toBeCalledTimes(1);
-    });
-
-    it('should emit error', () => {
-      const { next } = setUpStrict(throwError(() => new Error('🐞')));
-      expect(next).toBeCalledTimes(1);
-      expect(next).toBeCalledWith({
-        finalized: true,
-        hasError: true,
-        hasValue: false,
-        pending: false,
-        error: new Error('🐞'),
-      });
-    });
-
-    it('should mark finalized on complete with value', () => {
-      const { next } = setUpStrict(of('🍔'));
-
-      expect(next).toBeCalledWith({
-        finalized: true,
-        hasError: false,
-        hasValue: true,
-        pending: false,
-        value: '🍔',
-      });
-    });
-
-    it('should mark finalized on complete without value', () => {
-      const { next } = setUpStrict(EMPTY);
-
-      expect(next).toBeCalledWith({
-        finalized: true,
-        hasError: false,
-        hasValue: false,
-        pending: false,
-      });
-    });
-
-    it('should reset pending to false when value is emitted', () => {
-      const subject = new Subject<'🍔'>();
-      const { next } = setUpStrict(subject);
-
-      subject.error(new Error('🐞'));
-
-      expect(next).toBeCalledTimes(2);
-      expect(next).lastCalledWith(
-        expect.objectContaining({
-          pending: false,
-          error: new Error('🐞'),
-        })
-      );
-    });
-
-    async function getFirstSuspenseValue() {
-      return await firstValueFrom(of('🍔').pipe(suspensify()));
-    }
-
-    function setUpStrict<T>(source$: Observable<T>) {
-      const observer = observe(source$.pipe(suspensify()));
-      return {
-        next: observer.next,
-      };
-    }
-  });
-
-  describe('lax mode', () => {
-    it('should emit result with value', () => {
-      const { next } = setUpLax(of('🍔'));
-      expect(next).toBeCalledTimes(1);
-      expect(next).toBeCalledWith({
-        finalized: true,
-        hasError: false,
-        hasValue: true,
-        pending: false,
-        error: undefined,
-        value: '🍔',
-      });
-    });
-
-    it('should emit result with error', () => {
-      const { next } = setUpLax(throwError(() => new Error('🐞')));
-      expect(next).toBeCalledTimes(1);
-      expect(next).toBeCalledWith({
-        finalized: true,
-        hasError: true,
-        hasValue: false,
-        pending: false,
-        error: new Error('🐞'),
-        value: undefined,
-      });
-    });
-
-    it('should emit result with pending=true and without value nor error', () => {
-      const { next } = setUpLax(new Subject<'🍔'>());
-      expect(next).toBeCalledTimes(1);
-      expect(next).toBeCalledWith({
-        finalized: false,
-        hasError: false,
-        hasValue: false,
-        pending: true,
-        error: undefined,
-        value: undefined,
-      });
-    });
-
-    it('should reset pending to false when value is emitted', () => {
-      const subject = new Subject<'🍔'>();
-      const { next } = setUpLax(subject);
-
-      subject.next('🍔');
-
-      expect(next).toBeCalledTimes(2);
-      expect(next).lastCalledWith({
-        finalized: false,
-        hasError: false,
-        hasValue: true,
-        pending: false,
-        error: undefined,
-        value: '🍔',
-      });
-    });
-
-    it('should reset pending to false on error', () => {
-      const subject = new Subject<'🍔'>();
-      const { next } = setUpLax(subject);
-
-      subject.error(new Error('🐞'));
-
-      expect(next).toBeCalledTimes(2);
-      expect(next).lastCalledWith(
-        expect.objectContaining({
-          pending: false,
-          error: new Error('🐞'),
-        })
-      );
-    });
-
-    function setUpLax<T>(source$: Observable<T>) {
-      const observer = observe(source$.pipe(suspensify({ strict: false })));
-      return {
-        next: observer.next,
-      };
-    }
-  });
-});

package/src/lib/suspensify.ts

@@ -1,169 +0,0 @@
-import {
-  MonoTypeOperatorFunction,
-  Observable,
-  ObservableNotification,
-  OperatorFunction,
-  ReplaySubject,
-} from 'rxjs';
-import { debounce, map, materialize, scan, startWith } from 'rxjs/operators';
-
-export interface SuspenseLax<T> {
-  finalized: boolean;
-  hasError: boolean;
-  hasValue: boolean;
-  pending: boolean;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  error: undefined | any;
-  value: undefined | T;
-}
-
-export interface SuspensePending {
-  finalized: false;
-  hasError: false;
-  hasValue: false;
-  pending: true;
-}
-
-export interface SuspenseWithValue<T> {
-  finalized: boolean;
-  hasError: false;
-  hasValue: true;
-  pending: false;
-  value: T;
-}
-
-export interface SuspenseWithError {
-  finalized: true;
-  hasError: true;
-  hasValue: false;
-  pending: false;
-  error: unknown;
-}
-
-export interface SuspenseEmpty {
-  finalized: true;
-  hasError: false;
-  hasValue: false;
-  pending: false;
-}
-
-export type Suspense<T> =
-  | SuspensePending
-  | SuspenseWithValue<T>
-  | SuspenseWithError
-  | SuspenseEmpty;
-
-export interface SuspensifyOptions {
-  strict?: boolean;
-}
-
-/**
- * @description creates a derivated state from the source observable.
- *
- * @example source$.pipe(suspensify())
- *
- * @returns Observable<SuspenseLax<T> | SuspenseStrict<T>>
- */
-export function suspensify<T>(options: {
-  strict: false;
-}): OperatorFunction<T, SuspenseLax<T>>;
-export function suspensify<T>(options?: {
-  strict: true;
-}): OperatorFunction<T, Suspense<T>>;
-export function suspensify<T>({
-  strict = true,
-}: SuspensifyOptions = {}): OperatorFunction<T, SuspenseLax<T> | Suspense<T>> {
-  return (source$: Observable<T>): Observable<Suspense<T>> => {
-    const strictSuspense$ = source$.pipe(
-      _suspensify(),
-      _coalesceFirstEmittedValue()
-    );
-    return strict
-      ? strictSuspense$
-      : (strictSuspense$.pipe(
-          map((strictSuspense) => ({
-            error: undefined,
-            value: undefined,
-            ...strictSuspense,
-          }))
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ) as any);
-  };
-}
-
-/**
- * This is the initial state of the Suspense.
- * It is exposed for convenience and edge cases where the initial state must be set initially.
- * e.g. when using {@link suspensify} on inner observables.
- * @example toSignal(source$.pipe(switchMap(() => fetchData().pipe(suspensify()))), {initialValue: pending});
- */
-export const pending: SuspensePending = {
-  finalized: false,
-  hasError: false,
-  hasValue: false,
-  pending: true,
-};
-
-function _coalesceFirstEmittedValue<T>(): MonoTypeOperatorFunction<T> {
-  return (source$: Observable<T>): Observable<T> => {
-    return new Observable<T>((observer) => {
-      const isReadySubject = new ReplaySubject<unknown>(1);
-
-      const subscription = source$
-        .pipe(
-          /* Wait for all synchronous processing to be done. */
-          debounce(() => isReadySubject)
-        )
-        .subscribe(observer);
-
-      /* Sync emitted values have been processed now.
-       * Mark source as ready and emit last computed state. */
-      isReadySubject.next(undefined);
-
-      return () => subscription.unsubscribe();
-    });
-  };
-}
-
-/* Use values as types for better type checking. */
-const TRUE = true as const;
-const FALSE = false as const;
-
-function _suspensify<T>(): OperatorFunction<T, Suspense<T>> {
-  return (source$: Observable<T>): Observable<Suspense<T>> => {
-    return source$.pipe(
-      materialize(),
-      scan<ObservableNotification<T>, Suspense<T>>((state, notification) => {
-        switch (notification.kind) {
-          /* Value. */
-          case 'N':
-            return {
-              finalized: FALSE,
-              hasError: FALSE,
-              hasValue: TRUE,
-              value: notification.value,
-              pending: FALSE,
-            };
-          /* Error. */
-          case 'E':
-            return {
-              finalized: TRUE,
-              hasError: TRUE,
-              hasValue: FALSE,
-              pending: FALSE,
-              error: notification.error,
-            };
-          /* Complete. */
-          case 'C':
-            return {
-              ...state,
-              finalized: TRUE,
-              pending: FALSE,
-            };
-        }
-      }, pending),
-      startWith(pending)
-    );
-  };
-}

package/src/lib/testing/observer.ts

@@ -1,33 +0,0 @@
-/// <reference types="jest" />
-import { Observable, Observer, Subscription } from 'rxjs';
-
-export function createObserver() {
-  let subscription: Subscription;
-
-  beforeEach(() => (subscription = new Subscription()));
-  afterEach(() => subscription.unsubscribe());
-
-  return {
-    observe<T>(observable: Observable<T>) {
-      const observer: jest.Mocked<Observer<T>> = {
-        next: jest.fn<void, [T]>(),
-        error: jest.fn<void, [unknown]>(),
-        complete: jest.fn<void, []>(),
-      };
-      subscription.add(observable.subscribe(observer));
-      return {
-        ...observer,
-        mockClear() {
-          observer.next.mockClear();
-          observer.error.mockClear();
-          observer.complete.mockClear();
-        },
-        mockReset() {
-          observer.next.mockReset();
-          observer.error.mockReset();
-          observer.complete.mockReset();
-        },
-      };
-    },
-  };
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "exclude": ["**/*.spec.ts", "**/*.test.ts", "jest.config.ts"],
-  "include": ["**/*.ts"]
-}

package/tsconfig.spec.json

@@ -1,20 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "**/*.spec.tsx",
-    "**/*.test.tsx",
-    "**/*.spec.js",
-    "**/*.test.js",
-    "**/*.spec.jsx",
-    "**/*.test.jsx",
-    "**/*.d.ts",
-    "jest.config.ts"
-  ]
-}