@nextgis/ngw-connector 1.9.2 → 1.11.2

package/lib/ngw-connector.esm-browser.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-connector; version: 1.9.2; author: NextGIS */
+/** Bundle of @nextgis/ngw-connector; version: 1.11.2; author: NextGIS */
 var events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -832,6 +832,23 @@ var CancelablePromise = CancelablePromise$1;
  */
 function defined(val) {
     return val !== undefined && val !== null;
+}
+/**
+ * from https://github.com/CesiumGS/cesium/blob/master/Source/Core/defined.js
+ *
+ * @param val - The object.
+ * @returns Returns true if the object is defined and not empty string, returns false otherwise.
+ *
+ * @example
+ * ```javascript
+ * full('foo') // true
+ * full('') // false
+ * full(undefined) // false
+ * full(0) // true
+ * ```
+ */
+function full(val) {
+    return typeof val === 'string' ? !!val : defined(val);
 }
 
 function isEqual(a, b, o, p) {
@@ -900,13 +917,45 @@ function fixUrlStr(url) {
     return url.replace(/([^:]\/)\/+/g, '$1');
 }
 
+/**
+ * @example
+ * ```javascript
+ * const cache1 = new Cache();
+ * cache1.add('foo', 'value');
+ *
+ * const cache2 = new Cache();
+ * cache2.match('foo'); // value
+ *
+ * const cache3 = new Cache({ namespace: 'foo' });
+ * cache3.match('foo'); // undefined
+ * ```
+ *
+ * @example
+ * ```javascript
+ * let COUNTER = 0;
+ * const createPromise = () => new Promise((res) => {
+ *   COUNTER++
+ *   setTimeout(() => res('Ok'), 300)
+ * });
+ *
+ * const cache = new Cache();
+ * for (let i = 0; i < 10; i++) {
+ *   cache.add('foo', createPromise).then((data) => {
+ *     console.log(data); // 'Ok'
+ *   });
+ * }
+ * console.log(COUNTER); // 1
+ * ```
+ */
 class Cache$1 {
-    constructor() {
+    constructor(options = {}) {
+        var _a;
         this.cache = [];
-        if (Cache$1.instance) {
-            return Cache$1.instance;
+        const namespace = (_a = options.namespace) !== null && _a !== void 0 ? _a : 'default';
+        if (Cache$1.instance[namespace]) {
+            return Cache$1.instance[namespace];
         }
-        Cache$1.instance = this;
+        Cache$1.instance[namespace] = this;
         return this;
     }
     clean() {
@@ -915,8 +964,33 @@ class Cache$1 {
     all() {
         return this.cache;
     }
-    add(key, valueToSet, options) {
-        const exist = this._find(key, options);
+    /**
+     * Caching only a non-empty value.
+     *
+     * Useful for get or create strategy
+     * @example
+     * ```javascript
+     * const cache = new Cache();
+     * const getItemFunc = () => fetch(url).then((data) => {
+     *  return data.json(); // undefined
+     * });
+     * const item = await cache.addFull('foo', getItemFunc);
+     * if (!item) {
+     *   await createItem(); // 'New item'
+     * }
+     *
+     * // somewhere else in the code
+     * const item = await cache.addFull('foo', getItemFunc).then((resp) => {
+     *   console.log(resp); // 'New item'
+     * })
+     *
+     * ```
+     */
+    addFull(key, valueToSet, props) {
+        return this.add(key, valueToSet, props, true);
+    }
+    add(key, valueToSet, props, onlyFull) {
+        const exist = this._find(key, props);
         if (!exist) {
             let value;
             if (valueToSet instanceof Function) {
@@ -925,18 +999,31 @@ class Cache$1 {
             else {
                 value = valueToSet;
             }
-            const options_ = options && JSON.parse(JSON.stringify(objectRemoveEmpty(options)));
+            const props_ = props && JSON.parse(JSON.stringify(objectRemoveEmpty(props)));
             const cacheItem = {
                 key,
                 value,
-                options: options_,
+                props: props_,
+                // TODO: remove backward compatibility use only props
+                options: props_,
             };
+            if (onlyFull && !full(value)) {
+                return value;
+            }
             this.cache.push(cacheItem);
             if (value instanceof Promise) {
                 value.catch((er) => {
-                    this.delete(key, options);
+                    this.delete(key, props);
                     throw er;
                 });
+                if (onlyFull) {
+                    value.then((x) => {
+                        if (!full(x)) {
+                            this.delete(key, props);
+                        }
+                        return x;
+                    });
+                }
                 return value;
             }
             return value;
@@ -945,40 +1032,49 @@ class Cache$1 {
             return exist.value;
         }
     }
-    match(key, options) {
-        const cacheRecord = this._find(key, options);
+    match(key, props) {
+        const cacheRecord = this._find(key, props);
         if (cacheRecord) {
             return cacheRecord.value;
         }
     }
-    matchAll(key, options) {
+    matchAll(key, props) {
         if (key) {
             return this.cache
-                .filter((x) => this._filter(x, key, options))
+                .filter((x) => this._filter(x, key, props))
                 .map((x) => x.value);
         }
         return this.cache.map((x) => x.value);
     }
-    delete(key, options) {
-        const exist = this.cache.filter((x) => this._filter(x, key, options));
+    delete(keyOrItem, props) {
+        let exist = [];
+        if (typeof keyOrItem === 'string') {
+            exist = this.cache.filter((x) => this._filter(x, keyOrItem, props));
+        }
+        else {
+            exist.push(keyOrItem);
+        }
         for (const e of exist) {
             const index = this.cache.indexOf(e);
             this.cache.splice(index, 1);
         }
     }
-    _find(key, options) {
-        return this.cache.find((x) => this._filter(x, key, options));
+    _find(key, props) {
+        return this.cache.find((x) => this._filter(x, key, props));
     }
-    _filter(item, key, options) {
+    _filter(item, key, props) {
         if (item.key === key) {
-            if (options) {
-                return objectDeepEqual(item.options || {}, objectRemoveEmpty(options));
+            if (props) {
+                // TODO: remove backward compatibility
+                const itemProps = item.props || item.options;
+                return objectDeepEqual(itemProps || {}, objectRemoveEmpty(props));
             }
             return true;
         }
         return false;
     }
-}
+}
+Cache$1.instance = {};
 
 /**
  * Caching for asynchronous functions
@@ -1013,6 +1109,10 @@ class NetworkError extends Error {
     }
 }
 
+function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}
+
 let loadData;
 // @ts-ignore
 {
@@ -1046,7 +1146,7 @@ let loadData;
             }
         };
         xhr.onload = () => {
-            if ([401, 403, 404, 500].indexOf(xhr.status) !== -1) {
+            if ([401, 403, 404, 422, 500].indexOf(xhr.status) !== -1) {
                 error(new NgwError(getResponseText()));
             }
             processingResponse();
@@ -1101,7 +1201,7 @@ let loadData;
             data = new FormData();
             data.append('file', options.file);
             if (options.data) {
-                for (const d in data) {
+                for (const d in options.data) {
                     data.append(d, data[d]);
                 }
             }
@@ -1187,28 +1287,36 @@ function removeConnector(connector) {
     }
 }
 
-function isObject(val) {
-    return Object.prototype.toString.call(val) === '[object Object]';
-}
-
+const exclude = ['description'];
 /**
+ * @remarks
+ * https://docs.nextgis.ru/docs_ngweb_dev/doc/developer/resource.html#search-resources
+ *
  * ```
- * { keyname, parent: { id }} > { keyname, parent__id }
+ * { keyname, owner_user: { id }} > { keyname, owner_user__id }
  * ```
+ *
  * @param resource - Any property from NGW resource item
  */
 function resourceToQuery(resource, prefix = '') {
     prefix = prefix ? prefix + '__' : '';
     const query = {};
-    Object.entries(resource).forEach(([key, value]) => {
-        if (isObject(value)) {
-            const children = resourceToQuery(value, key);
-            Object.assign(query, children);
-        }
-        else if (defined(value)) {
-            query[prefix + key] = value;
+    for (const [key, value] of Object.entries(resource)) {
+        if (exclude.indexOf(key) === -1) {
+            if (isObject(value)) {
+                if (key === 'owner_user') {
+                    const children = resourceToQuery(value, key);
+                    Object.assign(query, children);
+                }
+                else if (key === 'parent' && 'id' in value) {
+                    query.parent_id = value.id;
+                }
+            }
+            else if (defined(value)) {
+                query[prefix + key] = value;
+            }
         }
-    });
+    }
     return query;
 }
 
@@ -1233,19 +1341,30 @@ class ResourcesControl {
      */
     getOne(resource, requestOptions) {
         const cache = new Cache();
+        const forCache = {};
+        const opt = { ...requestOptions, cache: false };
+        if (typeof resource === 'string') {
+            forCache.keyname = resource;
+        }
+        else if (typeof resource === 'number') {
+            forCache.id = resource;
+        }
+        else if (isObject(resource)) {
+            forCache.id = resource.id;
+        }
         const makeRequest = () => {
             if (typeof resource === 'string') {
-                return this._fetchResourceBy({ keyname: resource }, requestOptions);
+                return this._fetchResourceBy({ keyname: resource }, opt);
             }
             else if (typeof resource === 'number') {
-                return this._fetchResourceById(resource, requestOptions);
+                return this._fetchResourceById(resource, opt);
             }
             else if (isObject(resource)) {
-                return this._fetchResourceBy(resource, requestOptions);
+                return this._fetchResourceBy(resource, opt);
             }
             return CancelablePromise.resolve(undefined);
         };
-        return cache.add('resource', makeRequest, { resource });
+        return cache.addFull('resource', makeRequest, forCache);
     }
     getOneOrFail(resource, requestOptions) {
         return this.getOne(resource, requestOptions).then((res) => {
@@ -1311,11 +1430,11 @@ class ResourcesControl {
                 })
                     .then((resources) => {
                     if (resources) {
-                        resources.forEach((x) => {
+                        for (const x of resources) {
                             this.cache.add('resource.item', CancelablePromise.resolve(x), {
                                 id: x.resource.id,
                             });
-                        });
+                        }
                     }
                     return resources;
                 });
@@ -1362,12 +1481,35 @@ class ResourcesControl {
         return this.getId(resource).then((id) => {
             if (id !== undefined) {
                 return this.connector.delete('resource.item', null, { id }).then(() => {
-                    this.cache.delete('resource.item', { id });
+                    this._cleanResourceItemCache(id);
                     return undefined;
                 });
             }
         });
     }
+    async _cleanResourceItemCache(id) {
+        const all = this.cache.all();
+        const toDelete = [];
+        for (const c of all) {
+            const cid = c.options && c.options.id;
+            if (['resource.item', 'resource'].includes(c.key) && cid !== undefined) {
+                if (typeof cid === 'number') {
+                    if (cid === id) {
+                        toDelete.push(c);
+                    }
+                }
+                else {
+                    const rid = await this.getId(cid);
+                    if (rid === id) {
+                        toDelete.push(c);
+                    }
+                }
+            }
+        }
+        for (const d of toDelete) {
+            this.cache.delete(d);
+        }
+    }
     _fetchResourceById(id, requestOptions) {
         const promise = () => this.connector.get('resource.item', requestOptions, { id });
         return this.cache
@@ -1571,7 +1713,7 @@ class NgwConnector$1 {
             headers: this.getAuthorizationHeaders(credentials),
             // withCredentials: true
         };
-        // Do not use request('auth.current_user') to avoid circular-references
+        // Do not use apiRequest('auth.current_user') to avoid circular-references
         return this.makeQuery('/api/component/auth/current_user', {}, options)
             .then((data) => {
             this.user = data;
@@ -1729,7 +1871,7 @@ class NgwConnector$1 {
             }
             // remove double slash
             url = fixUrlStr(url);
-            return this._loadData(url, options);
+            return this._loadData(encodeURI(url), options);
         }
         else {
             throw new Error('Empty `url` not allowed');
@@ -1830,7 +1972,7 @@ class NgwConnector$1 {
             else {
                 // @ts-ignore
                 {
-                    console.warn(httpError);
+                    console.warn('DEV WARN', httpError);
                 }
                 const er = this._handleHttpError(httpError);
                 if (er) {