@epam/uui-db 4.9.2 → 4.10.0-rc.2

package/index.js

@@ -1,126 +1,157 @@
-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);
-/******/ })
-/************************************************************************/
-/******/ ({
+'use strict';
+
+var shallowEqual = require('shallowequal');
+var zip = require('lodash.zip');
+var transform = require('lodash.transform');
+var isEqual = require('lodash.isequal');
+var I = require('immutable');
+var uuiCore = require('@epam/uui-core');
+var groupBy = require('lodash.groupby');
+var map = require('lodash.map');
+var merge = require('lodash.merge');
+var countBy = require('lodash.countby');
+var filter = require('lodash.filter');
+var forEach = require('lodash.foreach');
+var pick = require('lodash.pick');
+var isEmpty = require('lodash.isempty');
+var react = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var shallowEqual__default = /*#__PURE__*/_interopDefault(shallowEqual);
+var zip__default = /*#__PURE__*/_interopDefault(zip);
+var transform__default = /*#__PURE__*/_interopDefault(transform);
+var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
+var I__namespace = /*#__PURE__*/_interopNamespace(I);
+var groupBy__default = /*#__PURE__*/_interopDefault(groupBy);
+var map__default = /*#__PURE__*/_interopDefault(map);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
+var countBy__default = /*#__PURE__*/_interopDefault(countBy);
+var filter__default = /*#__PURE__*/_interopDefault(filter);
+var forEach__default = /*#__PURE__*/_interopDefault(forEach);
+var pick__default = /*#__PURE__*/_interopDefault(pick);
+var isEmpty__default = /*#__PURE__*/_interopDefault(isEmpty);
+
+exports.DbRelationType = void 0;
+(function (DbRelationType) {
+    DbRelationType[DbRelationType["Aggregation"] = 0] = "Aggregation";
+    DbRelationType[DbRelationType["Association"] = 1] = "Association";
+})(exports.DbRelationType || (exports.DbRelationType = {}));
+
+// TBD: New typescript would contain better typing for this. Remove this hack after update.
+let objectKeys = Object.keys;
+function defaultCompareViewDependencies(prev, next) {
+    if (Array.isArray(prev) && Array.isArray(next)) {
+        if (prev.length === next.length) {
+            return zip__default.default(prev, next).every(([p, n]) => shallowEqual__default.default(p, n));
+        }
+        return false;
+    }
+    return shallowEqual__default.default(prev, next);
+}
+/**
+ * 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 transform__default.default(object, function (result, value, key) {
+            if (!isEqual__default.default(value, base[key])) {
+                result[key] = (typeof value === "object" && typeof base[key] === "object") ? changes(value, base[key]) : value;
+            }
+        });
+    }
+    return changes(object, base);
+}
+
+class Db {
+    constructor(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();
+        }
+    }
+    update(mutate) {
+        const clone = new this.constructor(this.tables, this.viewCache);
+        clone.tables = Object.assign({}, this.tables);
+        mutate(clone);
+        return clone;
+    }
+    with(patch) {
+        return this.update(db => {
+            objectKeys(db.tables).forEach(entityName => {
+                if (patch[entityName]) {
+                    db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
+                }
+            });
+        });
+    }
+    runView(view, params) {
+        let cache = this.viewCache.get(view);
+        if (!cache) {
+            cache = new Map();
+            this.viewCache.set(view, cache);
+        }
+        const key = view.getKey ? view.getKey(params) : JSON.stringify(params);
+        let cacheItem = cache.get(key);
+        if (!cacheItem) {
+            cacheItem = {
+                dependencies: this.valueAbsent,
+                currentValue: this.valueAbsent,
+                computedOnDb: this.valueAbsent,
+            };
+            cache.set(key, cacheItem);
+        }
+        let shouldUpdate = this !== cacheItem.computedOnDb;
+        let dependencies = this.valueAbsent;
+        if (view.getDependencies) {
+            const compare = view.compareDependencies || defaultCompareViewDependencies;
+            dependencies = view.getDependencies(this, params);
+            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
+        }
+        let previousValue = cacheItem.currentValue;
+        if (shouldUpdate) {
+            cacheItem.dependencies = dependencies;
+            let newValue = view.compute(this, params, dependencies);
+            cacheItem.computedOnDb = this;
+            let compareResults = view.compareResults || isEqual__default.default;
+            if (!compareResults(previousValue, newValue)) {
+                if (view.traceDiff) {
+                    console.debug(difference(previousValue, newValue));
+                }
+                cacheItem.currentValue = newValue;
+            }
+        }
+        return cacheItem.currentValue;
+    }
+}
 
-/***/ "../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, __spreadArray, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault, __classPrivateFieldGet, __classPrivateFieldSet, __classPrivateFieldIn */
-/***/ (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__, "__spreadArray", function() { return __spreadArray; });
-/* 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; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__classPrivateFieldIn", function() { return __classPrivateFieldIn; });
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -135,33 +166,6 @@ 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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    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 = {};
@@ -175,21 +179,6 @@ function __rest(s, e) {
     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) {
@@ -198,1614 +187,932 @@ function __awaiter(thisArg, _arguments, P, generator) {
         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 };
-    }
-}
-
-var __createBinding = Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-});
-
-function __exportStar(m, o) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, 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;
-}
-
-/** @deprecated */
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
-}
-
-/** @deprecated */
-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 __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-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;
-};
-
-var __setModuleDefault = Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-};
-
-function __importStar(mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-}
-
-function __importDefault(mod) {
-    return (mod && mod.__esModule) ? mod : { default: mod };
-}
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-function __classPrivateFieldIn(state, receiver) {
-    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
-    return typeof state === "function" ? receiver === state : state.has(receiver);
-}
-
-
-/***/ }),
-
-/***/ "./index.tsx":
-/*!*******************!*\
-  !*** ./index.tsx ***!
-  \*******************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-(0, 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;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-const lodash_isequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isequal */ "lodash.isequal"));
-class Db {
-    constructor(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();
-        }
-    }
-    update(mutate) {
-        const clone = new this.constructor(this.tables, this.viewCache);
-        clone.tables = Object.assign({}, this.tables);
-        mutate(clone);
-        return clone;
-    }
-    with(patch) {
-        return this.update(db => {
-            (0, utils_1.objectKeys)(db.tables).forEach(entityName => {
-                if (patch[entityName]) {
-                    db.tables[entityName] = db.tables[entityName].with(patch[entityName]);
-                }
-            });
-        });
-    }
-    runView(view, params) {
-        let cache = this.viewCache.get(view);
-        if (!cache) {
-            cache = new Map();
-            this.viewCache.set(view, cache);
-        }
-        const key = view.getKey ? view.getKey(params) : JSON.stringify(params);
-        let cacheItem = cache.get(key);
-        if (!cacheItem) {
-            cacheItem = {
-                dependencies: this.valueAbsent,
-                currentValue: this.valueAbsent,
-                computedOnDb: this.valueAbsent,
-            };
-            cache.set(key, cacheItem);
-        }
-        let shouldUpdate = this !== cacheItem.computedOnDb;
-        let dependencies = this.valueAbsent;
-        if (view.getDependencies) {
-            const compare = view.compareDependencies || utils_1.defaultCompareViewDependencies;
-            dependencies = view.getDependencies(this, params);
-            shouldUpdate = !compare(cacheItem.dependencies, dependencies);
-        }
-        let previousValue = cacheItem.currentValue;
-        if (shouldUpdate) {
-            cacheItem.dependencies = dependencies;
-            let newValue = view.compute(this, params, dependencies);
-            cacheItem.computedOnDb = this;
-            let compareResults = view.compareResults || lodash_isequal_1.default;
-            if (!compareResults(previousValue, newValue)) {
-                if (view.traceDiff) {
-                    console.debug((0, utils_1.difference)(previousValue, newValue));
-                }
-                cacheItem.currentValue = newValue;
-            }
-        }
-        return cacheItem.currentValue;
-    }
-}
-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;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const patchHelpers_1 = __webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts");
-const tempIds_1 = __webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx");
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-const lodash_isempty_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.isempty */ "lodash.isempty"));
-const Loader_1 = __webpack_require__(/*! ./Loader */ "./src/Loader.ts");
-const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
-const SimpleLoadingTracker_1 = __webpack_require__(/*! ./SimpleLoadingTracker */ "./src/SimpleLoadingTracker.ts");
-const ListLoadingTracker_1 = __webpack_require__(/*! ./ListLoadingTracker */ "./src/ListLoadingTracker.ts");
-class DbRef {
-    constructor(blank) {
-        this.blank = blank;
-        this.log = [];
-        this.autoSave = true;
-        this.savedPoint = 0;
-        this.throttleSaveMs = 1000;
-        /* Update subscriptions (aka live views) */
-        this.lastSubscriptionId = 1;
-        this.subscriptions = new Map();
-        this.updateHandlers = [];
-        /* Error Subscriptions */
-        this.saveErrorHandlers = [];
-        /* Save scheduling */
-        this.enqueueSave = (0, uui_core_1.batch)(() => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const cumulativePatch = this.makeCumulativePatch();
-            const lastLogEntry = this.log.length;
-            if ((0, lodash_isempty_1.default)(cumulativePatch)) {
-                return;
-            }
-            try {
-                const response = yield this.savePatch(cumulativePatch);
-                this.applyResponse(response, lastLogEntry);
-                this.update();
-            }
-            catch (error) {
-                this.saveError(cumulativePatch, error);
-                this.update();
-                throw error;
-            }
-        }));
-        this.handleBeforeUnload = (e) => {
-            if (this.enqueueSave.isBusy) {
-                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. */
-    save() {
-        return this.enqueueSave();
-    }
-    getAutoSave() {
-        return this.autoSave;
-    }
-    setAutoSave(val) {
-        if (this.autoSave != val) {
-            this.autoSave = val;
-            this.autoSave && this.enqueueSave();
-            this.update();
-        }
-    }
-    revert() {
-        this.db = this.base;
-        this.log = this.log.slice(0, this.savedPoint);
-        this.update();
-    }
-    /** Concrete DbRef instances should override and implement their save logic in this method */
-    savePatch(patch) {
-        return Promise.resolve({ submit: {} });
-    }
-    /* Db Update logic */
-    commit(patch) {
-        const dbBeforeUpdate = this.db.with(patch);
-        patch = this.beforeUpdate(patch, dbBeforeUpdate.tables, this.db.tables);
-        patch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, patch);
-        this.log.push({ patch });
-        this.db = this.db.with(patch);
-        this.autoSave && this.enqueueSave(null, { throttleMs: this.throttleSaveMs });
-        this.update();
-    }
-    beforeUpdate(patch, tables, prevTables) {
-        let patchAndDependencies = {};
-        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && !tables[entityName].schema.beforeUpdate).forEach(entityName => {
-            patchAndDependencies[entityName] = patch[entityName];
-        });
-        (0, utils_1.objectKeys)(tables).filter(entityName => patch[entityName] && tables[entityName].schema.beforeUpdate).forEach(entityName => {
-            const schema = tables[entityName].schema;
-            const { beforeUpdate } = schema;
-            let context = {
-                clientIdsMap: this.tempIdMap,
-                schema,
-                tables,
-                prevTables,
-            };
-            const results = patch[entityName].map(e => beforeUpdate(e, context));
-            const updatedPatch = { [entityName]: results.map(result => result.entity) };
-            const dependentEntityPatchesForUpdate = (0, patchHelpers_1.unionPatches)(results.filter(result => result.dependentEntities).map(result => result.dependentEntities));
-            const dependentEntityPatches = this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
-            patchAndDependencies = (0, patchHelpers_1.mergeEntityPatches)(tables, (0, patchHelpers_1.unionPatches)([patchAndDependencies, updatedPatch, dependentEntityPatches]));
-        });
-        return patchAndDependencies;
-    }
-    commitFetch(patch) {
-        patch = this.tempIdMap.serverToClientPatch(patch);
-        this.rebase(this.base.with(patch));
-        this.update();
-    }
-    rebase(newBase) {
-        this.base = newBase;
-        this.db = newBase;
-        for (let n = this.savedPoint; n < this.log.length; n++) {
-            this.db = this.db.with(this.log[n].patch);
-        }
-    }
-    makeCumulativePatch() {
-        const lastLogEntry = this.log.length;
-        const logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
-        let cumulativePatch = (0, patchHelpers_1.makeCumulativePatch)(this.db, logEntriesToSave.map(t => t.patch), this.tempIdMap);
-        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
-        return cumulativePatch;
-    }
-    applyResponse(response, newSavedPoint) {
-        this.tempIdMap.appendServerMapping(response);
-        let serverPatch = (0, patchHelpers_1.flattenResponse)(response.submit, this.db.tables);
-        serverPatch = (0, patchHelpers_1.mergeEntityPatches)(this.db.tables, serverPatch);
-        this.savedPoint = newSavedPoint;
-        this.base = this.db;
-        this.commitFetch(serverPatch);
-    }
-    subscribe(view, params, onUpdate) {
-        const id = this.lastSubscriptionId++;
-        const subscription = {
-            update: (params) => {
-                subscription.currentParams = params;
-                subscription.currentValue = this.db.runView(view, params);
-                return subscription.currentValue;
-            },
-            currentParams: null,
-            currentValue: null,
-            onUpdate,
-            unsubscribe: () => { this.subscriptions.delete(id); },
-        };
-        subscription.update(params);
-        this.subscriptions.set(id, subscription);
-        return subscription;
-    }
-    onUpdate(handler) {
-        this.subscribe({
-            compute: db => db,
-            compareResults: (a, b) => a === b,
-        }, null, handler);
-    }
-    update() {
-        this.subscriptions.forEach(subscription => {
-            const previousValue = subscription.currentValue;
-            subscription.update(subscription.currentParams);
-            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
-                subscription.onUpdate(subscription.currentValue);
-            }
-        });
-    }
-    onSaveError(handler) {
-        this.saveErrorHandlers.push(handler);
-    }
-    saveError(request, error) {
-        this.saveErrorHandlers.forEach(handler => handler(request, error));
-    }
-    makeLoader(options) {
-        const loader = new Loader_1.Loader(this, () => new SimpleLoadingTracker_1.SimpleLoadingTracker(), options);
-        this.loaders.push(loader);
-        return loader;
-    }
-    makeListLoader(options) {
-        const loader = new Loader_1.Loader(this, () => new ListLoadingTracker_1.ListLoadingTracker(), options);
-        this.loaders.push(loader);
-        return loader;
-    }
-    reload() {
-        this.loaders = [];
-    }
-}
-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;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
-const uui_core_1 = __webpack_require__(/*! @epam/uui-core */ "@epam/uui-core");
-const immutable_1 = __webpack_require__(/*! immutable */ "immutable");
-class DbTable {
-    constructor(schema, state, q) {
-        this.schema = schema;
-        this.state = state;
-        this.q = q;
-        if (!state) {
-            const indexes = (schema.indexes || []).map(indexDef => {
-                return {
-                    field: indexDef,
-                    map: I.Map(),
-                };
-            });
-            this.state = { pk: I.Map(), indexes };
-        }
-        if (!q) {
-            this.q = {};
-        }
-    }
-    keyToImmutable(id) {
-        if (Array.isArray(id)) {
-            return I.List(id);
-        }
-        else {
-            return id;
-        }
-    }
-    byId(id) {
-        return this.state.pk.get(this.keyToImmutable(id));
-    }
-    getId(entity) {
-        if (Array.isArray(this.schema.primaryKey)) {
-            return this.schema.primaryKey.map((key) => entity[key]);
-        }
-        return entity[this.schema.primaryKey];
-    }
-    update(mutate) {
-        const clone = new this.constructor(this.schema, this.state, this.q);
-        mutate(clone);
-        return clone;
-    }
-    /* Mutation */
-    with(patch) {
-        const updates = patch.map(entityPatch => {
-            const id = this.getId(entityPatch);
-            const immId = this.keyToImmutable(id);
-            const existing = this.state.pk.get(immId);
-            let isDeleted = false;
-            let updated = entityPatch;
-            if (existing) {
-                updated = Object.assign(Object.assign({}, existing), entityPatch);
-                if (this.schema.deleteFlag) {
-                    isDeleted = updated[this.schema.deleteFlag] === true;
-                }
-            }
-            return { id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted };
-        });
-        const idVal = immutable_1.Seq.Keyed(updates.map(entity => [entity.immId, entity.updated]));
-        let newPk = this.state.pk.merge(idVal);
-        // TBD: replace with deleteAll after migrating to immutable 4
-        updates.filter(u => u.isDeleted).forEach(u => {
-            newPk = newPk.delete(u.immId);
-        });
-        const newIndexes = this.state.indexes.map(index => {
-            let newMap = index.map;
-            for (let n = 0; n < updates.length; n++) {
-                let update = updates[n];
-                const newKey = update.updated[index.field];
-                if (update.existing) {
-                    const oldKey = update.existing[index.field];
-                    if (oldKey !== newKey || update.isDeleted) {
-                        newMap = newMap.update(oldKey, set => set.remove(update.immId));
-                    }
-                }
-                if (!update.isDeleted) {
-                    newMap = newMap.update(newKey, I.Set(), set => set.add(update.immId));
-                }
-            }
-            return Object.assign(Object.assign({}, index), { map: newMap });
-        });
-        const newState = { pk: newPk, indexes: newIndexes };
-        return this.update(t => t.state = newState);
-    }
-    /* Query */
-    find(filter) {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { filter: Object.assign(Object.assign({}, this.q.filter), filter) }));
-    }
-    order(order) {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: order }));
-    }
-    orderBy(field, direction = 'asc') {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [{ field, direction }] }));
-    }
-    thenBy(field, direction) {
-        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [...t.q.sorting, { field, direction }] }));
-    }
-    search(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(t => t.q = Object.assign(Object.assign({}, t.q), { search: text }));
-    }
-    /* Materializing */
-    range(from, count) {
-        return this.runQuery(Object.assign(Object.assign({}, this.q), { range: { from, count } }));
-    }
-    count() {
-        return this.runQuery(this.q).length;
-    }
-    one() {
-        return this.runQuery(this.q)[0] || null;
-    }
-    toArray() {
-        return this.runQuery(this.q);
-    }
-    map(fn) {
-        return this.toArray().map(fn);
-    }
-    /* Query implementation */
-    runQuery(q) {
-        let result = null;
-        let filter = q.filter;
-        if (filter) {
-            let indexes = this.state.indexes;
-            // Try to use indexes to fulfill filter conditions
-            for (let n = 0; n < indexes.length; n++) {
-                const index = indexes[n];
-                if (index.field in filter) {
-                    const _a = filter, _b = index.field, condition = _a[_b], rest = (0, tslib_1.__rest)(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-                    let 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
-                        const _c = condition, { in: inCriteria, isNull: nullCriteria } = _c, restCriteria = (0, 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 (let i = 0; i < conditionValues.length; i++) {
-                            const idsSet = index.map.get(conditionValues[i]);
-                            if (idsSet) {
-                                const idsArray = idsSet.toArray();
-                                for (let j = 0; j < idsArray.length; j++) {
-                                    const 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) {
-            let predicate = (0, uui_core_1.getFilterPredicate)(q.filter);
-            result = result.filter(predicate);
-        }
-        if (q.search) {
-            let searchFilter = (0, uui_core_1.getSearchFilter)(q.search);
-            result = result.filter(item => searchFilter(this.schema.searchBy.map(field => item[field])));
-        }
-        if (q.sorting) {
-            let comparer = (0, uui_core_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;
-    }
-}
-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;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-class ListLoadingTracker {
-    constructor(options) {
-        this.options = options;
-        this.cache = new Map();
-        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || ((r) => r);
-    }
-    prepare(request) {
-        const { filter, sorting, search, range } = request, unknownFields = (0, tslib_1.__rest)(request, ["filter", "sorting", "search", "range"]);
-        const options = {};
-        if (filter) {
-            options.filter = filter;
-        }
-        if (sorting) {
-            options.sorting = sorting;
-        }
-        if (search) {
-            options.search = search;
-        }
-        let keyObject = Object.assign(Object.assign({}, options), unknownFields);
-        const key = JSON.stringify(keyObject);
-        let entry = this.cache.get(key);
-        if (!entry) {
-            entry = { options, count: 0, maxCount: null, isComplete: false };
-            this.cache.set(key, entry);
-        }
-        return { options, range, unknownFields, entry };
-    }
-    diff(request) {
-        const { options, range, unknownFields, entry } = this.prepare(request);
-        if (entry.isComplete) {
-            return null;
-        }
-        if (!request.range) {
-            return request;
-        }
-        else {
-            const requestedMax = request.range.from + request.range.count;
-            let missingCount = requestedMax - entry.count;
-            if (entry.maxCount) {
-                missingCount = Math.min(missingCount, entry.maxCount);
-            }
-            if (missingCount > 0) {
-                return Object.assign(Object.assign(Object.assign({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
-            }
-            else {
-                return null;
-            }
-        }
-    }
-    count(request) {
-        const { entry } = this.prepare(request);
-        return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
-    }
-    append(request, response) {
-        const { options, range, unknownFields, entry } = this.prepare(request);
-        if (response) {
-            const 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 {
-                const 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;
-            }
-        }
-    }
-}
-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;
-class Loader {
-    constructor(dbRef, getTracker, options) {
-        this.dbRef = dbRef;
-        this.getTracker = getTracker;
-        this.options = options;
-        this.currentRequests = new Set();
-        this.load = (inputRequest) => {
-            const result = {
-                isComplete: this.loaded.diff(inputRequest) == null,
-                isLoading: false,
-                request: inputRequest,
-                missing: this.loadedAndLoading.diff(inputRequest),
-                promise: null,
-                reload: null,
-            };
-            result.reload = () => {
-                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(() => { });
-                    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();
-    }
-    loadImpl(state) {
-        this.loadedAndLoading.append(state.missing);
-        state.isLoading = true;
-        let serverRequest = state.missing;
-        if (this.options.clientToServerRequest) {
-            serverRequest = this.options.clientToServerRequest(serverRequest);
-        }
-        state.promise = this.options.api(serverRequest).then(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();
-            const flatten = this.options.convertToPatch(result);
-            this.options.postProcess && this.options.postProcess(flatten);
-            this.dbRef.commitFetch(flatten);
-        });
-        this.currentRequests.add(state.promise);
-        state.promise.finally(() => {
-            this.currentRequests.delete(state.promise);
-        });
-        return state.promise;
-    }
-}
-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;
-class SimpleLoadingTracker {
-    constructor() {
-        this.set = new Set();
-    }
-    getKey(request) {
-        return JSON.stringify(request);
-    }
-    diff(request) {
-        return this.set.has(this.getKey(request)) ? null : request;
-    }
-    append(request, result) {
-        this.set.add(this.getKey(request));
-    }
-}
-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 });
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./Db */ "./src/Db.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./DbTable */ "./src/DbTable.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./DbRef */ "./src/DbRef.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./tempIds */ "./src/tempIds.tsx"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./utils */ "./src/utils.ts"), exports);
-(0, tslib_1.__exportStar)(__webpack_require__(/*! ./patchHelpers */ "./src/patchHelpers.ts"), exports);
-(0, 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;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
-const I = (0, tslib_1.__importStar)(__webpack_require__(/*! immutable */ "immutable"));
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-const lodash_groupby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.groupby */ "lodash.groupby"));
-const lodash_map_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.map */ "lodash.map"));
-const lodash_merge_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.merge */ "lodash.merge"));
-const lodash_countby_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.countby */ "lodash.countby"));
-const lodash_filter_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.filter */ "lodash.filter"));
-const lodash_foreach_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.foreach */ "lodash.foreach"));
-const lodash_pick_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.pick */ "lodash.pick"));
-function unionPatches(patches) {
-    const result = {};
-    patches.forEach(patch => {
-        (0, utils_1.objectKeys)(patch).forEach(tableName => {
-            result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
-        });
-    });
-    return result;
-}
-exports.unionPatches = unionPatches;
-function mergeEntityPatches(tables, patch) {
-    const result = {};
-    (0, utils_1.objectKeys)(patch).forEach(key => {
-        const table = tables[key];
-        const groupedEntities = (0, lodash_groupby_1.default)(patch[key], item => table.getId(item));
-        const tablePatch = (0, lodash_map_1.default)(groupedEntities, entities => {
-            const result = (0, lodash_merge_1.default)({}, ...entities);
-            if (true) {
-                const props = (0, utils_1.objectKeys)(result).filter(prop => Object.keys((0, lodash_countby_1.default)(entities.filter(entity => entity[prop] !== undefined), entity => entity[prop])).length > 1);
-                if (props.length) {
-                    console.warn('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(item => flattenResponseHelper(result, item, tablesByTypeName));
-    }
-    else if (typeof object === 'object') {
-        const clone = {};
-        let tableKey;
-        let fields = {};
-        if ('__typename' in object) {
-            const table = tablesByTypeName[object.__typename];
-            if (table) {
-                tableKey = table.schema.tableName;
-                fields = table.schema.fields;
-            }
-        }
-        for (let key in object) {
-            const value = object[key];
-            const field = fields[key];
-            if ((field && !!field.disableFlatten)
-                || typeof value !== 'object'
-                || value === null
-                || (Array.isArray(value) && value.every(item => typeof item !== 'object'))) {
-                clone[key] = value;
-            }
-            else {
-                flattenResponseHelper(result, value, tablesByTypeName);
-            }
-        }
-        if (tableKey) {
-            result[tableKey].push(clone);
-        }
-    }
-}
-function flattenResponse(response, tables) {
-    const result = {};
-    let tablesByTypeName = {};
-    Object.values(tables).forEach(table => tablesByTypeName[table.schema.typeName] = table);
-    (0, utils_1.objectKeys)(tables).forEach(tableName => tablesByTypeName);
-    (0, utils_1.objectKeys)(tables).forEach(key => result[key] = []);
-    flattenResponseHelper(result, response, tablesByTypeName);
-    return result;
-}
-exports.flattenResponse = flattenResponse;
-function isPatchBlank(patch) {
-    return !(0, utils_1.objectKeys)(patch).some(key => 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) {
-    const result = {};
-    (0, utils_1.objectKeys)(updatedDb.tables).forEach(entityName => {
-        const table = updatedDb.tables[entityName];
-        const schema = table.schema;
-        let ids = I.Set();
-        patches.forEach(patch => {
-            let filteredPatch = (patch[entityName] || []).filter(entity => hasServerFields(entity, schema, clientIdsMap, updatedDb.tables));
-            ids = ids.union(filteredPatch.map(e => table.getId(e)));
-        });
-        const entities = ids
-            .map(id => table.byId(id))
-            .filter(e => !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];
-    }
-    const result = [];
-    (0, lodash_foreach_1.default)((0, lodash_pick_1.default)(entity, schema.primaryKey), (value) => {
-        result.push(value);
-    });
-    return result;
-}
-exports.getId = getId;
-function isNew(entity, schema, clientIdsMap) {
-    const id = getId(entity, schema);
-    return !clientIdsMap.clientToServer(id);
-}
-exports.isNew = isNew;
-function hasServerFields(entity, schema, clientIdsMap, tables) {
-    const fullEntity = Object.assign(Object.assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
-    if (isClientOnly(fullEntity, schema)) {
-        return false;
-    }
-    return (0, utils_1.objectKeys)(entity).some(fieldName => {
-        const fieldSchema = schema.fields[fieldName];
-        return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
-    });
-}
-exports.hasServerFields = hasServerFields;
-function getParentEntities(patch, tables) {
-    const dependenciesPatch = {};
-    (0, utils_1.objectKeys)(patch).forEach(key => {
-        const table = tables[key];
-        const tableSchema = table.schema;
-        const fields = (0, lodash_filter_1.default)((0, lodash_map_1.default)(tableSchema.fields, (field, name) => (Object.assign(Object.assign({}, field), { name }))), field => field.fk && field.fk.relationType == types_1.DbRelationType.Aggregation);
-        const tablePatch = patch[key];
-        fields.forEach(field => {
-            const { fk: { tableName }, name } = field;
-            tablePatch.forEach(entity => {
-                const actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
-                const dbEntity = table.byId(table.getId(entity));
-                const parentEntity = tables[actualTableName].byId(dbEntity[name]);
-                const idFields = (0, 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) {
-    let patch = { [entityName]: [entity] };
-    const resultPatches = [];
-    while (true) {
-        let parents = getParentEntities(patch, tables);
-        if (isPatchBlank(parents)) {
-            break;
-        }
-        resultPatches.push(parents);
-        patch = parents;
-    }
-    let result = unionPatches([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;
-const react_1 = __webpack_require__(/*! react */ "react");
-exports.DbContext = (0, react_1.createContext)(null);
-function useDbRef() {
-    return (0, react_1.useContext)(exports.DbContext);
-}
-exports.useDbRef = useDbRef;
-function useDbView(fn, params, options) {
-    const dbRef = useDbRef();
-    const [state, setState] = (0, react_1.useState)();
-    const subscription = (0, react_1.useMemo)(() => dbRef.subscribe(Object.assign({ compute: fn }, options), params, setState), []);
-    subscription.update(params);
-    (0, react_1.useEffect)(() => {
-        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;
-const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
-let lastTempId = -1;
-function getTempId() {
-    return --lastTempId;
-}
-exports.getTempId = getTempId;
-function isTempId(val) {
-    return typeof val === 'number' && val < 0;
-}
-exports.isTempId = isTempId;
-class TempIdMap {
-    constructor(db) {
-        this.db = db;
-        this.serverToClientIds = new Map();
-        this.clientToServerIds = new Map();
-        this.clientToServer = (id) => this.clientToServerIds.get(id);
-        this.serverToClient = (tableName, id) => this.getServerToClientMap(tableName).get(id);
-        this.clientToServerRequest = (request) => {
-            request = Object.assign({}, request);
-            if (request.filter) {
-                request.filter = this.clientToServerDataFilter(request.filter);
-            }
-            return request;
-        };
-        this.clientToServerDataFilter = (filter) => {
-            filter = Object.assign({}, filter);
-            const 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.
-            const clientToServer = (id) => {
-                const found = this.clientToServer(id);
-                if (found) {
-                    return found;
-                }
-                else {
-                    return id;
-                }
-            };
-            for (let n = 0; n < keys.length; n++) {
-                const key = keys[n];
-                let condition = filter[key];
-                if (condition != null && typeof condition === "object") {
-                    condition = Object.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;
-        };
-    }
-    copyPatch(patch) {
-        const newPatch = Object.assign({}, patch);
-        (0, utils_1.objectKeys)(patch).forEach(tableName => {
-            let tablePatch = patch[tableName].map(entityPatch => (Object.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!
-    mapFields(patch, filter, callback) {
-        (0, utils_1.objectKeys)(patch).forEach(tableName => {
-            const schema = this.db.tables[tableName].schema;
-            const fields = (0, utils_1.objectKeys)(schema.fields || [])
-                .map(fieldName => {
-                const fieldSchema = schema.fields[fieldName];
-                if (filter(fieldSchema, fieldName)) {
-                    return { name: fieldName, schema: fieldSchema };
-                }
-            })
-                .filter(f => !!f);
-            if (!fields.length) {
-                return;
-            }
-            patch[tableName].forEach(entityPatch => {
-                for (let n = 0; n < fields.length; n++) {
-                    const field = fields[n];
-                    const fieldValue = entityPatch[field.name];
-                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
-                }
-            });
-        });
-    }
-    getServerToClientMap(tableName) {
-        const existing = this.serverToClientIds.get(tableName);
-        if (existing) {
-            return existing;
-        }
-        else {
-            const newMap = new Map();
-            this.serverToClientIds.set(tableName, newMap);
-            return newMap;
-        }
-    }
-    serverToClientPatch(patch) {
-        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, f => f.isGenerated, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            let 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, f => !!(f.fk || (f.default != null) || f.toClient), (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            let isUndefined = typeof (fieldValue) === 'undefined';
-            if (fieldSchema.default != null && fieldValue == null) {
-                fieldValue = fieldSchema.default;
-                isUndefined = false;
-            }
-            if (fieldSchema.fk && fieldValue != null) {
-                const fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
-                let 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;
-    }
-    clientToServerPatch(patch) {
-        patch = this.copyPatch(patch);
-        this.mapFields(patch, f => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            if (fieldValue != null) {
-                const existingId = this.clientToServerIds.get(fieldValue);
-                if (existingId) {
-                    entityPatch[fieldName] = existingId;
-                }
-            }
-        });
-        this.mapFields(patch, f => !(f.isClientOnly || f.isReadOnly) && !!f.toServer, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
-        });
-        this.mapFields(patch, meta => meta.isClientOnly || meta.isReadOnly, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
-            delete entityPatch[fieldName];
-        });
-        return patch;
-    }
-    appendServerMapping(response) {
-        (0, utils_1.objectKeys)(response.submit).forEach(tableName => {
-            if (this.db.tables[tableName]) {
-                const tablePatch = response.submit[tableName];
-                if (tablePatch) {
-                    const serverToClientIds = this.getServerToClientMap(tableName);
-                    const table = this.db.tables[tableName];
-                    tablePatch.forEach(patch => {
-                        if (isTempId(patch.id)) {
-                            const clientId = patch.id;
-                            const serverId = table.getId(patch.payload);
-                            serverToClientIds.set(serverId, clientId);
-                            this.clientToServerIds.set(clientId, serverId);
-                        }
-                    });
-                }
-            }
-        });
-    }
-}
-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;
-const tslib_1 = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
-const shallowequal_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! shallowequal */ "shallowequal"));
-const lodash_zip_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.zip */ "lodash.zip"));
-const lodash_transform_1 = (0, tslib_1.__importDefault)(__webpack_require__(/*! lodash.transform */ "lodash.transform"));
-const lodash_isequal_1 = (0, 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 (0, lodash_zip_1.default)(prev, next).every(([p, n]) => (0, shallowequal_1.default)(p, n));
-        }
-        return false;
-    }
-    return (0, 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 (0, lodash_transform_1.default)(object, function (result, value, key) {
-            if (!(0, 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__(/*! D:\dev\UUI-main\uui-db\index.tsx */"./index.tsx");
-
-
-/***/ }),
-
-/***/ "@epam/uui-core":
-/*!*********************************!*\
-  !*** external "@epam/uui-core" ***!
-  \*********************************/
-/*! no static exports found */
-/***/ (function(module, exports) {
-
-module.exports = require("@epam/uui-core");
-
-/***/ }),
-
-/***/ "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
+}
+
+class DbTable {
+    constructor(schema, state, q) {
+        this.schema = schema;
+        this.state = state;
+        this.q = q;
+        if (!state) {
+            const indexes = (schema.indexes || []).map(indexDef => {
+                return {
+                    field: indexDef,
+                    map: I__namespace.Map(),
+                };
+            });
+            this.state = { pk: I__namespace.Map(), indexes };
+        }
+        if (!q) {
+            this.q = {};
+        }
+    }
+    keyToImmutable(id) {
+        if (Array.isArray(id)) {
+            return I__namespace.List(id);
+        }
+        else {
+            return id;
+        }
+    }
+    byId(id) {
+        return this.state.pk.get(this.keyToImmutable(id));
+    }
+    getId(entity) {
+        if (Array.isArray(this.schema.primaryKey)) {
+            return this.schema.primaryKey.map((key) => entity[key]);
+        }
+        return entity[this.schema.primaryKey];
+    }
+    update(mutate) {
+        const clone = new this.constructor(this.schema, this.state, this.q);
+        mutate(clone);
+        return clone;
+    }
+    /* Mutation */
+    with(patch) {
+        const updates = patch.map(entityPatch => {
+            const id = this.getId(entityPatch);
+            const immId = this.keyToImmutable(id);
+            const existing = this.state.pk.get(immId);
+            let isDeleted = false;
+            let updated = entityPatch;
+            if (existing) {
+                updated = Object.assign(Object.assign({}, existing), entityPatch);
+                if (this.schema.deleteFlag) {
+                    isDeleted = updated[this.schema.deleteFlag] === true;
+                }
+            }
+            return { id, immId, patch: entityPatch, existing, updated, isNew: !existing, isDeleted };
+        });
+        const idVal = I.Seq.Keyed(updates.map(entity => [entity.immId, entity.updated]));
+        let newPk = this.state.pk.merge(idVal);
+        // TBD: replace with deleteAll after migrating to immutable 4
+        updates.filter(u => u.isDeleted).forEach(u => {
+            newPk = newPk.delete(u.immId);
+        });
+        const newIndexes = this.state.indexes.map(index => {
+            let newMap = index.map;
+            for (let n = 0; n < updates.length; n++) {
+                let update = updates[n];
+                const newKey = update.updated[index.field];
+                if (update.existing) {
+                    const oldKey = update.existing[index.field];
+                    if (oldKey !== newKey || update.isDeleted) {
+                        newMap = newMap.update(oldKey, set => set.remove(update.immId));
+                    }
+                }
+                if (!update.isDeleted) {
+                    newMap = newMap.update(newKey, I__namespace.Set(), set => set.add(update.immId));
+                }
+            }
+            return Object.assign(Object.assign({}, index), { map: newMap });
+        });
+        const newState = { pk: newPk, indexes: newIndexes };
+        return this.update(t => t.state = newState);
+    }
+    /* Query */
+    find(filter) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { filter: Object.assign(Object.assign({}, this.q.filter), filter) }));
+    }
+    order(order) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: order }));
+    }
+    orderBy(field, direction = 'asc') {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [{ field, direction }] }));
+    }
+    thenBy(field, direction) {
+        return this.update(t => t.q = Object.assign(Object.assign({}, t.q), { sorting: [...t.q.sorting, { field, direction }] }));
+    }
+    search(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(t => t.q = Object.assign(Object.assign({}, t.q), { search: text }));
+    }
+    /* Materializing */
+    range(from, count) {
+        return this.runQuery(Object.assign(Object.assign({}, this.q), { range: { from, count } }));
+    }
+    count() {
+        return this.runQuery(this.q).length;
+    }
+    one() {
+        return this.runQuery(this.q)[0] || null;
+    }
+    toArray() {
+        return this.runQuery(this.q);
+    }
+    map(fn) {
+        return this.toArray().map(fn);
+    }
+    /* Query implementation */
+    runQuery(q) {
+        let result = null;
+        let filter = q.filter;
+        if (filter) {
+            let indexes = this.state.indexes;
+            // Try to use indexes to fulfill filter conditions
+            for (let n = 0; n < indexes.length; n++) {
+                const index = indexes[n];
+                if (index.field in filter) {
+                    const _a = filter, _b = index.field, condition = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                    let 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
+                        const _c = condition, { in: inCriteria, isNull: nullCriteria } = _c, restCriteria = __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 (let i = 0; i < conditionValues.length; i++) {
+                            const idsSet = index.map.get(conditionValues[i]);
+                            if (idsSet) {
+                                const idsArray = idsSet.toArray();
+                                for (let j = 0; j < idsArray.length; j++) {
+                                    const 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) {
+            let predicate = uuiCore.getFilterPredicate(q.filter);
+            result = result.filter(predicate);
+        }
+        if (q.search) {
+            let searchFilter = uuiCore.getSearchFilter(q.search);
+            result = result.filter(item => searchFilter(this.schema.searchBy.map(field => item[field])));
+        }
+        if (q.sorting) {
+            let comparer = uuiCore.getOrderComparer(q.sorting);
+            result = result.sort(comparer);
+        }
+        if (q.range) {
+            result = result.slice(q.range.from, q.range.from + q.range.count);
+        }
+        return result;
+    }
+}
+
+function unionPatches(patches) {
+    const result = {};
+    patches.forEach(patch => {
+        objectKeys(patch).forEach(tableName => {
+            result[tableName] = result[tableName] ? [...result[tableName], ...patch[tableName]] : patch[tableName];
+        });
+    });
+    return result;
+}
+function mergeEntityPatches(tables, patch) {
+    const result = {};
+    objectKeys(patch).forEach(key => {
+        const table = tables[key];
+        const groupedEntities = groupBy__default.default(patch[key], item => table.getId(item));
+        const tablePatch = map__default.default(groupedEntities, entities => {
+            const result = merge__default.default({}, ...entities);
+            if (process.env.NODE_ENV !== 'production') {
+                const props = objectKeys(result).filter(prop => Object.keys(countBy__default.default(entities.filter(entity => entity[prop] !== undefined), entity => entity[prop])).length > 1);
+                if (props.length) {
+                    console.warn('mergeEntityPatches: Different property values found for the same entity.\nProperty names:\n', props, '\nEntities:\n', ...entities);
+                }
+            }
+            return result;
+        });
+        result[key] = tablePatch;
+    });
+    return result;
+}
+function flattenResponseHelper(result, object, tablesByTypeName) {
+    if (Array.isArray(object)) {
+        object.forEach(item => flattenResponseHelper(result, item, tablesByTypeName));
+    }
+    else if (typeof object === 'object') {
+        const clone = {};
+        let tableKey;
+        let fields = {};
+        if ('__typename' in object) {
+            const table = tablesByTypeName[object.__typename];
+            if (table) {
+                tableKey = table.schema.tableName;
+                fields = table.schema.fields;
+            }
+        }
+        for (let key in object) {
+            const value = object[key];
+            const field = fields[key];
+            if ((field && !!field.disableFlatten)
+                || typeof value !== 'object'
+                || value === null
+                || (Array.isArray(value) && value.every(item => typeof item !== 'object'))) {
+                clone[key] = value;
+            }
+            else {
+                flattenResponseHelper(result, value, tablesByTypeName);
+            }
+        }
+        if (tableKey) {
+            result[tableKey].push(clone);
+        }
+    }
+}
+function flattenResponse(response, tables) {
+    const result = {};
+    let tablesByTypeName = {};
+    Object.values(tables).forEach(table => tablesByTypeName[table.schema.typeName] = table);
+    objectKeys(tables).forEach(tableName => tablesByTypeName);
+    objectKeys(tables).forEach(key => result[key] = []);
+    flattenResponseHelper(result, response, tablesByTypeName);
+    return result;
+}
+function isPatchBlank(patch) {
+    return !objectKeys(patch).some(key => patch[key].length > 0);
+}
+/**
+ * Given several patches, creates a new single patch with all fields from all entities in all patches.
+ */
+function makeCumulativePatch(updatedDb, patches, clientIdsMap) {
+    const result = {};
+    objectKeys(updatedDb.tables).forEach(entityName => {
+        const table = updatedDb.tables[entityName];
+        const schema = table.schema;
+        let ids = I__namespace.Set();
+        patches.forEach(patch => {
+            let filteredPatch = (patch[entityName] || []).filter(entity => hasServerFields(entity, schema, clientIdsMap, updatedDb.tables));
+            ids = ids.union(filteredPatch.map(e => table.getId(e)));
+        });
+        const entities = ids
+            .map(id => table.byId(id))
+            .filter(e => !isClientOnly(e, schema))
+            .toArray();
+        if (entities.length > 0) {
+            result[entityName] = entities;
+        }
+    });
+    return result;
+}
+function isClientOnly(entity, schema) {
+    if (typeof schema.isClientOnly === 'function') {
+        return schema.isClientOnly(entity);
+    }
+    return !!schema.isClientOnly;
+}
+function getId(entity, schema) {
+    if (typeof schema.primaryKey == 'string') {
+        return entity[schema.primaryKey];
+    }
+    const result = [];
+    forEach__default.default(pick__default.default(entity, schema.primaryKey), (value) => {
+        result.push(value);
+    });
+    return result;
+}
+function isNew(entity, schema, clientIdsMap) {
+    const id = getId(entity, schema);
+    return !clientIdsMap.clientToServer(id);
+}
+function hasServerFields(entity, schema, clientIdsMap, tables) {
+    const fullEntity = Object.assign(Object.assign({}, tables[schema.tableName].byId(entity.id) || {}), entity);
+    if (isClientOnly(fullEntity, schema)) {
+        return false;
+    }
+    return objectKeys(entity).some(fieldName => {
+        const fieldSchema = schema.fields[fieldName];
+        return !fieldSchema || !(fieldSchema.isClientOnly || fieldSchema.isReadOnly || (fieldSchema.isGenerated && !isNew(entity, schema, clientIdsMap)));
+    });
+}
+function getParentEntities(patch, tables) {
+    const dependenciesPatch = {};
+    objectKeys(patch).forEach(key => {
+        const table = tables[key];
+        const tableSchema = table.schema;
+        const fields = filter__default.default(map__default.default(tableSchema.fields, (field, name) => (Object.assign(Object.assign({}, field), { name }))), field => field.fk && field.fk.relationType == exports.DbRelationType.Aggregation);
+        const tablePatch = patch[key];
+        fields.forEach(field => {
+            const { fk: { tableName }, name } = field;
+            tablePatch.forEach(entity => {
+                const actualTableName = (typeof tableName == 'function' ? tableName(entity) : tableName);
+                const dbEntity = table.byId(table.getId(entity));
+                const parentEntity = tables[actualTableName].byId(dbEntity[name]);
+                const idFields = pick__default.default(parentEntity, tables[actualTableName].schema.primaryKey);
+                if (parentEntity) {
+                    dependenciesPatch[actualTableName] = dependenciesPatch[actualTableName] || [];
+                    dependenciesPatch[actualTableName].push(idFields);
+                }
+            });
+        });
+    });
+    return dependenciesPatch;
+}
+function getEntityParentDependencies(entity, entityName, tables) {
+    let patch = { [entityName]: [entity] };
+    const resultPatches = [];
+    while (true) {
+        let parents = getParentEntities(patch, tables);
+        if (isPatchBlank(parents)) {
+            break;
+        }
+        resultPatches.push(parents);
+        patch = parents;
+    }
+    let result = unionPatches([patch, ...resultPatches]);
+    result = mergeEntityPatches(tables, result);
+    return result;
+}
+
+let lastTempId = -1;
+function getTempId() {
+    return --lastTempId;
+}
+function isTempId(val) {
+    return typeof val === 'number' && val < 0;
+}
+class TempIdMap {
+    constructor(db) {
+        this.db = db;
+        this.serverToClientIds = new Map();
+        this.clientToServerIds = new Map();
+        this.clientToServer = (id) => this.clientToServerIds.get(id);
+        this.serverToClient = (tableName, id) => this.getServerToClientMap(tableName).get(id);
+        this.clientToServerRequest = (request) => {
+            request = Object.assign({}, request);
+            if (request.filter) {
+                request.filter = this.clientToServerDataFilter(request.filter);
+            }
+            return request;
+        };
+        this.clientToServerDataFilter = (filter) => {
+            filter = Object.assign({}, filter);
+            const 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.
+            const clientToServer = (id) => {
+                const found = this.clientToServer(id);
+                if (found) {
+                    return found;
+                }
+                else {
+                    return id;
+                }
+            };
+            for (let n = 0; n < keys.length; n++) {
+                const key = keys[n];
+                let condition = filter[key];
+                if (condition != null && typeof condition === "object") {
+                    condition = Object.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;
+        };
+    }
+    copyPatch(patch) {
+        const newPatch = Object.assign({}, patch);
+        objectKeys(patch).forEach(tableName => {
+            let tablePatch = patch[tableName].map(entityPatch => (Object.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!
+    mapFields(patch, filter, callback) {
+        objectKeys(patch).forEach(tableName => {
+            const schema = this.db.tables[tableName].schema;
+            const fields = objectKeys(schema.fields || [])
+                .map(fieldName => {
+                const fieldSchema = schema.fields[fieldName];
+                if (filter(fieldSchema, fieldName)) {
+                    return { name: fieldName, schema: fieldSchema };
+                }
+            })
+                .filter(f => !!f);
+            if (!fields.length) {
+                return;
+            }
+            patch[tableName].forEach(entityPatch => {
+                for (let n = 0; n < fields.length; n++) {
+                    const field = fields[n];
+                    const fieldValue = entityPatch[field.name];
+                    callback(field.name, field.schema, fieldValue, entityPatch, tableName);
+                }
+            });
+        });
+    }
+    getServerToClientMap(tableName) {
+        const existing = this.serverToClientIds.get(tableName);
+        if (existing) {
+            return existing;
+        }
+        else {
+            const newMap = new Map();
+            this.serverToClientIds.set(tableName, newMap);
+            return newMap;
+        }
+    }
+    serverToClientPatch(patch) {
+        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, f => f.isGenerated, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let 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, f => !!(f.fk || (f.default != null) || f.toClient), (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            let isUndefined = typeof (fieldValue) === 'undefined';
+            if (fieldSchema.default != null && fieldValue == null) {
+                fieldValue = fieldSchema.default;
+                isUndefined = false;
+            }
+            if (fieldSchema.fk && fieldValue != null) {
+                const fkTableName = typeof fieldSchema.fk.tableName === 'function' ? fieldSchema.fk.tableName(entityPatch) : fieldSchema.fk.tableName;
+                let 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;
+    }
+    clientToServerPatch(patch) {
+        patch = this.copyPatch(patch);
+        this.mapFields(patch, f => f.isGenerated || !!f.fk, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            if (fieldValue != null) {
+                const existingId = this.clientToServerIds.get(fieldValue);
+                if (existingId) {
+                    entityPatch[fieldName] = existingId;
+                }
+            }
+        });
+        this.mapFields(patch, f => !(f.isClientOnly || f.isReadOnly) && !!f.toServer, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            entityPatch[fieldName] = fieldSchema.toServer(entityPatch[fieldName]);
+        });
+        this.mapFields(patch, meta => meta.isClientOnly || meta.isReadOnly, (fieldName, fieldSchema, fieldValue, entityPatch, tableName) => {
+            delete entityPatch[fieldName];
+        });
+        return patch;
+    }
+    appendServerMapping(response) {
+        objectKeys(response.submit).forEach(tableName => {
+            if (this.db.tables[tableName]) {
+                const tablePatch = response.submit[tableName];
+                if (tablePatch) {
+                    const serverToClientIds = this.getServerToClientMap(tableName);
+                    const table = this.db.tables[tableName];
+                    tablePatch.forEach(patch => {
+                        if (isTempId(patch.id)) {
+                            const clientId = patch.id;
+                            const serverId = table.getId(patch.payload);
+                            serverToClientIds.set(serverId, clientId);
+                            this.clientToServerIds.set(clientId, serverId);
+                        }
+                    });
+                }
+            }
+        });
+    }
+}
+
+class Loader {
+    constructor(dbRef, getTracker, options) {
+        this.dbRef = dbRef;
+        this.getTracker = getTracker;
+        this.options = options;
+        this.currentRequests = new Set();
+        this.load = (inputRequest) => {
+            const result = {
+                isComplete: this.loaded.diff(inputRequest) == null,
+                isLoading: false,
+                request: inputRequest,
+                missing: this.loadedAndLoading.diff(inputRequest),
+                promise: null,
+                reload: null,
+            };
+            result.reload = () => {
+                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(() => { });
+                    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();
+    }
+    loadImpl(state) {
+        this.loadedAndLoading.append(state.missing);
+        state.isLoading = true;
+        let serverRequest = state.missing;
+        if (this.options.clientToServerRequest) {
+            serverRequest = this.options.clientToServerRequest(serverRequest);
+        }
+        state.promise = this.options.api(serverRequest).then(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();
+            const flatten = this.options.convertToPatch(result);
+            this.options.postProcess && this.options.postProcess(flatten);
+            this.dbRef.commitFetch(flatten);
+        });
+        this.currentRequests.add(state.promise);
+        state.promise.finally(() => {
+            this.currentRequests.delete(state.promise);
+        });
+        return state.promise;
+    }
+}
+
+class SimpleLoadingTracker {
+    constructor() {
+        this.set = new Set();
+    }
+    getKey(request) {
+        return JSON.stringify(request);
+    }
+    diff(request) {
+        return this.set.has(this.getKey(request)) ? null : request;
+    }
+    append(request, result) {
+        this.set.add(this.getKey(request));
+    }
+}
+
+class ListLoadingTracker {
+    constructor(options) {
+        this.options = options;
+        this.cache = new Map();
+        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || ((r) => r);
+    }
+    prepare(request) {
+        const { filter, sorting, search, range } = request, unknownFields = __rest(request, ["filter", "sorting", "search", "range"]);
+        const options = {};
+        if (filter) {
+            options.filter = filter;
+        }
+        if (sorting) {
+            options.sorting = sorting;
+        }
+        if (search) {
+            options.search = search;
+        }
+        let keyObject = Object.assign(Object.assign({}, options), unknownFields);
+        const key = JSON.stringify(keyObject);
+        let entry = this.cache.get(key);
+        if (!entry) {
+            entry = { options, count: 0, maxCount: null, isComplete: false };
+            this.cache.set(key, entry);
+        }
+        return { options, range, unknownFields, entry };
+    }
+    diff(request) {
+        const { options, range, unknownFields, entry } = this.prepare(request);
+        if (entry.isComplete) {
+            return null;
+        }
+        if (!request.range) {
+            return request;
+        }
+        else {
+            const requestedMax = request.range.from + request.range.count;
+            let missingCount = requestedMax - entry.count;
+            if (entry.maxCount) {
+                missingCount = Math.min(missingCount, entry.maxCount);
+            }
+            if (missingCount > 0) {
+                return Object.assign(Object.assign(Object.assign({}, options), unknownFields), { range: { from: entry.count, count: requestedMax - entry.count } });
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    count(request) {
+        const { entry } = this.prepare(request);
+        return { knownCount: Math.max(entry.count, entry.maxCount), exactCount: entry.maxCount };
+    }
+    append(request, response) {
+        const { options, range, unknownFields, entry } = this.prepare(request);
+        if (response) {
+            const 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 {
+                const 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;
+            }
+        }
+    }
+}
+
+class DbRef {
+    constructor(blank) {
+        this.blank = blank;
+        this.log = [];
+        this.autoSave = true;
+        this.savedPoint = 0;
+        this.throttleSaveMs = 1000;
+        /* Update subscriptions (aka live views) */
+        this.lastSubscriptionId = 1;
+        this.subscriptions = new Map();
+        this.updateHandlers = [];
+        /* Error Subscriptions */
+        this.saveErrorHandlers = [];
+        /* Save scheduling */
+        this.enqueueSave = uuiCore.batch(() => __awaiter(this, void 0, void 0, function* () {
+            const cumulativePatch = this.makeCumulativePatch();
+            const lastLogEntry = this.log.length;
+            if (isEmpty__default.default(cumulativePatch)) {
+                return;
+            }
+            try {
+                const response = yield this.savePatch(cumulativePatch);
+                this.applyResponse(response, lastLogEntry);
+                this.update();
+            }
+            catch (error) {
+                this.saveError(cumulativePatch, error);
+                this.update();
+                throw error;
+            }
+        }));
+        this.handleBeforeUnload = (e) => {
+            if (this.enqueueSave.isBusy) {
+                e.returnValue = false;
+                return false;
+            }
+        };
+        this.loaders = [];
+        this.db = blank;
+        this.base = blank;
+        this.tempIdMap = new TempIdMap(blank);
+        this.idMap = this.tempIdMap;
+        window.addEventListener('beforeunload', this.handleBeforeUnload);
+    }
+    /** Saves all committed patches. Useful only if autoSave is off. */
+    save() {
+        return this.enqueueSave();
+    }
+    getAutoSave() {
+        return this.autoSave;
+    }
+    setAutoSave(val) {
+        if (this.autoSave != val) {
+            this.autoSave = val;
+            this.autoSave && this.enqueueSave();
+            this.update();
+        }
+    }
+    revert() {
+        this.db = this.base;
+        this.log = this.log.slice(0, this.savedPoint);
+        this.update();
+    }
+    /** Concrete DbRef instances should override and implement their save logic in this method */
+    savePatch(patch) {
+        return Promise.resolve({ submit: {} });
+    }
+    /* Db Update logic */
+    commit(patch) {
+        const dbBeforeUpdate = this.db.with(patch);
+        patch = this.beforeUpdate(patch, dbBeforeUpdate.tables, this.db.tables);
+        patch = mergeEntityPatches(this.db.tables, patch);
+        this.log.push({ patch });
+        this.db = this.db.with(patch);
+        this.autoSave && this.enqueueSave(null, { throttleMs: this.throttleSaveMs });
+        this.update();
+    }
+    beforeUpdate(patch, tables, prevTables) {
+        let patchAndDependencies = {};
+        objectKeys(tables).filter(entityName => patch[entityName] && !tables[entityName].schema.beforeUpdate).forEach(entityName => {
+            patchAndDependencies[entityName] = patch[entityName];
+        });
+        objectKeys(tables).filter(entityName => patch[entityName] && tables[entityName].schema.beforeUpdate).forEach(entityName => {
+            const schema = tables[entityName].schema;
+            const { beforeUpdate } = schema;
+            let context = {
+                clientIdsMap: this.tempIdMap,
+                schema,
+                tables,
+                prevTables,
+            };
+            const results = patch[entityName].map(e => beforeUpdate(e, context));
+            const updatedPatch = { [entityName]: results.map(result => result.entity) };
+            const dependentEntityPatchesForUpdate = unionPatches(results.filter(result => result.dependentEntities).map(result => result.dependentEntities));
+            const dependentEntityPatches = this.beforeUpdate(dependentEntityPatchesForUpdate, tables, prevTables);
+            patchAndDependencies = mergeEntityPatches(tables, unionPatches([patchAndDependencies, updatedPatch, dependentEntityPatches]));
+        });
+        return patchAndDependencies;
+    }
+    commitFetch(patch) {
+        patch = this.tempIdMap.serverToClientPatch(patch);
+        this.rebase(this.base.with(patch));
+        this.update();
+    }
+    rebase(newBase) {
+        this.base = newBase;
+        this.db = newBase;
+        for (let n = this.savedPoint; n < this.log.length; n++) {
+            this.db = this.db.with(this.log[n].patch);
+        }
+    }
+    makeCumulativePatch() {
+        const lastLogEntry = this.log.length;
+        const logEntriesToSave = this.log.slice(this.savedPoint, lastLogEntry);
+        let cumulativePatch = makeCumulativePatch(this.db, logEntriesToSave.map(t => t.patch), this.tempIdMap);
+        cumulativePatch = this.tempIdMap.clientToServerPatch(cumulativePatch);
+        return cumulativePatch;
+    }
+    applyResponse(response, newSavedPoint) {
+        this.tempIdMap.appendServerMapping(response);
+        let serverPatch = flattenResponse(response.submit, this.db.tables);
+        serverPatch = mergeEntityPatches(this.db.tables, serverPatch);
+        this.savedPoint = newSavedPoint;
+        this.base = this.db;
+        this.commitFetch(serverPatch);
+    }
+    subscribe(view, params, onUpdate) {
+        const id = this.lastSubscriptionId++;
+        const subscription = {
+            update: (params) => {
+                subscription.currentParams = params;
+                subscription.currentValue = this.db.runView(view, params);
+                return subscription.currentValue;
+            },
+            currentParams: null,
+            currentValue: null,
+            onUpdate,
+            unsubscribe: () => { this.subscriptions.delete(id); },
+        };
+        subscription.update(params);
+        this.subscriptions.set(id, subscription);
+        return subscription;
+    }
+    onUpdate(handler) {
+        this.subscribe({
+            compute: db => db,
+            compareResults: (a, b) => a === b,
+        }, null, handler);
+    }
+    update() {
+        this.subscriptions.forEach(subscription => {
+            const previousValue = subscription.currentValue;
+            subscription.update(subscription.currentParams);
+            if (subscription.currentValue !== previousValue && subscription.onUpdate) {
+                subscription.onUpdate(subscription.currentValue);
+            }
+        });
+    }
+    onSaveError(handler) {
+        this.saveErrorHandlers.push(handler);
+    }
+    saveError(request, error) {
+        this.saveErrorHandlers.forEach(handler => handler(request, error));
+    }
+    makeLoader(options) {
+        const loader = new Loader(this, () => new SimpleLoadingTracker(), options);
+        this.loaders.push(loader);
+        return loader;
+    }
+    makeListLoader(options) {
+        const loader = new Loader(this, () => new ListLoadingTracker(), options);
+        this.loaders.push(loader);
+        return loader;
+    }
+    reload() {
+        this.loaders = [];
+    }
+}
+
+const DbContext = react.createContext(null);
+function useDbRef() {
+    return react.useContext(DbContext);
+}
+function useDbView(fn, params, options) {
+    const dbRef = useDbRef();
+    const [state, setState] = react.useState();
+    const subscription = react.useMemo(() => dbRef.subscribe(Object.assign({ compute: fn }, options), params, setState), []);
+    subscription.update(params);
+    react.useEffect(() => {
+        return () => subscription.unsubscribe();
+    }, []);
+    return subscription.currentValue;
+}
+
+exports.Db = Db;
+exports.DbContext = DbContext;
+exports.DbRef = DbRef;
+exports.DbTable = DbTable;
+exports.TempIdMap = TempIdMap;
+exports.defaultCompareViewDependencies = defaultCompareViewDependencies;
+exports.difference = difference;
+exports.flattenResponse = flattenResponse;
+exports.getEntityParentDependencies = getEntityParentDependencies;
+exports.getId = getId;
+exports.getParentEntities = getParentEntities;
+exports.getTempId = getTempId;
+exports.hasServerFields = hasServerFields;
+exports.isClientOnly = isClientOnly;
+exports.isNew = isNew;
+exports.isPatchBlank = isPatchBlank;
+exports.isTempId = isTempId;
+exports.makeCumulativePatch = makeCumulativePatch;
+exports.mergeEntityPatches = mergeEntityPatches;
+exports.objectKeys = objectKeys;
+exports.unionPatches = unionPatches;
+exports.useDbRef = useDbRef;
+exports.useDbView = useDbView;
+//# sourceMappingURL=index.js.map