larapi 0.0.6 → 0.0.8

package/lib/Core.d.ts

@@ -1,21 +1,20 @@
 import { Events, Event } from 'easy-event-emitter';
-import { TCache, TGroupsData, TMethod, TParams, TListenerEvents } from './types';
+import { TCacheBody, TData, TGroupsData, TListenerEvents } from './types';
 declare abstract class Core {
-    private host;
-    token: string;
-    cache: TCache;
+    private cache;
     initData: TGroupsData;
     protected events: Events;
-    constructor();
-    protected request(method: TMethod, params: TParams): {
-        clearCache: () => void;
-    } | undefined;
+    host: string;
+    token: string;
+    constructor(context?: Core);
     addListener(event: TListenerEvents, callback: (data: any) => void): Event;
-    private getCache;
+    protected getCache(key: string): TData | undefined;
     setHost(host: string): void;
-    private setCache;
-    deleteCacheGroup(group: string): void;
-    private deleteCache;
+    protected setCache(key: string, data: TData, group?: string): void;
+    clearCacheGroup(group: string): void;
+    updateCacheGroup(group: string, fieldKey: string, data: TData): void;
+    protected getCacheByIndex(index: string): TCacheBody;
+    protected deleteCache(key: string): void;
     setInitData(data: TGroupsData): void;
 }
 export default Core;

package/lib/Core.js

@@ -3,36 +3,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-//@ts-ignore
-const md5_1 = __importDefault(require("md5"));
 const easy_event_emitter_1 = __importDefault(require("easy-event-emitter"));
 class Core {
-    constructor() {
-        Object.defineProperty(this, "host", {
+    constructor(context) {
+        Object.defineProperty(this, "cache", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "token", {
+        Object.defineProperty(this, "initData", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "cache", {
+        Object.defineProperty(this, "events", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "initData", {
+        Object.defineProperty(this, "host", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "events", {
+        Object.defineProperty(this, "token", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -43,135 +41,16 @@ class Core {
         this.token = '';
         this.cache = {};
         this.initData = {};
-        this.request = this.request.bind(this);
         this.setHost = this.setHost.bind(this);
         this.addListener = this.addListener.bind(this);
         this.setInitData = this.setInitData.bind(this);
-    }
-    request(method, params) {
-        var _a;
-        if (typeof XMLHttpRequest === 'undefined')
-            return;
-        //Заголовки от 200 до 299
-        const success = (...args) => {
-            if (typeof params.success === 'function')
-                params.success(...args);
-        };
-        //Заголовки от 400 до 499
-        const fail = (...args) => {
-            if (typeof params.fail === 'function') {
-                params.fail(...args);
-            }
-            this.events.emit('api-request-fail', args);
-        };
-        //Все остальные
-        const error = (...args) => {
-            if (typeof params.error === 'function') {
-                params.error(...args);
-            }
-            this.events.emit('api-request-error', args);
-        };
-        const complete = (...args) => {
-            if (typeof params.complete === 'function') {
-                params.complete(...args);
-            }
-            this.events.emit('api-request-complete', args);
-        };
-        const encodeUrlParams = (data) => {
-            return Object.keys(data).map(function (k) {
-                return encodeURIComponent(k) + "=" + encodeURIComponent(data[k]);
-            }).join('&');
-        };
-        const cuteUndifinedParams = (data) => {
-            if (typeof data !== 'object') {
-                return;
-            }
-            for (const key in data) {
-                if (!data[key]) {
-                    delete data[key];
-                }
-            }
-            return data;
-        };
-        var path = params.path;
-        const fetchParams = {
-            method: method
-        };
-        fetchParams.headers = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': 'Bearer ' + this.token
-        };
-        params.data = params.data ? cuteUndifinedParams(params.data) : params.data;
-        if (method === 'POST') {
-            fetchParams.body = JSON.stringify(params.data);
-        }
-        if (method === 'GET') {
-            if (params.data)
-                path = params.path + '?' + encodeUrlParams(params.data);
-        }
-        const pathCache = (0, md5_1.default)(path + JSON.stringify(params.data));
-        var dataCache;
-        if (params.globalName) {
-            if (this.initData[params.globalName]) {
-                this.setCache(pathCache, this.initData[params.globalName], (typeof params.cache === 'boolean' ? undefined : params.cache));
-                params.cache = (_a = params.cache) !== null && _a !== void 0 ? _a : true;
-                delete this.initData[params.globalName];
-            }
-        }
-        if (params.cache) {
-            if (dataCache = this.getCache(pathCache)) {
-                success(dataCache);
-                complete(dataCache);
-            }
-        }
-        else {
-            this.deleteCache(pathCache);
-        }
-        if (!dataCache) {
-            try {
-                const xhr = new XMLHttpRequest();
-                xhr.open(method, this.host + path, true);
-                for (const header in fetchParams.headers) {
-                    xhr.setRequestHeader(header, fetchParams.headers[header]);
-                }
-                xhr.onreadystatechange = () => {
-                    if (xhr.readyState !== 4) {
-                        return;
-                    }
-                    const result = xhr.responseText ? JSON.parse(xhr.responseText) : {};
-                    if (xhr.status >= 200 && xhr.status <= 299) {
-                        if (params.cache) {
-                            this.setCache(pathCache, result, (typeof params.cache === 'boolean' ? undefined : params.cache));
-                        }
-                        success(result);
-                    }
-                    else {
-                        if (xhr.status >= 400 && xhr.status <= 499) {
-                            fail(result);
-                        }
-                        error(result);
-                        console.warn(result);
-                    }
-                    complete(result);
-                };
-                xhr.send(fetchParams.body);
-            }
-            catch (e) {
-                console.warn(e);
-            }
-        }
-        return {
-            clearCache: () => {
-                this.deleteCache(pathCache);
-            }
-        };
+        this.clearCacheGroup = this.clearCacheGroup.bind(this);
+        Object.assign(this, context);
     }
     addListener(event, callback) {
         return this.events.addListener(event, callback);
     }
-    getCache(request) {
-        const key = (0, md5_1.default)(request);
+    getCache(key) {
         if (this.cache[key]) {
             if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
                 return this.cache[key].data;
@@ -184,29 +63,53 @@ class Core {
     setHost(host) {
         this.host = host;
     }
-    setCache(request, data, group) {
-        this.cache[(0, md5_1.default)(request)] = {
+    setCache(key, data, group) {
+        this.cache[key] = {
             time: (new Date()).getTime(),
             data: data,
             group: group
         };
     }
-    deleteCacheGroup(group) {
+    clearCacheGroup(group) {
         for (const key in this.cache) {
             if (this.cache[key].group === group) {
                 delete this.cache[key];
             }
         }
     }
-    deleteCache(request) {
-        const keyCache = (0, md5_1.default)(request);
-        if (!this.cache[keyCache])
+    updateCacheGroup(group, fieldKey, data) {
+        const update = (cacheData) => {
+            if (cacheData[fieldKey] === data[fieldKey]) {
+                for (const fieldKey in cacheData) {
+                    if (fieldKey in data) {
+                        cacheData[fieldKey] = data[fieldKey];
+                    }
+                }
+            }
+            return cacheData;
+        };
+        for (const key in this.cache) {
+            if (this.cache[key].group === group) {
+                if (Array.isArray(this.cache[key].data)) {
+                    this.cache[key].data = Object.values(this.cache[key].data).map(update);
+                }
+                else {
+                    this.cache[key].data = update(this.cache[key].data);
+                }
+            }
+        }
+    }
+    getCacheByIndex(index) {
+        return this.cache[index];
+    }
+    deleteCache(key) {
+        if (!this.cache[key])
             return;
-        const group = this.cache[keyCache].group;
+        const group = this.cache[key].group;
         if (group) {
-            this.deleteCacheGroup(group);
+            this.clearCacheGroup(group);
         }
-        delete this.cache[keyCache];
+        delete this.cache[key];
     }
     setInitData(data) {
         this.initData = data;

package/lib/Http.d.ts

@@ -0,0 +1,18 @@
+import Core from "./Core";
+import { TMethod, TParams, TData } from "./types";
+declare class Http extends Core {
+    private cacheIndex;
+    method: TMethod;
+    params: TParams;
+    constructor(method: TMethod, params: TParams, context?: Core);
+    private success;
+    private fail;
+    private error;
+    private complete;
+    private encodeUrlParams;
+    private cuteUndifinedParams;
+    request(): this;
+    updateCache(fieldKey: string, data: TData): void;
+    clearCache(): void;
+}
+export default Http;

package/lib/Http.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-ignore
+const md5_1 = __importDefault(require("md5"));
+const Core_1 = __importDefault(require("./Core"));
+class Http extends Core_1.default {
+    constructor(method, params, context) {
+        super(context);
+        Object.defineProperty(this, "cacheIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "method", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "params", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cacheIndex = '';
+        this.method = method;
+        this.params = params;
+        this.success = this.success.bind(this);
+        this.fail = this.fail.bind(this);
+        this.error = this.error.bind(this);
+        this.complete = this.complete.bind(this);
+        this.request = this.request.bind(this);
+    }
+    //Заголовки от 200 до 299
+    success(...args) {
+        if (typeof this.params.success === 'function')
+            this.params.success(...args);
+    }
+    //Заголовки от 400 до 499
+    fail(...args) {
+        if (typeof this.params.fail === 'function') {
+            this.params.fail(...args);
+        }
+        this.events.emit('api-request-fail', args);
+    }
+    //Все остальные
+    error(...args) {
+        if (typeof this.params.error === 'function') {
+            this.params.error(...args);
+        }
+        this.events.emit('api-request-error', args);
+    }
+    complete(...args) {
+        if (typeof this.params.complete === 'function') {
+            this.params.complete(...args);
+        }
+        this.events.emit('api-request-complete', args);
+    }
+    encodeUrlParams(data) {
+        return Object.keys(data).map(function (k) {
+            return encodeURIComponent(k) + "=" + encodeURIComponent(data[k]);
+        }).join('&');
+    }
+    cuteUndifinedParams(data) {
+        if (typeof data !== 'object') {
+            return;
+        }
+        for (const key in data) {
+            if (!data[key]) {
+                delete data[key];
+            }
+        }
+        return data;
+    }
+    request() {
+        var _a;
+        if (typeof XMLHttpRequest === 'undefined')
+            return this;
+        var path = this.params.path;
+        const fetchParams = {
+            method: this.method
+        };
+        fetchParams.headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ' + this.token
+        };
+        this.params.data = this.params.data ? this.cuteUndifinedParams(this.params.data) : this.params.data;
+        if (this.method === 'POST') {
+            fetchParams.body = JSON.stringify(this.params.data);
+        }
+        if (this.method === 'GET') {
+            if (this.params.data)
+                path = this.params.path + '?' + this.encodeUrlParams(this.params.data);
+        }
+        this.cacheIndex = (0, md5_1.default)(path + JSON.stringify(this.params.data));
+        var dataCache;
+        if (this.params.globalName) {
+            if (this.initData[this.params.globalName]) {
+                this.setCache(this.cacheIndex, this.initData[this.params.globalName], (typeof this.params.cache === 'boolean' ? undefined : this.params.cache));
+                this.params.cache = (_a = this.params.cache) !== null && _a !== void 0 ? _a : true;
+                delete this.initData[this.params.globalName];
+            }
+        }
+        if (this.params.cache) {
+            if (dataCache = this.getCache(this.cacheIndex)) {
+                this.success(dataCache);
+                this.complete(dataCache);
+            }
+        }
+        else {
+            this.deleteCache(this.cacheIndex);
+        }
+        if (!dataCache) {
+            try {
+                const xhr = new XMLHttpRequest();
+                xhr.open(this.method, this.host + path, true);
+                for (const header in fetchParams.headers) {
+                    xhr.setRequestHeader(header, fetchParams.headers[header]);
+                }
+                xhr.onreadystatechange = () => {
+                    if (xhr.readyState !== 4) {
+                        return;
+                    }
+                    const result = xhr.responseText ? JSON.parse(xhr.responseText) : {};
+                    if (xhr.status >= 200 && xhr.status <= 299) {
+                        if (this.params.cache) {
+                            this.setCache(this.cacheIndex, result, (typeof this.params.cache === 'boolean' ? undefined : this.params.cache));
+                        }
+                        this.success(result);
+                    }
+                    else {
+                        if (xhr.status >= 400 && xhr.status <= 499) {
+                            fail(result);
+                        }
+                        this.error(result);
+                        console.warn(result);
+                    }
+                    this.complete(result);
+                };
+                xhr.send(fetchParams.body);
+            }
+            catch (e) {
+                console.warn(e);
+            }
+        }
+        return this;
+    }
+    updateCache(fieldKey, data) {
+        const cache = this.getCacheByIndex(this.cacheIndex);
+        if (cache && cache.group) {
+            this.updateCacheGroup(cache.group, fieldKey, data);
+        }
+    }
+    clearCache() {
+        this.deleteCache(this.cacheIndex);
+    }
+}
+exports.default = Http;

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import Core from "./Core";
-import { TParams } from "./types";
+import { TMethod, TParams } from "./types";
+import Http from "./Http";
 type TUser = {
     [index: string]: any;
 };
@@ -10,12 +11,9 @@ declare class API extends Core {
     private static instance;
     private _user;
     constructor(config: TConfig);
-    get(params: TParams): {
-        clearCache: () => void;
-    } | undefined;
-    post(params: TParams): {
-        clearCache: () => void;
-    } | undefined;
+    http(method: TMethod, params: TParams): Http;
+    get(params: TParams): Http;
+    post(params: TParams): Http;
     private init;
     setToken(token: string): void;
     getToken(): string;
@@ -26,12 +24,9 @@ declare class API extends Core {
     setUser(user: TUser): void;
     updateUser(user: TUser): void;
     logout(): void;
-    static get: (params: TParams) => {
-        clearCache: () => void;
-    } | undefined;
-    static post: (params: TParams) => {
-        clearCache: () => void;
-    } | undefined;
+    static http: (method: TMethod, params: TParams) => Http;
+    static get: (params: TParams) => Http;
+    static post: (params: TParams) => Http;
     static setHost: (host: string) => void;
     static setUser: (user: TUser) => void;
     static updateUser: (user: TUser) => void;
@@ -39,7 +34,7 @@ declare class API extends Core {
     static setToken: (token: string) => void;
     static addListener: (event: import("./types").TListenerEvents, callback: (data: any) => void) => import("easy-event-emitter").Event;
     static setInitData: (data: import("./types").TGroupsData) => void;
-    static deleteCacheGroup: (group: string) => void;
+    static clearCacheGroup: (group: string) => void;
     static getToken: () => string;
     static getUid: () => number;
     static getUser: () => TUser;

package/lib/index.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const Core_1 = __importDefault(require("./Core"));
+const Http_1 = __importDefault(require("./Http"));
 class API extends Core_1.default {
     constructor(config) {
         super();
@@ -22,16 +23,20 @@ class API extends Core_1.default {
         this.updateUser = this.updateUser.bind(this);
         this.logout = this.logout.bind(this);
         this.getToken = this.getToken.bind(this);
+        this.http = this.http.bind(this);
         this.get = this.get.bind(this);
         this.post = this.post.bind(this);
         this.getUid = this.getUid.bind(this);
         this.getUser = this.getUser.bind(this);
     }
+    http(method, params) {
+        return new Http_1.default(method, params, this);
+    }
     get(params) {
-        return this.request('GET', params);
+        return this.http('GET', params).request();
     }
     post(params) {
-        return this.request('POST', params);
+        return this.http('POST', params).request();
     }
     init() {
         if (typeof window === 'undefined')
@@ -97,6 +102,12 @@ Object.defineProperty(API, "instance", {
         host: ''
     })
 });
+Object.defineProperty(API, "http", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: _a.instance.http
+});
 Object.defineProperty(API, "get", {
     enumerable: true,
     configurable: true,
@@ -151,11 +162,11 @@ Object.defineProperty(API, "setInitData", {
     writable: true,
     value: _a.instance.setInitData
 });
-Object.defineProperty(API, "deleteCacheGroup", {
+Object.defineProperty(API, "clearCacheGroup", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: _a.instance.deleteCacheGroup
+    value: _a.instance.clearCacheGroup
 });
 Object.defineProperty(API, "getToken", {
     enumerable: true,

package/lib/types.d.ts

@@ -1,5 +1,10 @@
+export type TCacheBody = {
+    data: any;
+    group?: string;
+    time: number;
+};
 export type TCache = {
-    [index: string]: any;
+    [index: string]: TCacheBody;
 };
 export type TData = {
     [index: string]: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larapi",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "API client for laravel",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/Core.ts

@@ -1,182 +1,41 @@
-//@ts-ignore
-import md5 from 'md5';
 import EventEmitter,{
 	Events,
 	Event
 } from 'easy-event-emitter';
 import {
 	TCache,
+	TCacheBody,
 	TData,
 	TGroupsData,
-	TMethod,
-	TParams,
-	TRequestParams,
 	TListenerEvents
 } from './types';
 
 abstract class Core {
-	private host: string;
-		token: string;
-		cache: TCache;
+	private cache: TCache;
 		initData: TGroupsData;
 	protected events: Events;
+		host: string;
+		token: string;
 
-	constructor() {
+	constructor(context?: Core) {
 		this.events = new EventEmitter();
 		this.host = 'http://127.0.0.1/';
 		this.token = '';
 		this.cache = {};
 		this.initData = {};
 
-		this.request = this.request.bind(this);
 		this.setHost = this.setHost.bind(this);
 		this.addListener = this.addListener.bind(this);
 		this.setInitData = this.setInitData.bind(this);
-	}
-
-	protected request(method: TMethod, params: TParams) {
-		if (typeof XMLHttpRequest === 'undefined') return;
-
-		//Заголовки от 200 до 299
-		const success = (...args: any) => {
-			if (typeof params.success === 'function')
-				params.success(...args);
-		};
-
-		//Заголовки от 400 до 499
-		const fail = (...args: any) => {
-			if (typeof params.fail === 'function') {
-				params.fail(...args);
-			}
-			
-			this.events.emit('api-request-fail', args);
-		};
-
-		//Все остальные
-		const error = (...args: any) => {
-			if (typeof params.error === 'function') {
-				params.error(...args);
-			}
-			
-			this.events.emit('api-request-error', args);
-		};
-
-		const complete = (...args: any) => {
-			if (typeof params.complete === 'function') {
-				params.complete(...args);
-			}	
-
-			this.events.emit('api-request-complete', args);
-		};
-
-		const encodeUrlParams = (data: TData) => {
-			return Object.keys(data).map(function(k) {
-				return encodeURIComponent(k) + "=" + encodeURIComponent(data[k]);
-			}).join('&');
-		};
-
-		const cuteUndifinedParams = (data: TData) => {
-			if (typeof data !== 'object') {
-				return;
-			}
-			for(const key in data) {
-				if (!data[key]) {
-					delete data[key];
-				}
-			}
-			return data;
-		};
-
-		var path = params.path;
-		const fetchParams: TRequestParams = {
-			method: method
-		};
-
-		fetchParams.headers = {
-			'Accept': 'application/json',
-			'Content-Type': 'application/json',
-			'Authorization': 'Bearer ' + this.token
-		};
-
-		params.data = params.data ? cuteUndifinedParams(params.data) : params.data;
-
-		if (method === 'POST') {
-			fetchParams.body = JSON.stringify(params.data);
-		}
-
-		if (method === 'GET') {
-			if (params.data)
-				path = params.path + '?' + encodeUrlParams(params.data);
-		}
-		const pathCache = md5(path + JSON.stringify(params.data));
-		var dataCache;
-
-		if (params.globalName) {
-			if (this.initData[params.globalName]) {
-				this.setCache(pathCache, this.initData[params.globalName], (typeof params.cache === 'boolean' ? undefined : params.cache));
-				params.cache = params.cache ?? true;
-				delete this.initData[params.globalName];
-			}
-		}
-		
-		if (params.cache) {
-			if (dataCache = this.getCache(pathCache)) {
-				success(dataCache);
-				complete(dataCache);
-			}	
-		}else{
-			this.deleteCache(pathCache);
-		}
-		if (!dataCache) {
-			try {
-				const xhr = new XMLHttpRequest();
-
-				xhr.open(method, this.host + path, true);
-				for(const header in fetchParams.headers) {
-					xhr.setRequestHeader(header, fetchParams.headers[header]);
-				}
-	
-				xhr.onreadystatechange = () => {
-					if (xhr.readyState !== 4) {
-						return;
-					}
-					
-					const result = xhr.responseText ? JSON.parse(xhr.responseText) : {};
-	
-					if (xhr.status >= 200 && xhr.status <= 299) {
-						if (params.cache) {
-							this.setCache(pathCache, result, (typeof params.cache === 'boolean' ? undefined : params.cache));
-						}
-						success(result);
-					}else{
-						if (xhr.status >= 400 && xhr.status <= 499) {
-							fail(result);
-						}
-						
-						error(result);
-						console.warn(result);
-					}
-					complete(result);
-				}
-				xhr.send(fetchParams.body);
-			}catch(e) {
-				console.warn(e);
-			}
-			
-		}
-		return {
-			clearCache: () => {
-				this.deleteCache(pathCache);
-			}
-		}
+		this.clearCacheGroup = this.clearCacheGroup.bind(this);
+		Object.assign(this, context);
 	}
 
 	public addListener(event: TListenerEvents, callback: (data: any) => void): Event {
 		return this.events.addListener(event, callback);
 	}
 
-	private getCache(request: string): TData | undefined {
-		const key = md5(request);
+	protected getCache(key: string): TData | undefined {
 		if (this.cache[key]) {
 			if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
 				return this.cache[key].data;
@@ -190,15 +49,15 @@ abstract class Core {
 		this.host = host;
 	}
 
-	private setCache(request: string, data: TData, group?: string): void {
-		this.cache[md5(request)] = {
+	protected setCache(key: string, data: TData, group?: string): void {
+		this.cache[key] = {
 			time: (new Date()).getTime(),
 			data: data,
 			group: group
 		};
 	}
 
-	public deleteCacheGroup(group: string): void {
+	public clearCacheGroup(group: string): void {
 		for(const key in this.cache) {
 			if (this.cache[key].group === group) {
 				delete this.cache[key];
@@ -206,16 +65,43 @@ abstract class Core {
 		}
 	}
 
-	private deleteCache(request: string): void {
-		const keyCache = md5(request);
-		if (!this.cache[keyCache])
+	public updateCacheGroup(group: string, fieldKey: string, data: TData): void {
+
+		const update = (cacheData: any) => {
+			if (cacheData[fieldKey] === data[fieldKey]) {
+				for(const fieldKey in cacheData) {
+					if (fieldKey in data) {
+						cacheData[fieldKey] = data[fieldKey];
+					}
+				}
+			}
+			return cacheData;
+		};
+
+		for(const key in this.cache) {
+			if (this.cache[key].group === group) {
+				if (Array.isArray(this.cache[key].data)) {
+					this.cache[key].data = Object.values(this.cache[key].data).map(update);
+				}else{
+					this.cache[key].data = update(this.cache[key].data);
+				}
+			}
+		}
+	}
+
+	protected getCacheByIndex(index: string): TCacheBody {
+		return this.cache[index];
+	}
+
+	protected deleteCache(key: string): void {
+		if (!this.cache[key])
 			return;
 
-		const group = this.cache[keyCache].group;
+		const group = this.cache[key].group;
 		if (group) {
-			this.deleteCacheGroup(group);
+			this.clearCacheGroup(group);
 		}
-		delete this.cache[keyCache];
+		delete this.cache[key];
 	}
 
 	public setInitData(data: TGroupsData): void {

package/src/Http.ts

@@ -0,0 +1,175 @@
+//@ts-ignore
+import md5 from 'md5';
+import Core from "./Core";
+import {
+	TMethod,
+	TParams,
+	TData,
+	TRequestParams
+} from "./types";
+
+class Http extends Core {
+	private cacheIndex: string;
+		method: TMethod;
+		params: TParams;
+
+	constructor(method: TMethod, params: TParams, context?: Core) {
+		super(context);
+		this.cacheIndex = '';
+		this.method = method;
+		this.params = params;
+		
+		this.success = this.success.bind(this);
+		this.fail = this.fail.bind(this);
+		this.error = this.error.bind(this);
+		this.complete = this.complete.bind(this);
+		this.request = this.request.bind(this);
+	}
+
+	//Заголовки от 200 до 299
+	private success(...args: any) {
+		if (typeof this.params.success === 'function')
+			this.params.success(...args);
+	}
+
+	//Заголовки от 400 до 499
+	private fail(...args: any) {
+		if (typeof this.params.fail === 'function') {
+			this.params.fail(...args);
+		}
+		
+		this.events.emit('api-request-fail', args);
+	}
+
+	//Все остальные
+	private error(...args: any) {
+		if (typeof this.params.error === 'function') {
+			this.params.error(...args);
+		}
+		
+		this.events.emit('api-request-error', args);
+	}
+
+	private complete(...args: any) {
+		if (typeof this.params.complete === 'function') {
+			this.params.complete(...args);
+		}	
+
+		this.events.emit('api-request-complete', args);
+	}
+
+	private encodeUrlParams(data: TData) {
+		return Object.keys(data).map(function(k) {
+			return encodeURIComponent(k) + "=" + encodeURIComponent(data[k]);
+		}).join('&');
+	}
+
+	private cuteUndifinedParams(data: TData) {
+		if (typeof data !== 'object') {
+			return;
+		}
+		for(const key in data) {
+			if (!data[key]) {
+				delete data[key];
+			}
+		}
+		return data;
+	}
+
+	public request(): this {
+		if (typeof XMLHttpRequest === 'undefined') return this;
+
+		var path = this.params.path;
+		const fetchParams: TRequestParams = {
+			method: this.method
+		};
+
+		fetchParams.headers = {
+			'Accept': 'application/json',
+			'Content-Type': 'application/json',
+			'Authorization': 'Bearer ' + this.token
+		};
+
+		this.params.data = this.params.data ? this.cuteUndifinedParams(this.params.data) : this.params.data;
+
+		if (this.method === 'POST') {
+			fetchParams.body = JSON.stringify(this.params.data);
+		}
+
+		if (this.method === 'GET') {
+			if (this.params.data)
+				path = this.params.path + '?' + this.encodeUrlParams(this.params.data);
+		}
+
+		this.cacheIndex = md5(path + JSON.stringify(this.params.data));
+
+		var dataCache;
+
+		if (this.params.globalName) {
+			if (this.initData[this.params.globalName]) {
+				this.setCache(this.cacheIndex, this.initData[this.params.globalName], (typeof this.params.cache === 'boolean' ? undefined : this.params.cache));
+				this.params.cache = this.params.cache ?? true;
+				delete this.initData[this.params.globalName];
+			}
+		}
+		
+		if (this.params.cache) {
+			if (dataCache = this.getCache(this.cacheIndex)) {
+				this.success(dataCache);
+				this.complete(dataCache);
+			}	
+		}else{
+			this.deleteCache(this.cacheIndex);
+		}
+		if (!dataCache) {
+			try {
+				const xhr = new XMLHttpRequest();
+
+				xhr.open(this.method, this.host + path, true);
+				for(const header in fetchParams.headers) {
+					xhr.setRequestHeader(header, fetchParams.headers[header]);
+				}
+	
+				xhr.onreadystatechange = () => {
+					if (xhr.readyState !== 4) {
+						return;
+					}
+					
+					const result = xhr.responseText ? JSON.parse(xhr.responseText) : {};
+	
+					if (xhr.status >= 200 && xhr.status <= 299) {
+						if (this.params.cache) {
+							this.setCache(this.cacheIndex, result, (typeof this.params.cache === 'boolean' ? undefined : this.params.cache));
+						}
+						this.success(result);
+					}else{
+						if (xhr.status >= 400 && xhr.status <= 499) {
+							fail(result);
+						}
+						
+						this.error(result);
+						console.warn(result);
+					}
+					this.complete(result);
+				}
+				xhr.send(fetchParams.body);
+			}catch(e) {
+				console.warn(e);
+			}
+		}
+		return this
+	}
+
+	public updateCache(fieldKey: string, data: TData): void {
+		const cache = this.getCacheByIndex(this.cacheIndex);
+		if (cache && cache.group) {
+			this.updateCacheGroup(cache.group, fieldKey, data);
+		}
+	}
+
+	public clearCache(): void {
+		this.deleteCache(this.cacheIndex);
+	}
+}
+
+export default Http;

package/src/index.ts

@@ -1,5 +1,6 @@
 import Core from "./Core";
-import { TParams } from "./types";
+import { TMethod, TParams } from "./types";
+import Http from "./Http";
 
 type TUser = {
 	[index: string]: any;
@@ -26,18 +27,23 @@ class API extends Core {
 		this.updateUser = this.updateUser.bind(this);
 		this.logout = this.logout.bind(this);
 		this.getToken = this.getToken.bind(this);
+		this.http = this.http.bind(this);
 		this.get = this.get.bind(this);
 		this.post = this.post.bind(this);
 		this.getUid = this.getUid.bind(this);
 		this.getUser = this.getUser.bind(this);
 	}
 
-	public get(params: TParams) {
-		return this.request('GET', params);
+	public http(method: TMethod, params: TParams): Http {
+		return new Http(method, params, this);
 	}
 
-	public post(params: TParams) {
-		return this.request('POST', params);
+	public get(params: TParams): Http {
+		return this.http('GET', params).request();
+	}
+
+	public post(params: TParams): Http {
+		return this.http('POST', params).request();
 	}
 
 	private init(): void {
@@ -100,6 +106,7 @@ class API extends Core {
 		this.setToken('');
 	}
 
+	public static http = this.instance.http;
 	public static get = this.instance.get;
 	public static post = this.instance.post;
 	public static setHost = this.instance.setHost;
@@ -109,7 +116,7 @@ class API extends Core {
 	public static setToken = this.instance.setToken;
 	public static addListener = this.instance.addListener;
 	public static setInitData = this.instance.setInitData;
-	public static deleteCacheGroup = this.instance.deleteCacheGroup;
+	public static clearCacheGroup = this.instance.clearCacheGroup;
 	public static getToken = this.instance.getToken;
 	public static getUid = this.instance.getUid;
 	public static getUser = this.instance.getUser;

package/src/types.ts

@@ -1,5 +1,11 @@
+export type TCacheBody = {
+	data: any;
+	group?: string;
+	time: number;
+}
+
 export type TCache = {
-	[index: string]: any;
+	[index: string]: TCacheBody;
 }
 
 export type TData = {