@davidsouther/jiffies 1.1.0 → 2.0.2

package/build/observable/observable.js

@@ -1,148 +0,0 @@
-import { display } from "../display.js";
-import { DEFAULT_LOGGER } from "../log.js";
-export const Observable = {
-    of(...T) { },
-    combineLatest(...O) { },
-    from(f) { },
-    fromEvent(element, eventName) { },
-};
-export class Subject {
-    #subscribers = new Set();
-    #complete = false;
-    async next(t) {
-        if (this.#complete)
-            throw new Error("Cannot call next on a completed subject");
-        await Promise.all([...this.#subscribers].map((s) => s.next?.(t)));
-        return;
-    }
-    async error(e) {
-        if (this.#complete)
-            throw new Error("Cannot call error on a completed subject");
-        await Promise.all([...this.#subscribers].map((s) => s.error?.(e)));
-        return;
-    }
-    async complete() {
-        if (this.#complete)
-            throw new Error("Cannot call complete on a completed subject");
-        this.#complete = true;
-        const finished = Promise.all([...this.#subscribers].map((s) => s.complete?.()));
-        this.#subscribers.clear(); // Free subscribers for garbage collection
-        await finished;
-        return;
-    }
-    subscribe(subscriber) {
-        if (this.#complete)
-            throw new Error("Cannot call subscribe on a completed subject");
-        this.#subscribers.add(subscriber);
-        return { unsubscribe: () => this.#subscribers.delete(subscriber) };
-    }
-    pipe(o1, o2, o3, o4, o5) {
-        let o = o1.subscribe(this);
-    }
-}
-export class BehaviorSubject extends Subject {
-    #current;
-    constructor(t) {
-        super();
-        this.#current = t;
-    }
-    next(t) {
-        this.#current = t;
-        return super.next(t);
-    }
-    subscribe(subscriber) {
-        subscriber.next?.(this.#current);
-        return super.subscribe(subscriber);
-    }
-    get current() {
-        return this.#current;
-    }
-}
-export class ReplaySubject extends Subject {
-    n;
-    #history = [];
-    constructor(n) {
-        super();
-        this.n = n;
-    }
-    next(t) {
-        this.#history.push(t);
-        if (this.#history.length > this.n) {
-            this.#history.shift();
-        }
-        return super.next(t);
-    }
-    subscribe(subscriber) {
-        const history = [...this.#history];
-        (function send() {
-            if (history.length == 0)
-                return;
-            const t = history.shift();
-            subscriber.next?.(t);
-            new Promise(send);
-        })();
-        return super.subscribe(subscriber);
-    }
-}
-const operator = {
-    filter(fn) { },
-    first() { },
-    last() { },
-    map: (fn) => ({}),
-    publishReplay(n) { },
-    reduce(fn) { },
-    takeUntil(o) { },
-    tap(fn) { },
-};
-export const next = (value) => ({
-    value,
-    completed: false,
-    failed: false,
-});
-export const error = (e) => ({
-    error: e,
-    completed: false,
-    failed: true,
-});
-export const completed = () => ({ completed: true, failed: false });
-export const failed = () => ({ completed: true, failed: true });
-export const isNext = (event) => !event.completed && !event.failed && event.value !== undefined;
-export const isError = (event) => event.failed && !event.completed;
-export const isCompleted = (event) => event.completed && !event.failed;
-export const isFailed = (event) => event.completed && event.failed;
-export const isEvent = (t) => {
-    const b = t;
-    return isNext(b) || isError(b) || isCompleted(b);
-};
-export const asEvents = (a) => a.map((e) => (isEvent(e) ? e : next(e)));
-const marble = (event) => isError(event)
-    ? "X"
-    : isFailed(event)
-        ? "!"
-        : isCompleted(event)
-            ? "|"
-            : `(${display(event.value)})`;
-export const marbles = (events) => `:${events.map(marble).join("-")}`;
-export const collect = (input$) => {
-    const collected = [];
-    const subscription = input$.subscribe({
-        next: (x) => collected.push(next(x)),
-        error: (e) => collected.push(error(e)),
-        complete: () => collected.push(completed()),
-    });
-    subscription.unsubscribe();
-    return collected;
-};
-export const watch = (logger = DEFAULT_LOGGER) => (observable) => {
-    observable.pipe(operator.tap({
-        next(t) {
-            logger.info(t);
-        },
-        complete() {
-            logger.info("Observable completed");
-        },
-        error(e) {
-            logger.warn(e);
-        },
-    }));
-};

package/build/observable/observable.test.js

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "../scope/index.js";
-import { Subject } from "./observable.js";
-describe("Observables", () => {
-    describe("basics", () => {
-        it("can create and observe a scalar subject", async () => {
-            const subject = new Subject();
-            let resolved = 42;
-            subject.subscribe({
-                next: (n) => {
-                    resolved = n;
-                },
-            });
-            expect(resolved).toBe(42);
-            await subject.next(64);
-            expect(resolved).toBe(64);
-        });
-    });
-    describe("creation", () => { });
-    describe("pipes", () => { });
-    describe("subjects", () => { });
-});

package/build/test.mjs

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-import { parse } from "./flags.js";
-import { execute } from "./scope/execute.js";
-import { asXML } from "./scope/display/junit.js";
-import { onConsole } from "./scope/display/console.js";
-await import("./test_all.js");
-(async function () {
-    const results = await execute();
-    const FLAGS = parse(process.argv);
-    switch (FLAGS.asString("mode", "console")) {
-        case "junit":
-            const xml = asXML(results);
-            console.log(xml);
-            break;
-        case "console":
-        default:
-            onConsole(results);
-            break;
-    }
-    if (results.failed > 0) {
-        process.exit(1);
-    }
-})();