async generators

Author: mbostock

src/client/stdlib/generators/input.js

@@ -1,40 +1,36 @@
 import {observe} from "./observe.js";
 
-export function input(input) {
-  return observe(function (change) {
-    var event = eventof(input),
-      value = valueof(input);
-    function inputted() {
-      change(valueof(input));
-    }
-    input.addEventListener(event, inputted);
+export function input(element) {
+  return observe((change) => {
+    const event = eventof(element);
+    let value = valueof(element);
+    const inputted = () => change(valueof(element));
+    element.addEventListener(event, inputted);
     if (value !== undefined) change(value);
-    return function () {
-      input.removeEventListener(event, inputted);
-    };
+    return () => element.removeEventListener(event, inputted);
   });
 }
 
-function valueof(input) {
-  switch (input.type) {
+function valueof(element) {
+  switch (element.type) {
     case "range":
     case "number":
-      return input.valueAsNumber;
+      return element.valueAsNumber;
     case "date":
-      return input.valueAsDate;
+      return element.valueAsDate;
     case "checkbox":
-      return input.checked;
+      return element.checked;
     case "file":
-      return input.multiple ? input.files : input.files[0];
+      return element.multiple ? element.files : element.files[0];
     case "select-multiple":
-      return Array.from(input.selectedOptions, (o) => o.value);
+      return Array.from(element.selectedOptions, (o) => o.value);
     default:
-      return input.value;
+      return element.value;
   }
 }
 
-function eventof(input) {
-  switch (input.type) {
+function eventof(element) {
+  switch (element.type) {
     case "button":
     case "submit":
     case "checkbox":

src/client/stdlib/generators/observe.js

@@ -1,10 +1,14 @@
-import {that} from "./that.js";
-
-export function observe(initialize) {
-  let stale = false;
-  let value;
+export async function* observe(initialize) {
   let resolve;
-  const dispose = initialize(change);
+  let value;
+  let stale = false;
+
+  const dispose = initialize((x) => {
+    value = x;
+    if (resolve) resolve(x), (resolve = null);
+    else stale = true;
+    return x;
+  });
 
   if (dispose != null && typeof dispose !== "function") {
     throw new Error(
@@ -14,20 +18,13 @@ export function observe(initialize) {
     );
   }
 
-  function change(x) {
-    if (resolve) resolve(x), (resolve = null);
-    else stale = true;
-    return (value = x);
-  }
-
-  function next() {
-    return {done: false, value: stale ? ((stale = false), Promise.resolve(value)) : new Promise((_) => (resolve = _))};
+  try {
+    while (true) {
+      yield stale ? ((stale = false), value) : new Promise((_) => (resolve = _));
+    }
+  } finally {
+    if (dispose != null) {
+      dispose();
+    }
   }
-
-  return {
-    [Symbol.iterator]: that,
-    throw: () => ({done: true}),
-    return: () => (dispose != null && dispose(), {done: true}),
-    next
-  };
 }

src/client/stdlib/generators/queue.js

@@ -1,9 +1,12 @@
-import {that} from "./that.js";
-
-export function queue(initialize) {
+export async function* queue(initialize) {
   let resolve;
-  const queue = [];
-  const dispose = initialize(push);
+  const values = [];
+
+  const dispose = initialize((x) => {
+    values.push(x);
+    if (resolve) resolve(values.shift()), (resolve = null);
+    return x;
+  });
 
   if (dispose != null && typeof dispose !== "function") {
     throw new Error(
@@ -13,20 +16,13 @@ export function queue(initialize) {
     );
   }
 
-  function push(x) {
-    queue.push(x);
-    if (resolve) resolve(queue.shift()), (resolve = null);
-    return x;
+  try {
+    while (true) {
+      yield values.length ? values.shift() : new Promise((_) => (resolve = _));
+    }
+  } finally {
+    if (dispose != null) {
+      dispose();
+    }
   }
-
-  function next() {
-    return {done: false, value: queue.length ? Promise.resolve(queue.shift()) : new Promise((_) => (resolve = _))};
-  }
-
-  return {
-    [Symbol.iterator]: that,
-    throw: () => ({done: true}),
-    return: () => (dispose != null && dispose(), {done: true}),
-    next
-  };
 }