initial commit: scaffolding

1 files changed, 50 insertions, 0 deletions

diff --git a/node_modules/rxjs/src/internal/operators/switchScan.ts b/node_modules/rxjs/src/internal/operators/switchScan.ts
new file mode 100644
index 0000000..902a2a7
--- /dev/null
+++ b/node_modules/rxjs/src/internal/operators/switchScan.ts
@@ -0,0 +1,50 @@
+import { ObservableInput, ObservedValueOf, OperatorFunction } from '../types';
+import { switchMap } from './switchMap';
+import { operate } from '../util/lift';
+
+// TODO: Generate a marble diagram for these docs.
+
+/**
+ * Applies an accumulator function over the source Observable where the
+ * accumulator function itself returns an Observable, emitting values
+ * only from the most recently returned Observable.
+ *
+ * <span class="informal">It's like {@link mergeScan}, but only the most recent
+ * Observable returned by the accumulator is merged into the outer Observable.</span>
+ *
+ * @see {@link scan}
+ * @see {@link mergeScan}
+ * @see {@link switchMap}
+ *
+ * @param accumulator
+ * The accumulator function called on each source value.
+ * @param seed The initial accumulation value.
+ * @return A function that returns an observable of the accumulated values.
+ */
+export function switchScan<T, R, O extends ObservableInput<any>>(
+  accumulator: (acc: R, value: T, index: number) => O,
+  seed: R
+): OperatorFunction<T, ObservedValueOf<O>> {
+  return operate((source, subscriber) => {
+    // The state we will keep up to date to pass into our
+    // accumulator function at each new value from the source.
+    let state = seed;
+
+    // Use `switchMap` on our `source` to do the work of creating
+    // this operator. Note the backwards order here of `switchMap()(source)`
+    // to avoid needing to use `pipe` unnecessarily
+    switchMap(
+      // On each value from the source, call the accumulator with
+      // our previous state, the value and the index.
+      (value: T, index) => accumulator(state, value, index),
+      // Using the deprecated result selector here as a dirty trick
+      // to update our state with the flattened value.
+      (_, innerValue) => ((state = innerValue), innerValue)
+    )(source).subscribe(subscriber);
+
+    return () => {
+      // Release state on finalization
+      state = null!;
+    };
+  });
+}