larapi 0.0.1

package/__tests__/connect.test.js

@@ -0,0 +1,8 @@
+import API from "../lib/index.js";
+
+test('Connect', () => {
+	// const api = new API({
+	// 	host: 'http://127.0.0.1:8000'
+	// });
+	
+});

package/lib/Core.d.ts

@@ -0,0 +1,21 @@
+import { Events, Event } from 'easy-event-emitter';
+import { TCache, TMethod, TParams, TListenerEvents } from './types';
+declare abstract class Core {
+    private host;
+    token: string;
+    cache: TCache;
+    protected events: Events;
+    constructor();
+    protected request(method: TMethod, params: TParams): {
+        clearCache: () => void;
+    };
+    addListener(event: TListenerEvents, callback: (data: any) => void): Event;
+    private getCache;
+    setHost(host: string): void;
+    private setCache;
+    private deleteCacheGroup;
+    private deleteCache;
+    setToken(token: string): void;
+    getToken(): string;
+}
+export default Core;

package/lib/Core.js

@@ -0,0 +1,203 @@
+"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 easy_event_emitter_1 = __importDefault(require("easy-event-emitter"));
+class Core {
+    constructor() {
+        Object.defineProperty(this, "host", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.events = new easy_event_emitter_1.default();
+        this.host = 'http://127.0.0.1/';
+        this.token = '';
+        this.cache = {};
+        this.setHost = this.setHost.bind(this);
+        this.setToken = this.setToken.bind(this);
+        this.addListener = this.addListener.bind(this);
+    }
+    request(method, params) {
+        //Заголовки от 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 (__global && __global[params.globalName]) {
+            // 	Core.setCache(pathCache, __global[params.globalName], (typeof params.cache === 'boolean' ? undefined : params.cache));
+            // 	params.cache = params.cache ?? true;
+            // 	delete __global[params.globalName];
+            // }
+        }
+        if (params.cache) {
+            if (dataCache = this.getCache(pathCache)) {
+                success(dataCache);
+                complete(dataCache);
+            }
+        }
+        else {
+            this.deleteCache(pathCache);
+        }
+        if (!dataCache) {
+            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.error(result);
+                }
+                complete(result);
+            };
+            xhr.send(fetchParams.body);
+        }
+        return {
+            clearCache: () => {
+                this.deleteCache(pathCache);
+            }
+        };
+    }
+    addListener(event, callback) {
+        return this.events.addListener(event, callback);
+    }
+    getCache(request) {
+        const key = (0, md5_1.default)(request);
+        if (this.cache[key]) {
+            if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
+                return this.cache[key].data;
+            }
+            else {
+                delete this.cache[key];
+            }
+        }
+    }
+    setHost(host) {
+        this.host = host;
+    }
+    setCache(request, data, group) {
+        this.cache[(0, md5_1.default)(request)] = {
+            time: (new Date()).getTime(),
+            data: data,
+            group: group
+        };
+    }
+    deleteCacheGroup(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])
+            return;
+        const group = this.cache[keyCache].group;
+        if (group) {
+            this.deleteCacheGroup(group);
+        }
+        delete this.cache[keyCache];
+    }
+    setToken(token) {
+        localStorage.setItem('token', token);
+        this.token = token;
+    }
+    getToken() {
+        return this.token;
+    }
+}
+exports.default = Core;

package/lib/index.d.ts

@@ -0,0 +1,32 @@
+import Core from "./Core";
+import { TParams } from "./types";
+type TUser = {
+    [index: string]: any;
+};
+type TConfig = {
+    host: string;
+};
+declare class API extends Core {
+    private static instance;
+    private _user;
+    constructor(config: TConfig);
+    get(params: TParams): {
+        clearCache: () => void;
+    };
+    post(params: TParams): {
+        clearCache: () => void;
+    };
+    private init;
+    get uid(): number;
+    get user(): TUser;
+    setUser(user: TUser): void;
+    updateUser(user: TUser): void;
+    logout(): void;
+    static setHost: (host: string) => void;
+    static setUser: (user: TUser) => void;
+    static updateUser: (user: TUser) => void;
+    static logout: () => void;
+    static setToken: (token: string) => void;
+    static addListener: (event: import("./types").TListenerEvents, callback: (data: any) => void) => import("easy-event-emitter").Event;
+}
+export default API;

package/lib/index.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const Core_1 = __importDefault(require("./Core"));
+class API extends Core_1.default {
+    constructor(config) {
+        super();
+        Object.defineProperty(this, "_user", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.setHost(config.host);
+        this._user = {};
+        this.init();
+        this.setUser = this.setUser.bind(this);
+        this.updateUser = this.updateUser.bind(this);
+        this.logout = this.logout.bind(this);
+    }
+    get(params) {
+        return this.request('GET', params);
+    }
+    post(params) {
+        return this.request('POST', params);
+    }
+    init() {
+        const token = localStorage.getItem('token');
+        const strUser = localStorage.getItem('user');
+        if (strUser) {
+            const user = JSON.parse(strUser);
+            this.setUser(user);
+        }
+        if (token) {
+            this.setToken(token);
+        }
+    }
+    get uid() {
+        return 'id' in this._user ? Number(this._user.id) : 0;
+    }
+    get user() {
+        return this._user;
+    }
+    setUser(user) {
+        localStorage.setItem('user', JSON.stringify(user));
+        this._user = user;
+        this.events.emit('login', user);
+    }
+    updateUser(user) {
+        this.events.emit('update', this.user);
+        this.setUser(Object.assign(Object.assign({}, this.user), user));
+    }
+    logout() {
+        this.events.emit('logout', this.user);
+        localStorage.removeItem('user');
+        localStorage.removeItem('token');
+        this.setUser({});
+        this.setToken('');
+    }
+}
+_a = API;
+Object.defineProperty(API, "instance", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new API({
+        host: ''
+    })
+});
+Object.defineProperty(API, "setHost", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: _a.instance.setHost
+});
+Object.defineProperty(API, "setUser", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: _a.instance.setUser
+});
+Object.defineProperty(API, "updateUser", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: _a.instance.updateUser
+});
+Object.defineProperty(API, "logout", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: _a.instance.logout
+});
+Object.defineProperty(API, "setToken", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: _a.instance.setToken
+});
+Object.defineProperty(API, "addListener", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: _a.instance.addListener
+});
+exports.default = API;

package/lib/types.d.ts

@@ -0,0 +1,25 @@
+export type TCache = {
+    [index: string]: any;
+};
+export type TData = {
+    [index: string]: any;
+};
+export type TMethod = 'GET' | 'POST';
+export type TParams = {
+    path: string;
+    data?: TData;
+    cache?: string | boolean;
+    globalName?: string;
+    success?: (...args: any) => void;
+    error?: (...args: any) => void;
+    fail?: (...args: any) => void;
+    complete?: (...args: any) => void;
+};
+export type TRequestParams = {
+    method: TMethod;
+    headers?: {
+        [index: string]: string;
+    };
+    body?: string;
+};
+export type TListenerEvents = 'api-request-fail' | 'api-request-error' | 'api-request-complete' | 'login' | 'logout' | 'user-update';

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "larapi",
+  "version": "0.0.1",
+  "description": "API client for laravel",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "build": "tsc"
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.[t|j]sx?$": "babel-jest"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SergoMorello/larasopp.client.git"
+  },
+  "keywords": [
+    "api",
+    "laravel",
+    "cache",
+    "events"
+  ],
+  "author": "Sergey Serov",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/SergoMorello/larasopp.client/issues"
+  },
+  "homepage": "https://github.com/SergoMorello/larasopp.client#readme",
+  "devDependencies": {
+    "@babel/preset-env": "^7.22.9",
+    "@types/jest": "^29.5.3",
+    "babel-jest": "^29.4.3",
+    "jest": "^29.4.3",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "easy-event-emitter": "^1.0.7",
+    "md5": "^2.3.0"
+  }
+}

package/src/Core.ts

@@ -0,0 +1,222 @@
+//@ts-ignore
+import md5 from 'md5';
+import EventEmitter,{
+	Events,
+	Event
+} from 'easy-event-emitter';
+import {
+	TCache,
+	TData,
+	TMethod,
+	TParams,
+	TRequestParams,
+	TListenerEvents
+} from './types';
+
+abstract class Core {
+	private host: string;
+		token: string;
+		cache: TCache;
+	protected events: Events;
+
+	constructor() {
+		this.events = new EventEmitter();
+		this.host = 'http://127.0.0.1/';
+		this.token = '';
+		this.cache = {};
+
+		this.setHost = this.setHost.bind(this);
+		this.setToken = this.setToken.bind(this);
+		this.addListener = this.addListener.bind(this);
+	}
+
+	protected request(method: TMethod, params: TParams) {
+
+		//Заголовки от 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 (__global && __global[params.globalName]) {
+			// 	Core.setCache(pathCache, __global[params.globalName], (typeof params.cache === 'boolean' ? undefined : params.cache));
+			// 	params.cache = params.cache ?? true;
+			// 	delete __global[params.globalName];
+			// }
+		}
+		
+		if (params.cache) {
+			if (dataCache = this.getCache(pathCache)) {
+				success(dataCache);
+				complete(dataCache);
+			}	
+		}else{
+			this.deleteCache(pathCache);
+		}
+		if (!dataCache) {
+			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.error(result);
+				}
+				complete(result);
+			}
+
+			xhr.send(fetchParams.body);
+		}
+		return {
+			clearCache: () => {
+				this.deleteCache(pathCache);
+			}
+		}
+	}
+
+	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);
+		if (this.cache[key]) {
+			if ((new Date()).getTime() <= (this.cache[key].time + 3600000000)) {
+				return this.cache[key].data;
+			}else{
+				delete this.cache[key];
+			}
+		}
+	}
+
+	public setHost(host: string): void {
+		this.host = host;
+	}
+
+	private setCache(request: string, data: TData, group?: string): void {
+		this.cache[md5(request)] = {
+			time: (new Date()).getTime(),
+			data: data,
+			group: group
+		};
+	}
+
+	private deleteCacheGroup(group: string): void {
+		for(const key in this.cache) {
+			if (this.cache[key].group === group) {
+				delete this.cache[key];
+			}
+		}
+	}
+
+	private deleteCache(request: string): void {
+		const keyCache = md5(request);
+		if (!this.cache[keyCache])
+			return;
+
+		const group = this.cache[keyCache].group;
+		if (group) {
+			this.deleteCacheGroup(group);
+		}
+		delete this.cache[keyCache];
+	}
+
+	public setToken(token: string) {
+		localStorage.setItem('token', token);
+		this.token = token;
+	}
+
+	public getToken() {
+		return this.token;
+	}
+}
+
+export default Core;

package/src/index.ts

@@ -0,0 +1,84 @@
+import Core from "./Core";
+import { TParams } from "./types";
+
+type TUser = {
+	[index: string]: any;
+}
+
+type TConfig = {
+	host: string;
+}
+
+class API extends Core {
+	private static instance = new API({
+		host: ''
+	});
+	private _user: TUser;
+
+	constructor(config: TConfig) {
+		super();
+		this.setHost(config.host);
+		this._user = {};
+		this.init();
+
+		this.setUser = this.setUser.bind(this);
+		this.updateUser = this.updateUser.bind(this);
+		this.logout = this.logout.bind(this);
+	}
+
+	public get(params: TParams) {
+		return this.request('GET', params);
+	}
+
+	public post(params: TParams) {
+		return this.request('POST', params);
+	}
+
+	private init(): void {
+		const token = localStorage.getItem('token');
+		const strUser = localStorage.getItem('user');
+		if (strUser) {
+			const user: TUser = JSON.parse(strUser);
+			this.setUser(user);
+		}
+		if (token) {
+			this.setToken(token);
+		}
+	}
+
+	public get uid(): number {
+			return 'id' in this._user ? Number(this._user.id) : 0;
+	}
+
+	public get user(): TUser {
+		return this._user;
+	}
+
+	public setUser(user: TUser) {
+		localStorage.setItem('user', JSON.stringify(user));
+		this._user = user;
+		this.events.emit('login', user);
+	}
+
+	public updateUser(user: TUser) {
+		this.events.emit('update', this.user);
+		this.setUser({...this.user, ...user});
+	}
+
+	public logout() {
+		this.events.emit('logout', this.user);
+		localStorage.removeItem('user');
+		localStorage.removeItem('token');
+		this.setUser({});
+		this.setToken('');
+	}
+
+	public static setHost = this.instance.setHost;
+	public static setUser = this.instance.setUser;
+	public static updateUser = this.instance.updateUser;
+	public static logout = this.instance.logout;
+	public static setToken = this.instance.setToken;
+	public static addListener = this.instance.addListener;
+}
+
+export default API;

package/src/types.ts

@@ -0,0 +1,30 @@
+export type TCache = {
+	[index: string]: any;
+}
+
+export type TData = {
+	[index: string]: any;
+}
+
+export type TMethod = 'GET' | 'POST';
+
+export type TParams = {
+	path: string;
+	data?: TData;
+	cache?: string | boolean;
+	globalName?: string;
+	success?: (...args: any) => void;
+	error?: (...args: any) => void;
+	fail?: (...args: any) => void;
+	complete?: (...args: any) => void;
+}
+
+export type TRequestParams = {
+	method: TMethod;
+	headers?: {
+		[index: string]: string;
+	};
+	body?: string;
+}
+
+export type TListenerEvents = 'api-request-fail' | 'api-request-error' | 'api-request-complete' | 'login' | 'logout' | 'user-update';

package/tsconfig.json

@@ -0,0 +1,109 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./lib/",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}