@epam/uui-db 4.2.2

package/index.js

@@ -0,0 +1,1831 @@
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "/";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 0);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "../node_modules/tslib/tslib.es6.js":
+/*!******************************************!*\
+  !*** ../node_modules/tslib/tslib.es6.js ***!
+  \******************************************/
+/*! exports provided: __extends, __assign, __rest, __decorate, __param, __metadata, __awaiter, __generator, __createBinding, __exportStar, __values, __read, __spread, __spreadArrays, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault, __classPrivateFieldGet, __classPrivateFieldSet */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__extends", function() { return __extends; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__assign", function() { return __assign; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__rest", function() { return __rest; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__decorate", function() { return __decorate; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__param", function() { return __param; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__metadata", function() { return __metadata; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__awaiter", function() { return __awaiter; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__generator", function() { return __generator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__createBinding", function() { return __createBinding; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__exportStar", function() { return __exportStar; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__values", function() { return __values; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__read", function() { return __read; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spread", function() { return __spread; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spreadArrays", function() { return __spreadArrays; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__await", function() { return __await; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncGenerator", function() { return __asyncGenerator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncDelegator", function() { return __asyncDelegator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncValues", function() { return __asyncValues; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__makeTemplateObject", function() { return __makeTemplateObject; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importStar", function() { return __importStar; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importDefault", function() { return __importDefault; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__classPrivateFieldGet", function() { return __classPrivateFieldGet; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__classPrivateFieldSet", function() { return __classPrivateFieldSet; });
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __createBinding(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}
+
+function __exportStar(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result.default = mod;
+    return result;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+}
+
+
+/***/ }),
+
+/***/ "./index.tsx":
+/*!*******************!*\
+  !*** ./index.tsx ***!
+  \*******************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+tslib_1.__exportStar(__webpack_require__(/*! ./src */ "./src/index.ts"), exports);
+
+
+/***/ }),
+
+/***/ "./src/Db.ts":
+/*!*******************!*\
+  !*** ./src/Db.ts ***!
+  \*******************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Db = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+var lodash_isequal_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
+var Db = /** @class */ (function () {
+    function Db(tables, reusedCache) {
+        this.tables = tables;
+        this.viewCache = new Map();
+        /* Views (cached db projections) */
+        this.valueAbsent = Symbol("ValueAbsent");
+        if (reusedCache) {
+            this.viewCache = new Map(reusedCache);
+        }
+        else {
+            this.viewCache = new Map();
+        }
+    }
+    Db.prototype.update = function (mutate) {
+        var clone = new this.constructor(tslib_1.__assign({}, this.tables), this.viewCache);
+        mutate(clone);
+        return clone;
+    };
+    Db.prototype.with = function (patch) {
+        return this.update(function (db) {
+            utils_1.objectKeys(db.tables).forEach(function (entityName) {
+                if (patch[entityName]) {
+                    db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
+                }
+            });
+        });
+    };
+    Db.prototype.runView = function (view, params) {
+        var cache = this.viewCache.get(view);
+        if (!cache) {
+            cache = new Map();
+            this.viewCache.set(view, cache);
+        }
+        var key = view.getKey ? view.getKey(params) : JSON.stringify(params);
+        var cacheItem = cache.get(key);
+        if (!cacheItem) {
+            cacheItem = {
+                dependencies: this.valueAbsent,
+                currentValue: this.valueAbsent,
+                computedOnDb: this.valueAbsent,
+            };
+            cache.set(key, cacheItem);
+        }
+        var shouldUpdate = this !== cacheItem.computedOnDb;
+        var dependencies = this.valueAbsent;
+        if (view.getDependencies) {
+            var compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
+            dependencies = view.getDependencies(this, params);
+            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
+        }
+        var previousValue = cacheItem.currentValue;
+        if (shouldUpdate) {
+            cacheItem.dependencies = dependencies;
+            var newValue = view.compute(this, params, dependencies);
+            cacheItem.computedOnDb = this;
+            var compareResults = view.compareResults || lodash_isequal_1.default;
+            if (!compareResults(previousValue, newValue)) {
+                if (view.traceDiff) {
+                    console.debug(utils_1.difference(previousValue, newValue));
+                }
+                cacheItem.currentValue = newValue;
+            }
+        }
+        return cacheItem.currentValue;
+    };
+    return Db;
+}());
+exports.Db = Db;
+
+
+/***/ }),
+
+/***/ "./src/DbRef.ts":
+/*!**********************!*\
+  !*** ./src/DbRef.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbRef = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var patchHelpers_1 = __webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts");
+var tempIds_1 = __webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx");
+var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+var lodash_isempty_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.isempty */ "lodash.isempty"));
+var Loader_1 = __webpack_require__(/*! ./Loader */ "./src/Loader.ts");
+var SimpleLoadingTracker_1 = __webpack_require__(/*! ./SimpleLoadingTracker */ "./src/SimpleLoadingTracker.ts");
+var ListLoadingTracker_1 = __webpack_require__(/*! ./ListLoadingTracker */ "./src/ListLoadingTracker.ts");
+var DbRef = /** @class */ (function () {
+    function DbRef(blank) {
+        var _this = this;
+        this.blank = blank;
+        this.log = [];
+        this.autoSave = true;
+        this.savedPoint = 0;
+        this.errors = [];
+        this.throttleSaveMs = 1000;
+        /* Update subscriptions (aka live views) */
+        this.lastSubscriptionId = 1;
+        this.subscriptions = new Map();
+        this.updateHandlers = [];
+        /* Error Subscriptions */
+        this.saveErrorHandlers = [];
+        /* Save scheduling */
+        this.isSaveInProgress = false;
+        this.isSaveThrottled = false;
+        this.handleBeforeUnload = function (e) {
+            if (_this.isSaveInProgress || _this.isSaveThrottled) {
+                e.returnValue = false;
+                return false;
+            }
+        };
+        this.loaders = [];
+        this.db = blank;
+        this.base = blank;
+        this.tempIdMap = new tempIds_1.TempIdMap(blank);
+        this.idMap = this.tempIdMap;
+        window.addEventListener('beforeunload', this.handleBeforeUnload);
+    }
+    /** Saves all committed patches. Useful only if autoSave is off. */
+    DbRef.prototype.save = function () {
+        this.enqueueSave();
+        this.update();
+    };
+    DbRef.prototype.getAutoSave = function () {
+        return this.autoSave;
+    };
+    DbRef.prototype.setAutoSave = function (val) {
+        if (this.autoSave != val) {
+            this.autoSave = val;
+            this.enqueueSave();
+            this.update();
+        }
+    };
+    /** Concrete DbRef instances should override and implement their save logic in this method */
+    DbRef.prototype.savePatch = function (patch) {
+        return Promise.resolve({ submit: {} });
+    };
+    /* Db Update logic */
+    DbRef.prototype.commit = function (patch) {
+        try {
+            var dbBeforeUpdate = this.db.with(patch);
+            patch = this.beforeUpdate(patch, dbBeforeUpdate.tables, this.db.tables);
+            patch = patchHelpers_1.mergeEntityPatches(this.db.tables, patch);
+            this.log.push({ patch: patch });
+            this.db = this.db.with(patch);
+            this.autoSave && this.enqueueSave();
+            this.update();
+        }
+        catch (e) {
+            this.saveError(patch, e);
+        }
+    };
+    DbRef.prototype.beforeUpdate = function (patch, tables, prevTables) {
+        var _this = this;
+        var patchAndDependencies = {};
+        utils_1.objectKeys(tables).filter(function (entityName) { return patch[entityName] && !tables[entityName].schema.beforeUpdate; }).forEach(function (entityName) {
+            patchAndDependencies[entityName] = patch[entityName];
+        });
+        utils_1.objectKeys(tables).filter(function (entityName) { return patch[entityName] && tables[entityName].schema.beforeUpdate; }).forEach(function (entityName) {
+            var _a;
+            var schema = tables[entityName].schema;
+            var beforeUpdate = schema.beforeUpdate;
+            var context = {
+                clientIdsMap: _this.tempIdMap,
+                schema: schema,
+                tables: tables,
+                prevTables: prevTables,
+            };
+            var results = patch[entityName].map(function (e) { return beforeUpdate(e, context); });
+            var updatedPatch = (_a = {}, _a[entityName] = results.map(function (result) { return result.entity; }), _a);
+            var dependentEntityPatchesForUpdate = patchHelpers_1.unionPatches(results.filter(function (result) { return result.dependentEntities; }).map(function (result) { return result.dependentEntities; }));
+            var dependentEntityPatches = _this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
+            patchAndDependencies = patchHelpers_1.mergeEntityPatches(tables, patchHelpers_1.unionPatches([patchAndDependencies, updatedPatch, dependentEntityPatches]));
+        });
+        return patchAndDependencies;
+    };
+    DbRef.prototype.commitFetch = function (patch) {
+        patch = this.tempIdMap.serverToClientPatch(patch);
+        this.rebase(this.base.with(patch));
+        this.update();
+    };
+    DbRef.prototype.rebase = function (newBase) {
+        this.base = newBase;
+        this.db = newBase;
+        for (var n = this.savedPoint; n < this.log.length; n++) {
+            this.db = this.db.with(this.log[n].patch);
+        }
+    };
+    DbRef.prototype.makeCumulativePatch = function () {
+        var lastLogEntry = this.log.length;
+        var logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
+        var cumulativePatch = patchHelpers_1.makeCumulativePatch(this.db, logEntriesToSave.map(function (t) { return t.patch; }), this.tempIdMap);
+        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
+        return cumulativePatch;
+    };
+    DbRef.prototype.applyResponse = function (response, newSavedPoint) {
+        var _this = this;
+        if (this.errors.length == 0) {
+            this.tempIdMap.appendServerMapping(response);
+            var serverPatch = patchHelpers_1.flattenResponse(response.submit, this.db.tables);
+            serverPatch = patchHelpers_1.mergeEntityPatches(this.db.tables, serverPatch);
+            this.savedPoint = newSavedPoint;
+            this.base = this.db;
+            this.commitFetch(serverPatch);
+            if (this.autoSave) {
+                this.isSaveThrottled = true;
+                setTimeout(function () {
+                    _this.isSaveThrottled = false;
+                    if (_this.savedPoint < _this.log.length) {
+                        _this.enqueueSave();
+                    }
+                }, this.throttleSaveMs);
+            }
+        }
+    };
+    DbRef.prototype.subscribe = function (view, params, onUpdate) {
+        var _this = this;
+        var id = this.lastSubscriptionId++;
+        var subscription = {
+            update: function (params) {
+                subscription.currentParams = params;
+                subscription.currentValue = _this.db.runView(view, params);
+                return subscription.currentValue;
+            },
+            currentParams: null,
+            currentValue: null,
+            onUpdate: onUpdate,
+            unsubscribe: function () { _this.subscriptions.delete(id); },
+        };
+        subscription.update(params);
+        this.subscriptions.set(id, subscription);
+        return subscription;
+    };
+    DbRef.prototype.onUpdate = function (handler) {
+        this.subscribe({
+            compute: function (db) { return db; },
+            compareResults: function (a, b) { return a === b; },
+        }, null, handler);
+    };
+    DbRef.prototype.update = function () {
+        this.subscriptions.forEach(function (subscription) {
+            var previousValue = subscription.currentValue;
+            subscription.update(subscription.currentParams);
+            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
+                subscription.onUpdate(subscription.currentValue);
+            }
+        });
+    };
+    DbRef.prototype.onSaveError = function (handler) {
+        this.saveErrorHandlers.push(handler);
+    };
+    DbRef.prototype.saveError = function (request, error) {
+        this.saveErrorHandlers.forEach(function (handler) { return handler(request, error); });
+    };
+    DbRef.prototype.enqueueSave = function () {
+        var _this = this;
+        if (!this.isSaveInProgress && !this.isSaveThrottled) {
+            try {
+                this.isSaveInProgress = true;
+                var lastLogEntry_1 = this.log.length;
+                var cumulativePatch_1 = this.makeCumulativePatch();
+                if (lodash_isempty_1.default(cumulativePatch_1)) {
+                    this.isSaveInProgress = false;
+                    return;
+                }
+                this.savePatch(cumulativePatch_1)
+                    .then(function (response) {
+                    _this.applyResponse(response, lastLogEntry_1);
+                    _this.isSaveInProgress = false;
+                    _this.update();
+                })
+                    .catch(function (reason) {
+                    _this.saveError(cumulativePatch_1, reason);
+                    _this.isSaveInProgress = false;
+                    _this.update();
+                });
+            }
+            catch (e) {
+                this.isSaveInProgress = false;
+                this.isSaveThrottled = false;
+                throw e;
+            }
+        }
+    };
+    DbRef.prototype.makeLoader = function (options) {
+        var loader = new Loader_1.Loader(this, function () { return new SimpleLoadingTracker_1.SimpleLoadingTracker(); }, options);
+        this.loaders.push(loader);
+        return loader;
+    };
+    DbRef.prototype.makeListLoader = function (options) {
+        var loader = new Loader_1.Loader(this, function () { return new ListLoadingTracker_1.ListLoadingTracker(); }, options);
+        this.loaders.push(loader);
+        return loader;
+    };
+    DbRef.prototype.reload = function () {
+        this.loaders = [];
+    };
+    return DbRef;
+}());
+exports.DbRef = DbRef;
+
+
+/***/ }),
+
+/***/ "./src/DbTable.ts":
+/*!************************!*\
+  !*** ./src/DbTable.ts ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbTable = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var I = tslib_1.__importStar(__webpack_require__(/*! immutable */ "immutable"));
+var uui_1 = __webpack_require__(/*! @epam/uui */ "@epam/uui");
+var immutable_1 = __webpack_require__(/*! immutable */ "immutable");
+var DbTable = /** @class */ (function () {
+    function DbTable(schema, state, q) {
+        this.schema = schema;
+        this.state = state;
+        this.q = q;
+        if (!state) {
+            var indexes = (schema.indexes || []).map(function (indexDef) {
+                return {
+                    field: indexDef,
+                    map: I.Map(),
+                };
+            });
+            this.state = { pk: I.Map(), indexes: indexes };
+        }
+        if (!q) {
+            this.q = {};
+        }
+    }
+    DbTable.prototype.keyToImmutable = function (id) {
+        if (Array.isArray(id)) {
+            return I.List(id);
+        }
+        else {
+            return id;
+        }
+    };
+    DbTable.prototype.byId = function (id) {
+        return this.state.pk.get(this.keyToImmutable(id));
+    };
+    DbTable.prototype.getId = function (entity) {
+        if (Array.isArray(this.schema.primaryKey)) {
+            return this.schema.primaryKey.map(function (key) { return entity[key]; });
+        }
+        return entity[this.schema.primaryKey];
+    };
+    DbTable.prototype.update = function (mutate) {
+        var clone = new this.constructor(this.schema, this.state, this.q);
+        mutate(clone);
+        return clone;
+    };
+    /* Mutation */
+    DbTable.prototype.with = function (patch) {
+        var _this = this;
+        var updates = patch.map(function (entityPatch) {
+            var id = _this.getId(entityPatch);
+            var immId = _this.keyToImmutable(id);
+            var existing = _this.state.pk.get(immId);
+            var updated = entityPatch;
+            if (existing) {
+                updated = tslib_1.__assign(tslib_1.__assign({}, existing), entityPatch);
+            }
+            return { id: id, immId: immId, patch: entityPatch, existing: existing, updated: updated, updatedFieldsisNew: !existing };
+        });
+        var idVal = immutable_1.Seq.Keyed(updates.map(function (entity) { return [entity.immId, entity.updated]; }));
+        var newPk = this.state.pk.merge(idVal);
+        var newIndexes = this.state.indexes.map(function (index) {
+            var newMap = index.map;
+            var _loop_1 = function (n) {
+                var update = updates[n];
+                var newKey = update.updated[index.field];
+                if (update.existing) {
+                    var oldKey = update.existing[index.field];
+                    if (oldKey !== newKey) {
+                        newMap = newMap.update(oldKey, function (set) { return set.remove(update.immId); });
+                    }
+                }
+                newMap = newMap.update(newKey, I.Set(), function (set) { return set.add(update.immId); });
+            };
+            for (var n = 0; n < updates.length; n++) {
+                _loop_1(n);
+            }
+            return tslib_1.__assign(tslib_1.__assign({}, index), { map: newMap });
+        });
+        var newState = { pk: newPk, indexes: newIndexes };
+        return this.update(function (t) { return t.state = newState; });
+    };
+    /* Query */
+    DbTable.prototype.find = function (filter) {
+        var _this = this;
+        return this.update(function (t) { return t.q = tslib_1.__assign(tslib_1.__assign({}, t.q), { filter: tslib_1.__assign(tslib_1.__assign({}, _this.q.filter), filter) }); });
+    };
+    DbTable.prototype.order = function (order) {
+        return this.update(function (t) { return t.q = tslib_1.__assign(tslib_1.__assign({}, t.q), { sorting: order }); });
+    };
+    DbTable.prototype.orderBy = function (field, direction) {
+        if (direction === void 0) { direction = 'asc'; }
+        return this.update(function (t) { return t.q = tslib_1.__assign(tslib_1.__assign({}, t.q), { sorting: [{ field: field, direction: direction }] }); });
+    };
+    DbTable.prototype.thenBy = function (field, direction) {
+        return this.update(function (t) { return t.q = tslib_1.__assign(tslib_1.__assign({}, t.q), { sorting: tslib_1.__spreadArrays(t.q.sorting, [{ field: field, direction: direction }]) }); });
+    };
+    DbTable.prototype.search = function (text) {
+        if (!this.schema.searchBy) {
+            throw new Error("Can't search in the " + this.schema.typeName + " table - searchBy is not defined in the schema.");
+        }
+        return this.update(function (t) { return t.q = tslib_1.__assign(tslib_1.__assign({}, t.q), { search: text }); });
+    };
+    /* Materializing */
+    DbTable.prototype.range = function (from, count) {
+        return this.runQuery(tslib_1.__assign(tslib_1.__assign({}, this.q), { range: { from: from, count: count } }));
+    };
+    DbTable.prototype.count = function () {
+        return this.runQuery(this.q).length;
+    };
+    DbTable.prototype.one = function () {
+        return this.runQuery(this.q)[0] || null;
+    };
+    DbTable.prototype.toArray = function () {
+        return this.runQuery(this.q);
+    };
+    DbTable.prototype.map = function (fn) {
+        return this.toArray().map(fn);
+    };
+    /* Query implementation */
+    DbTable.prototype.runQuery = function (q) {
+        var _this = this;
+        var result = null;
+        var filter = q.filter;
+        if (filter) {
+            var indexes = this.state.indexes;
+            // Try to use indexes to fulfill filter conditions
+            for (var n = 0; n < indexes.length; n++) {
+                var index = indexes[n];
+                if (index.field in filter) {
+                    var _a = filter, _b = index.field, condition = _a[_b], rest = tslib_1.__rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                    var conditionValues = null;
+                    if (condition != null && typeof condition === "object") {
+                        // Attempt to use index for 'in' and 'isNull' criteria.
+                        // We need to be very conservative here, indexed field should work the same way as getPatternPredicate. So
+                        // - it's better to leave corner cases to getPatternPredicate
+                        var _c = condition, inCriteria = _c.in, nullCriteria = _c.isNull, restCriteria = tslib_1.__rest(_c, ["in", "isNull"]);
+                        if (inCriteria && Array.isArray(inCriteria)) {
+                            conditionValues = inCriteria;
+                        }
+                        else {
+                            restCriteria.in = inCriteria;
+                        }
+                        // Conditions in getPatternPredicate are composed with 'and' logic,
+                        // For now, let's not attempt to handle tricky cases like { in: [1,2] isNull: true }, or { in: [1, null] isNull: false }
+                        // - just leave this to getPatternPredicate.
+                        // Let's just handle the a most common case { isNull: true } - find all null and undefined
+                        if (nullCriteria === true && !conditionValues) {
+                            conditionValues = [null, undefined];
+                        }
+                        else {
+                            restCriteria.in = inCriteria;
+                        }
+                        // Keep other conditions, e.g. { in: [1,2,3], isNull: true } - in works via index, isNull - via filter
+                        if (Object.keys(restCriteria).length > 0) {
+                            rest[index.field] = restCriteria;
+                        }
+                    }
+                    else {
+                        conditionValues = [condition];
+                    }
+                    if (conditionValues) {
+                        result = [];
+                        for (var i = 0; i < conditionValues.length; i++) {
+                            var idsSet = index.map.get(conditionValues[i]);
+                            if (idsSet) {
+                                var idsArray = idsSet.toArray();
+                                for (var j = 0; j < idsArray.length; j++) {
+                                    var item = this.state.pk.get(idsArray[j]);
+                                    result.push(item);
+                                }
+                            }
+                        }
+                        filter = Object.keys(rest).length > 0 ? rest : null;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!result) {
+            result = this.state.pk.toArray();
+        }
+        if (filter) {
+            var predicate = uui_1.getPatternPredicate(q.filter);
+            result = result.filter(predicate);
+        }
+        if (q.search) {
+            var searchFilter_1 = uui_1.getSearchFilter(q.search);
+            result = result.filter(function (item) { return searchFilter_1(_this.schema.searchBy.map(function (field) { return item[field]; })); });
+        }
+        if (q.sorting) {
+            var comparer = uui_1.getOrderComparer(q.sorting);
+            result = result.sort(comparer);
+        }
+        if (q.range) {
+            result = result.slice(q.range.from, q.range.from + q.range.count);
+        }
+        return result;
+    };
+    return DbTable;
+}());
+exports.DbTable = DbTable;
+
+
+/***/ }),
+
+/***/ "./src/ListLoadingTracker.ts":
+/*!***********************************!*\
+  !*** ./src/ListLoadingTracker.ts ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListLoadingTracker = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var ListLoadingTracker = /** @class */ (function () {
+    function ListLoadingTracker(options) {
+        this.options = options;
+        this.cache = new Map();
+        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || (function (r) { return r; });
+    }
+    ListLoadingTracker.prototype.prepare = function (request) {
+        var filter = request.filter, sorting = request.sorting, search = request.search, range = request.range, unknownFields = tslib_1.__rest(request, ["filter", "sorting", "search", "range"]);
+        var options = {};
+        if (filter) {
+            options.filter = filter;
+        }
+        if (sorting) {
+            options.sorting = sorting;
+        }
+        if (search) {
+            options.search = search;
+        }
+        var keyObject = tslib_1.__assign(tslib_1.__assign({}, options), unknownFields);
+        var key = JSON.stringify(keyObject);
+        var entry = this.cache.get(key);
+        if (!entry) {
+            entry = { options: options, count: 0, maxCount: null, isComplete: false };
+            this.cache.set(key, entry);
+        }
+        return { options: options, range: range, unknownFields: unknownFields, entry: entry };
+    };
+    ListLoadingTracker.prototype.diff = function (request) {
+        var _a = this.prepare(request), options = _a.options, range = _a.range, unknownFields = _a.unknownFields, entry = _a.entry;
+        if (entry.isComplete) {
+            return null;
+        }
+        if (!request.range) {
+            return request;
+        }
+        else {
+            var requestedMax = request.range.from + request.range.count;
+            var missingCount = requestedMax - entry.count;
+            if (entry.maxCount) {
+                missingCount = Math.min(missingCount, entry.maxCount);
+            }
+            if (missingCount > 0) {
+                return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
+            }
+            else {
+                return null;
+            }
+        }
+    };
+    ListLoadingTracker.prototype.count = function (request) {
+        var _a = this.prepare(request), options = _a.options, range = _a.range, unknownFields = _a.unknownFields, entry = _a.entry;
+        return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
+    };
+    ListLoadingTracker.prototype.append = function (request, response) {
+        var _a = this.prepare(request), options = _a.options, range = _a.range, unknownFields = _a.unknownFields, entry = _a.entry;
+        if (response) {
+            var list = this.extractList(response);
+            if (list.count) {
+                entry.maxCount = list.count;
+            }
+            if (!range) {
+                entry.count = list.items.length;
+                entry.maxCount = list.items.length;
+                entry.isComplete = true;
+            }
+            else {
+                var from = (list.from == null) ? range.from : list.from;
+                if (list.items.length > 0) {
+                    entry.count = Math.max(entry.count, from + list.items.length);
+                }
+                if (list.items.length < range.count) {
+                    entry.maxCount = from + list.items.length;
+                    entry.count = entry.maxCount;
+                    entry.isComplete = true;
+                }
+            }
+        }
+        else {
+            if (range) {
+                entry.count = Math.max(entry.count, request.range.from + request.range.count);
+            }
+            else {
+                entry.isComplete = true;
+            }
+        }
+    };
+    return ListLoadingTracker;
+}());
+exports.ListLoadingTracker = ListLoadingTracker;
+
+
+/***/ }),
+
+/***/ "./src/Loader.ts":
+/*!***********************!*\
+  !*** ./src/Loader.ts ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loader = void 0;
+var Loader = /** @class */ (function () {
+    function Loader(dbRef, getTracker, options) {
+        var _this = this;
+        this.dbRef = dbRef;
+        this.getTracker = getTracker;
+        this.options = options;
+        this.currentRequests = new Set();
+        this.load = function (inputRequest) {
+            var result = {
+                isComplete: _this.loaded.diff(inputRequest) == null,
+                isLoading: false,
+                request: inputRequest,
+                missing: _this.loadedAndLoading.diff(inputRequest),
+                promise: null,
+                reload: null,
+            };
+            result.reload = function () {
+                result.missing = inputRequest;
+                _this.loadImpl(result);
+            };
+            if (result.isComplete) {
+                // Everything requested is already loaded
+                result.isComplete = true;
+                result.isLoading = false;
+                result.promise = Promise.resolve();
+                return result;
+            }
+            else {
+                if (result.missing == null) {
+                    // Everything requested is either loaded already, or being loaded
+                    result.isComplete = false;
+                    result.isLoading = true;
+                    // There's no good way to tell which of current requests is querying requested data - there actually can be 2 of them.
+                    // So we track all running requests, and await all of them in such case.
+                    result.promise = Promise.all(_this.currentRequests.entries()).then(function () { });
+                    return result;
+                }
+                else {
+                    // Something requested is not loaded, nor being loaded. Need to perform a new request.
+                    _this.loadImpl(result);
+                    return result;
+                }
+            }
+        };
+        this.loaded = getTracker();
+        this.loadedAndLoading = getTracker();
+    }
+    Loader.prototype.loadImpl = function (state) {
+        var _this = this;
+        this.loadedAndLoading.append(state.missing);
+        state.isLoading = true;
+        var serverRequest = state.missing;
+        if (this.options.clientToServerRequest) {
+            serverRequest = this.options.clientToServerRequest(serverRequest);
+        }
+        state.promise = this.options.api(serverRequest).then(function (result) {
+            _this.loaded.append(state.missing, result);
+            _this.loadedAndLoading.append(state.missing, result);
+            state.missing = null;
+            state.isLoading = false;
+            state.isComplete = true;
+            state.promise = Promise.resolve();
+            var flatten = _this.options.convertToPatch(result);
+            _this.options.postProcess && _this.options.postProcess(flatten);
+            _this.dbRef.commitFetch(flatten);
+        });
+        this.currentRequests.add(state.promise);
+        state.promise.finally(function () {
+            _this.currentRequests.delete(state.promise);
+        });
+        return state.promise;
+    };
+    return Loader;
+}());
+exports.Loader = Loader;
+
+
+/***/ }),
+
+/***/ "./src/SimpleLoadingTracker.ts":
+/*!*************************************!*\
+  !*** ./src/SimpleLoadingTracker.ts ***!
+  \*************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleLoadingTracker = void 0;
+var SimpleLoadingTracker = /** @class */ (function () {
+    function SimpleLoadingTracker() {
+        this.set = new Set();
+    }
+    SimpleLoadingTracker.prototype.getKey = function (request) {
+        return JSON.stringify(request);
+    };
+    SimpleLoadingTracker.prototype.diff = function (request) {
+        return this.set.has(this.getKey(request)) ? null : request;
+    };
+    SimpleLoadingTracker.prototype.append = function (request, result) {
+        this.set.add(this.getKey(request));
+    };
+    return SimpleLoadingTracker;
+}());
+exports.SimpleLoadingTracker = SimpleLoadingTracker;
+
+
+/***/ }),
+
+/***/ "./src/index.ts":
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+tslib_1.__exportStar(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
+tslib_1.__exportStar(__webpack_require__(/*! ./Db */ "./src/Db.ts"), exports);
+tslib_1.__exportStar(__webpack_require__(/*! ./DbTable */ "./src/DbTable.ts"), exports);
+tslib_1.__exportStar(__webpack_require__(/*! ./DbRef */ "./src/DbRef.ts"), exports);
+tslib_1.__exportStar(__webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx"), exports);
+tslib_1.__exportStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"), exports);
+tslib_1.__exportStar(__webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts"), exports);
+tslib_1.__exportStar(__webpack_require__(/*! ./reactHooks */ "./src/reactHooks.ts"), exports);
+
+
+/***/ }),
+
+/***/ "./src/patchHelpers.ts":
+/*!*****************************!*\
+  !*** ./src/patchHelpers.ts ***!
+  \*****************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntityParentDependencies = exports.getParentEntities = exports.hasServerFields = exports.isNew = exports.getId = exports.isClientOnly = exports.makeCumulativePatch = exports.isPatchBlank = exports.flattenResponse = exports.mergeEntityPatches = exports.unionPatches = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+var I = tslib_1.__importStar(__webpack_require__(/*! immutable */ "immutable"));
+var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+var lodash_groupby_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.groupby */ "lodash.groupby"));
+var lodash_map_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.map */ "lodash.map"));
+var lodash_merge_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.merge */ "lodash.merge"));
+var lodash_countby_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.countby */ "lodash.countby"));
+var lodash_filter_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.filter */ "lodash.filter"));
+var lodash_foreach_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.foreach */ "lodash.foreach"));
+var lodash_pick_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.pick */ "lodash.pick"));
+function unionPatches(patches) {
+    var result = {};
+    patches.forEach(function (patch) {
+        utils_1.objectKeys(patch).forEach(function (tableName) {
+            result[tableName] = result[tableName] ? tslib_1.__spreadArrays(result[tableName], patch[tableName]) : patch[tableName];
+        });
+    });
+    return result;
+}
+exports.unionPatches = unionPatches;
+function mergeEntityPatches(tables, patch) {
+    var result = {};
+    utils_1.objectKeys(patch).forEach(function (key) {
+        var table = tables[key];
+        var groupedEntities = lodash_groupby_1.default(patch[key], function (item) { return table.getId(item); });
+        var tablePatch = lodash_map_1.default(groupedEntities, function (entities) {
+            var result = lodash_merge_1.default.apply(void 0, tslib_1.__spreadArrays([{}], entities));
+            if (true) {
+                var props = utils_1.objectKeys(result).filter(function (prop) {
+                    return Object.keys(lodash_countby_1.default(entities.filter(function (entity) {
+                        return entity[prop] !== undefined;
+                    }), function (entity) { return entity[prop]; })).length > 1;
+                });
+                if (props.length) {
+                    console.warn.apply(console, tslib_1.__spreadArrays(['mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n'], entities));
+                }
+            }
+            return result;
+        });
+        result[key] = tablePatch;
+    });
+    return result;
+}
+exports.mergeEntityPatches = mergeEntityPatches;
+function flattenResponseHelper(result, object, tablesByTypeName) {
+    if (Array.isArray(object)) {
+        object.forEach(function (item) { return flattenResponseHelper(result, item, tablesByTypeName); });
+    }
+    else if (typeof object === 'object') {
+        var clone = {};
+        var tableKey = void 0;
+        var fields = {};
+        if ('__typename' in object) {
+            var table = tablesByTypeName[object.__typename];
+            if (table) {
+                tableKey = table.schema.tableName;
+                fields = table.schema.fields;
+            }
+        }
+        for (var key in object) {
+            var value = object[key];
+            var field = fields[key];
+            if ((field && !!field.disableFlatten)
+                || typeof value !== 'object'
+                || value === null
+                || (Array.isArray(value) && value.every(function (item) { return typeof item !== 'object'; }))) {
+                clone[key] = value;
+            }
+            else {
+                flattenResponseHelper(result, value, tablesByTypeName);
+            }
+        }
+        if (tableKey) {
+            result[tableKey].push(clone);
+        }
+    }
+}
+function flattenResponse(response, tables) {
+    var result = {};
+    var tablesByTypeName = {};
+    Object.values(tables).forEach(function (table) { return tablesByTypeName[table.schema.typeName] = table; });
+    utils_1.objectKeys(tables).forEach(function (tableName) { return tablesByTypeName; });
+    utils_1.objectKeys(tables).forEach(function (key) { return result[key] = []; });
+    flattenResponseHelper(result, response, tablesByTypeName);
+    return result;
+}
+exports.flattenResponse = flattenResponse;
+function isPatchBlank(patch) {
+    return !utils_1.objectKeys(patch).some(function (key) { return patch[key].length > 0; });
+}
+exports.isPatchBlank = isPatchBlank;
+/**
+ * Given several patches, creates a new single patch with all fields from all entities in all patches.
+ */
+function makeCumulativePatch(updatedDb, patches, clientIdsMap) {
+    var result = {};
+    utils_1.objectKeys(updatedDb.tables).forEach(function (entityName) {
+        var table = updatedDb.tables[entityName];
+        var schema = table.schema;
+        var ids = I.Set();
+        patches.forEach(function (patch) {
+            var filteredPatch = (patch[entityName] || []).filter(function (entity) { return hasServerFields(entity, schema, clientIdsMap, updatedDb.tables); });
+            ids = ids.union(filteredPatch.map(function (e) { return table.getId(e); }));
+        });
+        var entities = ids
+            .map(function (id) { return table.byId(id); })
+            .filter(function (e) { return !isClientOnly(e, schema); })
+            .toArray();
+        if (entities.length > 0) {
+            result[entityName] = entities;
+        }
+    });
+    return result;
+}
+exports.makeCumulativePatch = makeCumulativePatch;
+function isClientOnly(entity, schema) {
+    if (typeof schema.isClientOnly === 'function') {
+        return schema.isClientOnly(entity);
+    }
+    return !!schema.isClientOnly;
+}
+exports.isClientOnly = isClientOnly;
+function getId(entity, schema) {
+    if (typeof schema.primaryKey == 'string') {
+        return entity[schema.primaryKey];
+    }
+    var result = [];
+    lodash_foreach_1.default(lodash_pick_1.default(entity, schema.primaryKey), function (value) {
+        result.push(value);
+    });
+    return result;
+}
+exports.getId = getId;
+function isNew(entity, schema, clientIdsMap) {
+    var id = getId(entity, schema);
+    return !clientIdsMap.clientToServer(id);
+}
+exports.isNew = isNew;
+function hasServerFields(entity, schema, clientIdsMap, tables) {
+    var fullEntity = tslib_1.__assign(tslib_1.__assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
+    if (isClientOnly(fullEntity, schema)) {
+        return false;
+    }
+    return utils_1.objectKeys(entity).some(function (fieldName) {
+        var fieldSchema = schema.fields[fieldName];
+        return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
+    });
+}
+exports.hasServerFields = hasServerFields;
+function getParentEntities(patch, tables) {
+    var dependenciesPatch = {};
+    utils_1.objectKeys(patch).forEach(function (key) {
+        var table = tables[key];
+        var tableSchema = table.schema;
+        var fields = lodash_filter_1.default(lodash_map_1.default(tableSchema.fields, function (field, name) { return (tslib_1.__assign(tslib_1.__assign({}, field), { name: name })); }), function (field) { return field.fk && field.fk.relationType == types_1.DbRelationType.Aggregation; });
+        var tablePatch = patch[key];
+        fields.forEach(function (field) {
+            var tableName = field.fk.tableName, name = field.name;
+            tablePatch.forEach(function (entity) {
+                var actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
+                var dbEntity = table.byId(table.getId(entity));
+                var parentEntity = tables[actualTableName].byId(dbEntity[name]);
+                var idFields = lodash_pick_1.default(parentEntity, tables[actualTableName].schema.primaryKey);
+                if (parentEntity) {
+                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
+                    dependenciesPatch[actualTableName].push(idFields);
+                }
+            });
+        });
+    });
+    return dependenciesPatch;
+}
+exports.getParentEntities = getParentEntities;
+function getEntityParentDependencies(entity, entityName, tables) {
+    var _a;
+    var patch = (_a = {}, _a[entityName] = [entity], _a);
+    var resultPatches = [];
+    while (true) {
+        var parents = getParentEntities(patch, tables);
+        if (isPatchBlank(parents)) {
+            break;
+        }
+        resultPatches.push(parents);
+        patch = parents;
+    }
+    var result = unionPatches(tslib_1.__spreadArrays([patch], resultPatches));
+    result = mergeEntityPatches(tables, result);
+    return result;
+}
+exports.getEntityParentDependencies = getEntityParentDependencies;
+
+
+/***/ }),
+
+/***/ "./src/reactHooks.ts":
+/*!***************************!*\
+  !*** ./src/reactHooks.ts ***!
+  \***************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDbView = exports.useDbRef = exports.DbContext = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var react_1 = __webpack_require__(/*! react */ "react");
+exports.DbContext = react_1.createContext(null);
+function useDbRef() {
+    return react_1.useContext(exports.DbContext);
+}
+exports.useDbRef = useDbRef;
+function useDbView(fn, params, options) {
+    var dbRef = useDbRef();
+    var _a = react_1.useState(), state = _a[0], setState = _a[1];
+    var subscription = react_1.useMemo(function () { return dbRef.subscribe(tslib_1.__assign({ compute: fn }, options), params, setState); }, []);
+    subscription.update(params);
+    react_1.useEffect(function () {
+        return function () { return subscription.unsubscribe(); };
+    }, []);
+    return subscription.currentValue;
+}
+exports.useDbView = useDbView;
+
+
+/***/ }),
+
+/***/ "./src/tempIds.tsx":
+/*!*************************!*\
+  !*** ./src/tempIds.tsx ***!
+  \*************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempIdMap = exports.isTempId = exports.getTempId = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+var lastTempId = -1;
+function getTempId() {
+    return --lastTempId;
+}
+exports.getTempId = getTempId;
+function isTempId(val) {
+    return typeof val === 'number' && val < 0;
+}
+exports.isTempId = isTempId;
+var TempIdMap = /** @class */ (function () {
+    function TempIdMap(db) {
+        var _this = this;
+        this.db = db;
+        this.serverToClientIds = new Map();
+        this.clientToServerIds = new Map();
+        this.clientToServer = function (id) { return _this.clientToServerIds.get(id); };
+        this.serverToClient = function (tableName, id) { return _this.getServerToClientMap(tableName).get(id); };
+        this.clientToServerRequest = function (request) {
+            request = tslib_1.__assign({}, request);
+            if (request.filter) {
+                request.filter = _this.clientToServerDataFilter(request.filter);
+            }
+            return request;
+        };
+        this.clientToServerDataFilter = function (filter) {
+            filter = tslib_1.__assign({}, filter);
+            var keys = Object.keys(filter);
+            // I hope that we can rely that there won't be any negative numbers, which are not IDs, in queries.
+            // We need to invent better heuristics or a schema otherwise.
+            var clientToServer = function (id) {
+                var found = _this.clientToServer(id);
+                if (found) {
+                    return found;
+                }
+                else {
+                    return id;
+                }
+            };
+            for (var n = 0; n < keys.length; n++) {
+                var key = keys[n];
+                var condition = filter[key];
+                if (condition != null && typeof condition === "object") {
+                    condition = tslib_1.__assign({}, condition);
+                    if ('in' in condition && Array.isArray(condition.in) && condition.in.length) {
+                        condition.in = condition.in.map(clientToServer);
+                    }
+                }
+                else {
+                    condition = clientToServer(condition);
+                }
+                filter[key] = condition;
+            }
+            return filter;
+        };
+    }
+    TempIdMap.prototype.copyPatch = function (patch) {
+        var newPatch = tslib_1.__assign({}, patch);
+        utils_1.objectKeys(patch).forEach(function (tableName) {
+            var tablePatch = patch[tableName].map(function (entityPatch) { return (tslib_1.__assign({}, entityPatch)); });
+            newPatch[tableName] = tablePatch;
+        });
+        return newPatch;
+    };
+    // Iterate thru every field in every patch for every table, matching certain field criteria. The patch is mutated!
+    TempIdMap.prototype.mapFields = function (patch, filter, callback) {
+        var _this = this;
+        utils_1.objectKeys(patch).forEach(function (tableName) {
+            var schema = _this.db.tables[tableName].schema;
+            var fields = utils_1.objectKeys(schema.fields || [])
+                .map(function (fieldName) {
+                var fieldSchema = schema.fields[fieldName];
+                if (filter(fieldSchema, fieldName)) {
+                    return { name: fieldName, schema: fieldSchema };
+                }
+            })
+                .filter(function (f) { return !!f; });
+            if (!fields.length) {
+                return;
+            }
+            patch[tableName].forEach(function (entityPatch) {
+                for (var n = 0; n < fields.length; n++) {
+                    var field = fields[n];
+                    var fieldValue = entityPatch[field.name];
+                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
+                }
+            });
+        });
+    };
+    TempIdMap.prototype.getServerToClientMap = function (tableName) {
+        var existing = this.serverToClientIds.get(tableName);
+        if (existing) {
+            return existing;
+        }
+        else {
+            var newMap = new Map();
+            this.serverToClientIds.set(tableName, newMap);
+            return newMap;
+        }
+    };
+    TempIdMap.prototype.serverToClientPatch = function (patch) {
+        var _this = this;
+        patch = this.copyPatch(patch);
+        // We map PK in a separate pass, as we need to remap all PKs before re-mapping FKs
+        this.mapFields(patch, function (f) { return f.isGenerated; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+            var clientId = _this.getServerToClientMap(tableName).get(fieldValue);
+            if (!clientId) {
+                clientId = getTempId();
+                _this.clientToServerIds.set(clientId, fieldValue);
+                _this.getServerToClientMap(tableName).set(fieldValue, clientId);
+            }
+            entityPatch[fieldName] = clientId;
+        });
+        this.mapFields(patch, function (f) { return !!(f.fk || (f.default != null) || f.toClient); }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+            var isUndefined = typeof (fieldValue) === 'undefined';
+            if (fieldSchema.default != null && fieldValue == null) {
+                fieldValue = fieldSchema.default;
+                isUndefined = false;
+            }
+            if (fieldSchema.fk && fieldValue != null) {
+                var fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
+                var clientId = _this.getServerToClientMap(fkTableName).get(fieldValue);
+                if (!clientId) {
+                    clientId = getTempId();
+                    _this.clientToServerIds.set(clientId, fieldValue);
+                    _this.getServerToClientMap(fkTableName).set(fieldValue, clientId);
+                }
+                fieldValue = clientId;
+            }
+            if (!isUndefined && fieldSchema.toClient) {
+                fieldValue = fieldSchema.toClient(fieldValue);
+            }
+            if (!isUndefined) {
+                entityPatch[fieldName] = fieldValue;
+            }
+        });
+        return patch;
+    };
+    TempIdMap.prototype.clientToServerPatch = function (patch) {
+        var _this = this;
+        patch = this.copyPatch(patch);
+        this.mapFields(patch, function (f) { return f.isGenerated || !!f.fk; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+            if (fieldValue != null) {
+                var existingId = _this.clientToServerIds.get(fieldValue);
+                if (existingId) {
+                    entityPatch[fieldName] = existingId;
+                }
+            }
+        });
+        this.mapFields(patch, function (f) { return !(f.isClientOnly || f.isReadOnly) && !!f.toServer; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
+        });
+        this.mapFields(patch, function (meta) { return meta.isClientOnly || meta.isReadOnly; }, function (fieldName, fieldSchema, fieldValue, entityPatch, tableName) {
+            delete entityPatch[fieldName];
+        });
+        return patch;
+    };
+    TempIdMap.prototype.appendServerMapping = function (response) {
+        var _this = this;
+        utils_1.objectKeys(response.submit).forEach(function (tableName) {
+            if (_this.db.tables[tableName]) {
+                var tablePatch = response.submit[tableName];
+                if (tablePatch) {
+                    var serverToClientIds_1 = _this.getServerToClientMap(tableName);
+                    var table_1 = _this.db.tables[tableName];
+                    tablePatch.forEach(function (patch) {
+                        if (isTempId(patch.id)) {
+                            var clientId = patch.id;
+                            var serverId = table_1.getId(patch.payload);
+                            serverToClientIds_1.set(serverId, clientId);
+                            _this.clientToServerIds.set(clientId, serverId);
+                        }
+                    });
+                }
+            }
+        });
+    };
+    return TempIdMap;
+}());
+exports.TempIdMap = TempIdMap;
+
+
+/***/ }),
+
+/***/ "./src/types.ts":
+/*!**********************!*\
+  !*** ./src/types.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbRelationType = void 0;
+var DbRelationType;
+(function (DbRelationType) {
+    DbRelationType[DbRelationType["Aggregation"] = 0] = "Aggregation";
+    DbRelationType[DbRelationType["Association"] = 1] = "Association";
+})(DbRelationType = exports.DbRelationType || (exports.DbRelationType = {}));
+
+
+/***/ }),
+
+/***/ "./src/utils.ts":
+/*!**********************!*\
+  !*** ./src/utils.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.difference = exports.defaultCompareViewDependencies = exports.objectKeys = void 0;
+var tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+var shallowequal_1 = tslib_1.__importDefault(__webpack_require__(/*! shallowequal */ "shallowequal"));
+var lodash_zip_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.zip */ "lodash.zip"));
+var lodash_transform_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.transform */ "lodash.transform"));
+var lodash_isequal_1 = tslib_1.__importDefault(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
+// TBD: New typescript would contain better typing for this. Remove this hack after update.
+exports.objectKeys = Object.keys;
+function defaultCompareViewDependencies(prev, next) {
+    if (Array.isArray(prev) && Array.isArray(next)) {
+        if (prev.length === next.length) {
+            return lodash_zip_1.default(prev, next).every(function (_a) {
+                var p = _a[0], n = _a[1];
+                return shallowequal_1.default(p, n);
+            });
+        }
+        return false;
+    }
+    return shallowequal_1.default(prev, next);
+}
+exports.defaultCompareViewDependencies = defaultCompareViewDependencies;
+/**
+ * Deep diff between two object, using lodash
+ * @param  {Object} object Object compared
+ * @param  {Object} base   Object to compare with
+ * @return {Object}        Return a new object who represent the diff
+ */
+function difference(object, base) {
+    function changes(object, base) {
+        return lodash_transform_1.default(object, function (result, value, key) {
+            if (!lodash_isequal_1.default(value, base[key])) {
+                result[key] = (typeof value === "object" && typeof base[key] === "object") ? changes(value, base[key]) : value;
+            }
+        });
+    }
+    return changes(object, base);
+}
+exports.difference = difference;
+
+
+/***/ }),
+
+/***/ 0:
+/*!*************************!*\
+  !*** multi ./index.tsx ***!
+  \*************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(/*! /Users/aliaksei_manetau/work/UUI/uui-db/index.tsx */"./index.tsx");
+
+
+/***/ }),
+
+/***/ "@epam/uui":
+/*!****************************!*\
+  !*** external "@epam/uui" ***!
+  \****************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("@epam/uui");
+
+/***/ }),
+
+/***/ "immutable":
+/*!****************************!*\
+  !*** external "immutable" ***!
+  \****************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("immutable");
+
+/***/ }),
+
+/***/ "lodash.countby":
+/*!*********************************!*\
+  !*** external "lodash.countby" ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.countby");
+
+/***/ }),
+
+/***/ "lodash.filter":
+/*!********************************!*\
+  !*** external "lodash.filter" ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.filter");
+
+/***/ }),
+
+/***/ "lodash.foreach":
+/*!*********************************!*\
+  !*** external "lodash.foreach" ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.foreach");
+
+/***/ }),
+
+/***/ "lodash.groupby":
+/*!*********************************!*\
+  !*** external "lodash.groupby" ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.groupby");
+
+/***/ }),
+
+/***/ "lodash.isempty":
+/*!*********************************!*\
+  !*** external "lodash.isempty" ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.isempty");
+
+/***/ }),
+
+/***/ "lodash.isequal":
+/*!*********************************!*\
+  !*** external "lodash.isequal" ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.isequal");
+
+/***/ }),
+
+/***/ "lodash.map":
+/*!*****************************!*\
+  !*** external "lodash.map" ***!
+  \*****************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.map");
+
+/***/ }),
+
+/***/ "lodash.merge":
+/*!*******************************!*\
+  !*** external "lodash.merge" ***!
+  \*******************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.merge");
+
+/***/ }),
+
+/***/ "lodash.pick":
+/*!******************************!*\
+  !*** external "lodash.pick" ***!
+  \******************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.pick");
+
+/***/ }),
+
+/***/ "lodash.transform":
+/*!***********************************!*\
+  !*** external "lodash.transform" ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.transform");
+
+/***/ }),
+
+/***/ "lodash.zip":
+/*!*****************************!*\
+  !*** external "lodash.zip" ***!
+  \*****************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("lodash.zip");
+
+/***/ }),
+
+/***/ "react":
+/*!************************!*\
+  !*** external "react" ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("react");
+
+/***/ }),
+
+/***/ "shallowequal":
+/*!*******************************!*\
+  !*** external "shallowequal" ***!
+  \*******************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("shallowequal");
+
+/***/ })
+
+/******/ });
+//# sourceMappingURL=index.js.map