larapi 0.2.28 → 0.2.30

package/src/Core.ts

@@ -1,261 +0,0 @@
-import EventEmitter,{
-	Events
-} from 'easy-event-emitter';
-import type {
-	TConfig,
-	TCache,
-	TCacheBody,
-	TData,
-	TGroupsData,
-	TCoreRviverObject
-} from './types';
-
-abstract class Core {
-	private cache: TCache;
-		initData: TGroupsData;
-	protected readonly events: EventEmitter;
-		config: TConfig;
-		
-
-	constructor(context?: Core) {
-		this.events = new EventEmitter();
-		this.config = {
-			host: 'http://127.0.0.1/'
-		};
-		this.cache = {};
-		this.initData = {};
-
-		this.setConfig = this.setConfig.bind(this);
-		this.setHost = this.setHost.bind(this);
-		this.setInitData = this.setInitData.bind(this);
-		this.triggerByCacheGroup = this.triggerByCacheGroup.bind(this);
-		this.clearCacheGroup = this.clearCacheGroup.bind(this);
-		this.updateCacheGroup = this.updateCacheGroup.bind(this);
-		if (context) {
-			Object.assign(this, {
-				config: context?.config,
-				events: context?.events,
-				cache: context?.cache,
-				initData: context?.initData
-			});
-		}
-	}
-
-	protected setConfig(config: TConfig) {
-		this.config = config;
-	}
-
-	protected getCache(key: string): TData | undefined {
-		if (this.cache[key]) {
-			if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
-				return this.cache[key].data;
-			}else{
-				delete this.cache[key];
-			}
-		}
-	}
-
-	protected isJsonString(str: string) {
-		try {
-			JSON.parse(str);
-		} catch (e) {
-			return false;
-		}
-		return true;
-	}
-
-	protected jsonParse(str: string) {
-		if (typeof this.config.reviver === 'function') {
-			return JSON.parse(str, this.config.reviver);
-		}
-
-		if (this.config.dataReviver) {
-			const replace = this.config.dataReviver;
-			const dataKeys = Object.keys(replace);
-			const ifKeys: TCoreRviverObject = {};
-
-			dataKeys.forEach((key) => {
-				const and = key.split('&');
-				if (and.length > 1) {
-					ifKeys.and = ifKeys.and ?? {};
-					if (key in ifKeys.and) {
-						ifKeys.and[key].push(...and);
-					}else{
-						ifKeys.and[key] = and;
-					}
-				}
-			});
-
-			const data = JSON.parse(str, (key, value) => {
-				if ((key in replace && typeof replace[key] === 'function')) {
-					return replace[key](value);
-				}
-				return value;
-			});
-			
-			if (ifKeys.and && data) {
-				const dataKeys = Object.keys(data);
-
-				if (ifKeys.and) {
-					for (const [key, keys] of Object.entries(ifKeys.and)) {
-						if (keys.length === dataKeys.length && keys.every((key) => dataKeys.includes(key))) {
-							return replace[key](data);
-						}
-					}
-				}
-			}
-
-			return data;
-		}
-		
-		return JSON.parse(str);
-	}
-
-	public setHost(host: string): void {
-		this.config.host = host;
-	}
-
-	protected setCache(key: string, data: TData, group?: string): void {
-		this.cache[key] = {
-			time: (new Date()).getTime(),
-			data: data,
-			group: group
-		};
-	}
-
-	protected groupFromArray<T = string>(groups: T | T[], callback: (group: T, params?: string[]) => void, withoutSplit: boolean = false): void {
-		const currentCallback = (group: T) => {
-			if (typeof group === 'string' && !withoutSplit) {
-				const params = group.split('.');
-				const current = params.shift() as T;
-				callback(current, params);
-			}else{
-				callback(group);
-			}
-		};
-
-		if (Array.isArray(groups)) {
-			groups.map(currentCallback);
-		}else if (typeof groups === 'string') {
-			currentCallback(groups);
-		}
-	}
-
-	public triggerByCacheGroup(groups: string | string[]): void {
-		this.groupFromArray(groups, (group) => this.events.emit('trigger-request-by-cache-' + group, undefined));
-	}
-
-	public clearCacheGroup(groups: string | string[], data?: TData, fieldKey: string | null = 'id'): void {
-		this.groupFromArray(groups, (group) => {
-			if (data) {
-
-				const clear = (cacheData: any) => {
-					if ((fieldKey && cacheData?.[fieldKey] === data?.[fieldKey]) || fieldKey === null) {
-						for(const key in cacheData) {
-							if (key in data) {
-								return false
-							}
-						}
-					}
-					return true;
-				};
-	
-	
-				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).filter(clear);
-						}else{
-							if (!clear(this.cache[key].data))
-								delete this.cache[key];
-						}
-					}
-				}
-			}else{
-				for(const key in this.cache) {
-					if (this.cache[key].group === group) {
-						delete this.cache[key];
-					}
-				}
-			}
-		});
-	}
-
-	private setDataTree(obj: any, path: string, val: any) { 
-		const keys = path.split('.');
-		const lastKey = keys.pop();
-		const lastObj = keys.reduce((obj, key) => 
-			obj[key] = obj[key] || {}, 
-			obj);
-		if (typeof lastKey === 'string') {
-			lastObj[lastKey] = val;
-		}
-		return obj;
-	};
-
-	public updateCacheGroup(groups: string | string[], data: TData, fieldKey: string | null = 'id'): void {
-		const update = (cacheData: any) => {
-			const retData = cacheData;
-			
-			const fieldList = fieldKey!.split('.');
-			if (fieldList.length > 1) {
-				for(const key of fieldList) {
-					cacheData = cacheData[key];
-				}
-			}
-			
-			if ((fieldKey && cacheData[fieldKey] === data[fieldKey]) || fieldKey === null) {
-				for(const key in cacheData) {
-					if (key in data) {
-						cacheData[key] = data[key];
-					}
-				}
-			}
-			return retData;
-		};
-		
-		this.groupFromArray(groups, (group, params) => {
-			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);
-					}
-				}
-			}
-		});
-	}
-
-	public appendCacheGroup(group: string, data: TData): void {
-		
-
-		// for(const key in this.cache) {
-		// 	if (this.cache[key].group === group) {
-		// 		console.log(this.setDataTree(this.cache[key].data, 'data.test', 'tttttt'));
-		// 	}
-		// }
-		//console.log(this.cache);
-	}
-
-	protected getCacheByIndex(index: string): TCacheBody {
-		return this.cache[index];
-	}
-
-	protected deleteCache(key: string): void {
-		if (!this.cache[key])
-			return;
-
-		const group = this.cache[key].group;
-		if (group) {
-			this.clearCacheGroup(group);
-		}
-		delete this.cache[key];
-	}
-
-	public setInitData(data: TGroupsData): void {
-		this.initData = data;
-	}
-}
-
-export default Core;

package/src/Http.ts

@@ -1,402 +0,0 @@
-import md5 from 'md5';
-import Core from "./Core";
-import Queue from './Queue';
-import EventEmitter,{
-	EventListener
-} from "easy-event-emitter";
-import type {
-	TMethod,
-	TParams,
-	TData,
-	TRequestParams,
-	TListenerEvents,
-	TCacheControll,
-	TRequestProgress,
-	TResponseData,
-	TRequestHeaders
-} from "./types";
-
-class Http<D extends TResponseData = TResponseData, PATH = any, DATA extends ((...args: any) => any) = any> extends Core {
-	private cacheIndex: string;
-	private currentCache?: TData;
-	private currentEvents: EventEmitter
-	private requestParams: TRequestParams;
-	private method: TMethod;
-	private params: TParams<PATH, DATA>;
-	private path: string;
-	private queue: Queue<D>;
-	private queueName: string;
-	private _promise?: Promise<DATA>;
-	private xhr?: XMLHttpRequest;
-
-	constructor(method: TMethod, params: TParams<PATH, DATA>, context?: Core) {
-		super(context);
-		this.currentEvents = new EventEmitter();
-		this.queue = new Queue<D>(this);
-		this.cacheIndex = '';
-		this.queueName = '';
-		this.method = method;
-		this.params = params;
-		this.path = this.params.path as string;
-		this.requestParams = {
-			method: this.method
-		};
-
-		this.requestParams.headers = {
-			...this.params.headers
-		};
-		
-		this.handleSuccess = this.handleSuccess.bind(this);
-		this.handleAbort = this.handleAbort.bind(this);
-		this.handleFail = this.handleFail.bind(this);
-		this.handleError = this.handleError.bind(this);
-		this.handleComplete = this.handleComplete.bind(this);
-		this.handleProgress = this.handleProgress.bind(this);
-		this.setEmit = this.setEmit.bind(this);
-		this.request = this.request.bind(this);
-		this.addHeader = this.addHeader.bind(this);
-		this.deleteHeader = this.deleteHeader.bind(this);
-
-		this.initRequest();
-		this.initCache();
-		this.initQueue();
-	}
-
-	private initRequest(): void {
-		
-		if (typeof XMLHttpRequest !== 'undefined') {
-			this.xhr = new XMLHttpRequest();
-		}
-
-		this.params.data = this.params.data ? this.cuteUndifinedParams(this.params.data) : this.params.data;
-
-		if ((['GET', 'HEAD'] as TMethod[]).includes(this.method)) {
-			if (this.params.data)
-				this.path = (this.params.path as string) + '?' + this.encodeUrlParams(this.params.data);
-
-			if (this.method === 'HEAD') {
-				this.requestParams.withoutResponse = true;
-			}
-		}
-
-		if ((['POST', 'PUT', 'CONNECT', 'PATH'] as TMethod[]).includes(this.method)) {
-			this.requestParams.body = this.params.body ?? JSON.stringify(this.params.data);
-		}
-
-		if ((['PUT', 'DELETE', 'CONNECT', 'OPTIONS', 'TRACE'] as TMethod[]).includes(this.method)) {
-			this.params.cache = false;
-		}
-	}
-
-	private initCache(): void {
-		this.cacheIndex = md5(this.path + JSON.stringify(this.params.data));
-		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 (typeof this.params.cache === 'string') {
-				this.events.addListener('trigger-request-by-cache-' + this.params.cache, this.request);
-			}
-			if (this.currentCache = this.getCache(this.cacheIndex)) {
-				this.handleSuccess(this.currentCache);
-				this.handleComplete(this.currentCache);
-			}	
-		}else{
-			this.deleteCache(this.cacheIndex);
-		}
-	}
-
-	public get promise() {
-		return this._promise;
-	}
-
-	private initQueue(): void {
-		this.queueName = this.params.queueThrottling ? md5(this.path) : this.cacheIndex;
-	}
-
-	private setEmit<EVENT extends keyof TListenerEvents, DATA extends TListenerEvents[EVENT]>(event: EVENT, data: DATA) {
-		this.currentEvents.emit(event, data);
-		this.events.emit(event, {
-			cacheIndex: this.cacheIndex,
-			data
-		});
-	}
-
-	//Заголовки от 200 до 299
-	public handleSuccess(data: any) {
-		if (typeof this.params.success === 'function' && this.xhr)
-			this.params.success(data, this.xhr);
-		if (this.params.cacheUpdate && this.params.data) {
-			this.groupFromArray<TCacheControll>(this.params.cacheUpdate, (cacheUpdate, params) => {
-				this.updateCacheGroup(
-					typeof cacheUpdate === 'string' ? cacheUpdate : cacheUpdate.group,
-					this.params.data ?? {},
-					typeof cacheUpdate === 'string' ? undefined : cacheUpdate.fieldKey);
-			}, true);
-		}
-		
-		if (this.params.cacheClear && this.params.data) {
-			this.groupFromArray<TCacheControll>(this.params.cacheClear, (cacheClear) => {
-				this.clearCacheGroup(
-					typeof cacheClear === 'string' ? cacheClear : cacheClear.group,
-					this.params.data,
-					typeof cacheClear === 'string' ? undefined : cacheClear.fieldKey);
-			});
-		}
-		this.setEmit('api-request-success', data);
-	}
-
-	public handleAbort(data: any) {
-		if (typeof this.params.abort === 'function') {
-			this.params.abort(data);
-		}
-		
-		this.setEmit('api-request-abort', data);
-	}
-
-	//Заголовки от 400 до 499
-	public handleFail(data: any) {
-		if (typeof this.params.fail === 'function') {
-			this.params.fail(data);
-		}
-		
-		this.setEmit('api-request-fail', data);
-	}
-
-	//Все остальные
-	public handleError(data: any) {
-		if (typeof this.params.error === 'function') {
-			this.params.error(data);
-		}
-		
-		this.setEmit('api-request-error', data);
-	}
-
-	public handleComplete(data: any) {
-		if (typeof this.params.complete === 'function') {
-			this.params.complete(data);
-		}	
-
-		this.setEmit('api-request-complete', data);
-	}
-
-	public handleProgress(progress: TRequestProgress) {
-		if (typeof this.params.progress === 'function') {
-			this.params.progress(progress);
-		}	
-
-		this.setEmit('api-request-progress', progress);
-	}
-
-	private encodeUrlParams(data: TData) {
-		return Object.entries(data).map(([key, value]) => {
-			if (Array.isArray(value)) {
-				return value.map((val) => encodeURIComponent(key) + "[]=" + encodeURIComponent(val)).join('&');
-			}
-			if (typeof value === 'object') {
-				value = JSON.stringify(value);
-			}
-			return encodeURIComponent(key) + "=" + encodeURIComponent(value);
-		}).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(force?: boolean): this {
-
-		if (!force && (this.currentCache || this.queue.push(this.queueName))) return this;
-		this._promise = new Promise(async (resolve, reject) => {
-			if (this.params.stream) {
-				fetch(this.config.host + this.path, {
-					method: this.method,
-					headers: this.requestParams.headers,
-					body: this.requestParams.body,
-				}).then((response) => {
-					this.handleSuccess(response);
-					//@ts-expect-error Skip
-					resolve(response);
-				}).catch((e) => {
-					this.handleFail(e);
-					reject(e)
-				});
-				return;
-			}
-			if (typeof this.xhr === 'undefined') return;
-			try {
-				if (this.params.file) {
-					const data = this.params.file;
-					const chunkSize = this.params.fileSizeChunk ? this.params.fileSizeChunk * 1024 * 1024 : this.params.file.byteLength;
-					const totalChunks = Math.ceil(this.params.file.byteLength / chunkSize);
-					const fileId = `file-${new Date().getTime()}`;
-
-					for (let i = 0; i < totalChunks; i++) {
-						
-						const start = i * chunkSize;
-						const end = Math.min(start + chunkSize, data.byteLength);
-						const chunk = data.slice(start, end);
-
-						const formData = new FormData();
-						formData.append("file", new Blob([chunk]));
-						formData.append("file_id", fileId);
-						formData.append("chunk_index", String(i));
-						formData.append("total_chunks", String(totalChunks));
-						const headers: TRequestHeaders = {
-							...this.requestParams.headers
-						};
-
-						delete headers['Accept'];
-						delete headers['Content-Type'];
-
-						const http = new Http(this.method, {
-							...this.params,
-							file: undefined,
-							headers,
-							data: undefined,
-							fileSizeChunk: undefined,
-							body: formData,
-							success: (totalChunks - 1 > i) ? undefined : (data) => {
-								resolve(data);
-								this.handleSuccess(data);
-							},
-							progress: (progres) => {
-								const loaded = data.byteLength + progres.loaded;
-								this.handleProgress({
-									percent: (start / data.byteLength * 100),
-									total: data.byteLength,
-									loaded
-								});
-							},
-							fail: reject,
-							error: reject
-						}, this);
-
-						this.xhr = http.xhr;
-						
-						await http.request(true).promise;
-					}
-					return;
-				}
-				
-				this.xhr.open(this.method, this.config.host + this.path, true);
-				for(const header in this.requestParams.headers) {
-					this.xhr.setRequestHeader(header, this.requestParams.headers[header]);
-				}
-	
-				if (this.xhr.upload) {
-					this.xhr.upload.onprogress = ({lengthComputable, loaded, total}) => {
-						if (lengthComputable) {
-							this.handleProgress({
-								percent: (loaded / total * 100),
-								total,
-								loaded
-							});
-						}
-					}
-				}
-	
-				this.xhr.onabort = () => {
-					reject({
-						type: 'abort',
-						message: 'request abort'
-					});
-					this.handleAbort({
-						message: 'request abort'
-					});
-				};
-	
-				this.xhr.onerror = () => {
-					reject({
-						type: 'error',
-						message: 'request error'
-					});
-					this.handleError({
-						message: 'request error'
-					});
-				};
-	
-				this.xhr.onreadystatechange = () => {
-					if (this.xhr?.readyState !== XMLHttpRequest.DONE) return;
-	
-					const result = (!this.requestParams.withoutResponse && this.isJsonString(this.xhr.responseText)) ? this.jsonParse(this.xhr.responseText) : {};
-	
-					if (this.xhr?.status >= 200 && this.xhr.status <= 299) {
-						if (this.params.cache) {
-							this.setCache(this.cacheIndex, result, (typeof this.params.cache === 'boolean' ? undefined : this.params.cache));
-						}
-						resolve(result);
-						this.handleSuccess(result);
-					}else{
-						if (this.xhr.status >= 400 && this.xhr.status <= 499) {
-							reject(result);
-							this.handleFail(result);
-						}else{
-							reject(result);
-							this.handleError(result);
-						}
-					}
-					this.handleComplete(result);
-					this.queue.clear(this.queueName);
-				}
-				this.xhr.send(this.requestParams.body);
-			}catch(e) {
-				reject(e);
-			}
-		});
-		
-		return this
-	}
-
-	public abort() {
-		this.xhr?.abort();
-	}
-
-	public addHeader(key: string, value: string): this {
-		this.requestParams.headers = {...this.requestParams.headers, [key]: value};
-		return this;
-	}
-
-	public addListener<EVENT extends keyof TListenerEvents, DATA extends TListenerEvents[EVENT]>(event: EVENT, callback: (data: DATA) => void): EventListener {
-		return this.currentEvents.addListener(event, callback);
-	}
-
-	public deleteHeader(key: string): this {
-		if (this.requestParams.headers && (key in this.requestParams.headers)) {
-			delete this.requestParams.headers[key];
-		}
-		return this;
-	}
-
-	public updateCache(data: TData, fieldKey: string | null = 'id'): void {
-		const cache = this.getCacheByIndex(this.cacheIndex);
-		if (cache && cache.group) {
-			this.updateCacheGroup(cache.group, data, fieldKey);
-		}
-	}
-
-	public clearCache(data?: TData, fieldKey: string | null = 'id'): void {
-		if (data) {
-			const cache = this.getCacheByIndex(this.cacheIndex);
-			if (cache && cache.group) {
-				this.clearCacheGroup(cache.group, data, fieldKey);
-			}
-		}else{
-			this.deleteCache(this.cacheIndex);
-		}
-	}
-}
-
-export default Http;

package/src/Queue.ts

@@ -1,50 +0,0 @@
-import Http from "./Http";
-import type { TResponseData } from "./types";
-
-type TQueue = {
-	[index: string]: Http;
-};
-
-class Queue<D extends TResponseData = TResponseData> {
-	private static _Queue: TQueue = {};
-	private queue = Queue._Queue;
-		http: Http<D>;
-
-	constructor(http: Http<D>) {
-		this.http = http;
-		this.has = this.has.bind(this);
-		this.get = this.get.bind(this);
-		this.clear = this.clear.bind(this);
-		this.push = this.push.bind(this);
-	}
-
-	public has(request: string) {
-		return request in this.queue;
-	}
-
-	public get(request: string) {
-		return this.has(request) ? this.queue[request] : undefined;
-	}
-
-	public clear(request: string) {
-		if (this.has(request)) {
-			delete this.queue[request];
-		}
-	}
-
-	public push(request: string): boolean {
-		const refInstance = this.get(request);
-		if (!refInstance) {
-			(this.queue[request] as any) = this.http;
-		}else{
-			refInstance?.addListener('api-request-success', this.http.handleSuccess);
-			refInstance?.addListener('api-request-error', this.http.handleError);
-			refInstance?.addListener('api-request-fail', this.http.handleFail);
-			refInstance?.addListener('api-request-complete', this.http.handleComplete);
-			refInstance?.addListener('api-request-abort', this.http.handleAbort);
-		}
-		return refInstance instanceof Http;
-	}
-}
-
-export default Queue;