hybridables/exec-cmd

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

hybridables/exec-cmd

hybridables

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

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

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.

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.

then-got

Promisified `simple-get`.

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.