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

lie is a JavaScript promise/deferred implementation, implementing the Promises/A+ spec.

A fork of Ruben Verborgh's library called promiscuous. Which takes advantage of setImmediate if available, uses object cunstructors, and that I can actually consistently spell.

To use grab a copy from the dist folder, we offer both production (minfied) and development (readable) builds as well as a version that bundles a very good setImmediate shim in with it (set Immediate === much much faster promises).

API

by defailt adds 3 function to the global scope

return a promise

function waitAwhile
	var def = deferred();

	setTimeout(function(){
		def.resolve('DONE!');
	},10000);//resolve it in 10 secons

	return def.promise//return the promise
}

Create a resolved promise

var one = deferred.resolve("one");
one.then(console.log);
/* one */

Create a rejected promise

var none = deferred.reject("error");
none.then(console.log, console.error);
/* error */

Write a function turns node style callback to promises

function denodify(func) {
  return function(){
    var args = Array.prototype.concat.apply([],arguments);
    var def = deferred();
    args.push(function(err,success){
        if(err) {
            def.reject(err);
        } else {
            def.resolve(success);
        }
    });
    function.apply(undefined,args);
    return def.promise;
  }
}

##node

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

var deferred = require('lie');
var resolve = deferred.resolve;
var reject = deferred.reject;