Goal is to create ecosystem for javascript types with possibility to define custom types. This package provide easy and deep objects map and comparing, generic creating, filtering by types, content & other stuff

npm install @randajan/jet-core

or

yarn add @randajan/jet-core

These methods, are exclusive for default jet export

will return jet type name of variable any

• Arguments
  • any: any variable
  • strict: boolean (true = return closest type)
• Return
  • all=false: top type of variable
  • all=true: array with all types of variable
• Example
  • jet.type([]) === "Array";
  • jet(new (class {})(), true) === undefined;
  • jet(new (class {})(), false) === "Object";

Defining custom types for detecting, creating and copying Same jet methods will be attached to jet.name, to constructor.jet.() and to prototype.jet.*()

• Arguments
  • name: string (name of the type)
  • constructor: class
  • options: object
    • 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)
    • extend: _boolean (false=turn off extension of constructor and prototype)
    • extendConstructor: _boolean or object (false=turn off extension of constructor)
    • extendPrototype: _boolean or object (false=turn off extension of prototype)
• Return
  • constructor
• Example
  • jet.type.define("Array", Array, { create:x=>new Array(x), copy:x=>Array.from(x) } );
  • jet.type.define("Element", Element, { extendConstructor:{ find:query=>document.querySelector(query) } });

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

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

Return true if any typeof === function

• Arguments
  • any: any variable
• Return
  • true when variable is runnable
• Example
  • jet.isRunnable([]) === false
  • jet.isRunnable({}) === false;
  • jet.isRunnable(()=>{}) === true;

These methods acumulate main funcstionality. After 'jet.define(name, consturctor)' is called, those methods are attached to 3 different endpoints.

1. Global dynamic: jet.method(name, ...args)
2. Global static: _jet.method.name(...args)
3. Constructor: constructor.jet.method(...args)

Check the passed type with result. Endpoint 'jet.is(name, ...a)' also work like typeof and instanceof

• Arguments
  • name: string (name of the type)
  • any: any variable
  • strict: boolean (true = is instanceof)
• Example
  • jet.is.Array([]) === true;
  • jet.is.Object([]) === false;
  • jet.is.Object([], true) === true;
  • jet.is.RegExp(RegExp()) === true;

Catching empty mapable objects and NaN

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

Will create instance requested constructor (use without "new")

• Arguments
  • name: string (name of the type)
  • ...args: will be passed to the creating function
• Return
  • new instance
• Example
  • jet.create.Array("foo", "bar") == ["foo", "bar"];
  • jet.create.Object() == {};

Will create instance with random value

• Arguments
  • name: string (name of the type)
  • ...args: will be passed to the defined rnd method
• Return
  • new instance with random value

Used for selecting, filtering, creating or copying variables

• Arguments
  • name: string (name of the type)
  • ...any: any variables (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.only.Sring(1, "foo", [], ["bar"], {foo:"bar"}) == "foo";
  • jet.tap.Array(1, "foo", [], ["bar"], {foo:"bar"}) == [];
  • jet.full.Array(1, "foo", [], ["bar"], {foo:"bar"}) == ["bar"];
  • jet.only.RegExp(1, "foo", [], ["bar"], {foo:"bar"}) == null;
  • jet.tap.RegExp(1, "foo", [], ["bar"], {foo:"bar"}) == RegExp();
  • jet.pull.Object(1, "foo", [], ["bar"], {foo:"bar"}) == {foo:"bar"}

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.vals({foo:"bar"}) === ["bar"];
  • jet.keys({foo:"bar"}) === ["foo"];
  • jet.entries({foo:"bar"}) === [["foo"], ["bar"]];
  • jet.get({foo:"bar"}, "foo") === "bar";

• Arguments
  • length: number (desired length)
  • pattern: string (list of characters)
• Return
  • string (pseudo random)
• Example
  • jet.uid(8, "a") === "aaaaaaaa"

Will create copy of instance

• Arguments
  • any: any variable
  • deep: boolean (deep copy of mapable objects)
  • copyUnmapable: boolean (copy even unmapable values in the deep nested structure)
• Return
  • new instance or the old if there wasn't defined copy function
• Example
  • x = [{a:Symbol("test")}]; y = jet.copy(x); console.log(x===y, x[0]===y[0], x[0].a===y[0].a) // false true true
  • x = [{a:Symbol("test")}]; y = jet.copy(x, true); console.log(x===y, x[0]===y[0], x[0].a===y[0].a) // false false true
  • x = [{a:Symbol("test")}]; y = jet.copy(x, true, true); console.log(x===y, x[0]===y[0], x[0].a===y[0].a) // false false false

Will deflate nested structure to the flat object where indexes are whole original dot-separated paths

• Arguments
  • any: any variable
  • includeMapable: boolean
• Return
  • includeMapable=false: object (alle values exclude mapable values in original structure)
  • includeMapable=true: object (all values include mapable values in original structure)
• Example
  • jet.deflate({a:{b:["c"]}}) === {"a.b.0": "c"}
  • jet.deflate({a:{b:["c"]}}, true) === {"a.b.0": "c"}
  • jet.deflate({a:["c"]}, true) === { "a":["c"], "a.0":"c", "":{"a":["c"]} }

Will compare two variables include deep nested objects

• Arguments
  • anyA: any variable
  • anyB: any variable
  • diffList: boolean
• Return
  • diffList=false: boolean (false if the content is same)
  • diffList=true: boolean (list of differencies)
• Example
  • jet.compare({a:{b:["c"]}}, {a:{b:["c"]}}) === true
  • jet.compare({a:{b:["c"]}}, {a:{b:["d"]}}) === false
  • jet.compare({a:{b:["c"]}}, {a:{b:["d"]}}, true) === ["a.b.0"];

Will join any values even values of deep nested structure

• Arguments
  • any: any variable
  • comma: string ()
• Return
  • string (comma separated values)
• Example
  • jet.melt({a:["b", "c"], d:"e"}, ", ") === "b, c, e"

Exploring nested structure by path

• Arguments
  • any: any mapable variable
  • path: string or Array (even nested Array)
  • reductor: function(next, parent, dir+key, dir, key, isEnd)
• Return
  • result of first iteration of reductor

Return value from deep nested object

• Arguments
  • any: any mapable variable
  • path: string or Array (even nested Array)
  • val: any
  • force: boolean (create path if not exist)
  • reductor: function(next, parent, dir+key, dir, key, isEnd)
• Return
  • any
• Example
  • jet.digIn({}, "foo.0", "bar", true) == {foo:["bar"]};

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.digOut({foo:["bar"]}, "foo.0") == "bar";
  • jet.digOut({foo:["bar"]}, ["foo", 1], "foo") == "foo";

Will run every function that will discover

• Arguments
  • any: any (function || array/object with functions
  • ...args: arguments will be passed to every call
• Return
  • any=function: result of function
  • any=array/object: array of all results
• Example
  • jet.run(_=>console.log("foo")) console: "foo"

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

• Arguments
  • any: any mapable variable
  • fce: function(val, dir+key, dir, key) (handler)
  • deep: boolean or function (true=recursive maping; function=custom recursive maping)
  • dir: string (base dir of structure)
• Return
  • forEach: flat array with result from handler function
  • map: copy of structure with result from handler function
• Example
  • jet.forEach({foo:"bar"}, =>) == ["bar"];
  • jet.map({foo:"bar"}, =>) == {foo:"bar"};

MIT © randajan