werkstatt v1.25.0

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

Arguments

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

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

Arguments

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

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

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

NOTE: currently it only supports two numbers as paremeters.

Arguments

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

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

Arguments

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

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

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

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

Arguments

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

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

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

Arguments

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

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

Arguments

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

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

Arguments

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

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

Arguments

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

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

Arguments

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

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

Arguments

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

truncate(123.4567); // -> 123

Arguments

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

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

Float

Arguments

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

roundUp(3.2); // -> 4

Arguments

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

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

Arguments

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

roundDown(3.8); // -> 3

Arguments

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

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

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

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

Arguments

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.

Arguments

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

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

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

Arguments

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

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

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

NOTE: this is an implementation of quicksort algorithm

Arguments

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

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

Arguments

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

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

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

Arguments

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

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

Arguments

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

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

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

Arguments

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

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

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

Arguments

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

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

Arguments

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

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

Arguments

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

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

Arguments

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

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

Object

Arguments

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

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

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

isObject(obj1); // -> true

Other

Arguments

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

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

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

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

Arguments

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

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

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

Arguments

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

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

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

Arguments

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

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

Arguments

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

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

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 🥳