@davidsouther/jiffies 2026.24.0 → 2026.24.2

package/src/observable/_notes

@@ -1,26 +0,0 @@
-Subscriber
-    next(t: T)
-    error(e: E)
-    complete()
-
-Observable
-    ::of(...Ts)
-    ::combineLatest([...])
-    ::from(promise|Iterable|Subscribable)
-    ::fromEvent(element, eventName)
-    (subscriber) -> subscription
-    .subscribe(subscriber) -> subscription
-    .pipe(...operators) -> Observable
-
-Subject
-    -> BehaviorSubject(t)
-    -> ReplaySubject(n)
-
-operator
-    filter
-    first/last
-    map
-    publishReplay
-    reduce
-    takeUntil
-    tap

package/src/observable/event.ts

@@ -1,93 +0,0 @@
-import { display } from "../display.ts";
-import type { Observable } from "./observable.ts";
-
-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 type Event<T, E> = Next<T> | Error<E> | Completed | Failed;
-
-export interface EventSubscriber<T, E> {
-  next(e: Event<T, E>): void;
-}
-
-export const next = <T>(value: T): Next<T> => ({
-  value,
-  completed: false,
-  failed: false,
-});
-export const error = <E>(e: E): Error<E> => ({
-  error: e,
-  completed: false,
-  failed: true,
-});
-export const completed = (): Completed => ({ completed: true, failed: false });
-export const failed = (): Failed => ({ completed: true, failed: true });
-
-export const isNext = <T>(event: Event<T, unknown>): event is Next<T> =>
-  !event.completed && !event.failed && event.value !== undefined;
-export const isError = <E>(event: Event<unknown, E>): event is Error<E> =>
-  event.failed && !event.completed;
-export const isCompleted = (
-  event: Event<unknown, unknown>,
-): event is Completed => event.completed && !event.failed;
-export const isFailed = (event: Event<unknown, unknown>): event is Failed =>
-  event.completed && event.failed;
-
-export const isEvent = <T, E>(t: T | Event<T, E>): t is Event<T, E> => {
-  const b = t as Event<unknown, unknown>;
-  return isNext(b) || isError(b) || isCompleted(b);
-};
-
-export const asEvents = <T, E>(a: (T | Event<T, E>)[]): Event<T, E>[] =>
-  a.map((e) => (isEvent(e) ? e : next(e)));
-
-const marble = <T, E>(event: Event<T, E>): string =>
-  isError(event)
-    ? "X"
-    : isFailed(event)
-      ? "!"
-      : isCompleted(event)
-        ? "|"
-        : `(${display(event.value)})`;
-
-export const marbles = <T, E>(events: Event<T, E>[]): string =>
-  `:${events.map(marble).join("-")}`;
-
-export const collect = <T, E>(input$: Observable<T, E>) => {
-  const collected: Event<T, E>[] = [];
-
-  const subscription = input$.subscribe({
-    next: (x: T) => {
-      collected.push(next(x));
-    },
-    error: (e: E) => {
-      collected.push(error(e));
-    },
-    complete: () => {
-      collected.push(completed());
-    },
-  });
-
-  subscription.unsubscribe();
-
-  return collected;
-};

package/src/observable/observable.ts

@@ -1,484 +0,0 @@
-import { assertExists } from "../assert.ts";
-import type { Display } from "../display.ts";
-import { DEFAULT_LOGGER, type Logger } from "../log.ts";
-
-export interface FullSubscriber<T, E> {
-  // (t: T): void | Promise<undefined>;
-  next?: (t: T) => void | Promise<void>;
-  error?: (e: E) => void | Promise<void>;
-  complete?: () => void | Promise<void>;
-}
-
-export type Subscriber<T, E> =
-  | FullSubscriber<T, E>
-  // | EventSubscriber<T, E>
-  | ((t: T) => void | Promise<void>);
-
-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 = assertExists(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> {
-    const 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();
-    }
-
-    const o1sub = o1.subscribe({
-      next(t: T1) {
-        o1Latest = t;
-        o1LatestSet = true;
-        next();
-      },
-      error,
-      complete,
-    });
-
-    const o2sub = o2.subscribe({
-      next(t: T2) {
-        o2Latest = t;
-        o2LatestSet = true;
-        next();
-      },
-      error,
-      complete,
-    });
-
-    return latestSubject;
-  },
-};
-
-interface Scheduler {
-  execute(fn: () => (void | Promise<void>)[]): void | Promise<void>;
-}
-
-export const AsyncScheduler: Scheduler = {
-  execute(fn: () => Promise<void>[]): Promise<void> {
-    return Promise.all(fn()).then(() => undefined);
-  },
-};
-
-export const SyncScheduler: Scheduler = {
-  execute(fn: () => undefined[]): void {
-    fn();
-  },
-};
-
-let DefaultScheduler = SyncScheduler;
-export function setDefaultScheduler(scheduler: Scheduler) {
-  DefaultScheduler = scheduler;
-}
-
-export class Subject<T, E = unknown, T2 = T>
-  implements FullSubscriber<T, E>, Observable<T, E>
-{
-  private readonly scheduler: Scheduler;
-  #coldWaiters = new Set<CallableFunction>();
-  #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(scheduler: Scheduler = DefaultScheduler) {
-    this.scheduler = scheduler;
-  }
-
-  onWarm(fn: CallableFunction) {
-    if (this.cold) this.#coldWaiters.add(fn);
-  }
-
-  next(t: T | T2): void | Promise<void> {
-    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<void> {
-    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<void> {
-    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);
-
-    for (const w of this.#coldWaiters) 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 ?? AsyncScheduler);
-    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> {
-  readonly n: number;
-  #history: T[] = [];
-
-  constructor(n: number, scheduler?: Scheduler) {
-    super(scheduler ?? SyncScheduler);
-    this.n = n;
-  }
-
-  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 = assertExists(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> {
-  eventFn: (e: E) => void | Promise<void>;
-
-  constructor(eventFn: (e: E) => void | Promise<void>) {
-    super(AsyncScheduler);
-    this.eventFn = eventFn;
-  }
-
-  async next(e: E): Promise<undefined> {
-    e.preventDefault();
-    super.next(e);
-  }
-}
-
-export const watch =
-  <T extends Display, E extends Display>(logger: Logger = DEFAULT_LOGGER) =>
-  (observable: Observable<T, E>) => {
-    observable.tap({
-      async next(t: T) {
-        logger.info(t);
-      },
-      async complete() {
-        logger.info("Observable completed");
-      },
-      async error(e: E) {
-        logger.warn(e);
-      },
-    });
-  };
-
-class MapOperator<T, U, E>
-  extends Subject<U, E, T>
-  implements FullSubscriber<T, E>, Observable<U, E>
-{
-  private readonly mapFn: (t: T) => U;
-  constructor(mapFn: (t: T) => U) {
-    super(SyncScheduler);
-    this.mapFn = mapFn;
-  }
-
-  next(t: T): void | Promise<void> {
-    return super.next(this.mapFn(t));
-  }
-}
-
-class FilterOperator<T, E>
-  extends Subject<T, E>
-  implements FullSubscriber<T, E>, Observable<T, E>
-{
-  private readonly filterFn: (t: T) => boolean;
-  constructor(filterFn: (t: T) => boolean) {
-    super(SyncScheduler);
-    this.filterFn = filterFn;
-  }
-
-  next(t: T): void | Promise<void> {
-    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;
-  private readonly distinctFn: (t1: T, t2: T) => boolean;
-
-  constructor(distinctFn: (t1: T, t2: T) => boolean = Object.is) {
-    super(SyncScheduler);
-    this.distinctFn = distinctFn;
-  }
-
-  next(t: T): void | Promise<void> {
-    if (this.#prior === undefined) {
-      this.#prior = t;
-      return super.next(t);
-    }
-    const same = this.distinctFn(assertExists(this.#prior), t);
-    if (!same) {
-      this.#prior = t;
-      return super.next(t);
-    }
-    return undefined;
-  }
-}
-
-class ReduceOperator<A, T, E> extends BehaviorSubject<A, E, T> {
-  private readonly fn: (acc: A, t: T) => A;
-  constructor(fn: (acc: A, t: T) => A, init: A) {
-    super(init);
-    this.fn = fn;
-  }
-
-  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<void> {
-    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<void> {
-    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/range.ts

@@ -1,7 +0,0 @@
-export function range(start: number, end: number, stride = 1): number[] {
-  const range = [];
-  for (let i = start; i < end; i += stride) {
-    range.push(i);
-  }
-  return range;
-}

package/src/result.ts

@@ -1,107 +0,0 @@
-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> {
-  return null;
-}
-
-export function Some<T>(t: Option<T>): Option<T>;
-export function Some<T>(t: T): Option<T>;
-export function Some<T>(t: Option<T> | T): Option<T> {
-  return t;
-}
-
-export const isOk = <T, E>(t: Result<T, E>): t is Ok<T> =>
-  t && Object.hasOwn(t, "ok");
-export const isErr = <T, E>(e: Result<T, E>): e is Err<E> =>
-  e && Object.hasOwn(e, "err");
-export const isResult = <T, E>(t: Result<T, E>): t is Result<T, E> =>
-  isOk(t) || isErr(t);
-
-// Beware: Order matters for correct inference.
-export function Ok<T, _E = unknown>(ok: Ok<T>): T;
-export function Ok<T, _E = unknown>(t?: T): Ok<T>;
-export function Ok<T, E = unknown>(t: T | Ok<T>): T | Ok<T> {
-  return isOk(t as Ok<T>)
-    ? (t as Ok<T>).ok
-    : ({
-        ok: t,
-        map<U>(fn: (_: typeof t) => Result<U, E>): Result<U, E> {
-          return fn(Ok(this));
-        },
-      } as Ok<T>);
-}
-
-// Beware: Order matters for correct inference.
-export function Err<_T, E>(e: Err<E>): E;
-export function Err<_T, E>(e: E): Err<E>;
-export function Err<_T, E>(e: string): Err<E>;
-export function Err<T, E>(e: E | string | Err<E>): E | Err<E> {
-  return (
-    ((e as Err<E>).err as E) ??
-    ({
-      err: e,
-      map<U>(this: Result<T, E>, _fn: (t: unknown) => Result<U>): Result<U, E> {
-        return this as Result<U, E>;
-      },
-    } as Err<E>)
-  );
-}
-
-export function unwrap<T, E>(result: Result<T, E>): T | never;
-export function unwrap<O>(some: Option<O>): O | never;
-export function unwrap<T, E>(t: Result<T, E> | Option<T> | T): T | never {
-  if (isNone(t as Option<T>)) {
-    throw new Error("Attempted to unwrap None");
-  }
-  if (isErr(t as Result<T, E>)) {
-    throw Err(t);
-  }
-  if (isOk(t as Result<T, E>)) {
-    return Ok(t as Ok<T>);
-  }
-  return t as T;
-}
-
-export function unwrapOr<T, E>(result: Result<T, E>, def: T): T;
-export function unwrapOr<T>(some: Some<T>, def: T): T;
-export function unwrapOr<T, E>(t: Some<T> | Result<T, E>, def: T): T {
-  if (isNone(t as Some<T>)) {
-    return def;
-  }
-  if (isErr(t as Result<T, E>)) {
-    return def;
-  }
-  if (isOk(t as Result<T, E>)) {
-    return Ok(t as Ok<T>);
-  }
-  return t as T;
-}
-
-export function unwrapOrElse<T, E>(result: Result<T, E>, def: () => T): T;
-export function unwrapOrElse<T, _E>(some: Some<T>, def: () => T): T;
-export function unwrapOrElse<T, E>(t: Result<T, E> | Some<T>, def: () => T): T {
-  if (isNone(t as Some<T>)) {
-    return def();
-  }
-  if (isErr(t as Err<T>)) {
-    return def();
-  }
-  if (isOk(t as Ok<T>)) {
-    return Ok(t as Ok<T>);
-  }
-  return t as T;
-}
-
-export type None = null;
-// biome-ignore lint/suspicious/noRedeclare: This file does trickery with const and type.
-export type Some<T> = T;
-export type Option<T> = Some<T> | None;
-// biome-ignore lint/suspicious/noRedeclare: This file does trickery with const and type.
-export type Err<E = Error> = {
-  err: E;
-  map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
-};
-// biome-ignore lint/suspicious/noRedeclare: This file does trickery with const and type.
-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>;