transmutable/lib/benchmark.js

immutable objects that pretend to be mutable

'use strict';

var assert = require('assert');

var _require = require('.'),
    transform = _require.transform;
//const { State } = require('../mea/state');


var _require2 = require('./testUtils'),
    createExample = _require2.createExample;

var immer = require('immer').default;

var _require3 = require('immer'),
    setAutoFreeze = _require3.setAutoFreeze,
    setUseProxies = _require3.setUseProxies;

var _require4 = require('./docData'),
    benchmarks = _require4.benchmarks;

setAutoFreeze(false);
var max = benchmarks.max;

var original = {
    arr: []
};

var HOW_MANY_OBJECTS_TO_PUSH = 100;
for (var i = 0; i < 1000; i++) {
    original.arr.push({ a: i });
}

function transformer(state) {
    // for (let i = 0; i < 100; i++) {
    //     state['o' + i] = Object.assign({}, state.arr[1]);
    // }
    for (var _i = 0; _i < HOW_MANY_OBJECTS_TO_PUSH; _i++) {
        state.arr[_i].done = true;
    }
}

function benchmark(code, name) {
    var t0 = Date.now();
    var res = void 0;
    for (var _i2 = 0; _i2 < max; _i2++) {
        res = code();
    } //console.log(original.arr.length, res.arr.length)
    var t1 = Date.now();
    console.log('* Time for ' + name + ': ', t1 - t0 + 'ms');
}

console.log('\nchanging ' + HOW_MANY_OBJECTS_TO_PUSH + ' objects in array of ' + original.arr.length + ' items. Repeated ' + max + ' times.\n');
console.log('\nES6 Proxies\n');
benchmark(function () {
    return transform(transformer, original);
}, 'transmutable (ES6 - Proxy)');

benchmark(function () {
    return immer(original, transformer);
}, 'immer (ES6 - proxies, without autofreeze)');

console.log("\nES5 fallback\n");
benchmark(function () {
    var P = Proxy;
    Proxy = undefined;
    transform(transformer, original);
    Proxy = P;
}, 'transmutable (ES5 - diffing)');

benchmark(function () {
    setUseProxies(false);
    immer(original, transformer);
    setUseProxies(true);
}, 'immer (ES5 - getters/setters, without autofreeze)');

// benchmark(() => {
//     const state = new State(original);
//     state.run(transformer);
//     return state.get();
// }, 'transmutable (State object)- array')
//

console.log('\nupdating arbitrary object, one nested update. Repeated ' + max + ' times\n');
console.log("\nES6 Proxies\n");
benchmark(function () {
    return transform(function (state) {
        state.c.d = {};
    }, createExample());
}, 'transmutable (ES6 - proxies)');

benchmark(function () {
    return immer(createExample(), function (state) {
        state.c.d = {};
    });
}, 'immer - (ES6 - proxies, without autofreeze)');

console.log("\nES5 fallback\n");
// TODO tests should be both (ES6 and ES5) for transmutable and immer.

benchmark(function () {
    var P = Proxy;
    Proxy = undefined;
    transform(function (state) {
        state.c.d = {};
    }, createExample());
    Proxy = P;
}, 'transmutable (ES5 - diffing) - example');

benchmark(function () {
    setUseProxies(false);
    immer(createExample(), function (state) {
        state.c.d = {};
    });
    setUseProxies(true);
}, 'immer - (ES5 - getters/setters, without autofreeze)');

var state = createExample();
// benchmark(() => {
//
//     const res = Object.assign(
//         {},
//         state,
//         {c: Object.assign({}, state.c, {d: {}})},
//     )
//
//     // const expected = createExample();
//     // expected.c.d = {};
//     // assert.deepStrictEqual(res, expected);
//     return res;
//     // return transform((state) => {
//     //     state.c.d = {};
//     // }, );
// }, 'hand crafted - example')