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.

API

by default adds a function called 'Promise' to the global scope (or if you grab the noConflict version than one called Lie)

return a promise

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) {
    //short cut for error handling
});

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

##node

install with npm install lie, exactly the same as above but

var promise = require('lie');