@z1/preset-task NPM

Z1 Preset Task

Documentation under construction.

A simple wrapper over ramda and other commonly used functions in the @z1 Lib. reduces the dependancy on imports from one component to the next. Javascript operators are as reliable as wikipedia.

Usage

Install

yarn add @z1/preset-task

Import

import { task } from '@z1/preset-task'

Example

const fn = task((t,a) => { /* t = syncFN , a = asyncFN */ })

const channel = task(t => ({
  config: channelList => app => {
    if (t.notType(app.channel, 'Function')) {
      // If no real-time functionality has been configured
      // just return
      return null
    }
    if (t.isZeroLen(channelList)) {
      defaultChannelConfig(app)
    } else {
      t.forEach(channel => {
        channel(app)
      }, channelList || [])
    }
  },
}))

Top level functions

Sync

fn	custom fn	usage	docs
at		t.at(pathAt, object)	at
atOr		t.atOr(fallback, pathAt, object)	atOr
addIndex		t.addIndex((value, index) => {}, object)	addIndex
adjust		t.adjust(index, R.toUpper, list)	adjust
and		t.any(a → Boolean, b → Boolean)	and
anyOf	:heavy_check_mark:	t.anyOf(a → Boolean, b → Boolean, ...)	anyOf
allOf	:heavy_check_mark:	t.allOf(a → Boolean, b → Boolean, ...)	allOf
append		t.append(object, object)	append
compose		t.compose(t.toUpper ,(a => `${a}`)))	compose
concat		t.concat(object, object)	concat
dropLast		t.dropLast(n, array/string )	dropLast
endsWith		t.endWith(object, listOfObjects)	endsWith
equals		t.equals(object, object)	equals
eq	:heavy_check_mark:	t.eq(object, object)	shorthand for equals
neq	:heavy_check_mark:	t.neq(object, object)	pipe(equals, not)
filter		t.filter(fn, list)	filter
find		t.find(fn, list)	find
findIndex		t.findIndex(fn, list)	findIndex
flatten		t.flatten([replaced, remainder, toAdd])	flatten
forEach		t.forEach(fn, object)	forEach
forEachObjIndexed		t.forEachObjIndexed((value, key), object)	forEachObjIndexed
fromPairs		t.fromPairs(objectOfPairs)	fromPairs
groupBy		t.groupBy(fn)	groupBy
gt		t.gt(a-> int/string, b-> int/string)	gt
gte		t.gte(a-> int/string, b-> int/string)	gte
has		t.has(key)({ key: value })	has
hasIn		t.hasIn(prop, object)	hasIn
head		t.head(list/string)	head
includes		t.includes(object, list/string)	includes
isEmpty		t.isEmpty(object/list)	isEmpty
notEmpty		t.notEmpty(object/list)	pipe(isEmpty, not)
isNil		t.isNil(value)	isNil
notNil		t.notNil(value)	pipe(isNil, not)
keys		t.keys(object)	keys
keysIn		t.keysIn(object)	keysIn
last		t.last(list/string)	last
length		t.length(list/string)	length
len		t.len(list/string)	shorthand for `length`
lt		t.lt(a → int/string, b → int/string)	lt
lte		t.lte(a → int/string, b → int/string)	lte
map		t.map(fn, list)	map
mapIndexed	:heavy_check_mark:	t.mapIndex((value, index) => {}, list)	addIndex(map)
mapObjIndexed		t.mapObjIndexed(fn, list)	mapObjIndexed
merge		t.merge(object/list, object/list)	merge
mergeAll		t.mergeAll(object/list, object/list)	mergeAll
mergeDeepRight		t.mergeDeepRight(object/list, object/list)	mergeDeepRight
not		t.not(boolean)	not
omit		t.omit(keyA,keyB, list/object)	omit
or		t.or(a → Boolean, b → Boolean, ...)	or
path		t.path(key, ..., object)	path
pathOr		t.pathOr(fallback, key, ..., object)	pathOr
pick		t.pick(keys, object)	pick
pipe		t.pipe(fn,fn,...)	pipe
pluck		t.pluck(prop)	pluck
prepend		t.prepend(item, object)	prepend
prop		t.prop(key, object/list)	prop
range		t.range(from, to)	range
reduce		t.reduce(fn, object, list)	reduce
repeat		t.repeat(object/list/string, x)	repeat
replace		t.replace(toReplace, replceWith, string)	replace
sort		t.sort((a,b) => a - b)	sort
sortBy		t.sortBy(t.prop(0))	sortBy
sortWith		t.sortWith(fn, fn, ...)	sortWith
descend		t.sort(t.descend(t.Prop(0)), list)	descend
ascend		t.sort(t.ascend(t.Prop(0)), list)	ascend
reverse		t.reverse(list/string)	reverse
split		t.split(toSplitOn, string)	split
startsWith		t.startsWith(string,string)	startsWith
slice		t.slice(fromIndex(inclusive), toIndex(exclusive), string, string)	split
sum		t.sum(list)	sum
tail		t.tail(list)	tail
take		t.take(number, list)	take
takeLast		t.takeLast(number, list)	takeLast
toPairs		t.toPairs(object)	toPairs
toString		t.toString(number/object/list)	toString
trim		t.trim(string)	trim
tryCatch		t.tryCatch(fn, fn)	tryCatch
type		t.type(*)	type
update		t.update(index, value, list)	update
uniq		t.uniq(list)	uniq
values		t.values(object)	values
isType	:heavy_check_mark:	t.isType(object, string)	equals(toLower(rType(subject)), toLower(matcher))
ofType	:heavy_check_mark:	t.ofType(matcher, subject)	ofType
notType	:heavy_check_mark:	t.notType(fn,'Object')	(subject, typeKey) => not(isType(subject, typeKey))
when		t.when(a → Boolean, fn)	when
isZeroLen	:heavy_check_mark:	t.isZeroLen(list/string)	isZeroLen
notZeroLen	:heavy_check_mark:	t.notZeroLen(])	pipe(isZeroLen, not)
noLen	:heavy_check_mark:	t.noLen(list/string)	`isZeroLen`
hasLen	:heavy_check_mark:	t.hasLen(list/string)	`notZeroLen`
valPipe	:heavy_check_mark:	t.valPipe	val => (...args) => pipe(...args)(val)
vPipe	:heavy_check_mark:	t.vPipe	valPipe
runMatch	:heavy_check_mark:	t.runMatch()	runMatch
getMatch	:heavy_check_mark:	t.getMatch(prop.match)(match)	getMatch
match	:heavy_check_mark:		match
to		t.to.fn(string)	to
caseTo		t.caseTo(string)	Same as above `to` fn
html		t.html(string)	html
safeHtml		t.safeHtml(string)	safeHtml
oneLine		t.oneLine(`multiline string`)	oneLine
oneLineTrim		t.oneLineTrim(`multiline string`)	oneLineTrim
stripIndent		t.stripIndent(string)	stripIndent
stripIndents		t.stripIndents(string)	stripIndents
inlineLists		t.lineLists(string)	inlineLists
oneLineInlineLists		t.oneLineInlineLists(list)	oneLineInlineLists
commaLists		t.commaLists(list)	commaLists
oneLineCommaLists		t.oneLineCommaLists(list)	oneLineCommaLists
globrex		t.globrex(pattern).regex.test(string)	globrex
throttle		t.throttle(fn, number options={})	throttle
trampoline	:heavy_check_mark:	t.trampoline(async function rollup(props){})	trampoline

async

fn	custom fn	usage	docs
event	:heavy_check_mark:	a.event(server, 'listen')	Waits for `emitter` to emit an `eventName` event.
callback	:heavy_check_mark:	a.callback(fs.readFile, 'foo.txt')	Calls a function `func` that takes arguments `args` and an `(err, result)` callback. Waits for the callback result, throwing an Error if err is truthy.
awaited	:heavy_check_mark:	a.awaited(fs.readFile)	Wraps a node style function (see `callback`) into a new function, which instead of taking a callback function, returns an async function (`Promise`). This `Promise` resolves if the first (error) argument of the callback was called with a falsy value, rejects with the error otherwise. Takes the rest of the arguments as the original function `fn`.
single	:heavy_check_mark:	a.single( fetch(remoteFile), read(localFile) )	Waits for the first Promise in `list` to resolve.
set	:heavy_check_mark:	a.set(fn, fn,...,, count)	Waits for the first `count` Promises in `list` to resolve.
list	:heavy_check_mark:	a.list(fn, fn, ...	Waits for all Promises in `list` to resolve.
object	:heavy_check_mark:	a.object({container: fn, foo: fn, bar: fn, ...})	Waits for all Promises in the keys of `container` to resolve.
map	:heavy_check_mark:	a.map(list, concurrency, fn)	Passes each item in `list` to the Promise-returning function `fn`, running at most `concurrency` simultaneous promises.
failure	:heavy_check_mark:	a.failure(promise)	Waits for `promise` to reject, returning the Error object. If `promise` resolves successfully, returns `undefined`.
success	:heavy_check_mark:	a.success(promise)	Waits for the value of `promise`. If `promise` throws an Error, returns `undefined`.
result	:heavy_check_mark:	a.result(promise)	Waits for `promise` to resolve or reject. Returns either the resolved value, or the Error object.
of	:heavy_check_mark:		Waits for `promise` to resolve or reject. Returns either the resolved value, or the Error object.