hybridables/then-got

Stars
1
Language
JavaScript
License
MIT License
Created almost 10 years ago
Updated almost 8 years ago

hybridables/then-got

hybridables

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Promisified `simple-get`.

always-done

🏆 Handle completion and errors with elegance! Support for async/await, promises, callbacks, streams and observables. A drop-in replacement for async-done - pass 100% of its tests plus more

try-catch-core

Asynchronous and sync tryCatch in one place - works almost like `async-done`, used in `always-done`. The callback is securely wrapped with a `dezalgo` and `once`.

hybridify

Hybridify@2. Create sync or async function to support both promise and callback-style APIs in same time. Using the power of `relike`.

always-callback

💋 Create callback api for given sync function. Guarantee that given function (sync or async, no matter) will always have callback api.

try-catch-callback

try/catch block with a callback, used in `try-catch-core`. Use it when you don't care about asyncness so much and don't want guarantees. If you care use `try-catch-core`.

benz

Compose your control flow with absolute elegance. Support async/await, callbacks, thunks, generators, promises, observables, child processes and streams. Can power applications that need to have plugins. Useful for creating task, test and bench runners. Built with backward compatibility and future stability in mind.

make-callback

Make synchronous function or generator to support callback api

handle-arguments

Get separately non-callback arguments in `.arguments` and the last argument if it `is-callback-function` in `.callback` property. It also works like `sliced`, but returns object with `.arguments` and `.callback` properties.

always-promise

Promisify, basically, everything. Generator function, callback-style or synchronous function; sync function that returns child process, stream or observable; directly passed promise, stream or child process.

letta

#asyncfirst 🐈 Promisify sync, async or generator function, using relike. Kind of promisify, but lower level. Full compatibility with co4 and passing 100% of its tests.

relike-value

Create promise from sync, async, string, number, array and so on. Handle completion (results) and errors gracefully! Built on top of `relike`, used by `redolent` to build robust (hybrid) APIs.

callback2stream

Transform sync, async or generator function to Stream. Correctly handle errors and optional arguments.

always-generator

Generatorify, basically, everything. You can create generator function from callback-style or synchronous function; sync function that returns child process, stream or observable; directly passed promise, stream or child process.

value2stream

Transform any value to stream. Create stream from any value - string, array, buffer, number, promise or even Error object.

handle-callback

Make promise to have support for callback API, it returns promise in that same time.

always-stream

Create stream from any value - function, array, string, buffer, promise, number, object and etc. Always returns a function that returns Transform Stream, using through2.

redolent

Simple promisify with sane defaults, works on node 0.10 if you provide custom Promise through options

relike-all

Promisify all functions in an object, using `relike`.

promise2stream

Transform ES2015 Promise to Stream - specifically, Transform Stream using `through2`. Works in object mode by default, but you can pass options directly to the `through2` package.

hybridify-all

Hybridifies all the selected functions in an object.

promise2thunk

Convert (transform) promise to thunk, just like was in co@3

thunk2promise

Transform or convert thunk to Bluebird Promise, just like in co@4

relike

#asyncfirst ⭐ Simple promisify async or sync function with sane defaults. Lower level than `promisify` thing.

handle-observable

Handle completion of an observable, using observable's `.subscribe` method.

handle-errors

Handling/creating hybrid errors, if callback pass to it else throw

voala

WIP. Ultimate, feature-rich, minimal and stable testing framework for the future. ES2015-ready.

exec-cmd

Flexible and cross-platform executing commands. Hybrid, Async and Promise API.

merz

Wrapper to handle completion and errors of sync and async functions, promises, generators, streams, observables and child processes.

vez

Middleware composition at new level. Ultimate alternative to `ware`, `plugins`, `koa-compose` and `composition` packages. Allows you to use callbacks, promises, generators and async/await functions as middlewares.

always-thunk

Thunkify, basically, everything. Generator function, callback-style or synchronous function; sync function that returns child process, stream or observable; directly passed promise, stream or child process.

letta-callback

Just `letta` with good old callback-style api. Accepts sync, async, generators and generator functions.

meta

Logo license and `hybridables` organization discussion.

handle-stream

Handle completion of a stream, using `on-stream-end` and `stream-exhaust`.

create-callback

Create callback api from synchronous function. Same as `make-callback`, but won't handle generators and if async function is given returns it.

then-callback

Wrap a promise to allow passing callback to `.then` of given promise, also works as normal `.then`

is-hybrid

Check whether an object looks like Hybrid which is promises-a+ promise and callback api

voa

Acts like `co@4` and also is drop-in replacement for it (pass 100% of the tests). Built on top of `merz`, actually thanks to `always-done`. But accept everything, not only generators - sync functions, async functions, callbacks and more. Flow-control for now and then.

letta-value

Extends `letta` to accept and handles more than functions only. Handles all kind of results from `letta`/promise. Basically, creating promise from everything - strings, arrays, objects, functions, generators, generator functions, promises, streams, child processes, observables, maps, symbols, dates and etc.

coone

Acts like `co@3` and also is drop-in replacement for it. Built on top of `merz`, actually thanks to `always-done`. But accept everything, not only generators - sync functions, async functions, callbacks and more. Flow-control for now and then.