myobie

export function nextTick<O> (cb: () => O | Promise<O>): Promise<O> {
  return new Promise((resolve, reject) => {
    requestAnimationFrame(() => {
      Promise.resolve(cb())
        .then(value => resolve(value))
        .catch(e => reject(e))
    })
  })
}

myobie

def generate_id do
  result =
    Ecto.UUID.generate()
    |> String.replace(~r/-+/, "")
    |> Base.decode16(case: :lower)

  case result do
    :error ->
      throw("Something went wrong generating a uuid")

myobie

defmodule Example.RandomTest do
  use ExUnit.Case

  test "loads wasm file" do
    {:ok, bytes} = File.read("priv/vendor/needs-random.wasm")

    {:ok, agent} = Agent.start_link(fn -> nil end)

    {:ok, instance} =
      Wasmex.start_link(%{

myobie

const handler = require('serve-handler')
const { createServer } = require('http')
const launcher = require('chrome-launcher')
const remoteInterface = require('chrome-remote-interface')

let exitStatus = 0

const baseURL = 'http://localhost:6000'

const server = createServer((request, response) => {

myobie

// Fake immer

/** @template T */
export class State {
  /** @typedef {function(T):void} Callback */
  /** @typedef {function(): T} InitialValueFactory */

  /**
   * @param {T | InitialValueFactory} initialValue
   */

myobie

import { html, css, globalCSS } from './html.js'
import { State } from './state.js'

const isDraggingOver = new State(false)
let runOnce = false

isDraggingOver.onUpdate(newState => {
  const root = document.documentElement
  const dropzoneDisplay = newState ? 'block' : 'none'
  root.style.setProperty('--dropzone-display', dropzoneDisplay)

myobie

/** @template T */
class State {
  /** @typedef {function(T):void} Callback */

  /**
   * @param {T} initialValue
   */
  constructor (initialValue) {
    this.value = initialValue

myobie

import { createStorage } from './bassics/storage'
import { html, until, render } from './bassics/html'

const storage = createStorage()

const likes = storage.state('likes', fetchLikes())

function reloadLikes () {
  return likes.update(fetchLikes())
}

myobie

/**
 * @template T
 * @param {AsyncGenerator<T, void, void>} gen
 * @returns {AsyncGenerator<[T, number], void, void>}
 */
export async function * genIndexes (gen) {
  let i = 0
  for await (const item of gen) {
    yield [item, i]
    i++

myobie

• Why?
  • Use existing code and libraries, especially for encryption or hashing
  • Sharing code for algorithms or compute intensive operations
  • Don’t intend expose much (anything?) to the wasm instance
  • There some gotchas like 64bit integers
• Browser only, no toolchain
  • I have toolchain fatigue and it turns out the latest browsers are kinda great
  • import and export, async and await, wasm, etc all work
  • I like to use a tiny file server to serve a directory on a port on localhost
• serve