@xylabs/sdk-js 2.6.3 → 2.6.6

package/src/shared/delay.spec.ts

@@ -1,12 +0,0 @@
-import { delay } from './delay'
-
-describe('delay', () => {
-  test('checking happy path', async () => {
-    const testInterval = 500
-    const startTime = Date.now()
-    await delay(testInterval)
-    const passedTime = Date.now() - startTime
-    expect(passedTime).toBeGreaterThanOrEqual(testInterval)
-    expect(passedTime).toBeLessThan(testInterval * 1.05)
-  })
-})

package/src/shared/delay.ts

@@ -1,3 +0,0 @@
-export const delay = (ms: number) => {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}

package/src/shared/forget.spec.ts

@@ -1,37 +0,0 @@
-import { delay } from './delay'
-import { forget, ForgetPromise } from './forget'
-
-
-describe('forget', () => {
-  test('checking happy path', async () => {
-    let cancelled = false
-    forget(delay(100), {delay: 200, cancel: () => cancelled = true })
-    await delay(300)
-    expect(cancelled).toBeFalsy()
-  })
-  test('checking unhappy path', async () => {
-    let cancelled = false
-    forget(delay(200), {delay: 100, cancel: () => cancelled = true })
-    await delay(300)
-    expect(cancelled).toBeTruthy()
-  })
-  test('forget active', async () => {
-    forget(delay(300))
-    expect(ForgetPromise.active).toBeTruthy()
-    await delay(600)
-    expect(ForgetPromise.active).toBeFalsy()
-  })
-  test('forget active async', async () => {
-    forget(delay(1000))
-    await ForgetPromise.awaitInactive()
-    expect(ForgetPromise.active).toBeFalsy()
-  })
-  test('forget active async w/timeout', async () => {
-    forget(delay(300))
-    const activeCount = await ForgetPromise.awaitInactive(100, 200)
-    expect(activeCount).toBe(1)
-    expect(ForgetPromise.active).toBeTruthy()
-    await ForgetPromise.awaitInactive()
-    expect(ForgetPromise.active).toBeFalsy()
-  })
-})

package/src/shared/forget.ts

@@ -1,75 +0,0 @@
-import { delay } from './delay'
-
-export interface ForgetTimeoutConfig {
-  delay: number
-  cancel: () => void
-}
-
-export class ForgetPromise {
-  static get active() {
-    return this.activeForgets > 0
-  }
-
-  static activeForgets = 0
-
-  static async awaitInactive(interval = 100, timeout?: number) {
-    let timeoutRemaining = timeout
-    while (this.active) {
-      await delay(interval)
-      if (timeoutRemaining !== undefined) {
-        timeoutRemaining -= interval
-        if (timeoutRemaining <= 0) {
-          return this.activeForgets
-        }
-      }
-    }
-    return 0
-  }
-
-  //used to explicitly launch an async function (or Promise) with awaiting it
-  static forget(promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) {
-    let completed = false
-    this.activeForgets++
-
-    const promiseWrapper = async () => {
-      await promise
-        .then(() => {
-          this.activeForgets--
-          completed = true
-        })
-        .catch(() => {
-          this.activeForgets--
-          completed = true
-        })
-    }
-
-    const promises = [promiseWrapper()]
-
-    //if there is a timeout, add it to the race
-    if (timeout) {
-      const timeoutFunc = async () => {
-        await delay(timeout.delay)
-        if (!completed) {
-          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`)
-          timeout.cancel?.()
-        }
-      }
-      promises.push(timeoutFunc())
-    }
-
-    const all = Promise.race(promises)
-
-    all
-      .then(() => {
-        return
-      })
-      .catch(() => {
-        return
-      })
-  }
-}
-
-//used to explicitly launch an async function (or Promise) with awaiting it
-export const forget = (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => {
-  ForgetPromise.forget(promise, timeout)
-}