Universe Utilities

Installation

$ meteor add universe:utilities

Functions

UniUtils.set(object, pathInObject, value)

Creates an empty object inside namespace if not existent.

UniUtils.set({}, 'a.b.c', 'here');
//output: Object {a:{b:{c:"here"}}}

UniUtils.get(object, pathInObject, defaultValue)

Returns nested key value.

@param obj
@param key
@example var obj = {
        foo : {
            bar : 11
        }
    };

 get(obj, 'foo.bar'); // "11"
 get(obj, 'ipsum.dolorem.sit');  // undefined
@returns {*} found key or undefined if key doesn't exist.

UniUtils.has

Checks if object contains a child key. Useful for cases where you need to check if an object contain a nested key.

Recursive Iterator

Iterates javascript object recursively. Works in ES6 environments iteration protocols. Compatible with for...of cycle.

1var iterator = new UniUtils.RecursiveIterator(
2    root /*{Object|Array}*/,
3    // Method bypass of tree: `vertical` or `horizontal`
4    [bypassMode="vertical"] /*{String}*/, 
5    [ignoreCircular=false] /*{Boolean}*/,
6    [maxDeep=100] /*{Number}*/
7);
8
9var {value, done} = iterator.next();
10var {parent, node, key, path, deep} = value;
11
12// parent is parent node
13// node is current node
14// key is key of node
15// path is path to node
16// deep is current deep

iterator.isNode(node);

Returns true if any is node (as a default node is {Object}).

iterator.isLeaf(node);

Returns true if node is leaf. Leaf is all primitive types.

iterator.isCircular(node);

Returns true if object is circular reference.

iterator.onStepInto(state); // state = iterator.next();

It calls for each node. If returns false node will be skipped. You can override this function, if you need to have custom behavior

Example (es6)

1var root = {
2    object: {
3        number: 1
4    },
5    string: 'foo'
6};
7
8for(let {node, path} of new UniUtils.RecursiveIterator(root)) {
9    console.log(path.join('.'), node);
10}
11
12// object    Object {number: 1}
13// object.number    1
14// string    foo

UniUtils.findKey

Search key in object or array

@param obj or array
@param search predicate function or value
@param context

UniUtils.deepExtend

Recursive object extending.

1var obj1 = {
2    a: 1,
3    b: 2,
4    d: {
5        a: 1,
6        b: [],
7        c: { test1: 123, test2: 321 }
8    },
9    f: 5,
10    g: 123,
11    i: 321,
12    j: [1, 2]
13};
14var obj2 = {
15    b: 3,
16    c: 5,
17    d: {
18        b: { first: 'one', second: 'two' },
19        c: { test2: 222 }
20    },
21    e: { one: 1, two: 2 },
22    f: [],
23    g: (void 0),
24    h: /abc/g,
25    i: null,
26    j: [3, 4]
27};
28
29UniUtils.deepExtend(obj1, obj2);
30
31console.log(obj1);
32/*
33{ a: 1,
34  b: 3,
35  d:
36   { a: 1,
37     b: { first: 'one', second: 'two' },
38     c: { test1: 123, test2: 222 } },
39  f: null,
40  g: undefined,
41  c: 5,
42  e: { one: 1, two: 2 },
43  h: /abc/g,
44  i: null,
45  j: [3, 4] }
46*/

UniUtils.deepEqual

Node's assert.deepEqual() algorithm as a standalone module. This module is around 5 times faster than wrapping assert.deepEqual() in a try/catch.

1
2console.dir([
3    UniUtils.deepEqual(
4        { a : [ 2, 3 ], b : [ 4 ] },
5        { a : [ 2, 3 ], b : [ 4 ] }
6    ),
7    UniUtils.deepEqual(
8        { x : 5, y : [6] },
9        { x : 5, y : 6 }
10    )
11]);

UniUtils.deepEqual(a, b, opts) Compare objects a and b, returning whether they are equal according to a recursive equality algorithm.

If opts.strict is true, use strict equality (===) to compare leaf nodes. The default is to use coercive equality (==) because that's how assert.deepEqual() works by default.

UniUtils.getFieldsFromUpdateModifier(modifier)

Gets array of top-level fields, which will be changed by modifier (this from update method)

UniUtils.getFieldsFromUpdateModifier({$set: {a:1, b:2, c:4}, $inc: {d:1}});
// output: ["a", "b", "c", "d"]

UniUtils.getPreviewOfDocumentAfterUpdate(updateModifier, oldDoc = {})

Gets simulation of new version of document passed as a second argument

UniUtils.getPreviewOfDocumentAfterUpdate({$set: {a:1, b:2, c:4}, $inc: {d:1}}, {a:2});
// output: Object {a: 1, b: 2, c: 4, d: 1}

UniConfig

provides a simple configuration mechanism.

UniConfig provides on client side reactive method ready() (it's available on server too but always returns true) and hook onReady(), which calls passed callback only when config is ready.

UniConfig.onReady(function(){
    if(this.public.get('myKey')){
        //do something
    }
});

All types have methods get, set, getRow. But arguments for individual types can be different.

UniConfig.private - this type of config is available ONLY on server side.

 .get (name, defaultValue)
 .set (name, value)
 .getRow (name)
 .runOnce(name, function)

UniConfig.private.runOnce - call function only once and save date about this in private config, but if function threw error or returned false. function will be not check as executed.

UniConfig.users - this one is dedicated for users, it's available on both sides but on client it contains only stuff for logged in user.

.get (name, defaultValue, userId)
.set (name, value, userId)
.getRow (name, userId)

* userId is needed only on server side

UniConfig.public - this type is available on both sides, every can change setting, unless it was added with true value passed as the third parameter of set method.

 .get (name, defaultValue)
 .set (name, value, isServerWriteOnly)
 .getRow (name)

Writing Access in public scope

Package will grant the writing access in client side for: - every single user if this package is used without universe:collection package. - but if universe:collection is added to the project only admins can set records

You can validate access right for client calls by registering own validator:

    UniConfig.public.onAccessValidation(function(userId, settingObject, proposedResult){
    var user = Meteor.users.findOne(userId);
        return user && user.hasAccessForThis;
    })

And many more - check the source#

Licence

This package is distributed under MIT

Some parts of this package was based under:

substack/node-deep-equal
unclechu/node-deep-extend
[nervgh/recursive-iterator] (https://github.com/nervgh/recursive-iterator)