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

myobie

import Foundation

class Timer {
    private let source: DispatchSourceTimer
    private let block: () -> ()
    
    public let isRepeating: Bool
    
    init(_ interval: DispatchTimeInterval, repeat shouldRepeat: Bool = false, block: @escaping () -> ()) {
        self.source = DispatchSource.makeTimerSource()

myobie

import Cocoa
import Combine

class Timer: Cancellable, Publisher {
    enum Error: Swift.Error {
        case cancelled
    }
    
    typealias Output = Never
    typealias Failure = Error