Utils library

Description

This library contains useful functions you may need in your developments.

Installation

npm i -S @bonjourjohn/utils

Usage

const Utils = require("@bonjourjohn/utils");

Maths functions

getRandomInt(min, max)

Returns a random number between min and max.

const randomInt = Utils.Maths.getRandomInt(0, 100);

factorial(n)

Returns the result of n factorial: n!

Utils.Maths.factorial(3); //6
Utils.Maths.factorial(4); //24

getAllCombinations(segments)

Build and return all possible combinations using elements of the given array.

const combinations = Utils.Maths.getAllCombinations(["a", "b"]);
console.log(combinations);
/**
["ab", "ba"]
**/

const combinations = Utils.Maths.getAllCombinations(["a", "b", "c"]);
console.log(combinations);
/**
[
  "abc",
  "acb",
  "bac",
  "bca",
  "cab",
  "cba"
]
**/

const combinations = Utils.Maths.getAllCombinations(["a", "b", "c", "d"]);
console.log(combinations);
/**
[
  "abcd",
  "abdc",
  "acbd",
  "acdb",
  "adbc",
  "adcb",
  "bacd",
  "badc",
  "bcad",
  "bcda",
  "bdac",
  "bdca",
  "cabd",
  "cadb",
  "cbad",
  "cbda",
  "cdab",
  "cdba",
  "dabc",
  "dacb",
  "dbac",
  "dbca",
  "dcab",
  "dcba"
]
**/

getAllDistributions(segments, nDimensions)

Returns all distributions of given segments in nDimensions.

Utils.Maths.getAllDistributions(["a", "b"], 2);
/** Returns
[ [ [ 'a', 'b' ], [] ],
  [ [ 'a' ], [ 'b' ] ],
  [ [ 'b' ], [ 'a' ] ],
  [ [], [ 'a', 'b' ] ] ]
**/

Utils.Maths.getAllDistributions(["a", "b"], 3);
/** Returns
[ [ [ 'a', 'b' ], [], [] ],
  [ [ 'a' ], [ 'b' ], [] ],
  [ [ 'a' ], [], [ 'b' ] ],
  [ [ 'b' ], [ 'a' ], [] ],
  [ [], [ 'a', 'b' ], [] ],
  [ [], [ 'a' ], [ 'b' ] ],
  [ [ 'b' ], [], [ 'a' ] ],
  [ [], [ 'b' ], [ 'a' ] ],
  [ [], [], [ 'a', 'b' ] ] ]
**/

Utils.Maths.getAllDistributions(["a", "b", "c", "d"], 2);
/** Returns
[ [ [ 'a', 'b', 'c', 'd' ], [] ],
  [ [ 'a', 'b', 'c' ], [ 'd' ] ],
  [ [ 'a', 'b', 'd' ], [ 'c' ] ],
  [ [ 'a', 'b' ], [ 'c', 'd' ] ],
  [ [ 'a', 'c', 'd' ], [ 'b' ] ],
  [ [ 'a', 'c' ], [ 'b', 'd' ] ],
  [ [ 'a', 'd' ], [ 'b', 'c' ] ],
  [ [ 'a' ], [ 'b', 'c', 'd' ] ],
  [ [ 'b', 'c', 'd' ], [ 'a' ] ],
  [ [ 'b', 'c' ], [ 'a', 'd' ] ],
  [ [ 'b', 'd' ], [ 'a', 'c' ] ],
  [ [ 'b' ], [ 'a', 'c', 'd' ] ],
  [ [ 'c', 'd' ], [ 'a', 'b' ] ],
  [ [ 'c' ], [ 'a', 'b', 'd' ] ],
  [ [ 'd' ], [ 'a', 'b', 'c' ] ],
  [ [], [ 'a', 'b', 'c', 'd' ] ] ]
**/

cartesianProductArray(array1, array2)

Returns an array containing all combinations from the cartesian product of values in array1 and array2. Values have to be in sub arrays.

const array1 = [["a"], ["b"], ["1"], ["2"]];
const array2 = [["c"], ["d"], ["3"], ["4"]];

Utils.Maths.cartesianProductArray(array1, array2);
/** returns
[ [ 'ac' ],
  [ 'ad' ],
  [ 'a3' ],
  [ 'a4' ],
  [ 'bc' ],
  [ 'bd' ],
  [ 'b3' ],
  [ 'b4' ],
  [ '1c' ],
  [ '1d' ],
  [ '13' ],
  [ '14' ],
  [ '2c' ],
  [ '2d' ],
  [ '23' ],
  [ '24' ] ]
**/

cartesianProductLine(line1, line2)

Returns the cartesian product between two arrays of values having the same length.

const line1 = ["a"];
const line2 = ["c"];
Utils.Maths.cartesianProductLine(line1, line2);
/** Returns
[ 'ac' ]
**/

const line1 = ["a", "b"];
const line2 = ["c", "d"];
Utils.Maths.cartesianProductLine(line1, line2);
/** Returns
[ 'ac' , 'bd' ]
**/

String functions

getRandomString([length])

Returns a string of length length or 12 by default, composed by characters randomly picked into this chars collection: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

Utils.Strings.getRandomString(5); //produce a random string of length 5
Utils.Strings.getRandomString(); //produce a random string of length 12

safeFilename(unsafeFilename)

Removes special chars and spaces to return a sanitized filename.

Utils.Strings.safeFilename("I'm not safe nor gentle.ext"); //im-not-safe-nor-gentle.ext

Objects functions

isEmpty(element)

Returns true if element is considered empty, false otherwise.

Is considered empty:

emtpy strings """
empty arrays []
empty objects {}
null
undefined
arrays containing only empty values as listed above
objects containing only empty values as listed above

Utils.Objects.isEmpty(""); //true
Utils.Objects.isEmpty([]); //true
Utils.Objects.isEmpty({}); //true
Utils.Objects.isEmpty(null); //true
let undefinedVar;
Utils.Objects.isEmpty(undefinedVar); //true
Utils.Objects.isEmpty([""]); //true
Utils.Objects.isEmpty([{}]); //true
Utils.Objects.isEmpty([[]]); //true
Utils.Objects.isEmpty([null]); //true
Utils.Objects.isEmpty(["", {}, [], null]); //true
Utils.Objects.isEmpty({"a": ""}); //true
Utils.Objects.isEmpty({"a": {}}); //true
Utils.Objects.isEmpty({"a": []}); //true
Utils.Objects.isEmpty({"a": {}}); //true

hasProperty(object, path)

Returns true if object has a value existing at path, false otherwise.

Utils.Objects.hasProperty({"first": {"second": "value"}}, "first.second"); //returns true
Utils.Objects.hasProperty({"first": {"second": "value"}}, "first.third"); //returns false

hasProperties(object, paths)

Return true if object has values existing at all paths, false otherwise.

const witness = {
  "first": {
    "second": "value",
    "third": "value"
  },
  "fourth": "be with you"
};

Utils.Objects.hasProperties(witness, ["first.second", "first.third", "fourth"]); //returns true

getValueAt(object, path)

Returns the value found in object at path if it exists, null otherwise.

const witness = {
  "first": {
    "second": "value",
    "third": "value"
  },
  "fourth": "be with you"
};

Utils.Objects.getValueAt(witness, "first.second"); //returns "value"
Utils.Objects.getValueAt(witness, "first.fourth"); //returns null

setValueAt(object, value, path)

Set the value value at path path in object. Creates the path if necessary.

const witness = {
  "first": {
    "second": "value"
  }
};

Utils.Objects.setValueAt(witness, "bar", "first.foo");
console.log(witness);
/**
{
  "first": {
    "second": "value",
    "foo": "bar"
  }
}
**/

keepProperties(object, paths, [output])

Remove all properties from object except the given ones in paths. Returns new object or set result in output if given.

const witness = {
  "have": {
    "a": {
      "lot": "of",
      "extra": "values"
    },
    "and": {
      "I": "want"
    }
  },
  "to": {
    "get": "rid",
    "of": "them"
  }
};

let afterClean = {};

Utils.Objects.keepProperties(witness, ["have.a"], afterClean);

console.log(afterClean);
/**
{
  "have": {
    "a": {
      "lot": "of",
      "extra": "values"
    }
  }
}
**/

const otherClean = Utils.keepProperties(witness, ["have.a.lot", "have.and", "to.of"]);
console.log(otherClean);
/**
{
  "have": {
    "a": {
      "lot": "of"
    },
    "and": {
      "I": "want"
    }
  },
  "to": {
    "of": "them"
  }
}
**/

removeEmptyProperties(object)

Removes all empty properties from object. Empty follows the same definition as in isEmpty function.

const witness = {
  "foo": "bar",
  "bar": "",
  "baz": {
    "foo": "",
    "bar": {},
    "john": "bonjour"
  }
};

Utils.Objects.removeEmptyProperties(witness);
console.log(witness);
/**
{
  "foo": "bar",
  "baz": {
    "john": "bonjour"
  }
}
**/

isConstructor(obj)

Returns true if obj is a conscructor, false otherwise.

Utils.Objects.isConstructor(String); //true
Utils.Objects.isConstructor(Boolean); //true
Utils.Objects.isConstructor(Number); //true
Utils.Objects.isConstructor(Array); //true
Utils.Objects.isConstructor(Object); //true
Utils.Objects.isConstructor("Number"); //false
Utils.Objects.isConstructor(14); //false

inspectSchema(schema)

Inspect given schema and throw an error if it's not valid. Not valid = somewhere in the object a value is not a consctructor (and so is not a type)

Arrays must have a length of 1 contain valid sub schema or constructor. Sub objects must be valid.

//does not throw error
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": Number});
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": [Number]});
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": [{"fil": String, "fol": Boolean}]});
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": {"fooz": Number, "boz": String}});

///throws an error
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": 23});
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": [Number, String]});
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": [{"fil": Number, "fol": String}, {"fal": Number}]});
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": [23]});
Utils.Objects.inspectSchema({"foo": String, "bar": Boolean, "baz": {"fooz": Number, "boz": "biz"}});

buildSchema(schema)

Takes a schema with types defined by Strings instead of constructors and generate a fully typed Schema. Not valid = somewhere in the object a value is not a type.

Throws an error if one of the types is not known. Arrays must have a length of 1 contain valid sub schema or type. Sub objects must be valid.

//does not throw error
let schema = Utils.Objects.buildSchema({"foo": "String", "bar": "Boolean", "baz": "Number"});
//gives: {"foo": String, "bar": Boolean, "baz": Number}

matchFieldsAndTypes(object, schema, strict = false)

Check if object match schema and throw an error if it doesn't.

Check fails not depending on strict value if:

at least one object's field has not the expected type
at least one object's sub object's field has not the expected type

Check fails if only if strict is true if:

a field in schema is missing in object

//does not throw error
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": 23}, {"foo": String, "bar": Boolean, "baz": Number});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": 23, "boo": ["str1", "str2"]}, {"foo": String, "bar": Boolean, "baz": Number, "boo": [String]});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true}, {"foo": String, "bar": Boolean, "baz": Number}); //strict mode false
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": {"fooz": "bla", "faz": 23}}, {"foo": String, "bar": Boolean, "baz": {"fooz": String, "faz": Number}});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": {"fooz": "bla", "faz": {"gaz": "gaz", "goz": false}}}, {"foo": String, "bar": Boolean, "baz": {"fooz": String, "faz": {"gaz": String, "goz": Boolean}}});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": {"fooz": "bla", "faz": [{"gaz": "gaz", "goz": false}, {"gaz": "taz", "goz": true}]}}, {"foo": String, "bar": Boolean, "baz": {"fooz": String, "faz": [{"gaz": String, "goz": Boolean}]}});

//does throw error
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true}, {"foo": String, "bar": Boolean, "baz": Number}); //strict mode true
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": "string instead of number"}, {"foo": String, "bar": Boolean, "baz": Number});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": 23, "boo": [true, "str2"]}, {"foo": String, "bar": Boolean, "baz": Number, "boo": [String]});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": {"fooz": "bla", "faz": "23"}}, {"foo": String, "bar": Boolean, "baz": {"fooz": String, "faz": Number}});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": {"fooz": "bla", "faz": {"gaz": "gaz", "goz": "false"}}}, {"foo": String, "bar": Boolean, "baz": {"fooz": String, "faz": {"gaz": String, "goz": Boolean}}});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": {"fooz": "bla", "faz": [{"gaz": "gaz", "goz": false}, {"gaz": "taz", "goz": "true"}]}}, {"foo": String, "bar": Boolean, "baz": {"fooz": String, "faz": [{"gaz": String, "goz": Boolean}]}});
Utils.Objects.matchFieldsAndTypes({"foo": "foo", "bar": true, "baz": {"fooz": "bla", "faz": [{"gaz": "gaz"}, {"gaz": "taz", "goz": "true"}]}}, {"foo": String, "bar": Boolean, "baz": {"fooz": String, "faz": [{"gaz": String, "goz": Boolean}]}});

Name		Name	Last commit message	Last commit date
Latest commit History 11 Commits
lib		lib
test		test
.gitignore		.gitignore
index.js		index.js
package-lock.json		package-lock.json
package.json		package.json
readme.md		readme.md

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Utils library

Description

Installation

Usage

Maths functions

getRandomInt(min, max)

factorial(n)

getAllCombinations(segments)

getAllDistributions(segments, nDimensions)

cartesianProductArray(array1, array2)

cartesianProductLine(line1, line2)

String functions

getRandomString([length])

safeFilename(unsafeFilename)

Objects functions

isEmpty(element)

hasProperty(object, path)

hasProperties(object, paths)

getValueAt(object, path)

setValueAt(object, value, path)

keepProperties(object, paths, [output])

removeEmptyProperties(object)

isConstructor(obj)

inspectSchema(schema)

buildSchema(schema)

matchFieldsAndTypes(object, schema, strict = false)

About

Releases

Packages

Languages

nicolasespiau/utils

Folders and files

Latest commit

History

Repository files navigation

Utils library

Description

Installation

Usage

Maths functions

getRandomInt(min, max)

factorial(n)

getAllCombinations(segments)

getAllDistributions(segments, nDimensions)

cartesianProductArray(array1, array2)

cartesianProductLine(line1, line2)

String functions

getRandomString([length])

safeFilename(unsafeFilename)

Objects functions

isEmpty(element)

hasProperty(object, path)

hasProperties(object, paths)

getValueAt(object, path)

setValueAt(object, value, path)

keepProperties(object, paths, [output])

removeEmptyProperties(object)

isConstructor(obj)

inspectSchema(schema)

buildSchema(schema)

matchFieldsAndTypes(object, schema, strict = false)

About

Resources

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages