Werkstatt

🛠 Useful functions to encapsulate common scenarios.

As described here, is good to encapsulate conditionals to make our code more readable, reusable and avoid ambiguities. Also to avoid potential bugs due to some javascript features are error-prone:

let name = null;
typeof name; // "object"

Clearly, null is not an object. More of that 👉🏼here.

This is then, a package that encapsulates conditionals, but also other util functions.

⚠️ WARNING:

This is also a proof of concept. Some of the functions' names may not make all the sense to you or also may be many breaking changes.

📦 Install

npm

npm install -s werkstatt

yarn

yarn add werkstatt

browser

<script src="https://unpkg.com/werkstatt@1.16.0/dist/index.umd.min.js"></script>

<script>
  const { isEmail, isNull, areEqual } = werkstatt;

  console.log(isEmail("asdf")); // -> false
  console.log(isNull(3)); // -> false
  console.log(areEqual(6, 6, 6, 6)); // -> true
</script>

✨ Features

Number

isZero

Arguments

argument	type	description	returns
value	number	will be tested if it is 0 or not	boolean

const { isZero } = require("werkstatt");

isZero(7); // -> false
isZero(0); // -> true

add

Arguments

argument	type	description	returns
values	number	either an array of numbers or n args	number

const { add } = require("werkstatt");

add(3, 6, 11); // -> 20
const numbers = [1, 2, 3];
add(...numbers); // -> 6

// or just pass the array
add(numbers); // -> 6

subtract

Arguments

argument	type	description	returns
values	number	numbers that will be subtrtacted	number

const { subtract } = require("werkstatt");

subtract(6, 3); // -> 3

NOTE: currently it only supports two numbers as paremeters.

divide

Arguments

argument	type	description	returns
dividend	number	the dividend of the operation	number
divider	number	the divider of the operation	number

const { divide } = require("werkstatt");

divide(100, 2); // -> 50
divide(10, 5); // -> 2

isNumber

Arguments

argument	type	description	returns
value	any	will be tested if it is number or not	boolean

const { isNumber } = require("werkstatt");

isNumber(54); // -> true
isNumber({ hola: "adios" }); // -> false
isNumber([]); // -> false
isNumber(""); // -> false
isNumber(3); // -> true
isNumber(true); // -> false

Or use the .number getter exposed by the is() function.

const { is } = require("werkstatt");

is(54).number; // -> true
is([3]).number; // -> false

NOTE: this is an implementation of is-number package.

isOdd

Arguments

argument	type	description	returns
value	number	will be tested if it is odd number or not	boolean

const { isOdd } = require("werkstatt");

isOdd(7); // -> true
isOdd(4); // -> false

NOTE: this is an implementation of is-odd package.

isEven

Arguments

argument	type	description	returns
value	number	will be tested if it is even number or not	boolean

const { isEven } = require("werkstatt");

isEven(7); // -> false
isEven(4); // -> true

NOTE: this is an implementation of is-even package.

isNegative

Arguments

argument	type	description	returns
value	number	will be tested if it is negative number or not	boolean

const { isNegative } = require("werkstatt");

isNegative(-54); // -> true
isNegative(4); // -> false

isGreaterThan

Arguments

argument	type	description	returns
firstArgument	number	first value to be evaluated	boolean
secondArgument	number	second value to be evaluated	boolean

const { isGreaterThan } = require("werkstatt");

isGreaterThan(100, 50); // -> true
isGreaterThan(1, 50); // -> false

toFixed

Arguments

argument	type	description
value	number	number to convert
precision	number	desired amount of decimals

const { toFixed } = require("werkstatt");

toFixed(3.14, 4); // -> '3.1400'
toFixed(5.1346, 3); // -> '5.135'

min

Arguments

argument	type	description
value	array of numbers or several args	where to look for the lowest value

const { min } = require("werkstatt");

min(264, 736, 223, 979, 124); // -> 124
min([543, 333, 22, 1865, 976]); // -> 22

max

Arguments

argument	type	description
value	array of numbers or several args	where to look for the highest value

const { max } = require("werkstatt");

max(264, 736, 223, 979, 124); // -> 979
max([543, 333, 22, 1865, 976]); // -> 1865

truncate

Arguments

argument	type	description
value	number	float number where decimales will be removed

const { truncate } = require("werkstatt");

truncate(123.4567); // -> 123

random

Arguments

argument	type	description
lower	number	lower number desired
upper	number	upper number desired
precision	number	amount of decimals desired

const { random } = require("werkstatt");

random(5, 10, 2); // -> 9.32

Float

roundUp

Arguments

argument	type
number	float

const { roundUp } = require("werkstatt");

roundUp(3.2); // -> 4

round

Arguments

argument	type
number	float

const { round } = require("werkstatt");

round(5.95); // -> 6
round(5.5); // -> 6
round(5.05); // -> 5

roundDown

Arguments

argument	type
number	float

const { roundDown } = require("werkstatt");

roundDown(3.8); // -> 3

isFloat

Arguments

argument	type	description	returns
value	number, float	will be tested if is or not float	boolean

const { isFloat } = require("werkstatt");

isFloat(6); // -> false
isFloat(6.5); // -> true

Or use the .float getter exposed by the is() function.

const { is } = require("werkstatt");

is(5).float; // -> false
is(6.5).float; // -> true

String

capitalizeFirstLetter

Arguments

argument	type	description	returns
value	string	string to capitalize first letter	string

const { capitalizeFirstLetter } = require("werkstatt");

capitalizeFirstLetter("hola"); // -> 'Hola'
capitalizeFirstLetter("adios"); // -> 'Adios'

NOTE: this is an implementation of a Flavio's function

isEmail

Arguments

argument	type	description	returns
value	string	will be tested if it satisfies an email format	boolean

const { isEmail } = require("werkstatt");

isEmail("a@a.c"); // -> false
isEmail("[e-mail]"); // -> true

Or use the .email getter exposed by the is() function.

const { is } = require("werkstatt");

is("a@a.c").email; // -> false
is("[e-mail]").email; // -> true

Best regex found out there.

isString

Arguments

argument	type	description	returns
value	any	whether or not the value is a string	boolean

const { isString } = require("werkstatt");

isString("Hola"); // -> true
isString([3]); // -> false

Or use the .string getter exposed by the is() function.

const { is } = require("werkstatt");

is("Hola").string; // -> true
is([3]).tring; // -> false

slugify

Arguments

argument	type	description	returns
value	string	string to be slugified	string

const { slufigy } = require("werkstatt");

slufigy("Hola Mundo"); // -> hola-mundo
slufigy("Verbos modales en ingles"); // -> verbos-modales-en-ingles 

toString

Arguments

argument	type	description	returns
value	any	value to be converted to string	string

const { toString } = require("werkstatt");

toString(123); // -> "123"
toString({ greeting: 'hola' }); // -> '{"greeting":"hola"}'

Boolean

isTruthy

Whenever JavaScript expects a boolean value (e.g. for the condition of an if statement), any value can be used. It will be interpreted as either true or false. The following values are interpreted as false:

• undefined, null
• Boolean: false
• Number: -0, NaN
• String: ''

Speaking JavaScript by Alex Rauschmayer

That means that those values tend to to be false. So if you pass as parameter to isTruthy function any of those values, it will return false. All other values are considered true.

const { isTruthy } = require("werkstatt");

isTruthy(3); // -> true
isTruthy({}); // -> true

isTruthy(undefined); // -> false
isTruthy(null); // -> false
isTruthy(false); // -> false
isTruthy(Number("hola")); // -> false
isTruthy(0); // -> false
isTruthy(-0); // -> false
isTruthy(""); // -> false

isFalsy

Exactly the opposite of isTruthy.

const { isFalsy } = require("werkstatt");

isFalsy(3); // -> false
isFalsy(null); // -> true

Array

orderAsc

Arguments

argument	type	description	returns
value	array	will order the list in ascending mode	array (ordened)

const { orderAsc } = require("werkstatt");

orderAsc([8, 10, 6]); // -> [6, 8, 10]

NOTE: this is an implementation of quicksort algorithm

lengthOf

Arguments

argument	type	description	returns
value	array, string, json	length of the passed argument	number

const { lengthOf } = require("werkstatt");

lengthOf([8, 10, 6]); // -> 3

isLengthOf

Arguments

argument	type	description	returns
value	array, string, json	test if the first argument has the desired length (that specified in the second argument)	boolean

const { isLengthOf } = require("werkstatt");

isLengthOf([8, 10, 6], 3); // -> true
isLengthOf("hola", 0); // -> false
isLengthOf({ name: "Jorge", lasName: "Guerra" }, 2); // -> true

Or use the .lengthOf prop exposed by the is() function.

const { is } = require("werkstatt");

is(2).lengthOf([1, 2]); // -> true

insertAt

Arguments

argument	type	description
array	any	where the element will be inserted.
index	any	at which the element will be inserted.
elementToInsert	any	element to insert in the array.

const { insertAt } = require("werkstatt");

insertAt([1, 2, 3], 1, 4); // -> [1, 4, 2, 3]

isArrayOfNumbers

Arguments

argument	type	description	returns
values	number	array to test	boolean

const { isArrayOfNumbers } = require("werkstatt");

isArrayOfNumbers([3, 6, 11, "hola"]); // -> false
isArrayOfNumbers([1, 2, 3]); // -> true

toArray

Arguments

argument	type	description	returns
arrayLikeObject/NodeList	any	object to convert	array

const { toArray } = require("werkstatt");

function testToArray() {
  console.log(arguments); // array like object -> [Arguments] { '0': 1, '1': 2, '2': 3 }
  return toArray(arguments);
}

testToArray(1, 2, 3); // -> [ 1, 2, 3 ]

isArray

Arguments

argument	type	description	returns
value	any	whether or not the value is an array	boolean

const { isArray } = require("werkstatt");

isArray("Hola"); // -> false
isArray([3]); // -> true

uniquifiy

Arguments

argument	type	description	returns
array	array	Array to be processed	array

const { uniquify } = require("werkstatt");

const shoes = [
  { id: 1, name: "nikesb" },
  { id: 1, name: "nikesb" },
  { id: 2, name: "lakai" },
  { id: 2, name: "lakai" },
  { id: 3, name: "etnies" },
];

const unique = uniquify(shoes, (a, b) => a.id === b.id);

/*

[
  { id: 1, name: "nikesb" },
  { id: 2, name: "lakai" },
  { id: 3, name: "etnies" },
]

*/

map

Arguments

argument	type	description
array	array	Array to be processed
transform	func	function to apply to element in the array

const { map } = require("werkstatt");

const numbers = [1, 2, 3];
map(numbers, (x) => x * 2); // -> [2, 4, 6]

last

Arguments

argument	type	description
array	array	Array to be processed

const { last } = require("werkstatt");

const numbers = [1, 2, 3];
last(numbers); // -> [3]

join

Arguments

argument	type	description
array	array	Array to be processed

const { join } = require("werkstatt");

const array = ['a', 'b', 'c'];
join(array); // -> abc
join(array, '-'); // -> a-b-c

union

Arguments

argument	type	description
array	array	Array to be processed

const { union } = require("werkstatt");

union(['a', 'b', 'c'], ['a', 'z', 'x']); // -> ['a', 'b', 'c', 'z', 'x']

intersection

Arguments

argument	type	description
array	array	Array to be processed

const { intersection } = require("werkstatt");

intersection(['a', 'b', 'c'], ['a', 'z', 'x']); // -> ['a']

Object

mergeDeep

Arguments

argument	type
target	object
source	object

const { mergeDeep } = require("werkstatt");

const obj1 = {
  a: 1,
  b: 1,
  c: { x: 1, y: 1 },
  d: [1, 1],
};

const obj2 = {
  b: 2,
  c: { y: 2, z: 2 },
  d: [2, 2],
  e: 2,
};

mergeDeep(obj1, obj2);

/*

{ 
  a: 1, 
  b: 2, 
  c: { x: 1, y: 2, z: 2 }, 
  d: [ 1, 1, 2, 2 ], 
  e: 2 
};
*/

Author: jhildenbiddle

isObject

Arguments

argument	type
obj	any

const { isObject } = require("werkstatt");

const obj1 = {
  a: 1,
  b: 1,
  c: { x: 1, y: 1 },
  d: [1, 1],
};

isObject(obj1); // -> true

Other

typeOf

Arguments

argument	type	description	returns
value	any	will get the type of a passed value	string

const { typeOf } = require("werkstatt");

typeOf(6.5); // -> float
typeOf([]); // -> array
typeOf({}); // -> object
typeOf(null); // -> 'null'
typeOf(undefined); // -> 'undefined'
typeOf("undefined"); // -> 'string'
typeOf(true); // -> 'boolean'
typeOf(() => {}); // -> 'function'
typeOf(6); // -> number

areEqual

Arguments

argument	type	description	returns
n amount	any	args to compare	boolean

const { areEqual } = require("werkstatt");

areEqual(100, 2); // -> false

var name;
areEqual(typeOf(name), "undefined"); // -> true

const numbers = [4, 3, 5, 7, 3, 9];
areEqual(...numbers); // -> false

const ages = [9, 9, 9, 9, 9];
areEqual(...ages); // -> true

NOTE: This function supports primitive values only because objects are not compared by value but by reference.

isUndefined

Arguments

argument	type	description	returns
value	any	will be tested if is undefined or not	boolean

const { isUndefined } = require("werkstatt");

isUndefined(); // -> true
isUndefined("[e-mail]"); // -> false

isDefined

Arguments

argument	type	description	returns
value	any	will be tested if is or not defined	boolean

const { isDefined } = require("werkstatt");

isDefined(100); // -> true
var name;
isDefined(name); // -> false

var age = null;
isDefined(age); // -> false
isDefined({}); // -> true

isEmpty

Arguments

argument	type
param	any

const { isEmpty } = require("werkstatt");

isEmpty({}); // -> true
isEmpty({ hola: "adios" }); // -> false
isEmpty([]); // -> true
isEmpty(""); // -> true
isEmpty(3); // -> true
isEmpty(true); // -> true

Note: isEmpty currently supports array, object and string only.

has

Arguments

argument	type	description	returns
firstArgument	number	first value to be evaluated	boolean
secondArgument	number	second value to be evaluated	boolean

const { has } = require("werkstatt");

has([3, 5], 3); // -> true
has(["Hola", "adios"], "true"); // -> false
has("Jorge", "e"); // -> true

isNull

Arguments

argument	type	description	returns
value	any	value to be evaluated	boolean

const { isNull } = require("werkstatt");

var name = null;
isNull(name); // -> true
isNull("Hola"); // -> false

every

Arguments

argument	type	description	returns
args	array	arguments to match to a specific type	boolean

const { every } = require("werkstatt");

every("adios" === "adios", "hola" === "hola").is.true; // -> true
every("adios", "hola").is.string; // -> true
every(1, 2).is.number; // -> true

compose

Arguments

argument	type	description	returns
fns	array	functions to be executed	function

const { compose } = require("werkstatt");

const h = (n) => n / 2;
const g = (n) => n + 1;
const f = (n) => n * 2;

compose(f, g, h)(20); // -> 22

removeFrom

Arguments

argument	type	description	returns
item	array, object	item on where to remove from	copy of item with props or values removed

const { removeFrom } = require("werkstatt");

const object = {
  name: "Jorge",
  age: 20,
  sex: "M",
};
//  pass an array of props
const props = ["name", "sex"];
const newObject = removeFrom(object, props);

// or one prop as string
const newObject = removeFrom(object, "name");

// pass an array of values
const array = ["red", "blue", "pink"];
const values = ["blue", "red"];
const newArray = removeFrom(array, values);

// or one value as string
const array = ["red", "blue"];
const value = "blue";
const newArray = removeFrom(array, value);

more coming soon ✨

🙌🏽 Contribute

1. Fork and clone the repo
2. Run npm install to install dependencies
3. Create a branch for your PR with git checkout -b your-branch-name

To keep master branch pointing to remote repository and make pull requests from branches on your fork. To do this, run:

git remote add upstream https://github.com/sk8guerra/werkstatt.git
git fetch upstream
git branch --set-upstream-to=upstream/master master

4. Make your pull request 🥳