asygen 0.0.7 → 0.0.9

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "asygen",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "0-Deps, simple and fast async generator library for browser and NodeJS",
   "type": "module",
   "main": "build/index.cjs",
   "types": "build/index.d.ts",
   "files": [
     "build",
-    "src/index.ts"
+    "src/index.ts",
+    "src/defer.ts",
+    "src/generatorify.ts"
   ],
   "module": "build/index.js",
   "sideEffects": false,

package/src/defer.ts

@@ -0,0 +1,65 @@
+export enum Status {
+  PENDING = 'pending',
+  RESOLVED = 'resolved',
+  REJECTED = 'rejected',
+}
+
+const counter: [number, number] = [0,0];
+export const getId = () => {
+  const result = Date.now() * 100;
+  if (counter[0] !== result) {
+    counter[0] = result;
+    counter[1] = 0;
+  };
+  return (counter[0] + (counter[1]++)).toString(16);
+};
+
+export class Deferred<T = void, E = unknown> {
+  private txts = getId();
+  private _promise: Promise<T>;
+  private _resolve?: (value: T) => void;
+  private _reject?: (error: E) => void;
+  private _status: Status = Status.PENDING;
+
+  constructor() {
+    this._promise = new Promise<T>((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+    this.resolve = this.resolve.bind(this);
+    this.reject = this.reject.bind(this);
+  }
+
+  get [Symbol.toStringTag]() {
+    return `Deferred ${this.txts} ${this._status}`;
+  }
+
+  get promise() {
+    return this._promise;
+  }
+
+  get status() {
+    return this._status;
+  }
+
+  resolve(value: T) {
+    if (this._status === Status.PENDING) {
+      this._status = Status.RESOLVED;
+      this._resolve(value);
+    }
+
+    return this;
+  }
+
+  reject(error: E) {
+    if (this._status === Status.PENDING) {
+      this._status = Status.REJECTED;
+      this._reject(error);
+    }
+    return this;
+  }
+}
+
+export const defer = <T = void, E = unknown>() => {
+  return new Deferred<T, E>();
+}

package/src/generatorify.ts

@@ -0,0 +1,37 @@
+import { defer, Deferred } from './defer';
+
+export interface TaskCallback<T> {
+  (value: T): Promise<T>;
+}
+
+export interface Task<T, R = unknown> {
+  (callback: TaskCallback<T>): R;
+}
+
+export const generatorify = <T, R = unknown>(task: Task<T, R>): AsyncIterable<T> => {
+  const dPoll: Deferred<IteratorResult<T, R>>[] = [defer<IteratorYieldResult<T>>()];
+
+  Promise.resolve(task(value => {
+    const next = defer<IteratorYieldResult<T>>();
+    const prev = dPoll.push(next) - 2;
+    const prevDeferred = dPoll[prev] as Deferred<IteratorYieldResult<T>>;
+    prevDeferred.resolve({ value, done: false });
+    return prevDeferred.promise.then(v => v.value);
+  })).then(async (value) => {
+    dPoll[dPoll.length - 1].resolve({ value, done: true });
+    await Promise.all(dPoll.map(d => d.promise));
+    return { value, done: true };
+  });
+
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          const current = dPoll[0];
+          current.promise.then(() => dPoll.shift());
+          return current.promise;
+        },
+      };
+    }
+  };
+}