Transformations: Use Observable (#27584)

* WIP: changes transformer API to Observable

* Refactor: changes ResultProcessor

* WIP: TransformationUI

* wip

* Refactor: Cleaning up code in CalculateFieldTransformerEditorProps

* Refactor: pushing editor and input output down to TransformationEditor

* Refactor: renaming props

* Refactor: makes transformDataFrame more readable

* Refactor: fixes editor issues

* Refactor: changes after merge with master and first tests

* Tests: completes the tests for the Explore changes

* Tests: fixes all transform tests

* Tests: fixed annotations test

* Tests: fixed typechecks

* Refactor: changes transform interface to MonoTypeOperatorFunction

* Chore: cleans up typings

* Update packages/grafana-data/src/transformations/transformDataFrame.ts

Co-authored-by: Marcus Andersson <marcus.andersson@grafana.com>

* Tests: fixes broken tests

Co-authored-by: Marcus Andersson <marcus.andersson@grafana.com>

public/test/helpers/observableTester.ts

@@ -1,105 +0,0 @@
-import { Observable } from 'rxjs';
-
-interface ObservableTester<T> {
-  observable: Observable<T>;
-  done: jest.DoneCallback;
-}
-
-interface SubscribeAndExpectOnNext<T> extends ObservableTester<T> {
-  expect: (value: T) => void;
-}
-
-interface SubscribeAndExpectOnNextAndComplete<T> extends ObservableTester<T> {
-  expectOnNext: (value: T) => void;
-  expectOnComplete: () => void;
-}
-
-interface SubscribeAndExpectOnComplete<T> extends ObservableTester<T> {
-  expect: () => void;
-}
-
-interface SubscribeAndExpectOnError<T> extends ObservableTester<T> {
-  expect: (err: any) => void;
-}
-
-export const observableTester = () => {
-  const subscribeAndExpectOnNext = <T>({ observable, expect, done }: SubscribeAndExpectOnNext<T>): void => {
-    observable.subscribe({
-      next: value => {
-        try {
-          expect(value);
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-      error: err => done.fail(err),
-      complete: () => done(),
-    });
-  };
-
-  const subscribeAndExpectOnComplete = <T>({ observable, expect, done }: SubscribeAndExpectOnComplete<T>): void => {
-    observable.subscribe({
-      next: () => {},
-      error: err => done.fail(err),
-      complete: () => {
-        try {
-          expect();
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-    });
-  };
-
-  const subscribeAndExpectOnNextAndComplete = <T>({
-    observable,
-    expectOnComplete,
-    expectOnNext,
-    done,
-  }: SubscribeAndExpectOnNextAndComplete<T>): void => {
-    observable.subscribe({
-      next: (value: T) => {
-        try {
-          expectOnNext(value);
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-      error: err => done.fail(err),
-      complete: () => {
-        try {
-          expectOnComplete();
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-    });
-  };
-
-  const subscribeAndExpectOnError = <T>({ observable, expect, done }: SubscribeAndExpectOnError<T>): void => {
-    observable.subscribe({
-      next: () => {},
-      error: err => {
-        try {
-          expect(err);
-          done();
-        } catch (err) {
-          done.fail(err);
-        }
-      },
-      complete: () => {
-        done();
-      },
-    });
-  };
-
-  return {
-    subscribeAndExpectOnNext,
-    subscribeAndExpectOnComplete,
-    subscribeAndExpectOnNextAndComplete,
-    subscribeAndExpectOnError,
-  };
-};