@randajan/jetpack

@randajan/jetpack

Collection of devtools

Install

npm install --save @randajan/jetpack

About

Custom types, maping objects, generic creating, filtering by types & other stuff

Main content

jet.type

Superstructure of native typeof and instanceof methods

• Arguments
  • any: any variable
  • all: boolean (return all types?)
• Return
  • all=false || undefined: top type of variable
  • all=true: array with all types of variable sorted by its priority
• Example
  • jet.type([], true) === ["arr", "object"];
  • jet.type(RegExp()) === "regex";

jet.type.define

Defining custom types for detecting, creating and copying

• Arguments
  • name: string (name of the type)
  • constructor: class
  • opt: object
    • rank: number (>= 0)
    • create: function (creating new instance)
    • is: function (verify type of variable)
    • full: function (check if variable is full)
    • copy: function (perform copy)
    • rnd: function (create with random content)
    • keys: function (array of keys for mapable types)
    • vals: function (array of values for mapable types)
    • pairs: function (array of entries for mapable types)
    • get: function (get key for mapable types)
    • set: function (set key for mapable types)
    • rem: function (rem key for mapable types)
  • custom: object (functions that should be appended to jet.*)
• Return
  • object similiar to jet.* when successfully defined
• Example
  • jet.type.define("arr", Array, { rank:-1, create:x=>new Array(x), copy:x=>Array.from(x) } );
  • jet.type.define("ele", Element, { rank:-1 }, { find:query=>document.querySelector(query) });

jet.type.is

Check the passed type with result from instanceof compare || jet.type

• Arguments
  • type: string (type name) || class (for compare instanceof)
  • any: any variable
  • inclusive: boolean
• Return
  • type=class: any instanceof type
  • inclusive=true: true when the type is included in result of jet.type all=true
• Example
  • jet.is(Array, []) === true;
  • jet.is("arr", []) === true;
  • jet.is("obj", []) === false;
  • jet.is("obj", [], true) === true;
  • jet.is("regex", RegExp()) === true;

jet.type.is.map

Return true on any type of variable that has mapable=true on its type definition

• Arguments
  • any: any variable
• Return
  • true when variable is mapable
• Example
  • jet.is.map([]) === true
  • jet.is.map({}) === true;
  • jet.is.map("foo") === false;

jet.type.is.full

Catching empty mapable objects and NaN

• Arguments
  • any: any variable
• Return
  • true when variable is full
• Example
  • jet.is.full([]) === false;
  • jet.is.full({foo:bar}) === true;

jet.*

Will create instance requested * type (use without "new")

• Arguments
  • ...args: will be passed to the creating function
• Return
  • new instance
• Example
  • jet.arr("foo", "bar") == ["foo", "bar"];
  • jet.obj() == {};
  • jet.ele() ==
    ;

jet.*.is / .is.full

Same as jet.type.is && jet.type.is.full but without first argument

jet.*.copy

Will create copy of instance

• Arguments
  • any: any variable
• Return
  • new instance or the old if there isn't defined copy function
• Example
  • jet.obj.copy({a:1}) == Object.assign({}, {a:1});
  • jet.arr.copy(["foo", "bar"]) == Array.from(["foo", "bar"]);

jet.*.only / .tap / .full / .pull

Used for selecting, filtering, creating or copying variables

• Arguments
  • ...args: any variable (will be tested in order until the type will match)
• Return
  • only: undefined when there is no match
  • full: same as only but variable must be full
  • tap: same as only but try to create the type when there is no match
  • pull: same as tap but try to copy variable if there is match
• Example
  • jet.str.only(1, "foo", [], ["bar"], {foo:"bar"}) == "foo";
  • jet.arr.tap(1, "foo", [], ["bar"], {foo:"bar"}) == [];
  • jet.arr.full(1, "foo", [], ["bar"], {foo:"bar"}) == ["bar"];
  • jet.regex.only(1, "foo", [], ["bar"], {foo:"bar"}) == null;
  • jet.regex.tap(1, "foo", [], ["bar"], {foo:"bar"}) == RegExp();
  • jet.obj.pull(1, "foo", [], ["bar"], {foo:"bar"}) == {foo:"bar"}

jet.map.vals / .keys / .pairs / .get / .set / .rem

Handle mapable objects (it requires defined type)

• Arguments
  • any: any variable
  • key: any variable (usually string or number)
  • val: any variable (used just for for set function)
• Return
  • result from perform operation against the defined type_
• Example
  • jet.map.get({foo:"bar"}, "bar") === "bar";

jet.map.dig

Return value from deep nested object

• Arguments
  • any: any mapable variable
  • path: string or Array (even nested Array)
  • def: any
• Return
  • find value or def when no value was found
• Example
  • jet.map.dig({foo:["bar"]}, "foo.0") == "bar";
  • jet.map.dig({foo:["bar"]}, ["foo", 1], "foo") == "foo";

jet.map.it / .of

Map any mapable object by default: Object, Array, Set, Map, Pool

• Arguments
  • any: any mapable variable
  • fce: function(val, key, path) (handler)
  • deep: boolean (recursive maping)
• Return
  • it: flat array containing all items
  • of: copy of structure with result from handler function
• Example
  • jet.map.it({foo:"bar"}, =>) == 1;
  • jet.map.of({foo:"bar"}, =>"foo"+) == {foo:"foobar"};

jet.fce.run

Will run every function that will discover without collecting results

• Arguments
  • any: any (function || array/object with functions
  • ...args: arguments will be passed to every call
• Return
  • any=function: true when it was run successfully
  • any=array/object: count of succesfully runned functions
• Example
  • jet.fce.run(=>console.log()) === true console: "foo"

License

MIT © randajan