Add Deno support

src/asynciter.ts

@@ -0,0 +1,71 @@
+import Observable from "./observable.js";
+import Signal from "./signal.js";
+
+interface IAsyncIteratorMessage<T> {
+   error: Error | undefined;
+   data: T | undefined;
+   close: true | undefined;
+}
+export default class AsyncIteratorFromCB<T> implements AsyncIterable<T> {
+   private onData = new Observable<IAsyncIteratorMessage<T>>();
+   constructor() {}
+
+   public getCallback() {
+      return (error: Error | undefined, data: T | undefined) => {
+         this.onData.send({ error, data, close: undefined });
+      };
+   }
+
+   public send(data: T) {
+      this.onData.send({
+         error: undefined,
+         data,
+         close: undefined,
+      });
+   }
+
+   public close() {
+      this.onData.send({
+         close: true,
+         data: undefined,
+         error: undefined,
+      });
+      this.onData.close();
+   }
+
+   [Symbol.asyncIterator]() {
+      const queue: IAsyncIteratorMessage<T>[] = [];
+      const signal = new Signal();
+      this.onData.subscribe((data) => {
+         queue.push(data);
+         signal.sendSignal();
+      });
+      return {
+         async next() {
+            const send = () => {
+               const value = queue.shift();
+               if (!value) throw new Error("Error in AsyncIter");
+               if (value.close) {
+                  return {
+                     done: true,
+                     value: undefined as any,
+                  };
+               } else if (value.error) {
+                  throw value.error;
+               } else {
+                  return {
+                     done: false,
+                     value: value.data as T,
+                  };
+               }
+            };
+            if (queue.length > 0) {
+               return send();
+            } else {
+               await signal.awaitSignal();
+               return send();
+            }
+         },
+      };
+   }
+}

src/index.ts

@@ -6,12 +6,11 @@ import Observable, {
 } from "./observable.js";
 import AwaitStore from "./awaiter.js";
 
-export {
-   Lock,
+export type {
    Release,
-   Observable,
    ObserverCallback,
    ObserverCallbackCollect,
    ObservableInterface,
-   AwaitStore,
 };
+
+export { Lock, Observable, AwaitStore };

src/signal.ts

@@ -0,0 +1,12 @@
+export default class Signal {
+   awaiter: (() => void)[] = [];
+   sendSignal(): void {
+      this.awaiter.forEach((a) => a());
+      this.awaiter = [];
+   }
+   awaitSignal(): Promise<void> {
+      return new Promise((resolve) => {
+         this.awaiter.push(resolve);
+      });
+   }
+}