posipaki 0.3.2 → 0.3.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "posipaki",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
@@ -10,7 +10,8 @@
   "files": [
     "dist/*js",
     "dist/*map",
-    "dist/*d.ts"
+    "dist/*d.ts",
+    "src/*ts"
   ],
   "devDependencies": {
     "typescript": "^4.4.3"

package/src/index.ts

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

package/src/process.ts

@@ -0,0 +1,144 @@
+import { watchExit, Waiter, defer, makeWaiter } from './util.js';
+
+export type Message = {
+  type: string;
+};
+type ExitMessage = {
+  type: 'EXIT';
+  pid: Symbol;
+};
+
+type ProcessGenerator<ProcessState> =  Generator<ProcessState | null, void, Message>;
+type Fork<ChildArgs, ChildState> = (fn : ProcessFn<ChildArgs, ChildState>, pname : string) => (args: ChildArgs) => Process<ChildArgs, ChildState>;
+
+
+export type ProcessFn<Args, State> = (ctx: ProcessCtx, args: Args) => ProcessGenerator<State>;
+type ProcessMessageCb = (msg: Message | ExitMessage) => void;
+
+export type ProcessCtx = {
+  pname: string,
+  fork: Fork<unknown, unknown>,
+  send: (msg: Message) => void,
+  toParent: ProcessMessageCb,
+};
+
+type NotifyFn = () => void;
+type UnsubscibeFn = () => void;
+
+export function spawn<Args, State>(fn: ProcessFn<Args, State>, pname: string, toParent?: ProcessMessageCb) {
+  return (args: Args): Process<Args, State> => {
+    const process = new Process(fn, pname, toParent);
+    process.start(args);
+    return process;
+  };
+}
+const noop = ()=> null;
+
+class Process<Args, State> {
+  pgenerator: ProcessFn<Args, State>;
+  pname: string;
+  toParent: ProcessMessageCb;
+  id: Symbol;
+  state: State | null;
+
+  private current: ProcessGenerator<State> | null;
+  private buffer: Array<Message>;
+  private children: Array<Process<unknown, unknown>>;
+  private subscribers: Array<NotifyFn>;
+  private exitWaiter: Waiter;
+
+  constructor(fn: ProcessFn<Args, State>, pname: string, toParent: ProcessMessageCb | undefined) {
+    this.pgenerator = fn;
+    this.pname = pname;
+    this.toParent = toParent || noop;
+    this.id = Symbol(pname);
+
+
+    this.current = null;
+    this.state = null;
+    this.buffer = [];
+
+    this.children = [];
+    this.subscribers = [];
+    this.exitWaiter = makeWaiter();
+  }
+
+  start(arg0: Args) {
+    const ctx: ProcessCtx = {
+      pname: this.pname,
+      fork: this.fork.bind(this),
+      send: this.send.bind(this),
+      toParent: this.toParent,
+    };
+    const task = watchExit<Args, State>(this)(ctx, arg0);
+    this.current = task;
+    let ret = task.next();
+    this.state = ret.value || null;
+    this._tick(task.next());
+  }
+
+  fork<ChildArgs, ChildState> (fn : ProcessFn<ChildArgs, ChildState>, pname : string) {
+    return (args: ChildArgs) => {
+      const child =  new Process(fn, pname, this.fromChild.bind(this));
+      this.children.push(child as Process<unknown, unknown>);
+      child.start(args);
+      return child;
+    }
+  }
+
+  _tick (ret: IteratorResult<State | null, void> | null) {
+    if (!this.current) {
+      return;
+    }
+
+    let msg: Message | undefined;
+    while(msg = this.buffer.shift()) {
+      this._tick(this.current.next(msg));
+    }
+    this.notify();
+    if (ret && ret.done) {
+      this.exitWaiter.resolve();
+    }
+  }
+
+  toAllChildren(msg: Message) {
+    this.children.forEach(p => p.send(msg));
+  }
+
+  send(msg: Message) {
+    this.buffer.push(msg);
+    defer(()=> this._tick(null));
+  }
+
+  notify() {
+    this.subscribers.forEach((f) => f());
+  }
+
+  get isListenedTo() {
+    return this.subscribers.length > 0;
+  }
+
+  subscribe(f: NotifyFn) {
+    this.subscribers.push(f);
+    return () => {
+      const idx = this.subscribers.indexOf(f);
+      if (idx < 0) {
+        return;
+      }
+      this.subscribers.splice(idx, 1);
+    }
+  }
+
+  wait() {
+    return this.exitWaiter.promise;
+  }
+
+  fromChild(msg: Message | ExitMessage) {
+    if (msg.type === 'EXIT') {
+      this.children = this.children.filter(p=> p.id !== (msg as ExitMessage).pid);
+    }
+    this.send(msg);
+  }
+}
+
+export default Process;

package/src/util.ts

@@ -0,0 +1,54 @@
+import type Process from './process';
+import type { ProcessCtx, Message } from './process';
+
+function debugLog(level: boolean, ...args: Array<unknown>) {
+  if (level) {
+    console.log(...args);
+  }
+}
+
+type ReducerClosure = (msg: Message) => void;
+type ReadyFn = () => boolean;
+type NotifyFn = () => void;
+
+function* runDispatch(name: string, fn : ReducerClosure, readyFn: ReadyFn = ()=> false, debugLevel = false) : Generator<null, void, Message> {
+  let msg: Message;
+  while(!readyFn()) {
+    msg = yield null;
+    debugLog(debugLevel, 'msg', name, ' <- ', msg);
+    fn(msg);
+  }
+}
+
+function watchExit<Args, State>(process: Process<Args, State>) {
+  return function* (ctx: ProcessCtx, arg0: Args) {
+    yield* process.pgenerator(ctx, arg0);
+    process.toAllChildren({ type: 'STOP' });
+    process.toParent({ type: 'EXIT', pid: process.id});
+  }
+}
+
+type DeferCb = () => void;
+type Defer = (fn: DeferCb) => void;
+type WindowGlobal = {
+  setImmediate?: Defer
+};
+
+function defer(fn: DeferCb) {
+  const g = globalThis as WindowGlobal;
+  const setDefer = (g.setImmediate || requestIdleCallback) as Defer;
+  setDefer(fn);
+}
+export type Waiter = {
+  promise: Promise<void>;
+  resolve: NotifyFn;
+};
+function makeWaiter() : Waiter {
+  let resolve: unknown;
+  let promise = new Promise<void>(_resolve => {
+    resolve = _resolve;
+  });
+  return {promise, resolve: resolve as NotifyFn};
+}
+
+export { runDispatch, watchExit, defer, makeWaiter };

package/src/xfetch.ts

@@ -0,0 +1,83 @@
+import { runDispatch } from './util.js';
+import type { ProcessCtx, Message } from './process';
+
+function isJsonHelper(res : Response) {
+  const ct = res.headers.get('content-type');
+  return ct === 'application/json';
+}
+
+export type FetchState<T> = {
+  code: 'pending' | 'loading' | 'aborted' | 'failed' | 'ok',
+  data: T | null,
+  text: string | null,
+};
+export type FetchArgs = {
+  url: URL,
+};
+type FetchMessage<T> = {
+  type: string,
+  data?: T | null,
+  text?: string | null,
+};
+
+type FetchGenerator<T> = Generator<FetchState<T> | null, void, Message>;
+
+function* xfetch<Type>({ pname, toParent, send } : ProcessCtx, { url } : FetchArgs) : FetchGenerator<Type> {
+  const state: FetchState<Type> = { code: 'pending', data: null, text: null };
+  yield state;
+
+  const controller = new AbortController();
+  const signal = controller.signal;
+
+  const toSelf = (msg: unknown) => send(msg as Message);
+
+  (async function do_request() {
+    try {
+      toSelf({ type: 'LOADING'});
+      const res: Response = await fetch(url.href, { signal });
+      if (isJsonHelper(res)) {
+        const data = await res.json();
+        toSelf({ type: 'OK', data });
+      } else {
+        const text = await res.text();
+        toSelf({ type: 'OK', text });
+      }
+    } catch (e) {
+      const isAborted = (e instanceof DOMException && e.name === 'AbortError');
+      if (isAborted) {
+        toSelf({ type: 'ABORTED', pname });
+      } else {
+        //console.log('e', e);
+        toSelf({ type: 'ERROR', pname });
+      }
+    }
+  })();
+
+  const isDone = ()=> !(state.code === 'pending' || state.code === 'loading')
+
+  yield* runDispatch(pname, (msg : FetchMessage<Type>)=> {
+    if (msg.type === 'STOP') {
+      controller.abort();
+    }
+    if (msg.type === 'ABORTED') {
+      toParent(msg);
+      state.code = 'aborted';
+    }
+    if (msg.type === 'ERROR') {
+      toParent(msg);
+      state.code = 'failed';
+    }
+    if (msg.type === 'LOADING') {
+      state.code = 'loading';
+    }
+
+    if (msg.type === 'OK') {
+      toParent(msg);
+      state.code = 'ok';
+      state.data = msg.data || null;
+      state.text = msg.text || null;
+    }
+  }, isDone, true);
+}
+
+export { xfetch };