@davidsouther/jiffies 1.0.0 → 1.1.0

package/src/observable/observable.ts

@@ -0,0 +1,403 @@
+import { DEFAULT_LOGGER, Logger } from "../log.js";
+
+export interface FullSubscriber<T, E> {
+  // (t: T): void | Promise<undefined>;
+  next?: (t: T) => void | Promise<undefined>;
+  error?: (e: E) => void | Promise<undefined>;
+  complete?: () => void | Promise<undefined>;
+}
+
+export type Subscriber<T, E> =
+  | FullSubscriber<T, E>
+  // | EventSubscriber<T, E>
+  | ((t: T) => void | Promise<undefined>);
+
+export interface Subscription {
+  // (): void;
+  unsubscribe(): void;
+}
+
+export interface Observable<T, E = unknown> {
+  // (subscriber: Subscriber<T, E>): Subscription;
+  subscribe(subscriber: Subscriber<T, E>): Subscription;
+  pipe<T1>(o1: Subscriber<T, E> & Observable<T1, E>): Observable<T1, E>;
+  pipe<T1, T2>(
+    o1: Subscriber<T, E> & Observable<T1, E>,
+    o2: Subscriber<T1, E> & Observable<T2, E>
+  ): Observable<T2, E>;
+  filter(fn: (t: T) => boolean): Observable<T, E>;
+  map<U>(fn: (t: T) => U): Observable<U, E>;
+  reduce<A>(fn: (acc: A, t: T) => A, init: A): Observable<A, E>;
+  replay(n: number): Observable<T, E>;
+  tap(s: Subscriber<T, E>): Observable<T, E>;
+}
+
+export const Observable = {
+  of<T, E>(...ts: T[]): Observable<T, E> {
+    const subject = new Subject<T, E>();
+    (async function next() {
+      if (subject.cold) {
+        subject.onWarm(next);
+        return;
+      }
+      if (ts.length === 0) {
+        subject.complete();
+        return;
+      }
+      const t = ts.shift()!;
+      await subject.next(t);
+      next();
+    })();
+    return subject;
+  },
+  combineLatest<T1, T2, E>(
+    o1: Observable<T1, E>,
+    o2: Observable<T2, E>
+  ): Observable<[T1, T2], E> {
+    let latestSubject = new Subject<[T1, T2], E>();
+    let o1Latest: T1;
+    let o2Latest: T2;
+
+    function next() {
+      if (o1Latest && o2Latest) {
+        latestSubject.next([o1Latest, o2Latest]);
+      }
+    }
+
+    function error(e: E) {
+      latestSubject.error(e);
+    }
+
+    function complete() {
+      latestSubject.complete();
+      o1sub.unsubscribe();
+      o2sub.unsubscribe();
+    }
+
+    let o1sub = o1.subscribe({
+      next(t: T1) {
+        o1Latest = t;
+        next();
+      },
+      error,
+      complete,
+    });
+
+    let o2sub = o2.subscribe({
+      next(t: T2) {
+        o2Latest = t;
+        next();
+      },
+      error,
+      complete,
+    });
+
+    return latestSubject;
+  },
+};
+
+export class Subject<T, E = unknown, T2 = T>
+  implements FullSubscriber<T, E>, Observable<T, E>
+{
+  #coldWaiters = new Set<Function>();
+  #subscribers = new Set<FullSubscriber<T, E>>();
+  #complete = false;
+
+  get hot(): boolean {
+    return this.#subscribers.size > 0;
+  }
+
+  get cold(): boolean {
+    return !this.hot;
+  }
+
+  onWarm(fn: Function) {
+    if (this.cold) this.#coldWaiters.add(fn);
+  }
+
+  next(t: T | T2): void | Promise<undefined> {
+    if (this.#complete)
+      throw new Error("Cannot call next on a completed subject");
+    return Promise.all(
+      [...this.#subscribers].map((s) => s.next?.(t as T))
+    ).then(() => undefined);
+  }
+
+  error(e: E): void | Promise<undefined> {
+    if (this.#complete)
+      throw new Error("Cannot call error on a completed subject");
+    return Promise.all([...this.#subscribers].map((s) => s.error?.(e))).then(
+      () => undefined
+    );
+  }
+
+  complete(): void | Promise<undefined> {
+    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
+    return finished.then(() => undefined);
+  }
+
+  subscribe(subscriber: Subscriber<T, E>): Subscription {
+    if (this.#complete)
+      throw new Error("Cannot call subscribe on a completed subject");
+
+    if (subscriber instanceof Function) {
+      subscriber = { next: subscriber };
+    }
+
+    this.#subscribers.add(subscriber);
+
+    [...this.#coldWaiters].forEach((w) => w());
+    this.#coldWaiters.clear();
+
+    return {
+      unsubscribe: () =>
+        this.#subscribers.delete(subscriber as FullSubscriber<T, E>),
+    };
+  }
+
+  pipe<T1>(o1: Subscriber<T, E> & Observable<T1, E>): Observable<T1, E>;
+  pipe<T1, T2>(
+    o1: Subscriber<T, E> & Observable<T1, E>,
+    o2: Subscriber<T1, E> & Observable<T2, E>
+  ): Observable<T2, E>;
+  pipe(
+    ...os: (Subscriber<unknown, unknown> & Observable<unknown, unknown>)[]
+  ): Observable<unknown, E> {
+    this.subscribe(os[0]);
+    for (let i = 1; i < os.length; i++) {
+      os[i - 1].subscribe(os[i]);
+    }
+    return os[os.length - 1];
+  }
+
+  filter(fn: (t: T) => boolean): Observable<T, E> {
+    return this.pipe(operator.filter(fn));
+  }
+
+  map<U>(fn: (t: T) => U): Observable<U, E> {
+    return this.pipe(operator.map(fn));
+  }
+
+  reduce<A>(fn: (acc: A, t: T) => A, init: A): Observable<A, E> {
+    return this.pipe(operator.reduce(fn, init));
+  }
+
+  replay(n: number): Observable<T, E> {
+    return this.pipe(operator.replay(n));
+  }
+
+  tap(s: Subscriber<T, E>): Observable<T, E> {
+    return this.pipe(operator.tap(s));
+  }
+}
+
+export class BehaviorSubject<T, E = unknown, T2 = T> extends Subject<T, E, T2> {
+  #current: T;
+
+  constructor(t: T) {
+    super();
+    this.#current = t;
+  }
+
+  next(t: T | T2) {
+    this.#current = t as T;
+    return super.next(t);
+  }
+
+  subscribe(subscriber: Subscriber<T, E>): Subscription {
+    if (subscriber instanceof Function) {
+      subscriber = { next: subscriber };
+    }
+    subscriber.next?.(this.#current);
+    return super.subscribe(subscriber);
+  }
+
+  get current(): T {
+    return this.#current;
+  }
+}
+
+export class ReplaySubject<T, E = unknown> extends Subject<T, E> {
+  #history: T[] = [];
+
+  constructor(private readonly n: number) {
+    super();
+  }
+
+  next(t: T) {
+    this.#history.push(t);
+    if (this.#history.length > this.n) {
+      this.#history.shift();
+    }
+    return super.next(t);
+  }
+
+  subscribe(subscriber: Subscriber<T, E>): Subscription {
+    if (subscriber instanceof Function) {
+      subscriber = { next: 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);
+  }
+}
+
+export function eventListener<E extends Event>() {
+  const observable = new Subject<E, unknown>();
+  function listener(e: E) {
+    e.preventDefault();
+    observable.next(e);
+  }
+
+  return [observable, listener];
+}
+
+export class EventHandler<E extends Event> extends Subject<E> {
+  constructor(private readonly eventFn: (e: E) => void | Promise<undefined>) {
+    super();
+  }
+
+  next(e: E) {
+    e.preventDefault();
+    super.next(e);
+  }
+}
+
+export const watch =
+  <T, E>(logger: Logger = DEFAULT_LOGGER) =>
+  (observable: Observable<T, E>) => {
+    observable.tap({
+      next(t: T) {
+        logger.info(t);
+      },
+      complete() {
+        logger.info("Observable completed");
+      },
+      error(e: E) {
+        logger.warn(e);
+      },
+    });
+  };
+
+class MapOperator<T, U, E>
+  extends Subject<U, E, T>
+  implements FullSubscriber<T, E>, Observable<U, E>
+{
+  constructor(private readonly mapFn: (t: T) => U) {
+    super();
+  }
+
+  next(t: T): void | Promise<undefined> {
+    return super.next(this.mapFn(t));
+  }
+}
+
+class FilterOperator<T, E>
+  extends Subject<T, E>
+  implements FullSubscriber<T, E>, Observable<T, E>
+{
+  constructor(private readonly filterFn: (t: T) => boolean) {
+    super();
+  }
+
+  next(t: T): void | Promise<undefined> {
+    return this.filterFn(t) ? super.next(t) : undefined;
+  }
+}
+
+class ReduceOperator<A, T, E> extends BehaviorSubject<A, E, T> {
+  constructor(private readonly fn: (acc: A, t: T) => A, init: A) {
+    super(init);
+  }
+
+  next(t: T) {
+    return super.next(this.fn(this.current, t));
+  }
+}
+
+export class TakeUntilOperator<T, E> extends Subject<T, E> {
+  constructor(o: Observable<unknown, unknown>) {
+    super();
+    o.subscribe(() => this.complete());
+  }
+}
+export class TapOperator<T, E> extends Subject<T, E> {
+  private readonly subscriber: FullSubscriber<T, E>;
+  constructor(fn: Subscriber<T, E>) {
+    super();
+    this.subscriber = fn instanceof Function ? { next: fn } : fn;
+  }
+
+  next(t: T) {
+    this.subscriber.next?.(t);
+    return super.next(t);
+  }
+
+  error(e: E) {
+    this.subscriber.error?.(e);
+    return super.error(e);
+  }
+
+  complete() {
+    this.subscriber.complete?.();
+    return super.complete();
+  }
+}
+
+class FirstOperator<T, E> extends Subject<T, E> {
+  next(t: T): void | Promise<undefined> {
+    const next = super.next(t);
+    this.complete();
+    return next;
+  }
+}
+
+class LastOperator<T, E = Error> extends Subject<T, E> {
+  #latest?: T;
+
+  next(t: T) {
+    this.#latest = t;
+  }
+
+  complete(): void | Promise<undefined> {
+    if (this.#latest !== undefined) {
+      super.next(this.#latest);
+    }
+    return super.complete();
+  }
+}
+
+export const filter = <T, E>(fn: (t: T) => boolean) =>
+  new FilterOperator<T, E>(fn);
+export const first = <T, E>() => new FirstOperator<T, E>();
+export const last = <T, E>() => new LastOperator<T, E>();
+export const map = <T1, T2, E>(fn: (t: T1) => T2) =>
+  new MapOperator<T1, T2, E>(fn);
+export const replay = <T, E>(n: number) => new ReplaySubject<T, E>(n);
+export const reduce = <A, T, E>(fn: (acc: A, t: T) => A, init: A) =>
+  new ReduceOperator<A, T, E>(fn, init);
+export const takeUntil = <T, E>(o: Observable<unknown, unknown>) =>
+  new TakeUntilOperator<T, E>(o);
+export const tap = <T, E>(fn: Subscriber<T, E>) => new TapOperator<T, E>(fn);
+
+export const operator = {
+  filter,
+  first,
+  last,
+  map,
+  replay,
+  reduce,
+  takeUntil,
+  tap,
+};

package/src/scope/describe.ts

@@ -1,3 +1,4 @@
+import { assert } from "../assert.js";
 import { getLogger } from "../log.js";
 import { TestCase } from "./scope.js";
 
@@ -11,9 +12,10 @@ const logger = getLogger("scope");
 const CASES: TestCase = {};
 let cases = [CASES];
 let totalCases = 0;
+let skippedCases = 0;
 
 function push(title: string) {
-  const next = (cases[0][title] = {});
+  const next = (cases[0][title] = cases[0][title] ?? {}) as TestCase;
   cases.unshift(next);
 }
 
@@ -29,6 +31,10 @@ export function getTotalCases() {
   return totalCases;
 }
 
+export function getSkippedCases() {
+  return skippedCases;
+}
+
 export function describe(title: string, block: Function) {
   logger.debug(`describe(${title})`);
   push(title);
@@ -38,10 +44,17 @@ export function describe(title: string, block: Function) {
 
 export function it(title: string, block: Function) {
   logger.debug(`it(${title})`);
+  assert(cases[0][title] == undefined, `Block already has test ${title}`);
   totalCases += 1;
   cases[0][title] = block;
 }
 
+it.skip = (title: string, _block: Function) => {
+  logger.debug(`it.skip(${title})`);
+  totalCases += 1;
+  skippedCases += 1;
+};
+
 export function beforeEach(fn: () => void) {
   cases[0][beforeeach] = fn;
 }

package/src/scope/display/dom.ts

@@ -1,5 +1,5 @@
 import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js";
-import { DOMElement, Updatable } from "../../dom/dom.js";
+import { DOMElement } from "../../dom/dom.js";
 import { DEFAULT_LOGGER, LEVEL } from "../../log.js";
 import { getTotalCases } from "../describe.js";
 import { flattenResults } from "../execute.js";
@@ -7,7 +7,7 @@ import { TestResult } from "../scope.js";
 
 export function displayStatistics(
   results: TestResult,
-  root: Updatable<DOMElement> = document.body as unknown as Updatable<DOMElement>
+  root: DOMElement = document.body as DOMElement
 ) {
   const { executed, failed } = results;
   const logger = (() => {

package/src/scope/execute.ts

@@ -7,10 +7,7 @@ import {
 } from "./describe.js";
 import { TestFailed, TestPassed, TestResult, TestSummary } from "./scope.js";
 
-export async function execute(
-  prefix = "",
-  cases = rootCases()
-): Promise<TestResult> {
+export async function execute(cases = rootCases()): Promise<TestResult> {
   const beforeallfn = cases[beforeall] ?? (() => {});
   const beforeeachfn = cases[beforeeach] ?? (() => {});
   const afterallfn = cases[afterall] ?? (() => {});
@@ -42,7 +39,7 @@ export async function execute(
         result[title] = { error: /** @type Error */ e };
       }
     } else if (block) {
-      const run = await execute(title, block);
+      const run = await execute(block);
       result.executed += run.executed;
       result.passed += run.passed;
       result.failed += run.failed;

package/src/server/http/css.ts

@@ -2,8 +2,8 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import { contentResponse } from "./response.js";
 import { MiddlewareFactory } from "./index.js";
+// @ts-ignore
 import sass from "sass";
-import { error, info } from "../../log.js";
 const { compileStringAsync } = sass;
 
 function render(source: string) {
@@ -20,6 +20,7 @@ async function compile(
   vars: string
 ): Promise<string> {
   vars = vars.substring(1).replaceAll("=", ":");
+  filename = filename.replaceAll("\\", "/"); // Normalize for dart-sass
   const sassString = `// Using variables: ${vars}\n${vars};\n@import "${filename}";`;
   return (await compileStringAsync(sassString, { loadPaths: [root] })).css;
 }
@@ -36,6 +37,7 @@ export const cssFileServer: MiddlewareFactory =
         Url.pathname.startsWith(`/${s}`)
       );
       // Expand url with found scope
+      Url.protocol = "file";
       let url = scope ? Url.pathname.replace(scope[0], scope[1]) : Url.pathname;
       let filename = path.join(root, url);
       try {

package/src/test_all.ts

@@ -2,14 +2,6 @@
 // discarded during transpilation.
 import { describe, expect, it } from "./scope/index.js";
 
-import "./context.test.js";
-import "./equal.test.js";
-import "./flags.test.js";
-import "./fs.test.js";
-import "./generator.test.js";
-import "./lock.test.js";
-import "./result.test.js";
-
 describe("Test executor", () => {
   it("matches equality", () => {
     expect(1).toBe(1);
@@ -19,3 +11,13 @@ describe("Test executor", () => {
     expect(() => expect(1).toBe(2)).toThrow();
   });
 });
+
+import "./context.test.js";
+import "./diff.test.js";
+import "./equal.test.js";
+import "./flags.test.js";
+import "./fs.test.js";
+import "./generator.test.js";
+import "./lock.test.js";
+import "./result.test.js";
+import "./observable/observable.test.js";

package/src/observable/observable._js

@@ -1,175 +0,0 @@
-// import { Observable, ReplaySubject } from "rxjs";
-// import { tap } from "rxjs/operators";
-import { display } from "../display.js";
-import { DEFAULT_LOGGER, Logger } from "../log.js";
-
-/**
- * @template T
- * @typedef Next
- * @property {T} value
- * @property {false} completed
- * @property {false} failed
- */
-
-/**
- * @template E
- * @typedef Error
- * @property {E} error
- * @property {false} completed
- * @property {true} failed
- */
-
-/**
- * @typedef Completed
- * @property {true} completed
- * @property {false} failed
- */
-
-/**
- * @typedef Failed
- * @property {true} completed
- * @property {true} failed
- */
-
-/**
- * @template T
- * @template E
- * @typedef {Next<T> | Error<E> | Completed | Failed} Event
- */
-
-/**
- * @template T
- * @param {T} value
- * @returns {Next<T>}
- */
-export const next = (value) => ({ value, completed: false, failed: false });
-
-/**
- * @template E
- * @param {E} e
- * @returns {Error<E>}
- */
-export const error = (e) => ({ error: e, completed: false, failed: true });
-
-/** @returns {Completed} */
-export const completed = () => ({ completed: true, failed: false });
-
-/** @returns {Failed} */
-export const failed = () => ({ completed: true, failed: true });
-
-/**
- * @template T
- * @param {Event<T, unknown>} event
- * @returns {event is Next<T>}
- */
-export const isNext = (event) =>
-  !event.completed && !event.failed && event.value !== undefined;
-
-/**
- * @template E
- * @param {Event<unknown, E>} event
- * @returns {event is Error<E>}
- */
-export const isError = (event) => event.failed && !event.completed;
-
-/**
- * @param {Event<unknown, unknown>} event
- * @returns {event is Completed}
- */
-export const isCompleted = (event) => event.completed && !event.failed;
-
-/**
- * @param {Event<unknown, unknown>} event
- * @returns {event is Failed}
- */
-export const isFailed = (event) => event.completed && event.failed;
-
-/**
- * @template T
- * @param {T|Event<T, unknown>} t
- * @returns {t is Event<T, unknown>}
- */
-export const isEvent = (t) => {
-  /* @type unknown */
-  const b = t;
-  return isNext(b) || isError(b) || isCompleted(b);
-};
-
-/**
- * @template T
- * @param {(T|Event<T, unknown>)[]} a
- * @returns {(Event<T, unknown>)[]}
- */
-export const asEvents = (a) => a.map((e) => (isEvent(e) ? e : next(e)));
-
-/**
- * @template T
- * @param {Event<T, unknown>} event
- * @returns {string}
- */
-const marble = (event) =>
-  isError(event)
-    ? "X"
-    : isFailed(event)
-    ? "!"
-    : isCompleted(event)
-    ? "|"
-    : `(${display(event.value)})`;
-
-/**
- * @template T
- * @param {(Event<T, unknown>)[]} events
- * @returns string
- */
-export const marbles = (events) => `:${events.map(marble).join("-")}`;
-
-/**
- * @template T
- * @template E
- * @param {Observable<T>} input$
- * @returns {(Event<T, E>)[]}
- */
-export const collect = (input$) => {
-  /** @type {(Event<T, E>)[]} */
-  const collected = [];
-
-  const subscription = input$.subscribe({
-    next: (/* @type T */ x) => collected.push(next(x)),
-    error: (/* @type E */ e) => collected.push(error(e)),
-    complete: () => collected.push(completed()),
-  });
-
-  subscription.unsubscribe();
-
-  return collected;
-};
-
-/**
- * @template T
- * @param {Logger} logger
- * @returns {(o: Observable<T>) => Observable<T>}
- */
-export const watch =
-  (logger = DEFAULT_LOGGER) =>
-  /**
-   * @template E
-   * @param {Observable<T>} observable
-   * @returns {Observable<T>}
-   */
-  (observable) => {
-    observable.pipe(
-      tap({
-        next(/* @type T */ t) {
-          logger.info(t);
-        },
-        complete() {
-          logger.info("Observable completed");
-        },
-        error(/* @type E */ e) {
-          logger.warn(e);
-        },
-      })
-    );
-
-    return observable;
-  };