white_cats

White Cats define Pure functions

Usage:

node.js@^LTS

npm i white_cats

and...

  const _ = require('white_cats');

browser

<script src="https://cdn.jsdelivr.net/npm/[email protected]/cat.js"></script>

contents:

id

_.id(57)
// 57

_.pipe

is function pipe runner

_.pipe(
  v => v * 2,
  v => v + 5,
  v => v * 10
)(5)
// 150

_.loop

watch out on argument's first

_.loop(
  a => a.forEach(v => v),
  a => a.forEach(v => v)
)(
  [3, 5, 7]
)
// [3, 5, 7]

_.upto(prototype, descriptor)

is Object.create

(() =>  {
  const target = _.upto(Object.freeze({a: true, b: false}), {c: {value: false}});
  target.c === false
})()

_.put(base, assign)

is Object.assign

() => {
  const target = {a: 5, b: 3};
  _.put(target, {c: 1, d: 2});
  target.c === 1;
  target.d === 2;
}

_.define(base, 'key', description)

is Object.defineProperty

() => {
  const target = {a: 5, b: 3};
  _.defines(target, 'c', {value: 1});
  target.c === 1;
}

_.defines(base, descriptions)

is Object.defineProperties

() => {
  const target = {a: 5, b: 3};
  _.defines(target, {c: {value: 1}, d: {value: 2}});
  target.c === 1;
  target.d === 2;
}

_.keys

is Object.keys

_.keys({a: 5, b: 6})
// ['a', 'b']

_.vals

is Object.values

_.vals({a: 5, b: 6})
// [5, 6]

_.entries

is Object.entries

_.entries({a: 5, b: 6})
// [['a', 5], ['b', 6]]

_.equal

is Object.is

(() => {
  _.equal('foo', 'foo');     // true
  _.equal('foo', 'bar');     // false
  _.equal([], []);           // false

  const foo = { a: 1 };
  const bar = { a: 1 };
  _.equal(foo, foo);         // true
  _.equal(foo, bar);         // false

  _.equal(null, null);       // true

  _.equal(0, -0);            // false
  _.equal(-0, -0);           // true
  _.equal(NaN, 0/0);         // true
})()

_.owns

_.owns(target)

// same of
Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))

_.descpipting

is Object.getOwnPropertyDescriptors

_.descripting({
  a: 5,
  b: 6
})

_.adapt

assign arguments value in empty to left

_.adapt(1, 2, 5)([,,3,4,,6])
// [1, 2, 3, 4, 5, 6]

_.adaptL

assign arguments value in empty to left

_.adaptL(1, 2, 5)([,,3,4,,6])
// [1, 2, 3, 4, 5, 6]

_.adaptR

assign arguments value in empty to Right

_.adaptR(1, 2, 5)([,,3,4,,6])
// [5, 2, 3, 4, 1, 6]

_.less

omit voidly value

_.less([,,null ,undefined ,3 ,4 ,5,,])
// [3, 4, 5]

_.sure

change empty to undefined

_.sure([ , , ,0 , 3, 4, 5])
// [undefined, undefined, undefined, 0, 3, 4, 5]

_.by

get's constructor

_.by([])
// Array

_.isObject

// true
_.isObject({});
_.isObject([]);

// false
_.isObject(8);

_.isArray

// true
_.isArray([])

// false
_.isArray({})

_._(start, end, step)

[..._._(0, 8, 2)]
// [0, 2, 4, 6, 8]

[..._._(8, 0, -2)]
// [8, 6, 4, 2, 0]

[..._._(5)]
// [0, 1, 2, 3, 4, 5]

_.spin([])

create loop infinite iterator

const r = _.spin([1, 2, 3]);
r.now // 1
r.now // 2
r.again // 2
r.now // 3
r.now // 1

_.async(resolver)

create Promise

async () => await _.async(
  r => setTimeout(t => r('done'), 3000)
)();
// 3sec after return 'done'

_.asyncAll

is Promise.all

async () => await _.asyncAll(
      _.async(r => r(3)),
      _.async(r => r(4)),
      _.async(
        r => setTimeout(t => r('done'), 3000)
      )
    )
// 3sec after return [3, 4, 5]

_().$_

return right first

_(3).$_
// 3

_(3, 4).$_
// 4

_()._$

return left first

_(3)._$
// 3

_(3, 4)._$
// 3

_(null, 4)._$
// 4

_().re

swap starting and ending value

_(3, 4).re
// it same at _(4, 3)

_().flat

has Kleisli Triple and function piping

// left Identity
_({a: 5})
.flat(o => _({a: o.a * 3}))
._
(o => _({a: o.a * 3}))({a: 5})._

// Right Identity
_({a: 5})
.flat(_)
.flat(_)
._
// {a: 5}

// Associativity
_({a: 5})
.flat(o => _({a: o.a * 3}))
.flat(o => _({a: o.a + 5}))
._
_({a: 5})
.flat(
  o => _({a: o.a * 3})
  .flat(
    o => _({a: o.a + 5})
  )
)._

_().pipe

function's pipeline runner

_({a: 5})
.pipe(
  o => ({a: o.a * 3}),
  o => ({a: o.a + 5})
)
._.a
// 20

_().loop

is watch out on argument's first

_([3, 4, 5])
.loop(
  o => o.unshift(2, 3),
  o => o.push(2, 3),
  o => o.filter(v => v < 3)
)
._
// [2, 3. 3, 4, 5, 2, 3]

_().call

is Object's method caller in call(self) and return result

_([3, 4, 5]).call('push')(5, 6)._
// 5

_().s_r

is Object's method caller in call(self) and callback recieve result and return self

_([3, 4, 5]).s_r('push')(5, 6)(v => v === 5)._
// [3, 4, 5, 5, 6]

_().cast

is Object's method caller in call(self) and return self

_([3, 4, 5]).call('push')(5, 6)._
// [3, 4, 5, 5, 6]

_().Been

is Chaining method calling in the way to take a Object

_([3, 5, 7])
.Been
[0](7)((v, w) => w)       // rewrite
[1](10)()                 // nothing to do
[2](5)((v, w) => v + w)   // modify
.push(5, 6)(console.log)  // 5
.push(4, 3)(console.log)  // 7
.To
._
// [7, 5, 12, 5, 6, 4, 3]

_().As

is Chaining method calling in the way to take a Object

_([3, 5, 7])
.As
[0](console.log)       // refer
[1](console.log)      // 
[2](console.log)       // 
.push(5, 6)  // 5
.push(4, 3)  // 7
.As
._
// [3, 5, 7, 5, 6, 4, 3]

_().toJSON

is JSON.stringify

_({a: 5, b: 6}).toJSON._ === JSON.stringify({a: 5, b: 6})

_(function*).take

is take generator's valuelist

_((function* (x) {
  while (true) {
    yield x++;
  }
})(0))
.take(5)
._
//[0, 1, 2, 3, 4]

_({}).filter

is Object.filter

_({a: 5, b: 4, c: 3, d: 2, e : 1})
.filter(v => v < 4)
._
// {c: 3, d: 2, e : 1}

_({}).each

is Object.entries.forEach

_({
  req: undefined,
  res: undefined,
  get (req, res) {
    _.put(this, {req, res});
  },
  post (req, res) {
    _.put(this, {res});
  }
})
.each(
  (k, v) => emitter.on(k, v)
)

_({}).map

is Object.map

_({a: 5, b: 4, c: 6}).map((v, k) => k + v)._
// {a: 'a5', b: 'b4', c: 'c6'}

_({}).get

is getter about Object

_({a: 3, b: {c: 4, d: {e: 6}}}).get('b.d.e')._
// 6

_({a: 3, b: {c: 4, d: {e: 6}}}).get('b.e.f')._
// undefined

_({}).set

is setter about Object

_({a: 3, b: {c: 4, d: {e: 6}}}).set('b.d.e')(3)._
// {a: 3, b: {c: 4, d: {e: 3}}}

_({a: 3, b: {c: 4, d: {e: 6}}}).set('b.c.f')(3)._
// {a: 3, b: {c: {f: 3}, d: {e: 6}}}

_({}).put

is Object.assign

_({a: 3, b: {c: 4, d: {e: 6}}}).get('b.d').put({f: 7}).$_
// {a: 3, b: {c: 4, d: {e: 6, f: 7}}}

_({}).cut

is delete property

_({a: 3, b: {c: 4, d: {e: 6}}}).cut('b.d')._
// {a: 3, b: {c: 4}}

_({a: 3, b: {c: 4, d: {e: 6}}}).cut('b.e')._
// {a: 3, b: {c: 4, d: {e: 6}}}

_({}).refer

property referer callback

_({a: 3, b: {c: 4, d: {e: 6}}})
.refer('b.d.e')(console.log)
._ // 6
// {a: 3, b: {c: 4, d: {e: 6}}}

_({}).gaze

is refer property and get's more argument

_({a: 3, b: {c: 4, d: {e: 6}}})
.gaze('b.d.e')(4, 5, 6)(console.log)
._
// {a: 3, b: {c: 4, d: {e: 6}}}

_({}).mend

is property modifier

_({a: 3, b: {c: 4, d: {e: 6}}}).mend('b.d.e')(v => v * 3)._
// {a: 3, b: {c: 4, d: {e: 18}}}

_({}).modify

is modify property and get's more argument

_({a: 3, b: {c: 4, d: {e: 6}}})
.modify('b.d.e')(4, 5, 6)(
  (v, w, x, y) => (v - w) * x + y
)
._
// {a: 3, b: {c: 4, d: {e: 16}}}

_({}).give

is deepAssigning Object more safely about Object.assign

!!!Carefuly!!! give is take of the first argument Object normaly use _({}).take

_({a: 3, b: {c: 4, d: {e: 6}}})
.give(
  {a: 4, b: {d: {f: 8}, g: {h: 9, i: 10}}},
  {b: {d: {g: {j: 11, k: {l: 12}}}}},
  {b: {g: {j: 13, k: {l: 14}}}}
)
._

/*
  {
    b : {
      g : { j : 13, k : { l : 14 }, h : 9, i : 10 },
      d : { g : { j : 11, k : { l : 12 } }, f : 8, e : 6 },
      c : 4
    }, a : 3
  }
*/

_({}).take

is deepAssigning Object more safely about Object.assign

_({a: 3, b: {c: 4, d: {e: 6}}})
.take(
  {a: 4, b: {d: {f: 8}, g: {h: 9, i: 10}}},
  {b: {d: {g: {j: 11, k: {l: 12}}}}},
  {b: {g: {j: 13, k: {l: 14}}}}
)
._

/*
  {
    a: 4, b: {
      c: 4, d: {
        e: 6, f: 8, g: {
          j: 11, k: {l: 12}
        }
      },
      g: {
        h: 9, i: 10, j: 13, k: {l: 14}
      }
    }
  }
*/

_({}).define

is Object.defineProperties applying

(() => {
  const target = {a: 5, b: 3};
  _(target).define({c: {value: 1}, d: {value: 2}})._;
  // target like {a: 5, b: 3, c: 1, d: 2}
})

_({}).append

is promoting prototype that Object.create

_(Object.prototype).append({c: {value: false}})._;
// {c: false}

_({}).depend

is depending prototype that Object.create

_({c: {value: false}}).depend(Object.prototype)._;
// {c: false}

_({}).pick

Object's deepPicker that distinate Query String

_({
  a: 4, b: {
    c: 4, d: {
      e: 6, f: 8, g: {
        j: 11, k: {l: 12}
      }
    },
    g: {
      h: 9, i: 10, j: 13, k: {l: 14}
    }
  }
})
.pick('a, b[c, d[e, g.k], g[j, k]]') // parse to 'a, b.c, b.d.e, b.d.g.k, g.j, g.k'
._

/*
  {
    a: 4, b: {
      c: 4, d: {
        e: 6, g: {
          k: {l: 12}
        }
      },
      g: {
        j: 13, k: {l: 14}
      }
    }
  }
*/

_({}).drop

Object's deepDropper that distinate Query String

_({
  a: 4, b: {
    c: 4, d: {
      e: 6, f: 8, g: {
        j: 11, k: {l: 12}
      }
    },
    g: {
      h: 9, i: 10, j: 13, k: {l: 14}
    }
  }
})
.drop('a, b[c, d[e, g.k], g[j, k]]') // parse to  'a, b.c, b.d.e, b.d.g.k, g.j, g.k'
._

/*
  {
    b: {
      d: {
        f: 8, g: {
          j: 11
        }
      },
      g: {
        h: 9, i: 10,
      }
    }
  }
*/

_({}).keys

get's Object.keys

_({a: 5, b: 6}).keys._
// ['a', 'b']

_({}).vals

get's Object.values

_({a: 5, b: 6}).vals._
// [5, 6]

_({}).entries

get's Object.entries

_({a: 5, b: 6}).entries._
// [['a', 5], ['b', 6]]

_({}).toDate

process from Date structure to Date Object

_({
  yr: 2020,
  mo: 1,
  dt: 1,
  hr: 0,
  min: 0,
  sec: 0,
  ms: 0
}).toDate._

//Data: 2020-1-1 that have Local TimeZone

_({}).toDateUTC

process from DateUTC structure to Date Object

_({
  yrUTC: 2020,
  moUTC: 1,
  dtUTC: 1,
  hrUTC: 0,
  minUTC: 0,
  secUTC: 0,
}).toDateUTC._

//Data: 2020-1-1 that have UTC GMT

_(constructor).delegate

constructor function's inheritance Other One's

const MyEmitter = _(function (a, b) {
  events.EventEmitter.call(this)
  this.a = a;
  this.b = b;
})
.delegate(events.EventEmitter)
._

const MyImage = _(function (src, alt) {
  Image.call(this)
  this.src = src;
  this.alt = alt;
})
.delegate(Image)
._

_(constructor).prepends

assign methods in this constructor

const MyCtor = _(function (a, b) {
  this.a = a;
  this.b = b;
})
.prepends({
  ad (x) {
    this.a += x;
    this.b += x;
    return this;
  },
  mt (x) {
    this.a *= x;
    this.b *= x;
    return this;
  },
  get result () {
    return a + b;
  }
})
._

_(constructor).implements

define methods in this constructor

const MyCtor = _(function (a, b) {
  this['@a'] = a;
  this['@b'] = b;
})
.implements({
  a: {
    configurable: true,
    get () {
      return this['@a'];
    }
  },
  b: {
    configurable: true,
    get () {
      return this['@b'];
    }
  },
  ad: {
    configurable: true,
    value (x) {
      return new MyCtor(this.a + x, this.b + x);
    }
  },
  mt: {
    configurable: true,
    value (x) {
      return new MyCtor(this.a * x, this.b * x);
    }
  },
  result: {
    configurable: true,
    get () {
      return this.a + this.b;
    }
  }
})
._

_(function).take([])

is partial applying and what cut to overflow args and run once it

.of means args.push .to means args.unshift

_((...a) => a.reduce((p, c) => p + c))
.take([,,3,,,])
.to(1, 2)
.of(4, 5)
.to(3, 4)
.of(2, 3)
._
// 15

_(function).each

is applying each value

_(v => v * 3).each(3, 5, 7)._
// [9, 15, 21]

_(function).done

is manageing onto delaying and forceing or applying

_(v => v * 5)
.done(3) // apply it
.done(4) // no action
.done(5) // no action
._

// 15

_(Promise).pipe

is promiseObj.then pipe chaining;

_(_.async(r => r(3)))
.pipe(
  v => v + 5,
  v => v * 2
)
._

// {fullfilled, 16}

_(Promise).loop

is promiseObj.then pipe chaining;

_(_.async(r => r(3)))
.loop(
  console.log,
  console.log
)
._

// {fullfilled, 3}

_(Promise).Will

is promiseObj.pipeline method chaining;

// It is like to use wavy dot
//  const data = await disk~.(...args)~.openDirectory('foo')~.openFile('bar.txt')~.read();
async () => {
  const data = await _(getFileSystem())
    .Will
    .Be(...arg)
    .openDirectory('foo')
    .openFile('bar.txt')
    .read()
    .Done
  ._;
}

_([]).liken

to likely value array

_([0, 1, 2, 3, 4, 5]).liken([1, 100, 2, 200, 3, 300])._
// [1, 2, 3]

_([]).equaly

pick of same key value

_([0, 1, 2, 3, 4, 5]).equaly([1, 1, 2, 3, 5, 8])._
// [1, 2, 3]

_([]).toggle

exist value remove and unexist value add

_([0, 1, 2, 3, 4, 5]).toggle(1, 3, 5, 8)._
// [0, 2, 4, 8]

_([]).pick

pick up exist values

_([0, 1, 2, 3, 4, 5, 6, 7, 8]).pick(-1, 2 ,5 ,6)._
// [2, 5, 6]

_([]).drop

omit at exist values

_([1, 2, 3, 4, 5]).drop(2, 4, 6)._
// [1, 3, 5]

_([]).chunk

rewrap array in partial array

_([0, 1, 2, 3, 4, 5]).chunk(2)._
// [[0, 1], [2, 3], [4, 5]]

_([]).unique

is pick up different values

_([1, 2, 3, 4, 5, 2, 6, 3]).unique._
// [1, 2, 3, 4, 5, 6]

_([]).union

is concat other Array and pick up different values

_([3, 4, 5, 6]).union([0, 1, 2, 3, 4])._
// [0, 1, 2, 3, 4, 5, 6]

_([]).put

is replase other Array;

_([3, 4, 5, 6, 7]).put([,,3,4,,,8,9])._
// [3, 4, 3, 4, 7]

_([]).exist

is apply Array.prototype.includes

_([2, 8]).exist(8)._
// true

_([2, 8]).exist(3)._
// false

_([]).pickKey

is pick Array in Object can use _({}).pick 's query string

_([
  {a: 30, b: 40, c: 50},
  {a: 31, b: 41, c: 51},
  {a: 32, b: 42, c: 52},
  {a: 33, b: 43, c: 53}
])
.pickKey('a, c')
._

/*
  [
    {a: 30, c: 50},
    {a: 31, c: 51},
    {a: 32, c: 52},
    {a: 33, c: 53}
  ]
*/

_([]).dropKey

is drop Array in Object can use _({}).drop 's query string

_([
  {a: 30, b: 40, c: 50},
  {a: 31, b: 41, c: 51},
  {a: 32, b: 42, c: 52},
  {a: 33, b: 43, c: 53}
])
.dropKey('a, c')
._
/*
  [
    {b: 40},
    {b: 41},
    {b: 42},
    {b: 43}
  ]
*/

_([]).pushL

_([1, 2, 3]).pushL(-1, 0)._
// [-1, 0, 1, 2, 3]

_([]).pushR

_([1, 2, 3]).pushR(4, 5)._
// [1, 2, 3, 4, 5]

_([]).popL

_([1, 2, 3]).popL._
// 1

_([]).popR

_([1, 2, 3]).popR._
// 3

_([]).omitL

_([1, 2, 3]).omitL._
// [2, 3]

_([]).omitR

_([1, 2, 3]).omitR._
// [1, 2]

_([]).each

like for ...of iteration

_([1, 2, 3, 4, 5]).each(console.log)._

_([]).lift

highly function recieve in this Array

_([1 ,2 ,3 ,4 ,5])
.lift(
  a => a
  .map(v => v + 8)
  .reduce((p, c) => p + c)
)._
// 55

_([]).fold

is reduceing to left

_([1, 3, 5]).fold((p, c) => p - c)._
// -7

_([]).foldL

is reduceing to left

_([1, 3, 5]).foldL((p, c) => p - c)._
// -7

_([]).foldR

is reduceing to Right

_([1, 3, 5]).foldR((p, c) => p - c)._
// 1

_([]).filter

apply Array.prototype.filter

_([1, 2, 3, 4, 5]).filter(v => v < 4)._
// [1, 2, 3]

_([]).rotate

is transeform Array vector

_([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
])
.rotate
._

/*
  [
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9],
  ]
*/

_([]).aMap

via applicative map

_([v => v + 5, v => v * 5])
.aMap([1, 2, 3, 4, 5])
._

/*
  [
    [6, 7, 8, 9, 10],
    [5, 10, 15, 20, 25]
  ]
*/

_([1, 2, 3, 4, 5])
.aMap([v => v + 5, v => v * 5])
._
/*
  [
    [6, 5],
    [7, 10],
    [8, 15],
    [9, 20],
    [10, 25]
  ]
*/

_([]).map

is map to other Array

_([1, 2, 3, 4, 5])
.map(
  v => v * 5,
  v => v + 3,
)
._
// [8, 13, 18, 23, 28]

_([]).fMap

is Array flatMap

_([1, 2, 3, 4, 5])
.fMap(
  v => [v * 5],
  v => [v + 3],
)
._
// [8, 13, 18, 23, 28]

_([]).mapDeep

is map to other Array it apply deep Array

_([1, [2, [3, [4, [5]]]]])
.map(
  v => v * 5,
  v => v + 3,
)
._
// [8, [13, [18, [23, [28]]]]]

_([]).flatten

is Array flatten

_([[1, 2], 3, [4, [5]]]).flatten(2)._
// [ 1, 2, 3, 4, 5 ]

_([]).back

apply Array .prototype.reverce !!!Not Pure!!!

_([1, 2, 3, 4, 5]).back._
// [5, 4, 3, 2, 1]

_([]).adapt

assign empty place at left

_([ , ,3 , , ,]).adapt(1, 2, 4, 5)._
// [1, 2, 3, 4, 5]

_([]).adaptL

assign empty place at left

_([ , ,3 , , ,]).adaptL(1, 2, 4, 5)._
// [1, 2, 3, 4, 5]

_([]).adaptR

assign empty place at right

_([ , ,3 , , ,]).adaptR(1, 2, 4, 5)._
// [5, 4, 3, 2, 1]

_([]).concat

marge Array

_([1, 2, 3, 4, 5]).concat([6, 7, 8])._
// [1, 2, 3, 4, 5, 6, 7, 8]

_([]).replace

is Array replacement !!!Not Pure!!!

_([1, 2, 3, 4, 5]).replace(2, 2, 6)._
// [1, 2, 6, 5]

_([]).splice

call Array.prototype.splice !!!Not Pure!!!

_([1, 2, 3, 4, 5]).splice(2, 2, 6)._
// [3, 4]

_([]).slice

call Array.prototype.slice

_([1, 2, 3, 4, 5]).slice(2, 2)._
// [3, 4]

_([]).sort

apply Array.prototype.sort

_([4, 2, 5, 1, 3]).sort()._
// [1, 2, 3, 4, 5]

_([]).indexL

via indexOf

_([1, 2, 3, 2, 5]).indexL(2)._
// 1

_([]).indexR

via lastIndexOf

_([1, 2, 3, 2, 5]).indexR(2)._
// 3

_([]).any

via Array.prototype.some

_([1, 2, 3, 2, 5]).any(v => v > 4)._
// true

_([]).all

via Array.prototype.every

_([1, 2, 3, 2, 5]).all(v => v > 4)._
// [1, 2, 3, 4, 5].every(v => v > 4)

_([]).unite

spread and apply to function

_([1, 2, 3]).unite((a, b, c) => (a + b) * c)._
// 9

_([]).sum

add all value

_([1, 2, 3, 4, 5]).sum._
// 15

_([]).pi

product all value

_([1, 2, 3, 4, 5]).pi._
// 120

_([]).average

get average value

_([1,1,5,3,8,8,9,10,12,12,13,13,13,14]).average._
// 8.71...

_([]).max

get max value

_([1,2,3,4,5,3,8,2]).max._
// 8

_([]).min

get min value

_([1,2,3,4,-3,3,8,2]).min._
// -3

_([]).mid

get median value

_([3, 4, 2, 7, 6, 5, 1]).mid._
// 4

_([]).less

omit voidly value

_([ , ,3 ,4 , , ,5 , ,]).less._
// [3, 4, 5]

_([]).sure

replase from empty to undefined

_([ , ,3 ,4 , , ,5 , ,]).sure._
// [undefined ,undefined ,3 ,4 ,undefined ,undefined ,5 ,undefined]

_([]).admix

from Array to Object

_([1, 2, 3, 4, 5]).admix(...'abcde')._
/*
  {
    a: 1,
    b: 2,
    c: 3,
    d: 4,
    e: 5
  }
*/

_().fullen

not exist voidly value

// *** false ***
_([,2,3]).fullen._
_([1,,3]).fullen._
_([1,2,,]).fullen._
_([null, 2, 3]).fullen._
_([1, null, 3]).fullen._
_([1, 2, null]).fullen._
_([void 0, 2, 3]).fullen._
_([1, void 0, 3]).fullen._
_([1, 2, void 0]).fullen._
_({a: null, b: 2, c: 3}).fullen._
_({a: 1, b: null, c: 3}).fullen._
_({a: 1, b: 2, c: null}).fullen._
_({a: void 0, b: 2, c: 3}).fullen._
_({a: 1, b: void 0, c: 3}).fullen._
_({a: 1, b: 2, c: void 0}).fullen._

// *** true ***
_({a: 0, b: true, c: false}).fullen._
_([0, true, false]).fullen._

_('').toObject

apply JSON.parse

_('{"a": 5}').toObject._
// {a: 5}

_('').toDate

date string parse to Date Object

_("2000-01-01T00:00:00.000Z").toDate._.getDate()
// 1

_('{"yr": 2000, "mo": 1, "dt": 1}').toDate._.getDate()
// 1

​

_(Date).get

is get whitch

Get LocalTimeZone 'yr': fullYear 'mo': month (not month ID) 'dt': date 'dy': day of the week ID 'wk': number of the week 'hr': hour 'min': minute 'sec': secounds 'ms': msec

Get UTC 'yrUTC': fullYear 'moUTC': month (not month ID) 'dtUTC': date 'dyUTC': day of the week ID 'hrUTC': hour 'minUTC': minute 'secUTC': secounds 'msUTC': msec

if single kind return value

_(new Date(0)).get('yr')._
// 1970

if multi kind return Object

_(new Date(0)).get('yr, mo, dt, dy, hr, min, sec, ms')._

/*
  {
    yr: 1970,
    mo: 1,
    dt: 1,
    dy: 4,
    wk: 1,
    hr: Math.trunc(_.zone / 60),
    min: _.zone % 60,
    sec: 0,
    ms: 0
  }
*/

get UTC

_(new Date(0)).get('yrUTC, moUTC, dtUTC, dyUTC, hrUTC, minUTC, secUTC')._

/*
  {
    yrUTC: 1970,
    moUTC: 1,
    dtUTC: 1,
    dyUTC: 4,
    hrUTC: 0,
    minUTC: 0,
    secUTC: 0
  }
*/

_(Date).put

Date Object set value like a Object.assign

_(new Date(0))
.put({
  yr: 2020,
  mo: 5, // not Month ID It meen 'May'
  dt: 28,
  hr: 15,
  min: 28,
  sec: 16,
  ms: 330
})
.get('yr, mo, dt, dy, hr, min, sec, ms')
._

/*
  {
    yr: 2020,
    mo: 5,
    dt: 28,
    dy: 4,
    hr: 15,
    min: 28,
    sec: 16,
    ms: 330
  }
*/

_(new Date(0))
.put({
  yrUTC: 2020,
  moUTC: 5, // not Month ID It meen 'May'
  dtUTC: 28,
  hrUTC: 15,
  minUTC: 28,
  secUTC: 16
})
.get('yrUTC, moUTC, dtUTC, dyUTC, hrUTC, minUTC, secUTC')
._

/*
  {
    yrUTC: 2020,
    moUTC: 5,
    dtUTC: 28,
    dyUTC: 4,
    hrUTC: 15,
    minUTC: 28,
    secUTC: 16,
  }
*/

_(Date).map

modify Date Object's it works likely Date .get's and set's keys

_(new Date(0))
.map('min, sec')(
  ({min, sec}) => ({min: min + 1, sec: sec + 30})
)
.get('min, sec')
._

/*
  {
    min: 1,
    sec: 30
  }
*/

_(new Date(0))
.map(
  'sec'
)(
  s => s + 15
)
.get('sec')
._

// 15

_(Date).endOfMo

get the last month of the date

_(new Date(0)).endOfMo.get('mo, dt')._

/*
  {
    mo: 1,
    dt: 31
  }
*/

_(Date).endOfMoUTC

get the last month of the date in UTC GMT

_(new Date(0)).endOfMoUTC.get('moUTC, dtUTC')._

/*
  {
    moUTC: 1,
    dtUTC: 31
  }
*/

_(Date).zone

get TimeZone offset value

_(new Date(0)).zone._

_(Date).raw

get raw millisec at UTC 0

_(new Date(0)).raw._
// 0

_(Date).ISO

get ISO String

_(new Date(0)).ISO._

_(Date).UTC

get UTC String

_(new Date(0)).UTC._

_(Date).toObject

get Date infomation on Object

_(new Date(0)).toObject._

/*
  {
    yr: 1970,
    mo: 1,
    dt: 1,
    dy: 4,
    hr: Math.trunc(_.zone / 60),
    min: _.zone % 60,
    sec: 0,
    ms: 0
  }
*/

_(Date).toObjectUTC

get Date by UTC infomation on Object

_(new Date(0)).toObjectUTC._

/*
      {
        yrUTC: 1970,
        moUTC: 1,
        dtUTC: 1,
        dyUTC: 4,
        hrUTC: 0,
        minUTC: 0,
        secUTC: 0
      }
*/

_(Date).toJSON

via (Date).toObject.toJSON.

_(new Date(0)).toJSON._

// expect
JSON.stringify({
  yr: 1970,
  mo: 1,
  dt: 1,
  dy: 4,
  hr: Math.trunc(_.zone / 60),
  min: _.zone % 60,
  sec: 0,
  ms: 0
});

_(Date).toJSONUTC

via (Date).toObjectUTC.toJSON.

_(new Date(0)).toJSONUTC._

JSON.stringify({
  yrUTC: 1970,
  moUTC: 1,
  dtUTC: 1,
  dyUTC: 4,
  hrUTC: 0,
  minUTC: 0,
  secUTC: 0
})

_(JSON).toDate

Parse from (Date).toJSON.

_(new Date(0)).toJSON.toDate.toObject._

/*
  {
    yr: 1970,
    mo: 1,
    dt: 1,
    dy: 4,
    hr: Math.trunc(_.zone / 60),
    min: _.zone % 60,
    sec: 0,
    ms: 0
  }
*/

_(Date).toJSONUTC

Parse from (Date).toJSONUTC.

_(new Date(0)).toJSONUTC.toDateUTC.toObjectUTC._

/*
  {
    yrUTC: 1970,
    moUTC: 1,
    dtUTC: 1,
    dyUTC: 4,
    hrUTC: 0,
    minUTC: 0,
    secUTC: 0
  }
*/

_.zone

have a Timezone information on minutes base

Event driven development:

const EETest = _(EventEmitter).fork(function () {
  EventEmitter.call(this)
})._

const eeTest = new EETest()

//addLitener
_(eeTest).on({
  a: 3,
  "get" () {
    this.a === 3 // true
    this.put() // can call it
  },
  "put": () => {},
  "post": () => {},
  "delete": () => {}
})

//addOnce
_(eeTest).once({
  b: 10,
  "get" () {
    this.b === 10 // true
    this.put() // can call it
  },
  "put": () => {},
  "post": () => {},
  "delete": () => {}
})

Special Thanks mafumafuultu