lie

What is lie?

The 'lie' npm package is a lightweight, performant promise library implementing the Promises/A+ specification. It provides a simple way to work with asynchronous operations in JavaScript, allowing developers to create, manage, and compose promises for better asynchronous flow control.

What are lie's main functionalities?

Creating a new promise

This feature allows you to create a new promise. The constructor takes a function that contains the asynchronous operation. The function provides two arguments, resolve and reject, which are used to settle the promise.

var Promise = require('lie');
var myPromise = new Promise(function (resolve, reject) {
  // Asynchronous operation here
  if (/* operation successful */) {
    resolve('Success!');
  } else {
    reject('Failure!');
  }
});

Promise resolution

This feature is used to create a promise that is immediately resolved with a given value. It's useful for converting values to promises.

var Promise = require('lie');
Promise.resolve('Immediate resolve').then(function (value) {
  console.log(value); // 'Immediate resolve'
});

Promise rejection

This feature is used to create a promise that is immediately rejected with a given reason. It's useful for representing asynchronous operations that have failed.

var Promise = require('lie');
Promise.reject(new Error('Immediate reject')).catch(function (error) {
  console.error(error); // Error: 'Immediate reject'
});

Chaining promises

This feature allows you to chain multiple promises together and perform actions once all of them are settled. The Promise.all method returns a single promise that resolves when all of the promises in the iterable argument have resolved.

var Promise = require('lie');
var p1 = Promise.resolve(3);
var p2 = 1337;
var p3 = new Promise(function (resolve, reject) {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([p1, p2, p3]).then(function (values) {
  console.log(values); // [3, 1337, 'foo']
});

Other packages similar to lie

bluebird

Bluebird is a full-featured promise library with a focus on innovative features and performance. It is often considered one of the fastest promise libraries and includes additional utilities for concurrency, filtering, mapping, and more. Compared to 'lie', Bluebird is more feature-rich but also larger in size.

q

Q is one of the earliest promise libraries that implements the Promises/A+ specification. It provides a robust set of features for creating and managing promises. While 'lie' focuses on minimalism and performance, Q offers a wider API surface and additional features like progress notifications for long-running asynchronous operations.

es6-promise

The es6-promise library is a polyfill for the ES6 Promise specification. It aims to provide a lightweight and efficient implementation of promises for environments that do not natively support them. Compared to 'lie', es6-promise is more about compatibility with the ES6 standard, while 'lie' is a standalone implementation with a focus on being lightweight.

README

lie

[](https://travis-ci.org/calvinmetcalf/lie)

lie a small, performant, promise library implementing the Promises/A+ spec Version 1.1.

A originally a fork of Ruben Verborgh's library called promiscuous, version 2.6 and above are forked from ayepromise by Chris Burgmer.

npm install lie

var Promise = require('lie');
// or use the pollyfill
require('lie/polyfill');

Usage

Either use it with browserify (recommended) or grab one of the files from the dist folder

• lie.js/lie.min.js makes 'Promise' available in global scope (or since it's a UMD Promise will be available through a CJS or AMD loader if it's available instead)
• lie.polyfill.js/lie.polyfill.min.js adds 'Promise' to the global scope only if it's not already defined (not a UMD).

API

Implements the standard ES6 api,

new Promise(function(resolve, reject){
    doSomething(function(err, result) {
        if (err) {
            reject(err);
        } else {
            resolve(result);
        }
    });
}).then(function (value) {
    //on success
}, function (reason) {
    //on error
}).catch(function (reason) {
    //shortcut for error handling
});

Promise.all([
    //array of promises or values
]).then(function ([/* array of results */]));

Promise.race([
    //array of promises or values
]);
// either resolves or rejects depending on the first value to do so

Unhandled Rejections

In node lie emits unhandledRejection events when promises are not handled in line with how iojs does so meaning it can act as promise shim in node as well as the browser.