lib0 0.2.93 → 0.2.95

package/pledge.js

@@ -0,0 +1,292 @@
+/**
+ * @experimental Use of this module is not encouraged!
+ * This is just an experiment.
+ * @todo remove `c8 ignore` line once this is moved to "non-experimental"
+ */
+
+import * as queue from './queue.js'
+import * as object from './object.js'
+
+/* c8 ignore start */
+
+/**
+ * @type {queue.Queue<queue.QueueValue<()=>void>>}
+ */
+const ctxFs = queue.create()
+
+/**
+ * @param {() => void} f
+ */
+const runInGlobalContext = f => {
+  const isEmpty = queue.isEmpty(ctxFs)
+  queue.enqueue(ctxFs, new queue.QueueValue(f))
+  if (isEmpty) {
+    while (!queue.isEmpty(ctxFs)) {
+      /** @type {queue.QueueValue<()=>{}>} */ (ctxFs.start).v()
+      queue.dequeue(ctxFs)
+    }
+  }
+}
+
+/**
+ * @template V
+ * @typedef {V | PledgeInstance<V>} Pledge
+ */
+
+/**
+ * @template {any} Val
+ * @template {any} [CancelReason=Error]
+ */
+export class PledgeInstance {
+  constructor () {
+    /**
+     * @type {Val | CancelReason | null}
+     */
+    this._v = null
+    this.isResolved = false
+    /**
+     * @type {Array<function(Val):void> | null}
+     */
+    this._whenResolved = []
+    /**
+     * @type {Array<function(CancelReason):void> | null}
+     */
+    this._whenCanceled = []
+  }
+
+  get isDone () {
+    return this._whenResolved === null
+  }
+
+  get isCanceled () {
+    return !this.isResolved && this._whenResolved === null
+  }
+
+  /**
+   * @param {Val} v
+   */
+  resolve (v) {
+    const whenResolved = this._whenResolved
+    if (whenResolved === null) return
+    this._v = v
+    this.isResolved = true
+    this._whenResolved = null
+    this._whenCanceled = null
+    for (let i = 0; i < whenResolved.length; i++) {
+      whenResolved[i](v)
+    }
+  }
+
+  /**
+   * @param {CancelReason} reason
+   */
+  cancel (reason) {
+    const whenCanceled = this._whenCanceled
+    if (whenCanceled === null) return
+    this._v = reason
+    this._whenResolved = null
+    this._whenCanceled = null
+    for (let i = 0; i < whenCanceled.length; i++) {
+      whenCanceled[i](reason)
+    }
+  }
+
+  /**
+   * @template R
+   * @param {function(Val):Pledge<R>} f
+   * @return {PledgeInstance<R>}
+   */
+  map (f) {
+    /**
+     * @type {PledgeInstance<R>}
+     */
+    const p = new PledgeInstance()
+    this.whenResolved(v => {
+      const result = f(v)
+      if (result instanceof PledgeInstance) {
+        if (result._whenResolved === null) {
+          result.resolve(/** @type {R} */ (result._v))
+        } else {
+          result._whenResolved.push(p.resolve.bind(p))
+        }
+      } else {
+        p.resolve(result)
+      }
+    })
+    return p
+  }
+
+  /**
+   * @param {function(Val):void} f
+   */
+  whenResolved (f) {
+    if (this.isResolved) {
+      f(/** @type {Val} */ (this._v))
+    } else {
+      this._whenResolved?.push(f)
+    }
+  }
+
+  /**
+   * @param {(reason: CancelReason) => void} f
+   */
+  whenCanceled (f) {
+    if (this.isCanceled) {
+      f(/** @type {CancelReason} */ (this._v))
+    } else {
+      this._whenCanceled?.push(f)
+    }
+  }
+
+  /**
+   * @return {Promise<Val>}
+   */
+  promise () {
+    return new Promise((resolve, reject) => {
+      this.whenResolved(resolve)
+      this.whenCanceled(reject)
+    })
+  }
+}
+
+/**
+ * @template T
+ * @return {PledgeInstance<T>}
+ */
+export const create = () => new PledgeInstance()
+
+/**
+ * @typedef {Array<Pledge<unknown>> | Object<string,Pledge<unknown>>} PledgeMap
+ */
+
+/**
+ * @template {Pledge<unknown> | PledgeMap} P
+ * @typedef {P extends PledgeMap ? { [K in keyof P]: P[K] extends Pledge<infer V> ? V : P[K]} : (P extends Pledge<infer V> ? V : never)} Resolved<P>
+ */
+
+/**
+ * @todo Create a "resolveHelper" that will simplify creating indxeddbv2 functions. Double arguments
+ * are not necessary.
+ *
+ * @template V
+ * @template {Array<Pledge<unknown>>} DEPS
+ * @param {(p: PledgeInstance<V>, ...deps: Resolved<DEPS>) => void} init
+ * @param {DEPS} deps
+ * @return {PledgeInstance<V>}
+ */
+export const createWithDependencies = (init, ...deps) => {
+  /**
+   * @type {PledgeInstance<V>}
+   */
+  const p = new PledgeInstance()
+  // @ts-ignore @todo remove this
+  all(deps).whenResolved(ds => init(p, ...ds))
+  return p
+}
+
+/**
+ * @template R
+ * @param {Pledge<R>} p
+ * @param {function(R):void} f
+ */
+export const whenResolved = (p, f) => {
+  if (p instanceof PledgeInstance) {
+    return p.whenResolved(f)
+  }
+  return f(p)
+}
+
+/**
+ * @template {Pledge<unknown>} P
+ * @param {P} p
+ * @param {P extends PledgeInstance<unknown, infer CancelReason> ? function(CancelReason):void : function(any):void} f
+ */
+export const whenCanceled = (p, f) => {
+  if (p instanceof PledgeInstance) {
+    p.whenCanceled(f)
+  }
+}
+
+/**
+ * @template P
+ * @template Q
+ * @param {Pledge<P>} p
+ * @param {(r: P) => Q} f
+ * @return {Pledge<Q>}
+ */
+export const map = (p, f) => {
+  if (p instanceof PledgeInstance) {
+    return p.map(f)
+  }
+  return f(p)
+}
+
+/**
+ * @template {PledgeMap} PS
+ * @param {PS} ps
+ * @return {PledgeInstance<Resolved<PS>>}
+ */
+export const all = ps => {
+  /**
+   * @type {any}
+   */
+  const pall = create()
+  /**
+   * @type {any}
+   */
+  const result = ps instanceof Array ? new Array(ps.length) : {}
+  let waitingPs = ps instanceof Array ? ps.length : object.size(ps)
+  for (const key in ps) {
+    const p = ps[key]
+    whenResolved(p, r => {
+      result[key] = r
+      if (--waitingPs === 0) {
+        // @ts-ignore
+        pall.resolve(result)
+      }
+    })
+  }
+  return pall
+}
+
+/**
+ * @template Result
+ * @template {any} YieldResults
+ * @param {() => Generator<Pledge<YieldResults> | PledgeInstance<YieldResults,any>, Result, any>} f
+ * @return {PledgeInstance<Result>}
+ */
+export const coroutine = f => {
+  const p = create()
+  const gen = f()
+  /**
+   * @param {any} [yv]
+   */
+  const handleGen = (yv) => {
+    const res = gen.next(yv)
+    if (res.done) {
+      p.resolve(res.value)
+      return
+    }
+    // @ts-ignore
+    whenCanceled(res.value, (reason) => {
+      gen.throw(reason)
+    })
+    runInGlobalContext(() =>
+      whenResolved(res.value, handleGen)
+    )
+  }
+  handleGen()
+  return p
+}
+
+/**
+ * @param {number} timeout
+ * @return {PledgeInstance<undefined>}
+ */
+export const wait = timeout => {
+  const p = create()
+  setTimeout(p.resolve.bind(p), timeout)
+  return p
+}
+
+/* c8 ignore end */

package/pledge.test.d.ts

@@ -0,0 +1,6 @@
+export function testPledgeCoroutine(_tc: t.TestCase): Promise<void>;
+export function testPledgeVsPromisePerformanceTimeout(_tc: t.TestCase): Promise<void>;
+export function testPledgeVsPromisePerformanceResolved(_tc: t.TestCase): Promise<void>;
+export type MaybePromise = Promise<number> | number;
+import * as t from './testing.js';
+//# sourceMappingURL=pledge.test.d.ts.map

package/pledge.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pledge.test.d.ts","sourceRoot":"","sources":["pledge.test.js"],"names":[],"mappings":"AAOO,yCAFI,EAAE,QAAQ,iBAepB;AAKM,2DAFI,EAAE,QAAQ,iBAiBpB;AASM,4DAFI,EAAE,QAAQ,iBAqCpB;2BAzCY,QAAQ,MAAM,CAAC,GAAG,MAAM;mBA3ClB,cAAc"}

package/promise.d.ts

@@ -15,6 +15,7 @@ export function reject(reason?: Error | undefined): Promise<never>;
 export function resolve<T>(res: void | T): Promise<void | T>;
 export function resolveWith<T>(res: T): Promise<T>;
 export function until(timeout: number, check: () => boolean, intervalResolution?: number | undefined): Promise<void>;
+export function untilAsync(check: () => Promise<boolean> | boolean, timeout?: number, intervalResolution?: number): Promise<void>;
 export function wait(timeout: number): Promise<undefined>;
 export function isPromise(p: any): boolean;
 export type PromiseResolve<T> = (result?: T | PromiseLike<T> | undefined) => any;

package/promise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["promise.js"],"names":[],"mappings":"AAmBO,oEAHwC,KAAK,KAAE,IAAI,KAAE,GAAG,cAGM;AAM9D,4CAHwB,IAAI,eAAU,KAAK,KAAE,IAAI,KAAE,IAAI,GAClD,QAAQ,IAAI,CAAC,CAEqB;AAE9C;;;;;;GAMG;AACH;;;EAA4C;AAMrC,oDAFK,QAAQ,KAAK,CAAC,CAE4B;AAO/C,6DAA2C;AAO3C,mDAA+C;AAU/C,+BALI,MAAM,eACK,OAAO,4CAEjB,QAAQ,IAAI,CAAC,CAkBvB;AAMK,8BAHI,MAAM,GACL,QAAQ,SAAS,CAAC,CAE0D;AAWjF,6BAHI,GAAG,GACF,OAAO,CAEwE"}
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["promise.js"],"names":[],"mappings":"AAmBO,oEAHwC,KAAK,KAAE,IAAI,KAAE,GAAG,cAGM;AAM9D,4CAHwB,IAAI,eAAU,KAAK,KAAE,IAAI,KAAE,IAAI,GAClD,QAAQ,IAAI,CAAC,CAEqB;AAE9C;;;;;;GAMG;AACH;;;EAA4C;AAMrC,oDAFK,QAAQ,KAAK,CAAC,CAE4B;AAO/C,6DAA2C;AAO3C,mDAA+C;AAW/C,+BALI,MAAM,eACK,OAAO,4CAEjB,QAAQ,IAAI,CAAC,CAkBvB;AAQK,kCALI,MAAI,QAAQ,OAAO,CAAC,GAAC,OAAO,YAC5B,MAAM,uBACN,MAAM,GACL,QAAQ,IAAI,CAAC,CAWxB;AAMM,8BAHI,MAAM,GACL,QAAQ,SAAS,CAAC,CAE2D;AAWlF,6BAHI,GAAG,GACF,OAAO,CAEwE"}

package/promise.js

@@ -56,6 +56,7 @@ export const resolveWith = res => Promise.resolve(res)
 
 /**
  * @todo Next version, reorder parameters: check, [timeout, [intervalResolution]]
+ * @deprecated use untilAsync instead
  *
  * @param {number} timeout
  * @param {function():boolean} check
@@ -80,11 +81,28 @@ export const until = (timeout, check, intervalResolution = 10) => create((resolv
   const intervalHandle = setInterval(untilInterval, intervalResolution)
 })
 
+/**
+ * @param {()=>Promise<boolean>|boolean} check
+ * @param {number} timeout
+ * @param {number} intervalResolution
+ * @return {Promise<void>}
+ */
+export const untilAsync = async (check, timeout = 0, intervalResolution = 10) => {
+  const startTime = time.getUnixTime()
+  const noTimeout = timeout <= 0
+  // eslint-disable-next-line no-unmodified-loop-condition
+  while (noTimeout || time.getUnixTime() - startTime <= timeout) {
+    if (await check()) return
+    await wait(intervalResolution)
+  }
+  throw new Error('Timeout')
+}
+
 /**
  * @param {number} timeout
  * @return {Promise<undefined>}
  */
-export const wait = timeout => create((resolve, reject) => setTimeout(resolve, timeout))
+export const wait = timeout => create((resolve, _reject) => setTimeout(resolve, timeout))
 
 /**
  * Checks if an object is a promise using ducktyping.

package/promise.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promise.test.d.ts","sourceRoot":"","sources":["promise.test.js"],"names":[],"mappings":"AA6BO,uCAFI,EAAE,QAAQ,iBAgBpB;AAKM,mCAFI,EAAE,QAAQ,QAapB;AAKM,iCAFI,EAAE,QAAQ,iBAapB;mBA1EkB,cAAc"}
+{"version":3,"file":"promise.test.d.ts","sourceRoot":"","sources":["promise.test.js"],"names":[],"mappings":"AA6BO,uCAFI,EAAE,QAAQ,iBAmBpB;AAKM,mCAFI,EAAE,QAAQ,QAapB;AAKM,iCAFI,EAAE,QAAQ,iBAapB;mBA7EkB,cAAc"}

package/test.js

@@ -10,6 +10,7 @@ import * as encoding from './encoding.test.js'
 import * as diff from './diff.test.js'
 import * as testing from './testing.test.js'
 import * as indexeddb from './indexeddb.test.js'
+import * as indexeddbV2 from './indexeddbV2.test.js'
 import * as prng from './prng.test.js'
 import * as log from 'lib0/logging'
 import * as statistics from './statistics.test.js'
@@ -23,6 +24,7 @@ import * as time from './time.test.js'
 import * as pair from './pair.test.js'
 import * as object from './object.test.js'
 import * as observable from './observable.test.js'
+import * as pledge from './pledge.test.js'
 import * as math from './math.test.js'
 import * as number from './number.test.js'
 import * as buffer from './buffer.test.js'
@@ -55,6 +57,7 @@ runTests({
   diff,
   testing,
   indexeddb,
+  indexeddbV2,
   prng,
   statistics,
   binary,
@@ -67,6 +70,7 @@ runTests({
   pair,
   object,
   observable,
+  pledge,
   math,
   number,
   buffer,