bellajs

    9.3.0 • Public • Published

    BellaJS

    Lightweight util for handling data type, string... in your Node.js and browser apps.

    NPM CI test Coverage Status Quality Gate Status

    You may be interested in BellaPy too.

    Contents

    Setup

    Usage

    const bella = require('bellajs');
    
    // few methods only:
    const {
      isArray,
      isString,
    } = require('bellajs');
    
    // es6 syntax:
    import bella from 'bellajs';
    
    // with tree shacking
    import {
      isArray,
      isString,
    } from 'bellajs';

    APIs

    DataType detection

    • .isArray(Anything val)
    • .isBoolean(Anything val)
    • .isDate(Anything val)
    • .isElement(Anything val)
    • .isEmail(Anything val)
    • .isEmpty(Anything val)
    • .isFunction(Anything val)
    • .isInteger(Anything val)
    • .isLetter(Anything val)
    • .isNil(Anything val)
    • .isNull(Anything val)
    • .isNumber(Anything val)
    • .isObject(Anything val)
    • .isString(Anything val)
    • .isUndefined(Anything val)

    String manipulation

    • .ucfirst(String s)
    • .ucwords(String s)
    • .escapeHTML(String s)
    • .unescapeHTML(String s)
    • .slugify(String s)
    • .stripTags(String s)
    • .stripAccent(String s)
    • .truncate(String s, Number limit)
    • .replaceAll(String s, String|Array search, String|Array replace)

    Date format

    • toRelativeTime([Date | Timestamp])
    • toDateString([Date | Timestamp] [, String pattern])
    • toLocalDateString([Date | Timestamp])
    • toUTCDateString([Date | Timestamp])

    Default pattern for toDateString() method is D, M d, Y H:i:s A.

    Pattern for toLocalDateString() and toUTCDateString() is D, j M Y h:i:s O.

    Here are the available characters:

      - Y: full year, ex: 2050
      - y: short year, ex: 50
      - F: full month name, ex: August
      - M: short month name, ex: Aug
      - m: month index with zero, ex: 08 (in 08/24/2050)
      - n: short month name with no zero, ex: 8 (in 8/24/2050)
      - S: the ordering subfix for date, ext: 1st, 2nd, 3rd, 4th
      - j: day of the month, with no zero, ex: 3 (in 18/3/2050)
      - d: day of the month, with zero, ex: 03 (in 18/03/2050)
      - t: date in year
      - w: weekday in number
      - l: long name of weekday, ex: Sunday
      - D: short name of weekday, ex: Sun
      - G: hour, with no zero: 0 - 24
      - g: hour, with no zero: 0 - 12
      - h: hour, with zero:  00 - 24
      - i: minute:  00 - 59
      - s: second:  00 - 59
      - a: am, pm
      - A: AM, PM
      - O: timezone
    

    t s Example:

    import {
      toRelativeTime,
      toDateString,
      toLocalDateString,
      toUTCDateString
    } from 'bellajs';
    
    let t = 1509628030108;
    
    toRelativeTime(t); //=> 2 seconds ago
    toDateString(t, 'Y/m/d h:i:s'); //=> 2017/11/02 20:07:10
    toLocalDateString(t); //=> Thu, 2 Nov 2017 20:07:10 GMT+0007
    toUTCDateString(t); //=> Thu, 2 Nov 2017 13:07:10 GMT+0000

    Other utils

    clone

    clone(Anything val)

    Return a copy of val.

    let b = [
      1, 5, 0, 'a', -10, '-10', '',
      {
        a: 1,
        b: 'Awesome'
      }
    ];
    
    let cb = bella.clone(b);
    console.log(cb);

    cb now has the same values as b, while the properties are standalone, not reference. So that:

    cb[7].a = 2;
    cb[7].b = 'Noop';
    
    console.log(b[7]);

    What you get is still:

    {
      a: 1,
      b: 'Awesome'
    }

    compose

    Performs right-to-left function composition.

    compose(f1, f2, ...fN)

    Examples:

    import {compose} from 'bellajs';
    
    let f1 = (name) => {
      return `f1 ${name}`;
    };
    let f2 = (name) => {
      return `f2 ${name}`;
    };
    let f3 = (name) => {
      return `f3 ${name}`;
    };
    
    let addF = compose(f1, f2, f3);
    
    addF('Hello') // => 'f1 f2 f3 Hello'
    
    let add1 = (num) => {
      return num + 1;
    };
    
    let mult2 = (num) => {
      return num * 2;
    };
    
    let add1AndMult2 = compose(add1, mult2);
    add1AndMult2(3) // => 7
    // because multiple to 2 first, then add 1 late => 3 * 2 + 1

    copies

    Copy the properties from source to target.

    copies(Object source, Object target[[, Boolean requireMatching], Array excepts])
    • requireMatching: if true, BellaJS only copies the properties that are already exist in target.
    • excepts: array of the properties properties in source that you don't want to copy.

    Example:

    let a = {
      name: 'Toto',
      age: 30,
      level: 8,
      nationality: {
        name: 'America'
      }
    };
    let b = {
      level: 4,
      IQ: 140,
      epouse: {
        name: 'Alice',
        age: 27
      },
      nationality: {
        long: '18123.123123.12312',
        lat: '98984771.134231.1234'
      }
    };
    
    bella.copies(a, b);
    console.log(b);

    Output:

    {
      level: 8,
      IQ: 140,
      epouse: {
        name: 'Alice',
        age: 27
      },
      nationality: {
        long: '18123.123123.12312',
        lat: '98984771.134231.1234',
        name: 'America'
      },
      name: 'Toto',
      age: 30
    }

    curry

    curry(fn)

    Examples:

    import {curry} from 'bellajs';
    
    let sum = curry((a, b, c) => {
      return a + b + c;
    });
    
    sum(3)(2)(1) // => 6
    sum(1)(2)(3) // => 6
    sum(1, 2)(3) // => 6
    sum(1)(2, 3) // => 6
    sum(1, 2, 3) // => 6

    equals

    equals(Anything a, Anything b)

    Examples:

    import {equals} from 'bellajs';
    
    equals({}, {}); // => true
    equals(0, 1); // => false

    genid

    genid([Number length [, String prefix]])

    Examples:

    import {genid} from 'bellajs';
    
    genid(); // => random 32 chars
    genid(16); // => random 16 chars
    genid(5); // => random 5 chars
    genid(5, 'X_'); // => X_{random 3 chars}

    maybe

    maybe(Anything val)

    Return a static variant of Maybe monad.

    Examples:

    import {maybe} from 'bellajs';
    
    const plus5 = x => x + 5;
    const minus2 = x => x - 2;
    const isNumber = x => Number(x) === x;
    const toString = x => 'The value is ' + String(x);
    const getDefault = () => 'This is default value';
    
    maybe(5)
      .map(plus5)
      .map(minus2)
      .value()  // 8
    
    maybe('noop')
      .map(plus5)
      .map(minus2)
      .value()  // null
    
    maybe(5)
      .if(isNumber)
      .map(plus5)
      .map(minus2)
      .else(getDefault)
      .map(toString)
      .value()  // 'The value is 8'
    
    maybe()
      .if(isNumber)
      .map(plus5)
      .map(minus2)
      .map(toString)
      .value()  // null
    
    maybe()
      .if(isNumber)
      .map(plus5)
      .map(minus2)
      .else(getDefault)
      .map(toString)
      .value()  // 'This is default value'

    md5

    md5(String s)

    Examples:

    import {md5} from 'bellajs';
    
    md5('abc'); // => 900150983cd24fb0d6963f7d28e17f72

    pick

    Randomly choose N elements from array.

    pick(Integer count, Array arr)

    Examples:

    import {pick} from 'bellajs';
    
    const arr = [1, 3, 8, 2, 5, 7]
    pick(arr, 2);  // --> [3, 5]
    pick(arr, 2);  // --> [8, 1]

    pipe

    Performs left-to-right function composition.

    pipe(f1, f2, ...fN)

    Examples:

    import {pipe} from 'bellajs';
    
    let f1 = (name) => {
      return `f1 ${name}`;
    };
    let f2 = (name) => {
      return `f2 ${name}`;
    };
    let f3 = (name) => {
      return `f3 ${name}`;
    };
    
    let addF = pipe(f1, f2, f3);
    
    addF('Hello') // => 'f3 f2 f1 Hello'
    
    let add1 = (num) => {
      return num + 1;
    };
    
    let mult2 = (num) => {
      return num * 2;
    };
    
    let add1AndMult2 = pipe(add1, mult2);
    add1AndMult2(3) // => 8
    // because add 1 first, then multiple to 2 late => (3 + 1) * 2

    randint

    randint([Number min [, Number max]])

    Examples:

    import {randint} from 'bellajs';
    
    randint(); // => a random integer
    randint(1, 5); // => a random integer between 3 and 5, including 1 and 5

    sort

    sort(Array a [, Function compare])

    Examples:

    import {sort} from 'bellajs';
    
    const fn = (a, b) => {
      return a < b ? 1 : a > b ? -1 : 0;
    };
    
    sort([3, 1, 5, 2], fn); // => [ 1, 2, 3, 5 ]
    sort([3, 1, 5, 2], fn); // => [ 5, 3, 2, 1 ]

    sortBy

    sortBy(String property, Number order, Array a)

    Examples:

    import {sortBy} from 'bellajs';
    
    const players = [
      {
        name: 'Jerome Nash',
        age: 24
      },
      {
        name: 'Jackson Valdez',
        age: 21
      },
      {
        name: 'Benjamin Cole',
        age: 23
      },
      {
        name: 'Manuel Delgado',
        age: 33
      },
      {
        name: 'Caleb McKinney',
        age: 28
      }
    ];
    
    const result = sortBy('age', -1, players);
    console.log(result)

    shuffle

    Shuffle an array.

    shuffle(Array arr)

    Examples:

    import {shuffle} from 'bellajs';
    
    shuffle([1, 3, 8, 2, 5, 7]);

    unique

    unique(Array a)

    Examples:

    import {unique} from 'bellajs';
    
    unique([1, 2, 3, 2, 3, 1, 5]); // => [ 1, 2, 3, 5 ]

    Test

    git clone https://github.com/ndaidong/bellajs.git
    cd bellajs
    npm install
    npm test

    License

    The MIT License (MIT)

    Install

    npm i bellajs

    DownloadsWeekly Downloads

    1,641

    Version

    9.3.0

    License

    MIT

    Unpacked Size

    107 kB

    Total Files

    34

    Last publish

    Collaborators

    • avatar