@epam/uui-db 5.12.1 → 5.14.0-alpha.0

package/index.js

@@ -99,7 +99,7 @@ class Db {
     }
     update(mutate) {
         const clone = new this.constructor(this.tables, this.viewCache);
-        clone.tables = Object.assign({}, this.tables);
+        clone.tables = { ...this.tables };
         mutate(clone);
         return clone;
     }
@@ -152,50 +152,6 @@ class Db {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 class DbTable {
     constructor(schema, state, q) {
         this.schema = schema;
@@ -245,7 +201,7 @@ class DbTable {
             let isDeleted = false;
             let updated = entityPatch;
             if (existing) {
-                updated = Object.assign(Object.assign({}, existing), entityPatch);
+                updated = { ...existing, ...entityPatch };
                 if (this.schema.deleteFlag) {
                     isDeleted = updated[this.schema.deleteFlag] === true;
                 }
@@ -277,33 +233,33 @@ class DbTable {
                     newMap = newMap.update(newKey, I__namespace.Set(), (set) => set.add(update.immId));
                 }
             }
-            return Object.assign(Object.assign({}, index), { map: newMap });
+            return { ...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) })));
+        return this.update((t) => (t.q = { ...t.q, filter: { ...this.q.filter, ...filter } }));
     }
     order(order) {
-        return this.update((t) => (t.q = Object.assign(Object.assign({}, t.q), { sorting: order })));
+        return this.update((t) => (t.q = { ...t.q, sorting: order }));
     }
     orderBy(field, direction = 'asc') {
-        return this.update((t) => (t.q = Object.assign(Object.assign({}, t.q), { sorting: [{ field, direction }] })));
+        return this.update((t) => (t.q = { ...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 }] })));
+        return this.update((t) => (t.q = { ...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 })));
+        return this.update((t) => (t.q = { ...t.q, search: text }));
     }
     /* Materializing */
     range(from, count) {
-        return this.runQuery(Object.assign(Object.assign({}, this.q), { range: { from, count } }));
+        return this.runQuery({ ...this.q, range: { from, count } });
     }
     count() {
         return this.runQuery(this.q).length;
@@ -327,13 +283,13 @@ class DbTable {
             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 + ""]);
+                    const { [index.field]: condition, ...rest } = filter;
                     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"]);
+                        const { in: inCriteria, isNull: nullCriteria, ...restCriteria } = condition;
                         if (inCriteria && Array.isArray(inCriteria)) {
                             conditionValues = inCriteria;
                         }
@@ -515,7 +471,10 @@ function isNew(entity, schema, clientIdsMap) {
     return !clientIdsMap.clientToServer(id);
 }
 function hasServerFields(entity, schema, clientIdsMap, tables) {
-    const fullEntity = Object.assign(Object.assign({}, (tables[schema.tableName].byId(entity.id) || {})), entity);
+    const fullEntity = {
+        ...(tables[schema.tableName].byId(entity.id) || {}),
+        ...entity,
+    };
     if (isClientOnly(fullEntity, schema)) {
         return false;
     }
@@ -529,7 +488,7 @@ function getParentEntities(patch, tables) {
     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 fields = filter__default.default(map__default.default(tableSchema.fields, (field, name) => ({ ...field, name })), (field) => field.fk && field.fk.relationType == exports.DbRelationType.Aggregation);
         const tablePatch = patch[key];
         fields.forEach((field) => {
             const { fk: { tableName }, name, } = field;
@@ -578,14 +537,14 @@ class TempIdMap {
         this.clientToServer = (id) => this.clientToServerIds.get(id);
         this.serverToClient = (tableName, id) => this.getServerToClientMap(tableName).get(id);
         this.clientToServerRequest = (request) => {
-            request = Object.assign({}, request);
+            request = { ...request };
             if (request.filter) {
                 request.filter = this.clientToServerDataFilter(request.filter);
             }
             return request;
         };
         this.clientToServerDataFilter = (filter) => {
-            filter = Object.assign({}, filter);
+            filter = { ...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.
@@ -602,7 +561,7 @@ class TempIdMap {
                 const key = keys[n];
                 let condition = filter[key];
                 if (condition != null && typeof condition === 'object') {
-                    condition = Object.assign({}, condition);
+                    condition = { ...condition };
                     if ('in' in condition && Array.isArray(condition.in) && condition.in.length) {
                         condition.in = condition.in.map(clientToServer);
                     }
@@ -616,9 +575,9 @@ class TempIdMap {
         };
     }
     copyPatch(patch) {
-        const newPatch = Object.assign({}, patch);
+        const newPatch = { ...patch };
         objectKeys(patch).forEach((tableName) => {
-            const tablePatch = patch[tableName].map((entityPatch) => (Object.assign({}, entityPatch)));
+            const tablePatch = patch[tableName].map((entityPatch) => ({ ...entityPatch }));
             newPatch[tableName] = tablePatch;
         });
         return newPatch;
@@ -825,10 +784,10 @@ class ListLoadingTracker {
     constructor(options) {
         this.options = options;
         this.cache = new Map();
-        this.extractList = (options === null || options === void 0 ? void 0 : options.extractList) || ((r) => r);
+        this.extractList = options?.extractList || ((r) => r);
     }
     prepare(request) {
-        const { filter, sorting, search, range } = request, unknownFields = __rest(request, ["filter", "sorting", "search", "range"]);
+        const { filter, sorting, search, range, ...unknownFields } = request;
         const options = {};
         if (filter) {
             options.filter = filter;
@@ -839,7 +798,7 @@ class ListLoadingTracker {
         if (search) {
             options.search = search;
         }
-        const keyObject = Object.assign(Object.assign({}, options), unknownFields);
+        const keyObject = { ...options, ...unknownFields };
         const key = JSON.stringify(keyObject);
         let entry = this.cache.get(key);
         if (!entry) {
@@ -867,7 +826,11 @@ class ListLoadingTracker {
                 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 } });
+                return {
+                    ...options,
+                    ...unknownFields,
+                    range: { from: entry.count, count: requestedMax - entry.count },
+                };
             }
             else {
                 return null;
@@ -929,44 +892,42 @@ function batch(runBatch, options) {
     let batchPromise = null;
     let queue = [];
     let nextCallPossibleAtMs = new Date().getTime();
-    function batchedFn(arg, callOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            options = Object.assign(Object.assign({}, options), callOptions);
-            options.throttleMs = options.throttleMs || 0;
-            // Enqueue request
-            queue.push(arg);
-            const resultIndex = queue.length - 1; // an index of current item in queue. Result should be on the same index in batch.
-            batchedFn.isBusy = true;
-            // Wait current batch to complete
-            try {
-                yield batchPromise;
-            }
-            catch (_a) {
-                // ignore errors here. They are thrown to previous batch
-            }
-            // Wait for throttling delay to pass
-            yield delayPromise;
-            try {
-                // Start a batch if there are items.
-                // All calls that was awaiting will run this code.
-                // Only the first call will run batch, immediately clear the queue, and set batchPromise value
-                // Other calls will just await results of this call
-                if (queue.length > 0) {
-                    nextCallPossibleAtMs = new Date().getTime() + options.throttleMs;
-                    batchPromise = runBatch(queue);
-                    queue = [];
-                }
-                const results = yield batchPromise;
-                return results === null || results === void 0 ? void 0 : results[resultIndex];
-            }
-            finally {
-                const nowMs = new Date().getTime();
-                const delayMs = Math.max(0, nextCallPossibleAtMs - nowMs);
-                // It's safe to replace currentPromise here. All other requests are already awaiting
-                delayPromise = delay(delayMs);
-                batchedFn.isBusy = queue.length > 0;
+    async function batchedFn(arg, callOptions) {
+        options = { ...options, ...callOptions };
+        options.throttleMs = options.throttleMs || 0;
+        // Enqueue request
+        queue.push(arg);
+        const resultIndex = queue.length - 1; // an index of current item in queue. Result should be on the same index in batch.
+        batchedFn.isBusy = true;
+        // Wait current batch to complete
+        try {
+            await batchPromise;
+        }
+        catch {
+            // ignore errors here. They are thrown to previous batch
+        }
+        // Wait for throttling delay to pass
+        await delayPromise;
+        try {
+            // Start a batch if there are items.
+            // All calls that was awaiting will run this code.
+            // Only the first call will run batch, immediately clear the queue, and set batchPromise value
+            // Other calls will just await results of this call
+            if (queue.length > 0) {
+                nextCallPossibleAtMs = new Date().getTime() + options.throttleMs;
+                batchPromise = runBatch(queue);
+                queue = [];
             }
-        });
+            const results = await batchPromise;
+            return results?.[resultIndex];
+        }
+        finally {
+            const nowMs = new Date().getTime();
+            const delayMs = Math.max(0, nextCallPossibleAtMs - nowMs);
+            // It's safe to replace currentPromise here. All other requests are already awaiting
+            delayPromise = delay(delayMs);
+            batchedFn.isBusy = queue.length > 0;
+        }
     }
     batchedFn.isBusy = false;
     return batchedFn;
@@ -986,14 +947,14 @@ class DbRef {
         /* Error Subscriptions */
         this.saveErrorHandlers = [];
         /* Save scheduling */
-        this.enqueueSave = batch(() => __awaiter(this, void 0, void 0, function* () {
+        this.enqueueSave = batch(async () => {
             const cumulativePatch = this.makeCumulativePatch();
             const lastLogEntry = this.log.length;
             if (isEmpty__default.default(cumulativePatch)) {
                 return;
             }
             try {
-                const response = yield this.savePatch(cumulativePatch);
+                const response = await this.savePatch(cumulativePatch);
                 this.applyResponse(response, lastLogEntry);
                 this.update();
             }
@@ -1002,7 +963,7 @@ class DbRef {
                 this.update();
                 throw error;
             }
-        }));
+        });
         this.handleBeforeUnload = (e) => {
             if (this.enqueueSave.isBusy) {
                 e.returnValue = false;
@@ -1166,7 +1127,7 @@ function useDbRef() {
 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), []);
+    const subscription = react.useMemo(() => dbRef.subscribe({ compute: fn, ...options }, params, setState), []);
     subscription.update(params);
     react.useEffect(() => {
         return () => subscription.unsubscribe();