101-es6

    0.8.0 • Public • Published

    101

    NPM Build Status Coverage Status

    Why another JS util library?

    1) 101 will be maintained to minimize overlap with vanilla JS.

    • 101 utils are made to work well with vanilla JS methods.
    • 101 will only duplicate vanilla JS to provide Functional Programming paradigms, or if the method is not available in a widely supported JS version (currently ES5).
    • Other libraries often duplicate a lot of ES5: forEach, map, reduce, filter, sort, and more.

    2) No need for custom builds.

    • With 101, import naturally, and what you use will be bundled.
    • Each util method is a module that can be required require('101/<util>').
    • Currently node/browserify is supported, I will add other module system support on request.
    • Other libraries can be large, and require manually creating custom builds when optimizing for size.

    Why not release each as individual modules?

    I ussually agree with this philosophy; however, while in practice, adherence to the module-pattern
    can become quite annoying for micro-modules (like those in 101):

    • Micro-modules existance throughout a project can change very frequently, because of this one may find themselves constantly updating their package.json (repeatedly adding and removing the same micro-modules).
    • Unbundling micro-modules can lead to projects with 100's of dependencies which can be tedious to maintain.

    Installation

    npm install 101

    Usage

    assign (aka extend)

    Just like ES6's Object.assign. Extend an object with any number of objects (returns original).

    import assign from '101/assign';
     
    var target = { foo: 1 };
    var source1 = { bar: 1 };
    var source2 = { baz: 1 };
    assign(target, source1) // { foo: 1, bar: 1, baz: 1 } target extended with source objects
    assign(target, source1, source2) // { foo: 1, bar: 1, baz: 1 } target extended with source objects

    and

    Functional version of &&. Works great with array.reduce.

    import and from '101/and';
     
    and(true, false); // false
    and(true, true);  // true

    apply

    Functional version of function.apply. Supports partial functionality (great with array functions).

    import apply from '101/apply';
    [sum].map(apply(null, [1, 2, 3])); // [6] = [sum(1,2,3)] = [1+2+3]
    function sum () {  /* sums all arguments */ }
    apply({ prop: 'val' })(function () { return this.prop; });  // 'val'

    clone

    It's clone (Only exporting this bc it is used internal to 101)

    import clone from '101/clone';
    var obj = {
      foo: 1,
      bar: 2
    };
     
    clone(obj); // { foo: 1, bar: 2 }

    compose

    Functional composition method. Works great with array.reduce.

    import compose from '101/compose';
     
    compose(isNaN, parseInt)('nope'); // isNaN(parseInt('nope')) // true

    envIs

    Functional version of str === process.env.NODE_ENV. Or's multiple environments.

    import envIs from '101/env-is';
    // process.env.NODE_ENV = development
    envIs('development');     // true
    envIs('production');      // false
    envIs('staging', 'production');     // false
    envIs('development', 'production'); // true

    equals

    Functional version of ===. Supports partial functionality (great with array functions).

    import equals from '101/equals';
     
    equals(1, 1);            // true
    [1,2,3].some(equals(1)); // true
    equals(1, '1');          // false

    exists

    Simple exists function.

    import exists from '101/exists';
     
    exists('foo');     // true
    exists(null);      // false
    exists(undefined); // false

    find

    Just like ES6's array.find.

    Finds the first value in the list that passes the given function (predicate) and returns it. If list is not provided find will return a partial-function which accepts a list as the first argument.

    import find from '101/find';
    import hasProps from '101/has-properties';
    var arr = [{ a: 1, b: 1 }, { b: 1 }, { c: 1 }];
     
    var item = find(arr, hasProps({ a:1 }));
    // returns { a: 1, b: 1 }
    // returns null if not found

    findIndex

    Just like ES6's array.findIndex.

    Finds the first value in the list that passes the given function (predicate) and returns it's index. If list is not provided findIndex will return a partial-function which accepts a list as the first argument.

    import findIndex from '101/find-index';
    var arr = [1, 2, 3];
     
    var index = findIndex(arr, function (val, i, arr) {
      return val === 2;
    });
    // returns 1
    // returns -1 if not found

    hasKeypaths

    Determines whether the keypaths exist and have the specified values. Supports partial functionality (great with array functions, and 101/find).

    import hasKeypaths from '101/has-keypaths';
    var obj = {
      foo: {
        bar: {
          qux: 1
        }
      }
    };
     
    hasKeypaths(obj, ['foo.bar.qux']);      // true
    hasKeypaths(obj, { 'foo.bar.qux': 1 }); // true
    hasKeypaths(obj, ['foo.qux']);          // false
    hasKeypaths(obj, { 'foo.bar': 2 });     // false
    hasKeypaths(obj, { 'foo.bar': 1, 'nope': 1 }); // false
     
    // optional 'deep' arg, defaults to true
    var barObj = { bar: 1 };
    hasKeypaths(obj, { 'foo.bar': barObj });         // true
    hasKeypaths(obj, { 'foo.bar': barObj }, true);   // true
    hasKeypaths(obj, { 'foo.bar': barObj }, false);  // false
    hasKeypaths(obj, { 'foo.bar': obj.foo }, false); // true
    hasKeypaths(obj, ['foo.bar'], false);            // true, uses [hasOwnProperty vs in](http://stackoverflow.com/questions/13632999/if-key-in-object-or-ifobject-hasownpropertykey)
    // use it with find, findIndex, or filter!
    var arr = [obj, { b: 1 }, { c: 1 }];
    find(arr, hasProps({ 'foo.bar.qux':1 })); // { foo: { bar: { qux: 1 } } }
    find(arr, hasProps(['foo.bar.qux']));     // { foo: { bar: { qux: 1 } } }

    hasProperties

    Determines whether the keys exist and, if specified, has the values. Supports partial functionality (great with array functions, and 101/find).

    import hasProps from '101/has-properties';
    var obj = {
      foo: {
        bar: 1
      },
      qux: 1
    };
     
    hasProps(obj, ['foo', 'qux']); // true
    hasProps(obj, { qux: 1 }) // true
     
    // optional 'deep' arg, defaults to true
    var barObj = { bar: 1 };
    hasProps(obj, { 'foo.bar': barObj });         // true
    hasProps(obj, { 'foo.bar': barObj }, true);   // true
    hasProps(obj, { 'foo.bar': barObj }, false);  // false
    hasProps(obj, ['foo.bar'], false);            // true, uses [hasOwnProperty vs in](http://stackoverflow.com/questions/13632999/if-key-in-object-or-ifobject-hasownpropertykey)
    // use it with find, findIndex, or filter!
    var arr = [{ a: 1, b: 1 }, { b: 1 }, { c: 1 }];
    find(arr, hasProps({ a:1 })); // { a: 1, b: 1 }
    find(arr, hasProps(['a']));   // { a: 1, b: 1 }

    instanceOf

    Functional version of JavaScript's instanceof. Supports partial functionality (great with array functions).

    import instanceOf from '101/instance-of';
     
    ['foo', 'bar', 1].map(instanceOf('string')); // [true, true, false]

    isBoolean

    Functional version of typeof val === 'boolean'. Supports partial functionality (great with array functions).

    import isBoolean from '101/is-boolean';
     
    [true, false, 1].map(isBoolean); // [true, true, false]

    isEmpty

    Functional version of val empty object, array or object

    import isEmpty from '101/is-empty';
     
    isEmpty([]); // true
    isEmpty({}); // true
    isEmpty(""); // true
    isEmpty(" "); // false

    isFunction

    Functional version of typeof val === 'function'

    import isFunction from '101/is-function';
     
    [parseInt, function () {}, 'foo'].map(isFunction); // [true, true, false]

    isNumber

    Functional version of val typeof 'number'

    import isNumber from '101/is-number';
     
    ['foo', 'bar', 1].map(isString); // [false, false, true]

    isObject

    Functional strict version of val typeof 'object' (and not array or regexp)

    import isObject from '101/is-object';
     
    [{}, { foo: 1 }, 100].map(isObject); // [true, true, false]

    isString

    Functional version of val typeof 'string'

    import isString from '101/is-string';
     
    ['foo', 'bar', 1].map(isString); // [true, true, false]

    last

    Returns the last value of a list

    import last from '101/last';
     
    last([1, 2, 3]); // 3
    last('hello');   // 'o'

    noop

    No-op function

    require('101/noop'); // function () {}

    not

    Functional version of !.

    import not from '101/not';
     
    not(isString)('hey'); // false
    not(isString)(100);   // true

    omit

    Returns a new object without the specified keys. Supports partial functionality (great with array functions, like map).

    import omit from '101/omit';
    var obj = {
      foo: 1,
      bar: 2
    };
     
    omit(obj, 'foo');          // { bar: 1 }
    omit(obj, ['foo']);        // { bar: 1 }
    omit(obj, ['foo', 'bar']); // { }
     
    // use it with array.map
    [obj, obj, obj].map(omit('foo')); // [{ bar: 1 }, { bar: 1 }, { bar: 1 }];

    or

    Functional version of ||. Works great with array.reduce.

    import or from '101/or';
     
    or(true, true);   // true
    or(true, false);  // true
    or(false, false); // false

    passAll

    Muxes arguments across many functions and &&'s the results. Supports partial functionality (great with array functions, like map).

    import passAll from '101/pass-all';
     
    ['', 'foo', 'bar', 100].map(passAll(isString, isTruthy)); // [false, true, true, false]

    passAny

    Muxes arguments across many functions and ||'s the results. Supports partial functionality (great with array functions, like map).

    import passAny from '101/pass-any';
     
    ['', 'foo', 'bar', 100].map(passAny(isString, isNumber)); // [true, true, true, true]

    pick

    Returns a new object with the specified keys (with key values from obj). Supports partial functionality (great with array functions, like map).

    import pick from '101/pick';
    var obj = {
      foo: 1,
      bar: 2
    };
     
    pick(obj, 'foo');          // { foo: 1 }
    pick(obj, ['foo']);        // { foo: 1 }
    pick(obj, ['foo', 'bar']); // { foo: 1, bar: 2 }
     
    // use it with array.map
    [obj, obj, obj].map(pick('foo')); // [{ foo: 1 }, { foo: 1 }, { foo: 1 }];

    pluck

    Functional version of obj[key], returns the value of the key from obj. Supports partial functionality (great with array functions, like map).

    import pluck from '101/pluck';
    var obj = {
      foo: 1,
      bar: 2
    };
     
    pluck(obj, 'foo'); // 1
     
    // use it with array.map
    [obj, obj, obj].map(pluck('foo')); // [1, 1, 1]
     
    // supports keypaths by default
    var obj = {
      foo: {
        bar: 1
      },
      'foo.bar': 2
    };
     
    pluck(obj, 'foo.bar'); // 1, supports keypaths by default
    pluck(obj, 'foo.bar', false); // 2, pass false to not use keypaths

    set

    Functional version of obj[key] = val, returns a new obj with the key and value set. Supports partial functionality (great with array functions, like map).

    import set from '101/set';
    var obj = {
      foo: 1,
      bar: 2
    };
     
    set(obj, 'foo'); // 1
     
    // use it with array.map
    [obj, obj, obj].map(set('foo', 100)); // [{ foo: 100, bar: 2 }, {same}, {same}]
     
    // supports keypaths by default
    var obj = {
      foo: 1,
      bar: 2
    };
     
    set(obj, 'foo', 100); // { foo: 100, bar:2 }

    License

    MIT

    Install

    npm i 101-es6

    DownloadsWeekly Downloads

    2

    Version

    0.8.0

    License

    MIT

    Last publish

    Collaborators

    • tomekwi