From e4fa1e69e7ebfb627c7198fd1a9881e9327ec4d4 Mon Sep 17 00:00:00 2001
From: Pinapelz <yukais@pinapelz.com>
Date: Sat, 28 Jun 2025 17:26:46 -0700
Subject: initial commit: scaffolding

---
 .../rxjs/src/internal/observable/partition.ts      | 88 ++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 node_modules/rxjs/src/internal/observable/partition.ts

(limited to 'node_modules/rxjs/src/internal/observable/partition.ts')

diff --git a/node_modules/rxjs/src/internal/observable/partition.ts b/node_modules/rxjs/src/internal/observable/partition.ts
new file mode 100644
index 0000000..34a61a1
--- /dev/null
+++ b/node_modules/rxjs/src/internal/observable/partition.ts
@@ -0,0 +1,88 @@
+import { not } from '../util/not';
+import { filter } from '../operators/filter';
+import { ObservableInput } from '../types';
+import { Observable } from '../Observable';
+import { innerFrom } from './innerFrom';
+
+/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
+export function partition<T, U extends T, A>(
+  source: ObservableInput<T>,
+  predicate: (this: A, value: T, index: number) => value is U,
+  thisArg: A
+): [Observable<U>, Observable<Exclude<T, U>>];
+export function partition<T, U extends T>(
+  source: ObservableInput<T>,
+  predicate: (value: T, index: number) => value is U
+): [Observable<U>, Observable<Exclude<T, U>>];
+
+/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
+export function partition<T, A>(
+  source: ObservableInput<T>,
+  predicate: (this: A, value: T, index: number) => boolean,
+  thisArg: A
+): [Observable<T>, Observable<T>];
+export function partition<T>(source: ObservableInput<T>, predicate: (value: T, index: number) => boolean): [Observable<T>, Observable<T>];
+
+/**
+ * Splits the source Observable into two, one with values that satisfy a
+ * predicate, and another with values that don't satisfy the predicate.
+ *
+ * <span class="informal">It's like {@link filter}, but returns two Observables:
+ * one like the output of {@link filter}, and the other with values that did not
+ * pass the condition.</span>
+ *
+ * ![](partition.png)
+ *
+ * `partition` outputs an array with two Observables that partition the values
+ * from the source Observable through the given `predicate` function. The first
+ * Observable in that array emits source values for which the predicate argument
+ * returns true. The second Observable emits source values for which the
+ * predicate returns false. The first behaves like {@link filter} and the second
+ * behaves like {@link filter} with the predicate negated.
+ *
+ * ## Example
+ *
+ * Partition a set of numbers into odds and evens observables
+ *
+ * ```ts
+ * import { of, partition } from 'rxjs';
+ *
+ * const observableValues = of(1, 2, 3, 4, 5, 6);
+ * const [evens$, odds$] = partition(observableValues, value => value % 2 === 0);
+ *
+ * odds$.subscribe(x => console.log('odds', x));
+ * evens$.subscribe(x => console.log('evens', x));
+ *
+ * // Logs:
+ * // odds 1
+ * // odds 3
+ * // odds 5
+ * // evens 2
+ * // evens 4
+ * // evens 6
+ * ```
+ *
+ * @see {@link filter}
+ *
+ * @param source The source `ObservableInput` that will be split into a tuple of
+ * two Observable elements.
+ * @param predicate A function that evaluates each value emitted by the source
+ * Observable. If it returns `true`, the value is emitted on the first Observable
+ * in the returned array, if `false` the value is emitted on the second Observable
+ * in the array. The `index` parameter is the number `i` for the i-th source
+ * emission that has happened since the subscription, starting from the number `0`.
+ * @param thisArg An optional argument to determine the value of `this` in the
+ * `predicate` function.
+ * @return An array with two Observables: one with values that passed the
+ * predicate, and another with values that did not pass the predicate.
+ */
+export function partition<T>(
+  source: ObservableInput<T>,
+  predicate: (this: any, value: T, index: number) => boolean,
+  thisArg?: any
+): [Observable<T>, Observable<T>] {
+  return [filter(predicate, thisArg)(innerFrom(source)), filter(not(predicate, thisArg))(innerFrom(source))] as [
+    Observable<T>,
+    Observable<T>
+  ];
+}
-- 
cgit v1.2.3