@davidsouther/jiffies 1.0.0 → 2.0.1

package/src/observable/observable.ts

@@ -0,0 +1,463 @@
+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>;
+  distinct(fn?: (t1: T, t2: 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 o1LatestSet = false;
+    let o1Latest: T1;
+    let o2LatestSet = false;
+    let o2Latest: T2;
+
+    function next() {
+      if (o1LatestSet && o2LatestSet) {
+        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;
+        o1LatestSet = true;
+        next();
+      },
+      error,
+      complete,
+    });
+
+    let o2sub = o2.subscribe({
+      next(t: T2) {
+        o2Latest = t;
+        o2LatestSet = true;
+        next();
+      },
+      error,
+      complete,
+    });
+
+    return latestSubject;
+  },
+};
+
+interface Scheduler {
+  execute(fn: () => (void | Promise<undefined>)[]): void | Promise<undefined>;
+}
+
+export const AsyncScheduler: Scheduler = {
+  execute(fn: () => Promise<undefined>[]): Promise<undefined> {
+    return Promise.all(fn()).then(() => undefined);
+  },
+};
+
+export const SyncScheduler: Scheduler = {
+  execute(fn: () => void[]): void {
+    fn();
+  },
+};
+
+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 $(): Observable<T, E> {
+    return this;
+  }
+
+  get hot(): boolean {
+    return this.#subscribers.size > 0;
+  }
+
+  get cold(): boolean {
+    return !this.hot;
+  }
+
+  constructor(private readonly scheduler: Scheduler = AsyncScheduler) {}
+
+  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 this.scheduler.execute(() =>
+      [...this.#subscribers].map((s) => s.next?.(t as T))
+    );
+  }
+
+  error(e: E): void | Promise<undefined> {
+    if (this.#complete)
+      throw new Error("Cannot call error on a completed subject");
+    return this.scheduler.execute(() =>
+      [...this.#subscribers].map((s) => s.error?.(e))
+    );
+  }
+
+  complete(): void | Promise<undefined> {
+    if (this.#complete)
+      throw new Error("Cannot call complete on a completed subject");
+    this.#complete = true;
+    const finished = this.scheduler.execute(() =>
+      [...this.#subscribers].map((s) => s.complete?.())
+    );
+    this.#subscribers.clear(); // Free subscribers for garbage collection
+    return finished;
+  }
+
+  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));
+  }
+
+  distinct(fn: (t1: T, t2: T) => boolean = Object.is): Observable<T, E> {
+    return this.pipe(operator.distinct(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, scheduler?: Scheduler) {
+    super(scheduler);
+    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, scheduler?: Scheduler) {
+    super(scheduler);
+  }
+
+  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 DistinctOperator<T, E>
+  extends Subject<T, E>
+  implements FullSubscriber<T, E>, Observable<T, E>
+{
+  #prior: T | undefined = undefined;
+
+  constructor(
+    private readonly distinctFn: (t1: T, t2: T) => boolean = Object.is
+  ) {
+    super();
+  }
+
+  next(t: T): void | Promise<undefined> {
+    if (this.#prior === undefined) {
+      this.#prior = t;
+      return super.next(t);
+    }
+    const same = this.distinctFn(this.#prior!, t);
+    if (!same) {
+      this.#prior = t;
+      return super.next(t);
+    }
+    return 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 distinct = <T, E>(fn?: (t1: T, t2: T) => boolean) =>
+  new DistinctOperator<T, E>(fn ?? Object.is);
+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,
+  distinct,
+  first,
+  last,
+  map,
+  replay,
+  reduce,
+  takeUntil,
+  tap,
+};

package/src/pico/_variables.scss

@@ -9,7 +9,7 @@ $enable-class-container: false !default;
 
 // Enable a centered viewport for <header>, <main>, <footer> inside <body>
 // Options are "all" to center all, "main" to only center main, and "none" to treat all as fluid.
-$enable-viewport: "main" !default;
+$enable-viewport: "none" !default;
 
 // Enable responsive spacings for <header>, <main>, <footer>, <section>, <article>
 // Fixed spacings if disabled

package/src/pico/layout/_sectioning.scss

@@ -16,6 +16,8 @@ main {
 // Pico
 // ––––––––––––––––––––
 
+@import url("../themes/default/styles");
+
 // 1. Remove the margin in all browsers (opinionated)
 // 2. Body should be at least the height of the viewport (opinionated)
 body {

package/src/result.ts

@@ -8,7 +8,7 @@ export type Err<E = Error> = {
 export type Ok<T> = { ok: T; map: <U>(fn: (t: T) => Result<U>) => Result<U> };
 export type Result<T, E = Error> = Ok<T> | Err<E>;
 
-export const isNone = <T>(s: Option<T>): s is None => s == null;
+export const isNone = <T>(s: Option<T>): s is None => s === null;
 export const isSome = <T>(s: Option<T>): s is Some<T> => s != null;
 
 export function None<T = unknown>(_?: T): Option<T> {

package/src/scope/describe.ts

@@ -1,5 +1,7 @@
+import { assert } from "../assert.js";
 import { getLogger } from "../log.js";
 import { TestCase } from "./scope.js";
+import * as state from "./state.js";
 
 export const beforeall = Symbol("beforeAll");
 export const beforeeach = Symbol("beforeEach");
@@ -11,9 +13,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 +32,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 +45,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;
 }
@@ -62,9 +76,5 @@ export function cleanState<State extends {}>(
   init: () => State,
   runner: (action: () => void) => void = beforeEach
 ): State {
-  const state = {};
-  runner(() => {
-    Object.assign(state, init());
-  });
-  return state as State;
+  return state.cleanState(init, runner);
 }

package/src/scope/display/console.ts

@@ -1,7 +1,7 @@
-import { getLogger } from "../../log.js";
-import { getTotalCases } from "../describe.js";
-import { flattenResults } from "../execute.js";
-import { TestResult } from "../scope.js";
+import { getLogger } from "../../log.js"
+import { getTotalCases } from "../describe.js"
+import { flattenResults } from "../execute.js"
+import { TestResult } from "../scope.js"
 
 const logger = getLogger("Scope Test Runner");
 

package/src/scope/display/dom.ts

@@ -1,13 +1,13 @@
-import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js";
-import { DOMElement, Updatable } from "../../dom/dom.js";
-import { DEFAULT_LOGGER, LEVEL } from "../../log.js";
-import { getTotalCases } from "../describe.js";
-import { flattenResults } from "../execute.js";
-import { TestResult } from "../scope.js";
+import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js"
+import { DOMElement } from "../../dom/dom.js"
+import { DEFAULT_LOGGER, LEVEL } from "../../log.js"
+import { getTotalCases } from "../describe.js"
+import { flattenResults } from "../execute.js"
+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/display/junit.ts

@@ -1,6 +1,6 @@
-import { xml } from "../../dom/xml.js";
-import { FlatResult, flattenResults } from "../execute.js";
-import { TestResult } from "../scope.js";
+import { xml } from "../../dom/xml.js"
+import { FlatResult, flattenResults } from "../execute.js"
+import { TestResult } from "../scope.js"
 
 const cases = (results: TestResult) =>
   Object.entries(results).filter(

package/src/scope/execute.ts

@@ -4,13 +4,10 @@ import {
   beforeall,
   beforeeach,
   rootCases,
-} from "./describe.js";
-import { TestFailed, TestPassed, TestResult, TestSummary } from "./scope.js";
+} 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/scope/expect.ts

@@ -1,6 +1,6 @@
-import { assert } from "../assert.js";
-import { display } from "../display.js";
-import { equals } from "../equal.js";
+import { assert } from "../assert.js"
+import { display } from "../display.js"
+import { equals } from "../equal.js"
 
 export class Matcher<T> {
   actual: T;

package/src/scope/state.ts

@@ -0,0 +1,10 @@
+export function cleanState<State extends {}>(
+  init: () => State,
+  runner: (action: () => void) => void
+): State {
+  const state = {};
+  runner(() => {
+    Object.assign(state, init());
+  });
+  return state as State;
+}

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/server/http/sitemap.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { info } from "../../log.js";
-import { MiddlewareFactory, StaticMiddleware } from "./index.js";
+import { MiddlewareFactory } from "./index.js";
 import { contentResponse } from "./response.js";
 
 const findSiteMap = async (root: string, prefix = root) => {

package/src/server/main.ts

@@ -9,5 +9,12 @@ const FLAGS = parse(process.argv);
 import { makeServer } from "./http/index.js";
 import * as path from "node:path";
 
-const server = await makeServer({ root: path.join(process.cwd(), "src") });
-server.listen(FLAGS.asNumber("port", 8080), FLAGS.asString("host", "0.0.0.0"));
+async function main() {
+  const server = await makeServer({ root: path.join(process.cwd(), "src") });
+  server.listen(
+    FLAGS.asNumber("port", 8080),
+    FLAGS.asString("host", "0.0.0.0")
+  );
+}
+
+main();