applesauce-loaders 0.12.0 → 2.0.0

package/dist/operators/__tests__/generator-sequence.test.js

@@ -1,38 +0,0 @@
-import { expect, it } from "vitest";
-import { lastValueFrom, of, toArray } from "rxjs";
-import { TestScheduler } from "rxjs/testing";
-import { generatorSequence } from "../generator-sequence.js";
-let testScheduler = new TestScheduler((actual, expected) => {
-    expect(actual).toEqual(expected);
-});
-it("should work with normal generator functions", () => {
-    testScheduler.run(({ expectObservable }) => {
-        function* normalGenerator(value) {
-            yield of(value + 1);
-            yield of(value + 2);
-            yield of(value + 3);
-            yield value + 4;
-        }
-        const source$ = of(1).pipe(generatorSequence(normalGenerator));
-        // Define expected marble diagram
-        const expectedMarble = "(abcd|)";
-        const expectedValues = {
-            a: 2,
-            b: 3,
-            c: 4,
-            d: 5,
-        };
-        expectObservable(source$).toBe(expectedMarble, expectedValues);
-    });
-});
-it("should work with async generator functions", async () => {
-    async function* asyncGenerator(value) {
-        yield of(`${value}-1`);
-        yield of(`${value}-2`);
-        yield of(`${value}-3`);
-        yield `${value}-4`;
-    }
-    const source$ = of("test").pipe(generatorSequence(asyncGenerator));
-    const expectedValues = ["test-1", "test-2", "test-3", "test-4"];
-    expect(await lastValueFrom(source$.pipe(toArray()))).toEqual(expectedValues);
-});

package/dist/operators/generator-sequence.d.ts

@@ -1,3 +0,0 @@
-import { Observable, OperatorFunction } from "rxjs";
-/** Keeps retrying a value until the generator returns */
-export declare function generatorSequence<Input, Result>(createGenerator: (value: Input) => Generator<Observable<Result> | Result, void, Result[] | undefined> | AsyncGenerator<Observable<Result> | Result, void, Result[] | undefined>, shouldComplete?: boolean): OperatorFunction<Input, Result>;

package/dist/operators/generator-sequence.js

@@ -1,53 +0,0 @@
-import { isObservable, Observable } from "rxjs";
-/** Keeps retrying a value until the generator returns */
-export function generatorSequence(createGenerator, shouldComplete = true) {
-    return (source) => {
-        return new Observable((observer) => {
-            return source.subscribe((value) => {
-                const generator = createGenerator(value);
-                const nextSequence = (prevResults) => {
-                    const p = generator.next(prevResults);
-                    const handleResult = (result) => {
-                        // generator complete, exit
-                        if (result.done) {
-                            if (shouldComplete)
-                                observer.complete();
-                            return;
-                        }
-                        const results = [];
-                        if (isObservable(result.value)) {
-                            result.value.subscribe({
-                                next: (v) => {
-                                    // track results and pass along values
-                                    results.push(v);
-                                    observer.next(v);
-                                },
-                                error: (err) => {
-                                    observer.error(err);
-                                },
-                                complete: () => {
-                                    // run next step
-                                    nextSequence(results);
-                                },
-                            });
-                        }
-                        else {
-                            results.push(result.value);
-                            observer.next(result.value);
-                            nextSequence(results);
-                        }
-                    };
-                    // if its an async generator, wait for the promise
-                    if (p instanceof Promise)
-                        p.then(handleResult, (err) => {
-                            observer.error(err);
-                        });
-                    else
-                        handleResult(p);
-                };
-                // start running steps
-                nextSequence();
-            });
-        });
-    };
-}