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 = []

gordonbrander

// CDOM - Cached DOM
// CDOM minimizes DOM writes by caching last written value and only touching the
// DOM when a new value does not equal the cached value.
// The goal of CDOM is to make it safe to "bash the DOM" as often as you like
// without affecting performance, even bashing it every frame.

// Create a cached setter
export const CachedSetter = (ns, set) => (el, value) => {
  let cacheKey = Symbol.for(`CachedSetter::${ns}`)
  if (el[cacheKey] !== value) {

gordonbrander

import {StoreElement, change} from './modest.js'

class ModestApp extends StoreElement {
  static template() {
    return `
    <style>
    :host {
      display: block;
    }
    .time {