whenmap 0.1.1 → 0.2.1

package/README.md

@@ -7,17 +7,17 @@ initalizes the value.
 
  [CER]: https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/whenDefined
 
-## Use
+## WhenMap API
 
 ```javascript
 import { WhenMap } from 'whenmap'
 
-let whenmap = new WhenMap()
+let when_db = new WhenMap()
 
-let p_ready = whenmap.when('example_key')
+let p_ready = when_db.when('example_key')
 p_ready.then(v => console.log('Ready!', {v}))
 
-whenmap.set('example_key', example_init())
+when_db.set('example_key', example_init())
 
 async function example_init() {
   // async initialize process
@@ -25,24 +25,91 @@ async function example_init() {
 }
 ```
 
-## WhenMap API
-- `whenmap.when(key)` returns a promise for the key. The promise
-  may or may not be resolved.
+- `when_db.when(key)` returns a promise for the newly tracked key.
+  The promise may or may not be resolved.
 
-- `whenmap.get(key)` is an alias for `whenmap.when(key)`
+- `when_db.ref(key, p)` is a observation hook for newly tracked keys.
 
-- `whenmap.set(key, value)` resolves the promise for the specified key, returning `this`.
+- `when_db.get(key)` is an alias for `when_db.when(key)`
 
-- `whenmap.has(key)` returns
+- `when_db.set(key, value)` resolves the promise for the specified key, returning `this`.
+
+- `when_db.has(key)` returns
     `false` for untracked keys,
     `true` for resolved tracked keys, and
     `1` for unresolved tracked keys.
 
-- `whenmap.delete(key)` resolves a tracked key as `undefined` before removing it.
+- `when_db.delete(key)` resolves a tracked key as `undefined` before removing it.
 
-- `whenmap.clear()` resolves any outstanding tracked keys as `undefined` before
+- `when_db.clear()` resolves any outstanding tracked keys as `undefined` before
   clearing all tracked keys.
 
+
+## aiter_pipe API
+
+`aiter_pipe(opt)` returns a connected `[send, recv]` pair where `send` is a
+function and `recv` is an async iterable.
+
+- `send(value)` adds value to the internal queue, after awaiting it if a promisable.
+    - `opt.on_error(err)` is an optional promise `.catch()` handler.
+- `send.stop()` terminates the async iterable stream from within the `init_arg` closure.
+- `send.ready` is a promise to provide overflow backpressure.
+    - `opt.max_size` manages the `send.ready` promise, default of 5
+
+- `recv` extends the optional prototype
+- `recv.size` returns the interal queue size
+- `recv` supports async iterable protocol: `for await (let each of when_stream) {}`
+    - `recv.next()` returns the next resolved value
+        - if `opt.batch`, returns list of all resolved values
+    - `recv.return()`
+    - `recv.throw()`
+    - `recv[Symbol.asyncIterator]()`
+
+- an AbortSignal instance is aborted when the stream is stopped.
+    - assigned into `recv.signal` and `send.signal`
+
+## WhenAiter API
+
+`WhenAiter` is a Promise-like wrapper around `aiter_pipe` to transform callback
+events into async iteratable.
+
+```javascript
+import { WhenAiter } from 'whenmap'
+
+// For streaming events
+let when_stream = new WhenAiter(send => {
+  document.body.addEventListener(
+    'some_custom_event',
+    evt => send(evt.detail),
+    {signal: send.signal})
+})
+
+for await (let detail of when_stream) {
+  console.log('use aiter event stream:', detail)
+}
+```
+
+`WhenAiter` can also transform a collection promises into an async iteratable.
+
+```javascript
+import { WhenAiter } from 'whenmap'
+const sleep = new Promise(done => setTimeout(done, ms, `delay: ${ms}`) )
+// For streaming promises as they are settled
+let misc_promises = [ sleep(100), sleep(20), sleep(50) ]
+
+for await (let each of WhenAiter.from(misc_promises)) {
+  console.log('stream resolved:', detail)
+}
+```
+
+- `new WhenAiter(init_arg, opt)` returns an async iterable.
+    - If `init_arg` is iterable, `send()` is called on each item.
+    - other `init_arg(send)` is invoked.
+
+- `WhenAiter.from(init_arg, opt)` is an alias for `new WhenAiter`
+
+
+
 ## Install
 
 ```bash

package/esm/index.js

@@ -0,0 +1,3 @@
+export { WhenMap } from './whenmap.js';
+export { WhenAiter, aiter_pipe } from './whenaiter.js';
+//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/esm/index.min.js

@@ -0,0 +1 @@
+export{WhenMap}from"./whenmap.min.js";export{WhenAiter,aiter_pipe}from"./whenaiter.min.js";

package/esm/whenaiter.js

@@ -0,0 +1,72 @@
+class WhenAiter {
+  static from(init_arg, opt) {
+    return new this(init_arg, opt)}
+
+  constructor(init_arg, opt) {
+    let [send, recv_aiter] = aiter_pipe.call(this, opt);
+
+    if(init_arg)
+      init_arg?.call ? init_arg(send)
+        : Array.from(init_arg, send)
+            .reduce((a,b) => a.then(b), send.ready)
+            .then(_ => send.stop());
+
+    return recv_aiter} }
+
+
+function aiter_pipe(opt) {
+  const q=[], max_size = opt?.max_size ?? 5;
+  const pop_result = opt?.batch ? q => q.splice(0) : q => q.shift();
+  let abrt = new AbortController();
+  let p_underflow, p_overflow;
+
+  // Sender function closure
+  function send(v) {
+    if (v?.then) {
+      return v.then(send, opt?.on_error)}
+
+    q.push(v);
+    p_underflow = void p_underflow?.resolve();
+
+    // update overflow promise state
+    if (q.length >= max_size) {
+      send.ready = (p_overflow ??= Promise.withResolvers()).promise;} }
+
+  send.signal = abrt.signal;
+  send.ready = Promise.resolve();
+  send.stop = async () => {
+    abrt = void abrt?.abort();
+    p_underflow = void p_underflow?.resolve();
+    return { done: true }};
+
+  // Async Iterable Receiver
+  let recv_aiter ={
+    __proto__: this
+  , get size() {return q.length}
+  , signal: abrt.signal
+
+  , [Symbol.asyncIterator]() {return this}
+  , return: send.stop
+  , throw: send.stop
+  , async next() {
+      while (1) {
+        let r, len=q.length;
+        if (len) {// results are available
+          r = pop_result(q);
+
+          if (len <= max_size) {
+            // update overflow promise state
+            p_overflow = void p_overflow?.resolve();}
+          return { value: r, done: false }}
+
+        if (undefined === abrt) {// async iterable is done
+          return { done: true }}
+
+        // set underflow promise state
+        await (p_underflow ??= Promise.withResolvers()).promise;
+        } } };// after underflow resolved, loop to try again
+
+  return [send, recv_aiter]}
+
+export { WhenAiter, aiter_pipe };
+//# sourceMappingURL=whenaiter.js.map

package/esm/whenaiter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whenaiter.js","sources":["../code/whenaiter.jsy"],"sourcesContent":["\nexport class WhenAiter ::\n  static from(init_arg, opt) ::\n    return new this(init_arg, opt)\n\n  constructor(init_arg, opt) ::\n    let [send, recv_aiter] = aiter_pipe.call(this, opt)\n\n    if(init_arg)\n      init_arg?.call ? init_arg(send)\n        : Array.from(init_arg, send)\n            .reduce((a,b) => a.then(b), send.ready)\n            .then(_ => send.stop())\n\n    return recv_aiter\n\n\nexport function aiter_pipe(opt) ::\n  const q=[], max_size = opt?.max_size ?? 5\n  const pop_result = opt?.batch ? q => q.splice(0) : q => q.shift()\n  let abrt = new AbortController()\n  let p_underflow, p_overflow\n\n  // Sender function closure\n  function send(v) ::\n    if v?.then ::\n      return v.then(send, opt?.on_error)\n\n    q.push(v)\n    p_underflow = void p_underflow?.resolve()\n\n    // update overflow promise state\n    if q.length >= max_size ::\n      send.ready = (p_overflow ??= Promise.withResolvers()).promise\n\n  send.signal = abrt.signal\n  send.ready = Promise.resolve()\n  send.stop = async () => ::\n    abrt = void abrt?.abort()\n    p_underflow = void p_underflow?.resolve()\n    return { done: true }\n\n  // Async Iterable Receiver\n  let recv_aiter = @{}\n    __proto__: this\n    get size() :: return q.length\n    signal: abrt.signal\n\n    [Symbol.asyncIterator]() :: return this\n    return: send.stop\n    throw: send.stop\n    async next() ::\n      while 1 ::\n        let r, len=q.length\n        if len :: // results are available\n          r = pop_result(q)\n\n          if len <= max_size ::\n            // update overflow promise state\n            p_overflow = void p_overflow?.resolve()\n          return { value: r, done: false }\n\n        if undefined === abrt :: // async iterable is done\n          return { done: true }\n\n        // set underflow promise state\n        await (p_underflow ??= Promise.withResolvers()).promise\n        // after underflow resolved, loop to try again\n\n  return [send, recv_aiter]\n"],"names":[],"mappings":"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"}

package/esm/whenaiter.min.js

@@ -0,0 +1 @@
+class e{static from(e,r){return new this(e,r)}constructor(e,t){let[o,s]=r.call(this,t);return e&&(e?.call?e(o):Array.from(e,o).reduce(((e,r)=>e.then(r)),o.ready).then((e=>o.stop()))),s}}function r(e){const r=[],t=e?.max_size??5,o=e?.batch?e=>e.splice(0):e=>e.shift();let s,n,i=new AbortController;function l(o){if(o?.then)return o.then(l,e?.on_error);r.push(o),s=void s?.resolve(),r.length>=t&&(l.ready=(n??=Promise.withResolvers()).promise)}return l.signal=i.signal,l.ready=Promise.resolve(),l.stop=async()=>(i=void i?.abort(),s=void s?.resolve(),{done:!0}),[l,{__proto__:this,get size(){return r.length},signal:i.signal,[Symbol.asyncIterator](){return this},return:l.stop,throw:l.stop,async next(){for(;;){let e,l=r.length;if(l)return e=o(r),l<=t&&(n=void n?.resolve()),{value:e,done:!1};if(void 0===i)return{done:!0};await(s??=Promise.withResolvers()).promise}}}]}export{e as WhenAiter,r as aiter_pipe};

package/esm/whenmap.js

@@ -1,9 +1,14 @@
-const _when_fns = new WeakMap();
-const _as_when_tuples = ([k,v]) => [k, Promise.resolve(v)];
+const _when_fns = /* #__PURE__ */ new WeakMap();
+function _when_resolve(p, val) {
+  let fn = _when_fns.get(p);
+  _when_fns.delete(p);
+  fn?.(val);}
 
 class WhenMap extends Map {
   constructor(entries) {
-    super(entries &&= Array.from(entries, _as_when_tuples)); }
+    super();
+    for (let [k,v] of entries||[])
+      this.set(k,v);}
 
   has(key) {
     let p = super.get(key);
@@ -16,30 +21,25 @@ class WhenMap extends Map {
       p = new Promise(fn => f=fn);
       _when_fns.set(p, f);
       super.set(key, p);
-      this.on_ref?.(key, p);}
+      this.ref?.(key, p);}
     return p}
 
+  // ref(key, p) ::
+
   set(key, val) {
-    // resolve promise
-    _pop_when(this.when(key))?.(val);
+    _when_resolve(this.when(key),val);
     return this}
 
   delete(key) {
     // resolve outstanding promise, if exists
-    _pop_when(super.get(key))?.();
+    _when_resolve(super.get(key));
     return super.delete(key)}
 
   clear() {
     // resolve all outstanding promises
     for (let p of this.values()) {
-      _pop_when(p)?.();}
+      _when_resolve(p);}
     super.clear();} }
 
-
-function _pop_when(p) {
-  let f = _when_fns.get(p);
-  _when_fns.delete(p);
-  return f}
-
 export { WhenMap, WhenMap as default };
 //# sourceMappingURL=whenmap.js.map

package/esm/whenmap.js.map

@@ -1 +1 @@
-{"version":3,"file":"whenmap.js","sources":["../code/whenmap.jsy"],"sourcesContent":["const _when_fns = new WeakMap()\nconst _as_when_tuples = ([k,v]) => [k, Promise.resolve(v)]\n\nexport class WhenMap extends Map ::\n  constructor(entries) ::\n    super @ entries &&= Array.from(entries, _as_when_tuples)\n\n  has(key) ::\n    let p = super.get(key)\n    return p ? _when_fns.has(p) ? 1 : true : false\n\n  get get() :: return this.when\n  when(key) ::\n    let p = super.get(key), f\n    if ! p ::\n      p = new Promise(fn => f=fn)\n      _when_fns.set(p, f)\n      super.set(key, p)\n      this.on_ref?.(key, p)\n    return p\n\n  set(key, val) ::\n    // resolve promise\n    _pop_when(this.when(key))?.(val)\n    return this\n\n  delete(key) ::\n    // resolve outstanding promise, if exists\n    _pop_when(super.get(key))?.()\n    return super.delete(key)\n\n  clear() ::\n    // resolve all outstanding promises\n    for let p of this.values() ::\n      _pop_when(p)?.()\n    super.clear()\n\nexport default WhenMap\n\n\nfunction _pop_when(p) ::\n  let f = _when_fns.get(p)\n  _when_fns.delete(p)\n  return f\n\n"],"names":[],"mappings":"AAAA,MAAA,SAAA,GAAA,IAAA,OAAA;AACA,MAAA,eAAA,GAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,KAAA,CAAA,CAAA,EAAA,OAAA,CAAA,OAAA,CAAA,CAAA,CAAA;;AAEA,MAAA,OAAA,SAAA,GAAA,CAAA;AACE,EAAA,WAAA,CAAA,OAAA,EAAA;IACE,KAAO,CAAA,OAAA,KAAA,KAAA,CAAA,IAAA,CAAA,OAAA,EAAA,eAAA,CAAA,EAAA;;AAET,EAAA,GAAA,CAAA,GAAA,EAAA;AACE,IAAA,IAAA,CAAA,GAAA,KAAA,CAAA,GAAA,CAAA,GAAA;AACA,IAAA,OAAA,CAAA,GAAA,SAAA,CAAA,GAAA,CAAA,CAAA,CAAA,GAAA,CAAA,GAAA,IAAA,GAAA,KAAA;;EAEF,IAAY,GAAA,GAAA,CAAA,OAAA,IAAA,CAAA,IAAA;AACZ,EAAA,IAAA,CAAA,GAAA,EAAA;AACE,IAAA,IAAA,CAAA,GAAA,KAAA,CAAA,GAAA,CAAA,GAAA,CAAA,EAAA;AACG,IAAA,IAAA,EAAA,CAAA,EAAA;AACD,MAAA,CAAA,GAAA,IAAA,OAAA,CAAA,EAAA,IAAA,CAAA,CAAA,EAAA;AACA,MAAA,SAAA,CAAA,GAAA,CAAA,CAAA,EAAA,CAAA;AACA,MAAA,KAAA,CAAA,GAAA,CAAA,GAAA,EAAA,CAAA;AACA,MAAA,IAAA,CAAA,MAAA,GAAA,GAAA,EAAA,CAAA,EAAA;AACF,IAAA,OAAA,CAAA;;AAEF,EAAA,GAAA,CAAA,GAAA,EAAA,GAAA,EAAA;;AAEE,IAAA,SAAA,CAAA,IAAA,CAAA,IAAA,CAAA,GAAA,CAAA,CAAA,GAAA,GAAA;AACA,IAAA,OAAA,IAAA;;AAEF,EAAA,MAAA,CAAA,GAAA,EAAA;;AAEE,IAAA,SAAA,CAAA,KAAA,CAAA,GAAA,CAAA,GAAA,CAAA,CAAA;AACA,IAAA,OAAA,KAAA,CAAA,MAAA,CAAA,GAAA,CAAA;;AAEF,EAAA,KAAA,GAAA;;AAEK,IAAA,KAAA,IAAA,CAAA,IAAA,IAAA,CAAA,MAAA,EAAA,EAAA;AACD,MAAA,SAAA,CAAA,CAAA,CAAA,KAAA;AACF,IAAA,KAAA,CAAA,KAAA,GAAA,CAAA;;;AAKJ,SAAA,SAAA,CAAA,CAAA,EAAA;AACE,EAAA,IAAA,CAAA,GAAA,SAAA,CAAA,GAAA,CAAA,CAAA;AACA,EAAA,SAAA,CAAA,MAAA,CAAA,CAAA;AACA,EAAA,OAAA,CAAA;;;;"}
+{"version":3,"file":"whenmap.js","sources":["../code/whenmap.jsy"],"sourcesContent":["const _when_fns = /* #__PURE__ */ new WeakMap()\nfunction _when_resolve(p, val) ::\n  let fn = _when_fns.get(p)\n  _when_fns.delete(p)\n  fn?.(val)\n\nexport class WhenMap extends Map ::\n  constructor(entries) ::\n    super()\n    for (let [k,v] of entries||[])\n      this.set(k,v)\n\n  has(key) ::\n    let p = super.get(key)\n    return p ? _when_fns.has(p) ? 1 : true : false\n\n  get get() :: return this.when\n  when(key) ::\n    let p = super.get(key), f\n    if ! p ::\n      p = new Promise(fn => f=fn)\n      _when_fns.set(p, f)\n      super.set(key, p)\n      this.ref?.(key, p)\n    return p\n\n  // ref(key, p) ::\n\n  set(key, val) ::\n    _when_resolve(this.when(key),val)\n    return this\n\n  delete(key) ::\n    // resolve outstanding promise, if exists\n    _when_resolve(super.get(key))\n    return super.delete(key)\n\n  clear() ::\n    // resolve all outstanding promises\n    for let p of this.values() ::\n      _when_resolve(p)\n    super.clear()\n\nexport default WhenMap\n\n"],"names":[],"mappings":"AAAA,MAAA,SAAA,mBAAiC,IAAA,OAAA;AACjC,SAAA,aAAA,CAAA,CAAA,EAAA,GAAA,EAAA;AACE,EAAA,IAAA,EAAA,GAAA,SAAA,CAAA,GAAA,CAAA,CAAA;AACA,EAAA,SAAA,CAAA,MAAA,CAAA,CAAA;AACA,EAAA,EAAA,GAAA,GAAA,EAAA;;AAEF,MAAA,OAAA,SAAA,GAAA,CAAA;AACE,EAAA,WAAA,CAAA,OAAA,EAAA;AACE,IAAA,KAAA;AACA,IAAA,KAAA,IAAA,CAAA,CAAA,CAAA,CAAA,CAAA,IAAA,OAAA,EAAA,EAAA;AACE,MAAA,IAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA,EAAA;;AAEJ,EAAA,GAAA,CAAA,GAAA,EAAA;AACE,IAAA,IAAA,CAAA,GAAA,KAAA,CAAA,GAAA,CAAA,GAAA;AACA,IAAA,OAAA,CAAA,GAAA,SAAA,CAAA,GAAA,CAAA,CAAA,CAAA,GAAA,CAAA,GAAA,IAAA,GAAA,KAAA;;EAEF,IAAA,GAAA,GAAA,CAAY,OAAA,IAAA,CAAA,IAAA;AACZ,EAAA,IAAA,CAAA,GAAA,EAAA;AACE,IAAA,IAAA,CAAA,GAAA,KAAA,CAAA,GAAA,CAAA,GAAA,CAAA,EAAA;AACG,IAAA,IAAA,EAAA,CAAA,EAAA;AACD,MAAA,CAAA,GAAA,IAAA,OAAA,CAAA,EAAA,IAAA,CAAA,CAAA,EAAA;AACA,MAAA,SAAA,CAAA,GAAA,CAAA,CAAA,EAAA,CAAA;AACA,MAAA,KAAA,CAAA,GAAA,CAAA,GAAA,EAAA,CAAA;AACA,MAAA,IAAA,CAAA,GAAA,GAAA,GAAA,EAAA,CAAA,EAAA;AACF,IAAA,OAAA,CAAA;;;;AAIF,EAAA,GAAA,CAAA,GAAA,EAAA,GAAA,EAAA;AACE,IAAA,aAAA,CAAA,IAAA,CAAA,IAAA,CAAA,GAAA,CAAA,CAAA,GAAA;AACA,IAAA,OAAA,IAAA;;AAEF,EAAA,MAAA,CAAA,GAAA,EAAA;;AAEE,IAAA,aAAA,CAAA,KAAA,CAAA,GAAA,CAAA,GAAA,CAAA;AACA,IAAA,OAAA,KAAA,CAAA,MAAA,CAAA,GAAA,CAAA;;AAEF,EAAA,KAAA,GAAA;;AAEK,IAAA,KAAA,IAAA,CAAA,IAAA,IAAA,CAAA,MAAA,EAAA,EAAA;AACD,MAAA,aAAA,CAAA,CAAA,EAAA;AACF,IAAA,KAAA,CAAA,KAAA,GAAA,CAAA;;;;"}

package/esm/whenmap.min.js

@@ -1 +1 @@
-const e=new WeakMap,t=([e,t])=>[e,Promise.resolve(t)];class r extends Map{constructor(e){super(e&&=Array.from(e,t))}has(t){let r=super.get(t);return!!r&&(!e.has(r)||1)}get get(){return this.when}when(t){let r,s=super.get(t);return s||(s=new Promise((e=>r=e)),e.set(s,r),super.set(t,s),this.on_ref?.(t,s)),s}set(e,t){return s(this.when(e))?.(t),this}delete(e){return s(super.get(e))?.(),super.delete(e)}clear(){for(let e of this.values())s(e)?.();super.clear()}}function s(t){let r=e.get(t);return e.delete(t),r}export{r as WhenMap,r as default};
+const e=new WeakMap;function t(t,s){let r=e.get(t);e.delete(t),r?.(s)}class s extends Map{constructor(e){super();for(let[t,s]of e||[])this.set(t,s)}has(t){let s=super.get(t);return!!s&&(!e.has(s)||1)}get get(){return this.when}when(t){let s,r=super.get(t);return r||(r=new Promise((e=>s=e)),e.set(r,s),super.set(t,r),this.ref?.(t,r)),r}set(e,s){return t(this.when(e),s),this}delete(e){return t(super.get(e)),super.delete(e)}clear(){for(let e of this.values())t(e);super.clear()}}export{s as WhenMap,s as default};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whenmap",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "",
   "license": "BSD-2-Clause",
   "author": "Shane Holloway <shane.holloway@ieee.org>",
@@ -17,7 +17,7 @@
   ],
   "type": "module",
   "exports": {
-    ".": "./esm/whenmap.js",
+    ".": "./esm/index.js",
     "./esm": "./esm"
   },
   "imports": {
@@ -28,12 +28,12 @@
   },
   "devDependencies": {
     "@rollup/plugin-terser": "^0.4.4",
-    "chai": "^5.2.0",
-    "rollup": "^4.36.0",
-    "rollup-plugin-jsy": "^1.9.2"
+    "chai": "^6.2.2",
+    "rollup": "^4.54.0",
+    "rollup-plugin-jsy": "^1.9.4"
   },
   "optionalDependencies": {
-    "vite": "^6.2.2"
+    "vite": "^7.3.0"
   },
   "scripts": {
     "clean": "rm ./esm/* || true",