posipaki 0.5.4 → 0.6.0

package/dist/util.d.ts

@@ -1,5 +1,5 @@
-import type Process from './process';
-import type { ProcessCtx, Message } from './process';
+import type Process from './process.js';
+import type { ProcessCtx, Message } from './process.js';
 type ReducerClosure<M> = (msg: M) => void;
 type ReadyFn = () => boolean;
 type NotifyFn = () => void;

package/dist/xfetch.d.ts

@@ -1,6 +1,6 @@
 import { ExitMessage } from './util.js';
-import type Process from './process';
-import type { ProcessCtx } from './process';
+import type Process from './process.js';
+import type { ProcessCtx } from './process.js';
 export type FetchState<T> = {
     code: 'pending' | 'loading' | 'aborted' | 'failed' | 'ok';
     data: T | null;

package/package.json

@@ -1,11 +1,12 @@
 {
   "type": "module",
   "name": "posipaki",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "jest"
   },
   "files": [
     "dist/*js",
@@ -14,6 +15,11 @@
     "src/*ts"
   ],
   "devDependencies": {
-    "typescript": "^4.4.3"
+    "@babel/parser": "^7.22.5",
+    "@babel/types": "^7.22.5",
+    "@types/jest": "^29.5.2",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.1.3"
   }
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-import Process, { spawn, Message, ProcessCtx, ProcessFn } from './process.js';
-import { ExitMessage, runDispatch } from './util.js';
+import Process, { spawn, Message, ProcessCtx, ProcessFn } from './process';
+import { ExitMessage, runDispatch } from './util';
 
 export { Process, spawn, runDispatch, Message, ExitMessage, ProcessCtx, ProcessFn }

package/src/process.ts

@@ -1,4 +1,4 @@
-import { ExitMessage, watchExit, Waiter, defer, makeWaiter } from './util.js';
+import { ExitMessage, watchExit, Waiter, defer, DeferredCall, makeWaiter } from './util';
 
 export interface Message {
   type: string;
@@ -39,9 +39,11 @@ class Process<Args, State, InMessage extends Message, OutMessage extends Message
 
   private current: ProcessGenerator<State, InMessage> | null;
   private buffer: Array<InMessage>;
+  private nextTick: DeferredCall | null;
   private children: Array<Process<unknown, unknown, Message, Message>>;
   private subscribers: Array<NotifyFn>;
   private exitWaiter: Waiter;
+  private _isPaused: boolean = false;
 
   constructor(fn: ProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent: ProcessMessageCb<OutMessage> | undefined) {
     this.pgenerator = fn;
@@ -53,6 +55,7 @@ class Process<Args, State, InMessage extends Message, OutMessage extends Message
     this.current = null;
     this.state = null;
     this.buffer = [];
+    this.nextTick = null;
 
     this.children = [];
     this.subscribers = [];
@@ -70,7 +73,7 @@ class Process<Args, State, InMessage extends Message, OutMessage extends Message
     this.current = task;
     let ret = task.next();
     this.state = ret.value || null;
-    this._tick(task.next());
+    this._eatResult(task.next());
   }
 
   fork<ChildArgs, ChildState, ChildIM extends Message, ChildOM extends Message> (fn : ProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>, pname : string) {
@@ -85,16 +88,23 @@ class Process<Args, State, InMessage extends Message, OutMessage extends Message
     }
   }
 
-  _tick (ret: IteratorResult<State | null, void> | null) {
+  _tick () {
     if (!this.current) {
       return;
     }
-
     let msg: InMessage | undefined;
+    let ret: IteratorResult<State | null, void> | null = null;
     while(msg = this.buffer.shift()) {
-      this._tick(this.current.next(msg));
+      ret = this.current.next(msg);
+      if (ret.done) {
+        break;
+      }
     }
     this.notify();
+    this._eatResult(ret);
+  }
+
+  _eatResult(ret: IteratorResult<State | null, void> | null) {
     if (ret && ret.done) {
       this.exitWaiter.resolve();
     }
@@ -106,7 +116,24 @@ class Process<Args, State, InMessage extends Message, OutMessage extends Message
 
   send(msg: InMessage) {
     this.buffer.push(msg);
-    defer(()=> this._tick(null));
+    this._scheduleTick();
+  }
+
+  tick() {
+    this.nextTick?.flush();
+    this.nextTick = null;
+  }
+  
+  _scheduleTick() {
+    if (this._isPaused) {
+      return;
+    }
+
+    this.nextTick?.cancel();
+    this.nextTick = defer(()=>  {
+      this.nextTick = null;
+      this._tick()
+    });
   }
 
   notify() {
@@ -128,6 +155,17 @@ class Process<Args, State, InMessage extends Message, OutMessage extends Message
     }
   }
 
+  pause() {
+    this.nextTick?.cancel();
+    this.nextTick = null;
+    this._isPaused = true;
+  }
+
+  resume() {
+    this._isPaused = false;
+    this._scheduleTick();
+  }
+
   wait() {
     return this.exitWaiter.promise;
   }

package/src/util.ts

@@ -1,5 +1,5 @@
-import type Process from './process';
-import type { ProcessCtx, Message } from './process';
+import type Process from './process.js';
+import type { ProcessCtx, Message } from './process.js';
 
 function debugLog(level: boolean, ...args: Array<unknown>) {
   if (level) {
@@ -34,15 +34,42 @@ function watchExit<Args, State, InMessage extends Message, OutMessage extends (M
 }
 
 type DeferCb = () => void;
-type Defer = (fn: DeferCb) => void;
+type Defer = (fn: DeferCb) => unknown;
+type Cancel = (taskId: any)=> void;
 type WindowGlobal = {
-  setImmediate?: Defer
+  setImmediate?: Defer,
+  clearImmediate?: Cancel,
+  requestIdleCallback?: Defer,
+  cancelIdleCallback?: Cancel,
+  setTimeout: Defer,
+  clearTimeout: Cancel,
 };
 
-function defer(fn: DeferCb) {
+export type DeferredCall = {
+  cancel: ()=> void,
+  flush: () => void,
+};
+function defer(fn: DeferCb) : DeferredCall {
   const g = globalThis as WindowGlobal;
-  const setDefer = (g.setImmediate || requestIdleCallback) as Defer;
-  setDefer(fn);
+  function schedule(deferFn: Defer, cancelFn: Cancel) {
+    const taskId = deferFn(fn);
+    return ()=> cancelFn(taskId);
+  }
+  let cancel : ()=> void;
+  if (g.setImmediate && g.clearImmediate) {
+    cancel = schedule(g.setImmediate, g.clearImmediate);
+  } else if (g.requestIdleCallback && g.cancelIdleCallback) {
+    cancel = schedule(g.requestIdleCallback, g.cancelIdleCallback);
+  } else {
+    cancel = schedule((f) => setTimeout(f, 0), clearTimeout);
+  }
+
+  function flush() {
+    cancel();
+    fn();
+  }
+
+  return { flush, cancel };
 }
 export type Waiter = {
   promise: Promise<void>;

package/src/xfetch.ts

@@ -1,6 +1,6 @@
 import { ExitMessage, runDispatch } from './util.js';
-import type Process from './process';
-import type { ProcessCtx, Message } from './process';
+import type Process from './process.js';
+import type { ProcessCtx, Message } from './process.js';
 
 function isJsonHelper(res : Response) {
   const ct = res.headers.get('content-type');