npmpackage.info

@kaciras/deasync

Turns async function into sync via JavaScript wrapper of Node event loop

1.1.0

MIT

TypeScript

495.00 B

150,885 3.8

Installations

npm install @kaciras/deasync

Pull Requests

Open

0

Total

0

Closed

0

Issues

Open

0

Total

0

Closed

0

Releases

v1.1.0

Published on 24 Oct 2024

v1.0.4

Published on 06 Apr 2024

v1.0.3

Published on 04 Dec 2022

v1.0.2

Published on 17 Feb 2022

v1.0.1

Published on 17 Feb 2022

View all 5 releases

Developer

Kaciras

Developer Guide

BETA

Module System

CommonJS

Min. Node Version

>=20

Typescript Support

Yes

Node Version

23.0.0

NPM Version

10.9.0 Statistics

42 Stars

306 Commits

5 Forks

2 Watching

1 Branches

13 Contributors

Updated on 25 Nov 2024

Bundle Size

858.00 B

Minified

495.00 B

Minified + Gzipped

Bundlephobia

Languages

TypeScript (64.58%)

JavaScript (31.52%)

C++ (3.34%)

Python (0.57%)

Total Downloads

Cumulative downloads

Total Downloads

150,885

Last day

-61.4%

262

Compared to previous day

Last week

-33.8%

2,721

Compared to previous week

Last month

-13.9%

10,377

Compared to previous month

Last year

254.4%

108,930

Compared to previous year

Daily Downloads

Weekly Downloads

Monthly Downloads

Yearly Downloads

Dependencies

follow-redirects tar-fs

Dev Dependencies

@kaciras/eslint-config-core @kaciras/eslint-config-typescript @types/mocha @types/node c8 eslint mocha ts-directly typescript

Versions

DeAsync

NPM Type Definitions node-current (scoped)

DeAsync turns async code into sync, implemented with a blocking mechanism by calling Node.js event loop at JavaScript layer. The core of deasync is written in C++.

This project is forked from abbr/deasync and rewritten in modern code, adding some new features: types, Promise support, and prebuild binaries.

The benefit of this package over synckit, await-sync and others libs is that this runs your code in the current context, so parameters and the return value of your function are no need to be serializable, you are free to use Symbol, functions, and objects with prototypes.

[!WARNING]

Due to uv_run() is not reentrant, functions that poll the event loop and deasynced functions only work at the top level, and calling them from asynchronous callbacks can lead to deadlocks.

Installation

1npm install @kaciras/deasync

DeAsync downloads prebuild binary from GitHub releases during installation, if download fails, try to build locally. You can skip the install phase by setting the environment variable NO_PREBUILD=1.

DeAsync uses node-gyp to compile C++ source code, so to build Deasync you may need the compilers listed in node-gyp.

Usage

`deasync(function)`

Generic wrapper of async function with conventional API signature function(...args, (error, result) => {}). Returns result and throws error as exception if not null.

Sleep (a wrapper of setTimeout):

1const { deasync } = require("@kaciras/deasync");
2
3const sleep = deasync((timeout, callback) => {
4	setTimeout(() => callback(null, "wake up!"), timeout);
5});
6
7console.log("Timestamp before: " + performance.now());
8console.log(sleep(1000));
9console.log("Timestamp after: " + performance.now());

`awaitSync(promise)`

Similar with the keyword await but synchronously.

1const { awaitSync } = require("@kaciras/deasync");
2
3const promise = new Promise(resolve => setTimeout(resolve, 1000)).then(() => "wake up!")
4
5console.log("Timestamp before: " + performance.now());
6console.log(awaitSync(promise));
7console.log("Timestamp after: " + performance.now());

`uvRun()`

Run pending callbacks of macro tasks in the event loop.

1const { uvRun } = require("@kaciras/deasync");
2
3let called = false;
4setImmediate(() => called = true);
5
6uvRun();
7console.log(`Called is ${called}`); // Called is true

`runLoopOnce()`

Run micro task callbacks until the queue has been exhausted, then run pending callbacks of macro tasks.

If a new micro task callback enqueued when executing another, it will also be executed.
Callbacks enqueued in macro task callback will not be executed.

`loopWhile(predicate)`

For async function with unconventional API, for instance function asyncFunction(p1,function cb(res){}), use loopWhile(predicateFunc) where predicateFunc is a function that returns boolean loop condition.

1let done = false;
2let data;
3asyncFunction(p1, res => {
4	data = res;
5	done = true;
6});
7require('deasync').loopWhile(() => !done);
8// data is now populated

Recommendation

DeAsync changes code execution sequence and the task scheduling, which typically degrades performance. The primary use case for DeAsync is compatibility with legacy code that does not support asynchronous. If all you are facing is syntactic problem such as callback hell, using a less drastic package implemented in pure js is recommended.

No vulnerabilities found.

10

Maintained

Determines if the project is "actively maintained".

10

Dangerous-Workflow

Determines if the project's GitHub Action workflows avoid dangerous patterns.

10

Binary-Artifacts

Determines if the project has generated executable (binary) artifacts in the source repository.

10

License

Determines if the project has defined a license.

8

Vulnerabilities

Determines if the project has open, known unfixed vulnerabilities.

0

Code-Review

Determines if the project requires human code review before pull requests (aka merge requests) are merged.

0

SAST

Determines if the project uses static code analysis.

0

Pinned-Dependencies

Determines if the project has declared and pinned the dependencies of its build process.

0

Token-Permissions

Determines if the project's workflows follow the principle of least privilege.

0

CII-Best-Practices

Determines if the project has an OpenSSF (formerly CII) Best Practices Badge.

0

Fuzzing

Determines if the project uses fuzzing.

0

Security-Policy

Determines if the project has published a security policy.

0

Signed-Releases

Determines if the project cryptographically signs release artifacts.

0

Branch-Protection

Determines if the default and release branches are protected with GitHub's branch protection settings.

Score

3.8

/10

Last Scanned on 2024-11-25

The Open Source Security Foundation is a cross-industry collaboration to improve the security of open source software (OSS). The Scorecard provides security health metrics for open source projects.

Learn More