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

<summary>isZero</summary>

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

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

<summary>subtract</summary>

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.

<summary>divide</summary>

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

<summary>isNumber</summary>

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.

<summary>isOdd</summary>

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.

<summary>isEven</summary>

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.

<summary>isNegative</summary>

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

<summary>isGreaterThan</summary>

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

<summary>toFixed</summary>

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'

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

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

<summary>truncate</summary>

Arguments

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

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

truncate(123.4567); // -> 123

<summary>random</summary>

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

<summary>roundUp</summary>

Arguments

argument	type
number	float

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

roundUp(3.2); // -> 4

<summary>round</summary>

Arguments

argument	type
number	float

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

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

<summary>roundDown</summary>

Arguments

argument	type
number	float

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

roundDown(3.8); // -> 3

<summary>isFloat</summary>

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

<summary>capitalizeFirstLetter</summary>

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

<summary>isEmail</summary>

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("a@a.co"); // -> true

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

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

is("a@a.c").email; // -> false
is("a@a.co").email; // -> true

Best regex found out there.

<summary>isString</summary>

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

<summary>slugify</summary>

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

<summary>toString</summary>

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

<summary>isTruthy</summary>

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

<summary>isFalsy</summary>

Exactly the opposite of isTruthy.

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

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

Array

<summary>orderAsc</summary>

Arguments

argument	type	description	returns
value	array<number>	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

<summary>lengthOf</summary>

Arguments

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

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

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

<summary>isLengthOf</summary>

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

<summary>insertAt</summary>

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]

<summary>isArrayOfNumbers</summary>

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

<summary>toArray</summary>

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 ]

<summary>isArray</summary>

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

<summary>uniquifiy</summary>

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" },
]

*/

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]

Arguments

argument	type	description
array	array	Array to be processed

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

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

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

<summary>union</summary>

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']

<summary>intersection</summary>

Arguments

argument	type	description
array	array	Array to be processed

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

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

Object

<summary>mergeDeep</summary>

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

<summary>isObject</summary>

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

<summary>typeOf</summary>

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

<summary>areEqual</summary>

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.

<summary>isUndefined</summary>

Arguments

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

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

isUndefined(); // -> true
isUndefined("a@a.co"); // -> false

<summary>isDefined</summary>

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

<summary>isEmpty</summary>

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.

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

<summary>isNull</summary>

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

<summary>every</summary>

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

<summary>compose</summary>

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

<summary>removeFrom</summary>

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

Fork and clone the repo
Run npm install to install dependencies
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

Make your pull request 🥳

Package detail

readme

Werkstatt

📦 Install

✨ Features

Number

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Float

Arguments

Arguments

Arguments

Arguments

String

Arguments

Arguments

Arguments

Arguments

Arguments

Boolean

Array

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Object

Arguments

Arguments

Other

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

Arguments

🙌🏽 Contribute