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/[email protected]/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

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

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.

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

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.

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.

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.

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

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

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

Arguments

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

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

truncate(123.4567); // -> 123

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

Arguments

| argument | type | | -------- | ----- | | number | float |

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

roundUp(3.2); // -> 4

Arguments

| argument | type | | -------- | ----- | | number | float |

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

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

Arguments

| argument | type | | -------- | ----- | | number | float |

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

roundDown(3.8); // -> 3

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

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

Arguments

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

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

isEmail("[email protected]"); // -> false
isEmail("[email protected]"); // -> true

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

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

is("[email protected]").email; // -> false
is("[email protected]").email; // -> true

Best regex found out there.

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

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 

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

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

Exactly the opposite of isTruthy.

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

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

Array

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

Arguments

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

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

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

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

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]

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

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 ]

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

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

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

Arguments

| argument | type | description | | --------- | ----- | ----------------------------------------- | | array | array | Array to be processed |

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

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

Object

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

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

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

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.

Arguments

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

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

isUndefined(); // -> true
isUndefined("[email protected]"); // -> false

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

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

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

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

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

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 🥳