A collection of F(unctional) Util(ities). Resistance is futile.
Mostly, these are generic utilities that could conceivably be part of a library like lodash/fp, but for some reason or other are not.
See our changelog
npm i -S futil-js
This package requires lodash/fp, so make sure that's available in your app.
(fn, a, b) -> fn(a, b) If fn is a function, call the function with the passed-in arguments. Otherwise, return false.
([f, g]) -> !f(x) && !g(x) Creates a function that checks if none of the predicates return truthy when invoked with the arguments it receives.
...fns:functions -> map:function Runs a map function that runs a flow of the functions passed in to this method.
These are conversions of lodash fp methods.
getIn, includesIn, pickIn
lodash/fp is great, but sometimes the curry order isn't exactly what you want.
These methods provide alternative orderings that are sometimes more convenient.
The idea of In methods is to name them by convention, so when ever you need a method that actually takes the collection first (e.g. a get where the data is static but the field is dynamic), you can just add In to the end (such as getIn which takes the object first)
extendOn, defaultsOn
lodash/fp likes to keep things pure, but sometimes JS can get pretty dirty.
These methods are alternatives for working with data that--for whatever the use case is--needs to be mutable
Any methods that interact with mutable data will use the On convention (as it is some action occuring On some data)
join:string -> data:array -> result:string Joins an array after compacting.
data:array -> result:string Compacts and joins an array with '.'
data:array -> result:array Returns an array of elements that are repeated in the array.
(k, v) -> {k: v} Creates an object with a key and value.
(v, k) -> {k: v} Flipped version of singleObject.
({a, b}) -> [{a}, {b}] Breaks an object into an array of objects with one key each.
Remove properties with falsey values.
Example: ({ a: 1, b: null, c: false }) -> {a:1}
Check if the variable is an empty object ({}).
Check if the variable is not an empty object ({}).
Omit properties whose values are empty objects.
Example: { a:1, b:{}, c:2 } -> {a:1, c:2}
(TODO remame to omitEmptyObjects)
Checks if an object's property is equal to a value.
Returns true if object keys are only elements from signature list. (but does not require all signature keys to be present)
TODO
from:string -> to:string: -> target:object -> result:object
Rename a property on an object.
Example: renameProperty('a', 'b', {a:1}) -> {b:1)
Just like mongo's $unwind.
Example: { x:['a','b'], y:1 } -> [{ x:'a', y:1 }, { x:'b', y:1 }]
Flatten an object with the paths for keys.
Example: { a: { b: { c: 1 } } } => { 'a.b.c' : 1 }.
'asdf' -> '(asdf)' Wraps a string in parenthesis.
regex -> string -> bool Just like rambda test, creates a function to test a regex on a string.
number -> bool Returns true if number is greater than one.