@nevware21/ts-async - npm Package Compare versions

Comparing version 0.4.0 to 0.5.0

package.json

 {
     "name": "@nevware21/ts-async",
     "description": "support for asynchronous development with a Promise based task Scheduler, several different Promise implementations (synchronous, idle, asynchronous and native runtime wrappers), await helpers, and aliases all built and tested using TypeScript.",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "homepage": "https://github.com/nevware21/ts-async",
@@ -35,7 +35,7 @@ "sideEffects": false,
     ],
-    "main": "dist/es5/umd/ts-async.js",
-    "esnext:main": "dist/es6/umd/ts-async.js",
-    "module": "dist-es5/index.js",
-    "esnext": "dist-es6/index.js",
-    "types": "types/ts-async.d.ts",    
+    "main": "dist/es5/main/ts-async.js",
+    "esnext:main": "dist/es6/main/ts-async.js",
+    "module": "dist/es5/mod/index.js",
+    "esnext": "dist/es6/mod/index.js",
+    "types": "dist/types/ts-async.d.ts",    
     "repository": {
@@ -58,8 +58,8 @@ "type": "git",
         "package": "rollup -c rollup.config.js --bundleConfigAsCjs",
-        "test": "grunt ts_async-test && npm run test:node && npm run test:worker && npm run test:browser && npm run coverage:report",
+        "test": "npm run pre-proc test && grunt ts_async-test && npm run test:node && npm run test:browser && npm run test:worker && npm run coverage:report&& npm run pre-proc -- -restore",
         "test:node": "nyc ts-mocha --type-check -p ./test/tsconfig.test.json ./test/**/*.test.ts --trace-uncaught",
         "test:browser": "karma start karma.browser.conf.js --single-run",
-        "test:worker": "karma start karma.worker.conf.js --single-run",
+        "test:worker": "cross-env NODE_OPTIONS=--max-old-space-size=8192 karma start karma.worker.conf.js --single-run",
         "debug:browser": "karma start karma.debug.browser.conf.js --watch",
-        "debug:worker": "karma start karma.debug.worker.conf.js --watch",
+        "debug:worker": "cross-env NODE_OPTIONS=--max-old-space-size=8192 karma start karma.debug.worker.conf.js --watch",
         "lint": "grunt ts_async-lint",
@@ -79,3 +79,3 @@ "coverage:report": "npm run coverage:nyc && npm run coverage:merge",
     "dependencies": {
-        "@nevware21/ts-utils": ">= 0.10.0 < 2.x"
+        "@nevware21/ts-utils": ">= 0.11.0 < 2.x"
     },
@@ -94,5 +94,6 @@ "devDependencies": {
         "@types/sinon": "^10.0.11",
-        "chai": "^4.3.6",
+        "chai": "4.3.10",
         "chromium": "^3.0.3",
         "codecov": "^3.8.3",
+        "cross-env": "^7.0.3",
         "grunt": "^1.5.3",
@@ -99,0 +100,0 @@ "grunt-cli": "^1.4.3",

README.md

@@ -31,22 +31,34 @@ <h1 align="center">@nevware21 ts-async</h1>
 
-| Type / Function       | Details
-|-----------------------|------------------------------
-| **Scheduler**
-| [`createTaskScheduler`](https://nevware21.github.io/ts-async/typedoc/functions/createTaskScheduler.html) | Create a Task Scheduler using the optional promise implementation and scheduler name. The newPromise can be any value promise creation function, where the execution of the queued tasks will be processed based on how the promise implementation processes it's chained promises (asynchrounsly; synchronously; idle processing, etc)<br />There is no limit on the number of schedulers that you can create, when using more than one scheduler it is recommended that you provide a `name` to each scheduler to help identify / group promises during debugging.
+| Type / Function       | Since | Details
+|-----------------------|-------|-----------------------
+| **Promise based Scheduler**
+| [`createTaskScheduler`](https://nevware21.github.io/ts-async/typedoc/functions/createTaskScheduler.html) | |Create a Task Scheduler using the optional promise implementation and scheduler name. The newPromise can be any value promise creation function, where the execution of the queued tasks will be processed based on how the promise implementation processes it's chained promises (asynchrounsly; synchronously; idle processing, etc)<br />There is no limit on the number of schedulers that you can create, when using more than one scheduler it is recommended that you provide a `name` to each scheduler to help identify / group promises during debugging.
+| [`ITaskScheduler`](https://nevware21.github.io/ts-async/typedoc/interfaces/ITaskScheduler.html) | 0.2.0 |Defines a Task Scheduler that uses IPromise implementations to serialize the execution of the tasks. Each added task will not get executed until the previous task has completed.
+| [`StartQueuedTaskFn`](https://nevware21.github.io/ts-async/typedoc/types/StartQueuedTaskFn.html) | 0.2.0 | Identifies the function to call to start and execute the task when its ready to be executed.
 | **Interfaces**
-| [`IPromise`](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) | This package uses and exports the `IPromise<T>` interface which extends both the `PromiseLike<T>` and `Promise<T>` to provide type compatibility when passing the Promises created with this package to any function that expects a `Promise` (including returning from an `async function`). As part of it's definition it exposes an [optional] string `status` to represent the current state of the `Promise`. These values include `pending`, `resolved` `rejected` and `resolving` which is a special case when a Promise is being `resolved` via another Promise returned via the `thenable` onResolved / onRejected functions.
-| [`AwaitResponse`](https://nevware21.github.io/ts-async/typedoc/interfaces/AwaitResponse.html) | This interface is used to represent the result whether resolved or rejected when using the [`doAwaitResponse`](https://nevware21.github.io/ts-async/typedoc/functions/doAwaitResponse.html), this function is useful when you want to avoid creating both a `resolved` and `rejected` functions, as this function only requires a single callback function to be used which will receive an object that conforms to this interface. 
+| [`IPromise`](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) | |This package uses and exports the `IPromise<T>` interface which extends both the `PromiseLike<T>` and `Promise<T>` to provide type compatibility when passing the Promises created with this package to any function that expects a `Promise` (including returning from an `async function`). As part of it's definition it exposes an [optional] string `status` to represent the current state of the `Promise`. These values include `pending`, `resolved` `rejected` and `resolving` which is a special case when a Promise is being `resolved` via another Promise returned via the `thenable` onResolved / onRejected functions.
+| [`AwaitResponse`](https://nevware21.github.io/ts-async/typedoc/interfaces/AwaitResponse.html) | |This interface is used to represent the result whether resolved or rejected when using the [`doAwaitResponse`](https://nevware21.github.io/ts-async/typedoc/functions/doAwaitResponse.html), this function is useful when you want to avoid creating both a `resolved` and `rejected` functions, as this function only requires a single callback function to be used which will receive an object that conforms to this interface.
+| [`IWhileState`](https://nevware21.github.io/ts-async/typedoc/interfaces/IWhileState.html) | 0.5.0| The current state of the while loop while processing the callback function, this is passed to eht callback function.
+| [`IPromiseResult`](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromiseResult.html) | 0.5.0 |The result of a promise. It can either be fulfilled with a value, or rejected with a reason.
 | **Alias**
-| [`createPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createPromise.html)<br/> [`createAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAllPromise.html) <br/> [`createRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createRejectedPromise.html) <br/> [`createResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createResolvedPromise.html) <br/> <br/> [`setCreatePromiseImpl`](https://nevware21.github.io/ts-async/typedoc/functions/setCreatePromiseImpl.html) | These function use the current promise creator implementation that can be set via <code>[`setCreatePromiseImpl`](https://nevware21.github.io/ts-async/typedoc/functions/setCreatePromiseImpl.html)(creator: &lt;T&gt;(executor: PromiseExecutor&lt;T&gt;, timeout?: number) => IPromise&lt;T&gt;): void</code> <br/>Unless otherwise set this defaults to the `createNativePromise` implementation, to provide a simplified wrapper around any native runtime Promise support. <br/>Available implementation: <ul><li>[`createNativePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativePromise.html) <li>[`createAsyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncPromise.html) <li>[`createSyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncPromise.html) <li>[`createIdlePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdlePromise.html) </ul> By using these aliases, it's possible to switch between any of these implementations as needed without duplicating your code. This will not change any existing promises, it only affects new promises. 
-| [`createNativePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativePromise.html) <br/> [`createNativeAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeAllPromise.html) <br/> [`createNativeRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeRejectedPromise.html) <br/> [`createNativeResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeResolvedPromise.html) <br/> | These are effectively wrappers around the runtime `Promise` class, so this is effectivly the same as `new Promise(...)` but as a non-global class name it can be heavily minified to something like `a(...)`. These wrappers also add an accessible `status` property for identifying the current status of this promise. However, the `status` property is NOT available on any returned chained Promise (from calling `then`, `catch` or `finally`) 
-| **Asynchronous**
-| [`createAsyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncPromise.html) <br/> [`createAsyncAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncAllPromise.html) <br/> [`createAsyncRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncRejectedPromise.html) <br/> [`createAsyncResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncResolvedPromise.html) <br/> | Provides an implementation of the `Promise` contract that uses timeouts to process any chained promises (returned by `then(...)`, `catch(...)`, `finally(...)`), when creating the initial promise you can also provide (override) the default duration of the timeout (defaults to 0ms) to further delay the execution of the chained Promises.<br/>, but can also be provided) to process any chained promises (of any type)
-| **Synchronous**
-| [`createSyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncPromise.html) <br/> [`createSyncAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncAllPromise.html) <br/> [`createSyncRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncRejectedPromise.html) <br/> [`createSyncResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncResolvedPromise.html) <br/>    | Also implements the `Promise` contract but will immediately execute any chained promises at the point of the original promise getting resolved or rejected, or if already resolved, rejected then at the point of registering the `then`, `catch` or `finally`
-| **Idle**
-| [`createIdlePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdlePromise.html) <br/> [`createIdleAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleAllPromise.html) <br/> [`createIdleRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleRejectedPromise.html) <br/> [`createIdleResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleResolvedPromise.html) <br/>   | Implements the `Promise` contract and will process any chained promises using the available `requestIdleCallback` (with no timeout by default - but can also be changes by `setDetaultIdlePromiseTimeout`). And when `requestIdleCallback` is not supported this will default to using a timeout via the [`scheduleIdleCallback` from `@nevware21/ts-utils`](https://nevware21.github.io/ts-utils/typedoc/functions/scheduleIdleCallback.html)
+| [`createPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createPromise.html)<br/> [`createAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAllPromise.html) <br/> [`createAllSettledPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAllSettledPromise.html) <br/> [`createAnyPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAnyPromise.html) <br/> [`createRacePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createRacePromise.html) <br/> [`createRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createRejectedPromise.html) <br/> [`createResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createResolvedPromise.html) <br /> <br/> [`setCreatePromiseImpl`](https://nevware21.github.io/ts-async/typedoc/functions/setCreatePromiseImpl.html) | <br /> <br /> 0.5.0 <br /> 0.5.0 <br /> 0.5.0 <br /> <br /> <br /> <br /> <br /> | These function use the current promise creator implementation that can be set via <code>[`setCreatePromiseImpl`](https://nevware21.github.io/ts-async/typedoc/functions/setCreatePromiseImpl.html)(creator: &lt;T&gt;(executor: PromiseExecutor&lt;T&gt;, timeout?: number) => IPromise&lt;T&gt;): void</code> <br/>Unless otherwise set this defaults to the `createNativePromise` implementation, to provide a simplified wrapper around any native runtime Promise support. <br/>Available implementation: <ul><li>[`createNativePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativePromise.html) <li>[`createAsyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncPromise.html) <li>[`createSyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncPromise.html) <li>[`createIdlePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdlePromise.html) </ul> By using these aliases, it's possible to switch between any of these implementations as needed without duplicating your code. This will not change any existing promises, it only affects new promises. 
+| [`createNativePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativePromise.html) <br/> [`createNativeAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeAllPromise.html) <br/> [`createNativeAllSettledPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeAllSettledPromise.html) <br/> [`createNativeAnyPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeAnyPromise.html) <br/> [`createNativeRacePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeRacePromise.html) <br/> [`createNativeRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeRejectedPromise.html) <br/> [`createNativeResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createNativeResolvedPromise.html) | <br /> <br /> 0.5.0 <br /> 0.5.0 <br /> 0.5.0 <br /> <br /> <br /> | These are effectively wrappers around the runtime `Promise` class, so this is effectivly the same as `new Promise(...)` but as a non-global class name it can be heavily minified to something like `a(...)`. These wrappers also add an accessible `status` property for identifying the current status of this promise. However, the `status` property is NOT available on any returned chained Promise (from calling `then`, `catch` or `finally`) 
+| **Asynchronous Promise**
+| [`createAsyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncPromise.html) <br/> [`createAsyncAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncAllPromise.html) <br/> [`createAsyncAllSettledPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncAllSettledPromise.html) <br/> [`createAsyncAnyPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncAnyPromise.html) <br/> [`createAsyncRacePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncRacePromise.html) <br/> [`createAsyncRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncRejectedPromise.html) <br/> [`createAsyncResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createAsyncResolvedPromise.html) | <br /> <br /> 0.5.0 <br /> 0.5.0 <br /> 0.5.0 <br /> <br /> <br /> | Provides an implementation of the `Promise` contract that uses timeouts to process any chained promises (returned by `then(...)`, `catch(...)`, `finally(...)`), when creating the initial promise you can also provide (override) the default duration of the timeout (defaults to 0ms) to further delay the execution of the chained Promises.<br/>, but can also be provided) to process any chained promises (of any type)
+| **Synchronous Promise**
+| [`createSyncPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncPromise.html) <br/> [`createSyncAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncAllPromise.html) <br/> [`createSyncAllSettledPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncAllSettledPromise.html) <br/> [`createSyncAnyPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncAnyPromise.html) <br/> [`createSyncRacePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncRacePromise.html) <br/> [`createSyncRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncRejectedPromise.html) <br/> [`createSyncResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createSyncResolvedPromise.html)  | <br /> <br /> 0.5.0 <br /> 0.5.0 <br /> 0.5.0 <br /> <br /> <br /> | Also implements the `Promise` contract but will immediately execute any chained promises at the point of the original promise getting resolved or rejected, or if already resolved, rejected then at the point of registering the `then`, `catch` or `finally`
+| **Idle Promise**
+| [`createIdlePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdlePromise.html) <br/> [`createIdleAllPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleAllPromise.html) <br/> [`createIdleAllSettledPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleAllSettledPromise.html) <br/> [`createIdleAnyPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleAnyPromise.html) <br/> [`createIdleRacePromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleRacePromise.html) <br/> [`createIdleRejectedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleRejectedPromise.html) <br/> [`createIdleResolvedPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createIdleResolvedPromise.html)  | <br /> <br /> 0.5.0 <br /> 0.5.0 <br /> 0.5.0 <br /> <br /> <br /> | Implements the `Promise` contract and will process any chained promises using the available `requestIdleCallback` (with no timeout by default - but can also be changes by `setDetaultIdlePromiseTimeout`). And when `requestIdleCallback` is not supported this will default to using a timeout via the [`scheduleIdleCallback` from `@nevware21/ts-utils`](https://nevware21.github.io/ts-utils/typedoc/functions/scheduleIdleCallback.html)
+| **Timeout**
+| [`createTimeoutPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createTimeoutPromise.html) | | Creates a Promise instance that resolve or reject after the specified timeout.
 | **Helpers**
-| [`doAwait`](https://nevware21.github.io/ts-async/typedoc/functions/doAwait.html)             | Helper which handles `await` "handling" via callback functions to avoid the TypeScript boilerplate code that is added for multiple branches. Internal it handles being passed an `IPromise` or a result value so you avoid needing to test whether the result you have is also a `Promise`.<br />It takes three (3) optional callback functions for `resolved`, `rejected` and `finally`.
-| [`doAwaitResponse`](https://nevware21.github.io/ts-async/typedoc/functions/doAwaitResponse.html)     | Helper which handles `await` "handling" via a single callback where `resolved` and `rejected` cases are handled by the same callback, this receives an `AwaitResponse` object that provides the `value` or `reason` and a flag indicating whether the Promise was `rejected`)
-| [`doFinally`](https://nevware21.github.io/ts-async/typedoc/functions/doFinally.html)           | Helper to provide `finally` handling for any promise using a callback implementation, analogous to using `try` / `finally` around an `await` function or using the `finally` on the promise directly
+| [`createTimeoutPromise`](https://nevware21.github.io/ts-async/typedoc/functions/createTimeoutPromise.html) | 0.5.0 | Creates a Promise instance that resolve or reject after the specified timeout.
+| [`doAwait`](https://nevware21.github.io/ts-async/typedoc/functions/doAwait.html)             | | Helper which handles `await` "handling" via callback functions to avoid the TypeScript boilerplate code that is added for multiple branches. Internal it handles being passed an `IPromise` or a result value so you avoid needing to test whether the result you have is also a `Promise`.<br />It takes three (3) optional callback functions for `resolved`, `rejected` and `finally`.
+| [`doAwaitResponse`](https://nevware21.github.io/ts-async/typedoc/functions/doAwaitResponse.html)     | | Helper which handles `await` "handling" via a single callback where `resolved` and `rejected` cases are handled by the same callback, this receives an `AwaitResponse` object that provides the `value` or `reason` and a flag indicating whether the Promise was `rejected`
+| [`doFinally`](https://nevware21.github.io/ts-async/typedoc/functions/doFinally.html)           | | Helper to provide `finally` handling for any promise using a callback implementation, analogous to using `try` / `finally` around an `await` function or using the `finally` on the promise directly
+| [`arrForEachAsync`](https://nevware21.github.io/ts-async/typedoc/functions/arrForEachAsync.html) | 0.5.0 | Performs an asynchronous for loop where the calling function may return an [`IPromise`](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) which must be fulfilled before the next iteration is called.
+| [`doWhileAsync`](https://nevware21.github.io/ts-async/typedoc/functions/doWhileAsync.html) | 0.5.0          | Performs a while loop where the calling function may return an [`IPromise`](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) which must be fulfilled before the next iteration is called.
+| [`iterForOfAsync`](https://nevware21.github.io/ts-async/typedoc/functions/iterForOfAsync.html) | 0.5.0           | Iterates over the iterator where the calling function may return an [`IPromise`](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) which must be fulfilled before the next iteration is called.
+| **Polyfill**
+| [`PolyPromise`](https://nevware21.github.io/ts-async/typedoc/classes/PolyPromise.html) | 0.5.0 | A full polyfill for the Promise class
 
@@ -90,3 +102,3 @@ All promise implementations are validated using TypeScript with `async` / `await` and the internal helper functions `doAwait`, `doFinally` and `doAwaitResponse` helpers. Usage of the `doAwait` or `doAwaitResponse` is recommended as this avoids the additional boiler plate code that is added by TypeScript when handling the branches in an `async` / `await` operations, this does however, mean that your calling functions will also need to handle this `async` operations via callbacks rather than just causing the code path to "halt" at the `await` and can therefore may be a little more complex (depending on your implementation).
 > ```json
-> "@nevware21/ts-async": ">= 0.4.0 < 2.x"
+> "@nevware21/ts-async": ">= 0.5.0 < 2.x"
 > ```
@@ -100,3 +112,3 @@
 
-```TypeScript
+```ts
 import { createTaskScheduler } from "@nevware21/ts-async";
@@ -140,3 +152,3 @@ import { scheduleTimeout } from "@nevware21/ts-utils";
 
-```TypeScript
+```ts
 import { createPromise } from "@nevware21/ts-async";
@@ -143,0 +155,0 @@ import { scheduleTimeout } from "@nevware21/ts-utils";

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Number of package files

151

increased by5.59%

Lines of code

26866

increased by28.45%

Number of lines in readme file

205

increased by6.22%

Worsened metrics

Total package byte prevSize

6787365

decreased by-0.53%

Dev dependency count

39

increased by2.63%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updated@nevware21/ts-utils@>= 0.11.0 < 2.x