gordonbrander

/**
 * SQLite-backed event queue for inter-worker communication.
 *
 * Provides a simple pub/sub mechanism where workers can push events and poll
 * for new events using cursor-based pagination. Each worker maintains its own
 * cursor position, enabling reliable at-least-once delivery.
 *
 * @module event-queue
 */

gordonbrander

export type RouteHandler = (context: URLPatternResult) => void;
export type Cancel = () => void;

type Matcher = (route: string) => URLPatternResult | undefined;

const matcher = (pathname: string, baseUrl?: string): Matcher => {
  const pattern = new URLPattern({ pathname, baseURL: baseUrl });
  return (route: string) => pattern.exec(route) ?? undefined;
};

gordonbrander

import { type Receive, type Send, useMailbox } from "./mailbox.ts";

export type Context<Msg> = {
  self: string;
  send: (id: string, msg: Msg) => Promise<void>;
  receive: Receive<Msg>;
  spawn: (id: string, actor: Actor<Msg>) => string;
};

export type Actor<Msg> = (context: Context<Msg>) => Promise<void>;

gordonbrander

#[macro_export]
macro_rules! pipe {
    // Base case - single function
    ($value:expr, $func:expr) => {
        $func($value)
    };

    // Recursive case - multiple functions
    ($value:expr, $func:expr, $($rest:expr),+) => {
        pipe!($func($value), $($rest),+)

gordonbrander

import { strict as assert } from "assert";
import { createMiddleware, Msg } from "./middleware.js";

describe("createMiddleware", () => {
  it("should create middleware with empty initial state", () => {
    const middleware = createMiddleware();
    assert.deepEqual(middleware("test"), "test");
  });

  it("should execute single middleware", () => {

gordonbrander

let slowAnimations = false;

/** Set slow animations for debugging */
export const setSlowAnimations = (isSlow: boolean) => {
  slowAnimations = isSlow;
};

/** @returns 10s if slow animations is turned on, otherwise returns `ms` */
export const slowable = (ms: number) => (slowAnimations ? 10000 : ms);

gordonbrander

export const multidispatch = <T>() => {
  const routes = new Map<
    (...args: unknown[]) => boolean,
    (...args: unknown[]) => T
  >();

  const call = (...args: unknown[]) => {
    for (const [isMatch, handler] of routes.entries()) {
      if (isMatch(...args)) {
        return handler(...args);

gordonbrander

// Set key on object, but only if value has changed.
// This is useful when setting keys on DOM elements, where setting the same 
// value may trigger a style recalc.
//
// Note that the typical layout-triggering DOM properties are read-only,
// so this is safe to use to write to DOM element properties.
// See https://gist.github.com/paulirish/5d52fb081b3570c81e3a.
export const prop = (object, key, value) => {
  if (object[key] !== value) {
    object[key] = value

gordonbrander

// Set property of element.
// Uses a write-through cache to only set
// when value actually changes.
export const prop = (el, key, value) => {
  let cacheKey = Symbol.from(`prop.${key}`)
  if (el[cacheKey] != value) {
    el[cacheKey] = value
    el[key] = value
  }
}

gordonbrander

export const sleep = ms => new Promise(resolve => {
  setTimeout(resolve, ms)
})

export const hz = x => (1/x * 1000)

const complete = Symbol('complete')

export class Mailbox {
  #buffer = []