@davidsouther/jiffies 1.1.0 → 2.0.2

package/src/index.html

@@ -23,10 +23,10 @@
         import("./components/test.js"),
       ]);
 
-      import { execute } from "./scope/execute.js";
-      import { displayStatistics } from "./scope/display/dom.js";
-      import { onConsole } from "./scope/display/console.js";
-      import { asXML } from "./scope/display/junit.js";
+      import { execute } from "./scope/execute"
+      import { displayStatistics } from "./scope/display/dom"
+      import { onConsole } from "./scope/display/console"
+      import { asXML } from "./scope/display/junit"
 
       function write(id, value) {
         const start = `--- START_${id.toUpperCase()} ---`;
@@ -46,8 +46,8 @@
       })();
     </script>
     <script type="module">
-      import { nav, ul, li, strong } from "./dom/html.js";
-      import { link } from "./dom/router/link.js";
+      import { nav, ul, li, strong } from "./dom/html"
+      import { link } from "./dom/router/link"
 
       const getUrls = async () => {
         const sitemap = await fetch("/sitemap.json");

package/src/observable/event.ts

@@ -1,5 +1,5 @@
-import { display } from "../display.js";
-import { Observable } from "./observable.js";
+import { display } from "../display.js"
+import { Observable } from "./observable.js"
 
 export interface Next<T> {
   value: T;

package/src/observable/observable.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from "../scope/index.js";
-import { Observable, Subject, filter, map } from "./observable.js";
+import { describe, expect, it } from "../scope/index.js"
+import { Observable, Subject, filter, map } from "./observable.js"
 
 describe("Observables", () => {
   describe("basics", () => {

package/src/observable/observable.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_LOGGER, Logger } from "../log.js";
+import { DEFAULT_LOGGER, Logger } from "../log.js"
 
 export interface FullSubscriber<T, E> {
   // (t: T): void | Promise<undefined>;
@@ -26,6 +26,7 @@ export interface Observable<T, E = unknown> {
     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>;
@@ -55,11 +56,13 @@ export const Observable = {
     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 (o1Latest && o2Latest) {
+      if (o1LatestSet && o2LatestSet) {
         latestSubject.next([o1Latest, o2Latest]);
       }
     }
@@ -77,6 +80,7 @@ export const Observable = {
     let o1sub = o1.subscribe({
       next(t: T1) {
         o1Latest = t;
+        o1LatestSet = true;
         next();
       },
       error,
@@ -86,6 +90,7 @@ export const Observable = {
     let o2sub = o2.subscribe({
       next(t: T2) {
         o2Latest = t;
+        o2LatestSet = true;
         next();
       },
       error,
@@ -96,6 +101,22 @@ export const Observable = {
   },
 };
 
+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>
 {
@@ -103,6 +124,10 @@ export class Subject<T, E = unknown, T2 = T>
   #subscribers = new Set<FullSubscriber<T, E>>();
   #complete = false;
 
+  get $(): Observable<T, E> {
+    return this;
+  }
+
   get hot(): boolean {
     return this.#subscribers.size > 0;
   }
@@ -111,6 +136,8 @@ export class Subject<T, E = unknown, T2 = T>
     return !this.hot;
   }
 
+  constructor(private readonly scheduler: Scheduler = AsyncScheduler) {}
+
   onWarm(fn: Function) {
     if (this.cold) this.#coldWaiters.add(fn);
   }
@@ -118,16 +145,16 @@ export class Subject<T, E = unknown, T2 = T>
   next(t: T | T2): void | Promise<undefined> {
     if (this.#complete)
       throw new Error("Cannot call next on a completed subject");
-    return Promise.all(
+    return this.scheduler.execute(() =>
       [...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
+    return this.scheduler.execute(() =>
+      [...this.#subscribers].map((s) => s.error?.(e))
     );
   }
 
@@ -135,11 +162,11 @@ export class Subject<T, E = unknown, T2 = T>
     if (this.#complete)
       throw new Error("Cannot call complete on a completed subject");
     this.#complete = true;
-    const finished = Promise.all(
+    const finished = this.scheduler.execute(() =>
       [...this.#subscribers].map((s) => s.complete?.())
     );
     this.#subscribers.clear(); // Free subscribers for garbage collection
-    return finished.then(() => undefined);
+    return finished;
   }
 
   subscribe(subscriber: Subscriber<T, E>): Subscription {
@@ -180,6 +207,10 @@ export class Subject<T, E = unknown, T2 = T>
     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));
   }
@@ -200,8 +231,8 @@ export class Subject<T, E = unknown, T2 = T>
 export class BehaviorSubject<T, E = unknown, T2 = T> extends Subject<T, E, T2> {
   #current: T;
 
-  constructor(t: T) {
-    super();
+  constructor(t: T, scheduler?: Scheduler) {
+    super(scheduler);
     this.#current = t;
   }
 
@@ -226,8 +257,8 @@ export class BehaviorSubject<T, E = unknown, T2 = T> extends Subject<T, E, T2> {
 export class ReplaySubject<T, E = unknown> extends Subject<T, E> {
   #history: T[] = [];
 
-  constructor(private readonly n: number) {
-    super();
+  constructor(private readonly n: number, scheduler?: Scheduler) {
+    super(scheduler);
   }
 
   next(t: T) {
@@ -316,6 +347,32 @@ class FilterOperator<T, E>
   }
 }
 
+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);
@@ -380,6 +437,8 @@ class LastOperator<T, E = Error> extends Subject<T, E> {
 
 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) =>
@@ -393,6 +452,7 @@ export const tap = <T, E>(fn: Subscriber<T, E>) => new TapOperator<T, E>(fn);
 
 export const operator = {
   filter,
+  distinct,
   first,
   last,
   map,

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,6 +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");
@@ -75,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,9 +1,9 @@
-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";
+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,

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,8 +4,8 @@ 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(cases = rootCases()): Promise<TestResult> {
   const beforeallfn = cases[beforeall] ?? (() => {});

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/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();

package/src/test.mjs

@@ -5,25 +5,29 @@ 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 main() {
+  await import("./test_all.js");
 
-(async function () {
-  const results = await execute();
+  (async function () {
+    const results = await execute();
 
-  const FLAGS = parse(process.argv);
+    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;
-  }
+    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);
-  }
-})();
+    if (results.failed > 0) {
+      process.exit(1);
+    }
+  })();
+}
+
+main();

package/src/test_all.ts

@@ -21,3 +21,13 @@ import "./generator.test.js";
 import "./lock.test.js";
 import "./result.test.js";
 import "./observable/observable.test.js";
+
+import * as components from "./components/test.js";
+import * as dom from "./dom/test.js";
+
+if (process?.env.CI?.toLowerCase() !== "true") {
+  (async () => {
+    await components.loadTests();
+    await dom.loadTests();
+  })();
+}

package/build/components/select.d.ts

@@ -1,13 +0,0 @@
-import { EventHandler } from "../dom/dom.js";
-export declare const Select: import("../dom/fc.js").FCComponentCtor<{
-    name: string;
-    value: string;
-    events: {
-        change: EventHandler;
-    };
-    disabled: boolean;
-    options: [
-        string,
-        string
-    ][];
-}, {}>;

package/build/components/test.js

@@ -1,2 +0,0 @@
-await import("./virtual_scroll.test.js");
-export {};

package/build/debounce.d.ts

@@ -1 +0,0 @@
-export declare function debounce(fn: (...args: any[]) => any, ms?: number): (...args: Parameters<typeof fn>) => ReturnType<typeof fn>;

package/build/dom/test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/dom/test.js

@@ -1,2 +0,0 @@
-await Promise.all([import("./html.test.js"), import("./fc.test.js")]);
-export {};

package/build/observable/observable.d.ts

@@ -1,83 +0,0 @@
-import { Logger } from "../log.js";
-export interface Subscriber<T, E> {
-    next?: (t: T) => void | Promise<undefined>;
-    error?: (e: E) => void | Promise<undefined>;
-    complete?: () => void | Promise<undefined>;
-}
-export interface Subscription {
-    unsubscribe(): void;
-}
-export interface Observable<T, E = unknown> {
-    subscribe(subscriber: Subscriber<T, E>): Subscription;
-    pipe<T1>(o1: (t: T) => T1): Observable<T1, E>;
-    pipe<T1, T2>(o1: (t: T) => T1, o2: (t: T) => T2): Observable<T2, E>;
-    pipe<T1, T2, T3>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3): Observable<T3, E>;
-    pipe<T1, T2, T3, T4>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4): Observable<T4, E>;
-    pipe<T1, T2, T3, T4, T5>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4, o5: (t: T4) => T5): Observable<T5, E>;
-}
-export declare const Observable: {
-    of<T, E>(...T: T[]): void;
-    combineLatest<T_1, E_1>(...O: Observable<T_1, E_1>[]): void;
-    from<T_2, E_2>(f: Promise<T_2> | Iterable<T_2> | Observable<T_2, E_2>): void;
-    fromEvent<T_3, E_3>(element: {
-        addEventListener<Ev>(fn: (e: Ev) => void): void;
-    }, eventName: string): void;
-};
-export declare class Subject<T, E = unknown> implements Subscriber<T, E>, Observable<T, E> {
-    #private;
-    next(t: T): Promise<undefined>;
-    error(e: E): Promise<undefined>;
-    complete(): Promise<undefined>;
-    subscribe(subscriber: Subscriber<T, E>): Subscription;
-    pipe<T1>(o1: (t: T) => T1): Observable<T1, E>;
-    pipe<T1, T2>(o1: (t: T) => T1, o2: (t: T1) => T2): Observable<T2, E>;
-    pipe<T1, T2, T3>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3): Observable<T3, E>;
-    pipe<T1, T2, T3, T4>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4): Observable<T4, E>;
-    pipe<T1, T2, T3, T4, T5>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4, o5: (t: T4) => T5): Observable<T5, E>;
-}
-export declare class BehaviorSubject<T, E = unknown> extends Subject<T, E> {
-    #private;
-    constructor(t: T);
-    next(t: T): Promise<undefined>;
-    subscribe(subscriber: Subscriber<T, E>): Subscription;
-    get current(): T;
-}
-export declare class ReplaySubject<T, E = unknown> extends Subject<T, E> {
-    #private;
-    private readonly n;
-    constructor(n: number);
-    next(t: T): Promise<undefined>;
-    subscribe(subscriber: Subscriber<T, E>): Subscription;
-}
-export interface Next<T> {
-    value: T;
-    completed: false;
-    failed: false;
-}
-export interface Error<E> {
-    error: E;
-    completed: false;
-    failed: true;
-}
-export interface Completed {
-    completed: true;
-    failed: false;
-}
-export interface Failed {
-    completed: true;
-    failed: true;
-}
-export declare type Event<T, E> = Next<T> | Error<E> | Completed | Failed;
-export declare const next: <T>(value: T) => Next<T>;
-export declare const error: <E>(e: E) => Error<E>;
-export declare const completed: () => Completed;
-export declare const failed: () => Failed;
-export declare const isNext: <T>(event: Event<T, unknown>) => event is Next<T>;
-export declare const isError: <E>(event: Event<unknown, E>) => event is Error<E>;
-export declare const isCompleted: (event: Event<unknown, unknown>) => event is Completed;
-export declare const isFailed: (event: Event<unknown, unknown>) => event is Failed;
-export declare const isEvent: <T, E>(t: T | Event<T, E>) => t is Event<T, E>;
-export declare const asEvents: <T, E>(a: (T | Event<T, E>)[]) => Event<T, E>[];
-export declare const marbles: <T, E>(events: Event<T, E>[]) => string;
-export declare const collect: <T, E>(input$: Observable<T, E>) => Event<T, E>[];
-export declare const watch: <T, E>(logger?: Logger) => (observable: Observable<T, E>) => void;