@xylabs/forget 4.13.19 → 4.13.21

package/README.md

@@ -12,13 +12,433 @@
 [![snyk-badge][]][snyk-link]
 [![socket-badge][]][socket-link]
 
-Version: 4.13.15
 
 Base functionality used throughout XY Labs TypeScript/JavaScript libraries
 
-## Documentation
+## API Documentation
+
+**@xylabs/forget**
+
+***
+
+## Classes
+
+- [ForgetPromise](#classes/ForgetPromise)
+
+## Interfaces
+
+- [ForgetNodeConfig](#interfaces/ForgetNodeConfig)
+
+## Variables
+
+- [defaultForgetNodeConfig](#variables/defaultForgetNodeConfig)
+
+## Functions
+
+- [forget](#functions/forget)
+
+### classes
+
+  ### <a id="ForgetPromise"></a>ForgetPromise
+
+[**@xylabs/forget**](#../README)
+
+***
+
+## Extends
+
+- `ForgetPromise`
+
+## Constructors
+
+### Constructor
+
+```ts
+new ForgetPromise(): ForgetPromiseNode;
+```
+
+### Returns
+
+`ForgetPromiseNode`
+
+### Inherited from
+
+```ts
+ForgetPromise.constructor
+```
+
+## Properties
+
+### activeForgets
+
+```ts
+static activeForgets: number = 0;
+```
+
+### Inherited from
+
+```ts
+ForgetPromise.activeForgets
+```
+
+***
+
+### exceptedForgets
+
+```ts
+static exceptedForgets: number = 0;
+```
+
+### Inherited from
+
+```ts
+ForgetPromise.exceptedForgets
+```
+
+***
+
+### logger
+
+```ts
+static logger: Logger = console;
+```
+
+### Inherited from
+
+```ts
+ForgetPromise.logger
+```
+
+## Accessors
+
+### active
+
+### Get Signature
+
+```ts
+get static active(): boolean;
+```
+
+#### Returns
+
+`boolean`
+
+### Inherited from
+
+```ts
+ForgetPromise.active
+```
+
+## Methods
+
+### awaitInactive()
+
+```ts
+static awaitInactive(interval, timeout?): Promise<number>;
+```
+
+### Parameters
+
+#### interval
+
+`number` = `100`
+
+#### timeout?
+
+`number`
+
+### Returns
+
+`Promise`\<`number`\>
+
+### Inherited from
+
+```ts
+ForgetPromise.awaitInactive
+```
+
+***
+
+### exceptionHandler()
+
+```ts
+static exceptionHandler(
+   error, 
+   config, 
+   externalStackTrace?): void;
+```
+
+### Parameters
+
+#### error
+
+`Error`
+
+#### config
+
+[`ForgetNodeConfig`](#../interfaces/ForgetNodeConfig)
+
+#### externalStackTrace?
+
+`string`
+
+### Returns
+
+`void`
+
+### Overrides
+
+```ts
+ForgetPromise.exceptionHandler
+```
+
+***
+
+### forget()
+
+```ts
+static forget<T>(promise, config?): void;
+```
+
+Used to explicitly launch an async function (or Promise) with awaiting it
+
+### Type Parameters
+
+#### T
+
+`T`
+
+### Parameters
+
+#### promise
+
+`Promisable`\<`T`\>
+
+The promise to forget
+
+#### config?
+
+[`ForgetNodeConfig`](#../interfaces/ForgetNodeConfig)\<`T`\>
+
+Configuration of forget settings
+
+### Returns
+
+`void`
+
+### Overrides
+
+```ts
+ForgetPromise.forget
+```
+
+***
+
+### timeoutHandler()
+
+```ts
+static timeoutHandler(
+   time, 
+   config, 
+   externalStackTrace?): void;
+```
+
+### Parameters
+
+#### time
+
+`number`
+
+#### config
+
+[`ForgetNodeConfig`](#../interfaces/ForgetNodeConfig)
+
+#### externalStackTrace?
+
+`string`
+
+### Returns
+
+`void`
+
+### Overrides
+
+```ts
+ForgetPromise.timeoutHandler
+```
+
+### functions
+
+  ### <a id="forget"></a>forget
+
+[**@xylabs/forget**](#../README)
+
+***
+
+```ts
+function forget<T>(promise, config?): void;
+```
+
+## Type Parameters
+
+### T
+
+`T`
+
+## Parameters
+
+### promise
+
+`Promisable`\<`T`\>
+
+### config?
+
+[`ForgetNodeConfig`](#../interfaces/ForgetNodeConfig)\<`T`\>
+
+## Returns
+
+`void`
+
+### interfaces
+
+  ### <a id="ForgetNodeConfig"></a>ForgetNodeConfig
+
+[**@xylabs/forget**](#../README)
+
+***
+
+## Extends
+
+- `ForgetConfig`\<`T`\>
+
+## Type Parameters
+
+### T
+
+`T` = `any`
+
+## Properties
+
+### name?
+
+```ts
+optional name: string;
+```
+
+### Inherited from
+
+```ts
+ForgetConfig.name
+```
+
+***
+
+### onCancel()?
+
+```ts
+optional onCancel: () => void;
+```
+
+### Returns
+
+`void`
+
+### Inherited from
+
+```ts
+ForgetConfig.onCancel
+```
+
+***
+
+### onComplete()?
+
+```ts
+optional onComplete: (result) => void;
+```
+
+### Parameters
+
+#### result
+
+\[`undefined` \| `T`, `undefined` \| `Error`\]
+
+### Returns
+
+`void`
+
+### Inherited from
+
+```ts
+ForgetConfig.onComplete
+```
+
+***
+
+### onException()?
+
+```ts
+optional onException: (error) => void;
+```
+
+### Parameters
+
+#### error
+
+`Error`
+
+### Returns
+
+`void`
+
+### Inherited from
+
+```ts
+ForgetConfig.onException
+```
+
+***
+
+### timeout?
+
+```ts
+optional timeout: number;
+```
+
+### Inherited from
+
+```ts
+ForgetConfig.timeout
+```
+
+***
+
+### terminateOnException?
+
+```ts
+optional terminateOnException: boolean;
+```
+
+***
+
+### terminateOnTimeout?
+
+```ts
+optional terminateOnTimeout: boolean;
+```
+
+### variables
+
+  ### <a id="defaultForgetNodeConfig"></a>defaultForgetNodeConfig
+
+[**@xylabs/forget**](#../README)
+
+***
+
+```ts
+const defaultForgetNodeConfig: ForgetNodeConfig<unknown>;
+```
 
-Coming Soon!
 
 Part of [sdk-js](https://www.npmjs.com/package/@xyo-network/sdk-js)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/forget",
-  "version": "4.13.19",
+  "version": "4.13.21",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "keywords": [
     "forget",
@@ -30,24 +30,31 @@
     ".": {
       "node": {
         "types": "./dist/node/node/index.d.ts",
+        "source": "./src/node/index.ts",
         "default": "./dist/node/index.mjs"
       },
       "types": "./dist/node/node/index.d.ts",
+      "source": "./src/node/index.ts",
       "default": "./dist/node/index.mjs"
     },
     "./package.json": "./package.json"
   },
   "module": "./dist/node/index.mjs",
+  "source": "./src/node/index.ts",
   "types": "./dist/node/node/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
-    "@xylabs/delay": "^4.13.19",
-    "@xylabs/logger": "^4.13.19",
-    "@xylabs/promise": "^4.13.19",
-    "@xylabs/typeof": "^4.13.19"
+    "@xylabs/delay": "^4.13.21",
+    "@xylabs/logger": "^4.13.21",
+    "@xylabs/promise": "^4.13.21",
+    "@xylabs/typeof": "^4.13.21"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^7.0.0-rc.27",
-    "@xylabs/tsconfig-dom": "^7.0.0-rc.27",
+    "@xylabs/ts-scripts-yarn3": "^7.0.0",
+    "@xylabs/tsconfig-dom": "^7.0.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },

package/src/spec/forget.node.spec.ts

@@ -0,0 +1,61 @@
+import { delay } from '@xylabs/delay'
+import {
+  beforeAll,
+  describe, expect, it, test,
+  vi,
+} from 'vitest'
+
+import { forgetNode } from '../forgetNode.ts'
+import { ForgetPromiseNode } from '../ForgetPromiseNode.ts'
+
+describe('forgetNode', () => {
+  beforeAll(() => {
+    vi.spyOn(console, 'log').mockImplementation(() => {
+      // Stop expected logs from being logged
+    })
+  })
+  describe('with types', () => {
+    const cases: Promise<unknown>[] = [
+      Promise.resolve(1),
+      Promise.resolve({ a: 1 }),
+      Promise.resolve('resolved'),
+      Promise.resolve([1, 2, 3, 4]),
+      Promise.resolve(null),
+      Promise.resolve(),
+    ]
+    it.each(cases)('properly infers the type', (promise) => {
+      forgetNode(promise)
+    })
+  })
+  test('checking happy path', async () => {
+    let cancelled = false
+    forgetNode(delay(100), { onCancel: () => (cancelled = true), timeout: 200 })
+    await delay(300)
+    expect(cancelled).toBeFalsy()
+  })
+  test('checking unhappy path', async () => {
+    let cancelled = false
+    forgetNode(delay(200), { onCancel: () => (cancelled = true), timeout: 100 })
+    await delay(300)
+    expect(cancelled).toBeTruthy()
+  })
+  test('forget active', async () => {
+    forgetNode(delay(300))
+    expect(ForgetPromiseNode.active).toBeTruthy()
+    await delay(600)
+    expect(ForgetPromiseNode.active).toBeFalsy()
+  })
+  test('forget active async', async () => {
+    forgetNode(delay(1000))
+    await ForgetPromiseNode.awaitInactive()
+    expect(ForgetPromiseNode.active).toBeFalsy()
+  })
+  test('forget active async w/timeout', async () => {
+    forgetNode(delay(300))
+    const activeCount = await ForgetPromiseNode.awaitInactive(100, 200)
+    expect(activeCount).toBe(1)
+    expect(ForgetPromiseNode.active).toBeTruthy()
+    await ForgetPromiseNode.awaitInactive()
+    expect(ForgetPromiseNode.active).toBeFalsy()
+  })
+})

package/src/spec/forget.spec.ts

@@ -0,0 +1,61 @@
+import { delay } from '@xylabs/delay'
+import {
+  beforeAll,
+  describe, expect, it, test,
+  vi,
+} from 'vitest'
+
+import { forget } from '../forget.ts'
+import { ForgetPromise } from '../ForgetPromise.ts'
+
+describe('forget', () => {
+  beforeAll(() => {
+    vi.spyOn(console, 'log').mockImplementation(() => {
+      // Stop expected logs from being logged
+    })
+  })
+  describe('with types', () => {
+    const cases: Promise<unknown>[] = [
+      Promise.resolve(1),
+      Promise.resolve({ a: 1 }),
+      Promise.resolve('resolved'),
+      Promise.resolve([1, 2, 3, 4]),
+      Promise.resolve(null),
+      Promise.resolve(),
+    ]
+    it.each(cases)('properly infers the type', (promise) => {
+      forget(promise)
+    })
+  })
+  test('checking happy path', async () => {
+    let cancelled = false
+    forget(delay(100), { onCancel: () => (cancelled = true), timeout: 200 })
+    await delay(300)
+    expect(cancelled).toBeFalsy()
+  })
+  test('checking unhappy path', async () => {
+    let cancelled = false
+    forget(delay(200), { onCancel: () => (cancelled = true), timeout: 100 })
+    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/xy.config.ts

@@ -1,11 +0,0 @@
-import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
-const config: XyTsupConfig = {
-  compile: {
-    entryMode: 'custom',
-    browser: {},
-    neutral: { src: { entry: ['neutral/index.ts'] } },
-    node: { src: { entry: ['node/index.ts'] } },
-  },
-}
-
-export default config