@labeg/tfetch 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Evgeny Labutin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+Typescript Serializable Fetch
+=====
+
+A small library for sending serialized data and receiving deserialized data with strict data type checking.
+
+Installation
+------
+
+You can use the following command to install this package:
+
+``` bash
+npm install ts-fetch
+```
+
+Usage
+------
+
+todo...
+
+```typescript
+todo...
+```

package/dist/contructors/CrudHttpRepository.d.ts

@@ -0,0 +1,16 @@
+import type { Serializable } from "ts-serializable";
+import type { IGraphQuery } from "../models/view-models/graph-query.vm.js";
+import type { PageListQuery } from "../models/view-models/page-list-query.vm.js";
+import type { PagedList } from "../models/view-models/paged-list.vm.js";
+import { TsFetch } from "./TsFetch.js";
+export declare abstract class CrudHttpRepository<T1 extends Serializable> extends TsFetch {
+    protected abstract apiRoot: string;
+    protected abstract modelConstructor: new () => T1;
+    getById(id: number | string, ...keys: (number | string)[]): Promise<T1>;
+    getAll(...keys: (number | string)[]): Promise<T1[]>;
+    create(value: T1, ...keys: (number | string)[]): Promise<T1>;
+    update(id: number | string, value: T1, ...keys: (number | string)[]): Promise<void>;
+    delete(id: number | string, ...keys: (number | string)[]): Promise<void>;
+    getGraphById(_id: number | string, ..._keys: (IGraphQuery | number | string)[]): Promise<T1>;
+    getPaged(..._keys: (PageListQuery | number | string)[]): Promise<PagedList<T1>>;
+}

package/dist/contructors/CrudHttpRepository.js

@@ -0,0 +1,68 @@
+import { TsFetch } from "./TsFetch.js";
+export class CrudHttpRepository extends TsFetch {
+    async getById(id, ...keys) {
+        let url = this.apiRoot;
+        keys.forEach((key) => {
+            url = url.replace(/\{.+\}/gu, String(key));
+        });
+        return this.send({
+            method: "GET",
+            url: `${url}/${String(id)}`,
+            returnType: this.modelConstructor
+        });
+    }
+    async getAll(...keys) {
+        let url = this.apiRoot;
+        keys.forEach((key) => {
+            url = url.replace(/\{.+\}/gu, String(key));
+        });
+        return this.send({
+            method: "GET",
+            url: `${url}/`,
+            returnType: [this.modelConstructor]
+        });
+    }
+    async create(value, ...keys) {
+        let url = this.apiRoot;
+        keys.forEach((key) => {
+            url = url.replace(/\{.+\}/gu, String(key));
+        });
+        return this.send({
+            method: "POST",
+            url: `${url}/`,
+            body: value,
+            returnType: this.modelConstructor
+        });
+    }
+    async update(id, value, ...keys) {
+        let url = this.apiRoot;
+        keys.forEach((key) => {
+            url = url.replace(/\{.+\}/gu, String(key));
+        });
+        return this.send({
+            method: "PUT",
+            url: `${url}/${String(id)}`,
+            body: value
+        });
+    }
+    async delete(id, ...keys) {
+        let url = this.apiRoot;
+        keys.forEach((key) => {
+            url = url.replace(/\{.+\}/gu, String(key));
+        });
+        return this.send({
+            method: "DELETE",
+            url: `${url}/${String(id)}`
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
+    async getGraphById(_id, ..._keys) {
+        await Promise.resolve();
+        throw new Error("Method not implemented.");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
+    async getPaged(..._keys) {
+        await Promise.resolve();
+        throw new Error("Method not implemented.");
+    }
+}

package/dist/contructors/TsFetch.d.ts

@@ -0,0 +1,30 @@
+import { BackError } from "../models/errors/back.error.js";
+import { BodyInit } from "undici-types";
+type PromiseResRej = (obj: any) => void;
+export interface TsRequestInit<T> extends Omit<RequestInit, "body"> {
+    /**
+     * URL for request
+     */
+    url: string | URL | globalThis.Request;
+    /**
+     * Body for fetch
+     */
+    body?: BodyInit | object;
+    /**
+     * Response Type
+     */
+    returnType?: T;
+}
+export declare class TsFetch {
+    protected readonly requestCache: Map<string, [PromiseResRej, PromiseResRej][]>;
+    send(options: TsRequestInit<void>): Promise<void>;
+    send<T extends boolean>(options: TsRequestInit<T>): Promise<T>;
+    send<T extends number>(options: TsRequestInit<T>): Promise<T>;
+    send<T extends string>(options: TsRequestInit<T>): Promise<T>;
+    send<T>(options: TsRequestInit<new () => T>): Promise<T>;
+    send<T>(options: TsRequestInit<[new () => T]>): Promise<T[]>;
+    protected handleError(response: Response): Promise<Response>;
+    protected setHeaders(): Headers;
+    protected parseBackendError(response: Response, body: string): BackError;
+}
+export {};

package/dist/contructors/TsFetch.js

@@ -0,0 +1,165 @@
+/* eslint-disable class-methods-use-this */
+import { Serializable } from "ts-serializable";
+import { BackError } from "../models/errors/back.error.js";
+import { NetError } from "../models/errors/net.error.js";
+export class TsFetch {
+    constructor() {
+        // Cache for all GET and HEAD request
+        this.requestCache = new Map();
+    }
+    // eslint-disable-next-line max-lines-per-function, max-statements, complexity
+    async send(options) {
+        const { url, body, returnType, ...otherInits } = options;
+        const headers = options.headers ?? this.setHeaders();
+        const input = url;
+        /**
+         * Setup cache
+         */
+        const isCacheableRequest = options.method === "GET" || options.method === "HEAD";
+        const cacheKey = [
+            options.method,
+            input instanceof globalThis.Request ? input.url : input
+        ].join(" ");
+        if (isCacheableRequest) {
+            if (this.requestCache.has(cacheKey)) {
+                return new Promise((res, rej) => {
+                    this.requestCache.get(cacheKey)?.push([res, rej]); // [res, rej] - its tuple
+                });
+            }
+            this.requestCache.set(cacheKey, []);
+        }
+        /**
+         * Process request
+         */
+        // eslint-disable-next-line no-useless-assignment
+        let responseText = "";
+        try {
+            let response = await fetch(input, {
+                method: options.method,
+                body: typeof body === "undefined" ? void 0 : JSON.stringify(body),
+                headers,
+                ...otherInits
+            });
+            response = await this.handleError(response);
+            responseText = await response.text();
+        }
+        catch (fetchError) {
+            if (isCacheableRequest && this.requestCache.has(cacheKey)) {
+                this.requestCache.get(cacheKey)?.forEach((tuple) => {
+                    try {
+                        tuple[1](fetchError);
+                    }
+                    catch (re) {
+                        // eslint-disable-next-line no-console
+                        console.error(re);
+                    }
+                });
+                this.requestCache.delete(cacheKey);
+            }
+            throw fetchError;
+        }
+        /**
+         * Parse data
+         */
+        let data = void 0;
+        if (returnType === void 0) {
+            data = void 0;
+        }
+        else if (Array.isArray(returnType) &&
+            responseText.startsWith("[")) {
+            data = JSON.parse(responseText);
+            // Return models.map((model: object) => new returnType[0]().fromJSON(model));
+        }
+        else if (typeof returnType === "function" &&
+            returnType.prototype instanceof Serializable &&
+            responseText.startsWith("{")) {
+            const constructor = returnType;
+            data = new constructor().fromJSON(JSON.parse(responseText));
+        }
+        else if (typeof returnType === "object" && responseText.startsWith("{")) {
+            data = JSON.parse(responseText);
+        }
+        else if (typeof returnType === "string") {
+            data = responseText;
+        }
+        else if (typeof returnType === "number") {
+            data = Number(responseText);
+        }
+        else if (typeof returnType === "boolean") {
+            data = Boolean(responseText);
+        }
+        else if (typeof returnType === "undefined") {
+            data = void 0;
+        }
+        else {
+            const error = new NetError(`Wrong returned type. Must by ${typeof returnType} but return ${typeof responseText}`);
+            if (isCacheableRequest && this.requestCache.has(cacheKey)) {
+                this.requestCache.get(cacheKey)?.forEach((tuple) => {
+                    try {
+                        tuple[1](error);
+                    }
+                    catch (typeError) {
+                        // eslint-disable-next-line no-console
+                        console.error(typeError);
+                    }
+                });
+                this.requestCache.delete(cacheKey);
+            }
+            throw error;
+        }
+        /**
+         * Restore cache
+         */
+        if (isCacheableRequest && this.requestCache.has(cacheKey)) {
+            this.requestCache.get(cacheKey)?.forEach((tuple) => {
+                try {
+                    tuple[0](data);
+                }
+                catch (promiseError) {
+                    // eslint-disable-next-line no-console
+                    console.error(promiseError);
+                }
+            });
+            this.requestCache.delete(cacheKey);
+        }
+        return data;
+    }
+    // eslint-disable-next-line max-statements
+    async handleError(response) {
+        if (response.ok) {
+            return response;
+        }
+        const body = await response.text();
+        // eslint-disable-next-line no-useless-assignment
+        let error = null;
+        if (response.status === 401) {
+            error = new NetError("Authorization exception", 401);
+        }
+        else if (body.startsWith("<")) { // Java xml response
+            // eslint-disable-next-line prefer-named-capture-group
+            const match = (/<b>description<\/b> <u>(.+?)<\/u>/gu).exec(body);
+            error = new NetError(`${response.status.toString()} - ${((match?.[1] ?? response.statusText) || "Ошибка не указана")}`);
+        }
+        else if (body.startsWith("{")) { // Backend response
+            error = this.parseBackendError(response, body);
+        }
+        else {
+            error = new NetError(`${response.status.toString()} - ${response.statusText}`);
+        }
+        error.status = response.status;
+        error.body = body;
+        throw error;
+    }
+    setHeaders() {
+        const headers = new Headers();
+        headers.set("content-type", "application/json");
+        headers.set("Pragma", "no-cache");
+        return headers;
+    }
+    parseBackendError(response, body) {
+        // Override method, check on message property
+        const backError = new BackError(`${response.status.toString()} - ${response.statusText}`);
+        backError.body = body;
+        return backError;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./models/index.js";
+export * from "./contructors/TsFetch.js";
+export * from "./contructors/CrudHttpRepository.js";
+import { TsFetch } from "./contructors/TsFetch.js";
+declare const instance: TsFetch;
+export declare const tsfetch: typeof instance.send;
+export declare const tf: {
+    (options: import("./contructors/TsFetch.js").TsRequestInit<void>): Promise<void>;
+    <T extends boolean>(options: import("./contructors/TsFetch.js").TsRequestInit<T>): Promise<T>;
+    <T extends number>(options: import("./contructors/TsFetch.js").TsRequestInit<T>): Promise<T>;
+    <T extends string>(options: import("./contructors/TsFetch.js").TsRequestInit<T>): Promise<T>;
+    <T>(options: import("./contructors/TsFetch.js").TsRequestInit<new () => T>): Promise<T>;
+    <T>(options: import("./contructors/TsFetch.js").TsRequestInit<[new () => T]>): Promise<T[]>;
+};

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./models/index.js";
+export * from "./contructors/TsFetch.js";
+export * from "./contructors/CrudHttpRepository.js";
+import { TsFetch } from "./contructors/TsFetch.js";
+const instance = new TsFetch();
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return
+export const tsfetch = (options) => instance.send(options);
+export const tf = tsfetch; // Alias

package/dist/models/errors/back.error.d.ts

@@ -0,0 +1,5 @@
+export declare class BackError extends Error {
+    status: number | null;
+    body: string | null;
+    constructor(message: string, status?: number | null);
+}

package/dist/models/errors/back.error.js

@@ -0,0 +1,11 @@
+export class BackError extends Error {
+    constructor(message, status = null) {
+        super(message);
+        this.status = null;
+        this.body = null;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, BackError.prototype);
+        this.name = "BackError";
+        this.status = status;
+    }
+}

package/dist/models/errors/net.error.d.ts

@@ -0,0 +1,5 @@
+export declare class NetError extends Error {
+    status: number | null;
+    body: string | null;
+    constructor(message: string, status?: number | null);
+}

package/dist/models/errors/net.error.js

@@ -0,0 +1,11 @@
+export class NetError extends Error {
+    constructor(message, status = null) {
+        super(message);
+        this.status = null;
+        this.body = null;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, NetError.prototype);
+        this.name = "NetError";
+        this.status = status;
+    }
+}

package/dist/models/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./errors/back.error.js";
+export * from "./errors/net.error.js";
+export * from "./view-models/graph-query.vm.js";
+export * from "./view-models/page-list-query.vm.js";
+export * from "./view-models/page-meta.vm.js";
+export * from "./view-models/paged-list.vm.js";

package/dist/models/index.js

@@ -0,0 +1,6 @@
+export * from "./errors/back.error.js";
+export * from "./errors/net.error.js";
+export * from "./view-models/graph-query.vm.js";
+export * from "./view-models/page-list-query.vm.js";
+export * from "./view-models/page-meta.vm.js";
+export * from "./view-models/paged-list.vm.js";

package/dist/models/view-models/graph-query.vm.d.ts

@@ -0,0 +1,6 @@
+export type IGraphQueryDeep5 = Record<string, object | null>;
+export type IGraphQueryDeep4 = Record<string, IGraphQueryDeep5 | null>;
+export type IGraphQueryDeep3 = Record<string, IGraphQueryDeep4 | null>;
+export type IGraphQueryDeep2 = Record<string, IGraphQueryDeep3 | null>;
+export type IGraphQueryDeep1 = Record<string, IGraphQueryDeep2 | null>;
+export type IGraphQuery = Record<string, IGraphQueryDeep1 | null>;

package/dist/models/view-models/graph-query.vm.js

@@ -0,0 +1 @@
+export {};

package/dist/models/view-models/page-list-query.vm.d.ts

@@ -0,0 +1,32 @@
+import type { IGraphQuery } from "./graph-query.vm";
+export declare enum PageListQueryFilterMethod {
+    Less = "Less",
+    LessOrEqual = "LessOrEqual",
+    Equal = "Equal",
+    GreatOrEqual = "GreatOrEqual",
+    Great = "Great",
+    Like = "Like",
+    ILike = "ILike"
+}
+export declare class PageListQueryFilter {
+    property: string;
+    method?: PageListQueryFilterMethod;
+    value: number | string;
+    constructor(property: string, value: number | string, method?: PageListQueryFilterMethod);
+}
+export declare enum PageListQuerySortDirection {
+    Asc = "Asc",
+    Desc = "Desc"
+}
+export declare class PageListQuerySort {
+    property: string;
+    direction?: PageListQuerySortDirection;
+    constructor(property: string, direction?: PageListQuerySortDirection);
+}
+export declare class PageListQuery {
+    pageNumber?: number;
+    pageSize?: number;
+    filter?: PageListQueryFilter[];
+    sort?: PageListQuerySort[];
+    graph?: IGraphQuery;
+}

package/dist/models/view-models/page-list-query.vm.js

@@ -0,0 +1,42 @@
+export var PageListQueryFilterMethod;
+(function (PageListQueryFilterMethod) {
+    PageListQueryFilterMethod["Less"] = "Less";
+    PageListQueryFilterMethod["LessOrEqual"] = "LessOrEqual";
+    PageListQueryFilterMethod["Equal"] = "Equal";
+    PageListQueryFilterMethod["GreatOrEqual"] = "GreatOrEqual";
+    PageListQueryFilterMethod["Great"] = "Great";
+    PageListQueryFilterMethod["Like"] = "Like";
+    PageListQueryFilterMethod["ILike"] = "ILike";
+})(PageListQueryFilterMethod || (PageListQueryFilterMethod = {}));
+export class PageListQueryFilter {
+    constructor(property, value, method = PageListQueryFilterMethod.Equal) {
+        this.property = "";
+        this.method = PageListQueryFilterMethod.Equal;
+        this.value = "";
+        this.property = property;
+        this.method = method;
+        this.value = value;
+    }
+}
+export var PageListQuerySortDirection;
+(function (PageListQuerySortDirection) {
+    PageListQuerySortDirection["Asc"] = "Asc";
+    PageListQuerySortDirection["Desc"] = "Desc";
+})(PageListQuerySortDirection || (PageListQuerySortDirection = {}));
+export class PageListQuerySort {
+    constructor(property, direction = PageListQuerySortDirection.Asc) {
+        this.property = "";
+        this.direction = PageListQuerySortDirection.Asc;
+        this.property = property;
+        this.direction = direction;
+    }
+}
+export class PageListQuery {
+    constructor() {
+        this.pageNumber = 0;
+        this.pageSize = 0;
+        this.filter = [];
+        this.sort = [];
+        this.graph = void 0;
+    }
+}

package/dist/models/view-models/page-meta.vm.d.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+import { Serializable } from "ts-serializable";
+export declare class PageMeta extends Serializable {
+    pageNumber: number;
+    pageSize: number;
+    elementsInPage: number;
+    totalPages: number;
+    totalElements: number;
+}

package/dist/models/view-models/page-meta.vm.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import "reflect-metadata";
+import { jsonProperty, Serializable } from "ts-serializable";
+export class PageMeta extends Serializable {
+    constructor() {
+        super(...arguments);
+        this.pageNumber = 0;
+        this.pageSize = 0;
+        this.elementsInPage = 0;
+        this.totalPages = 0;
+        this.totalElements = 0;
+    }
+}
+__decorate([
+    jsonProperty(Number),
+    __metadata("design:type", Number)
+], PageMeta.prototype, "pageNumber", void 0);
+__decorate([
+    jsonProperty(Number),
+    __metadata("design:type", Number)
+], PageMeta.prototype, "pageSize", void 0);
+__decorate([
+    jsonProperty(Number),
+    __metadata("design:type", Number)
+], PageMeta.prototype, "elementsInPage", void 0);
+__decorate([
+    jsonProperty(Number),
+    __metadata("design:type", Number)
+], PageMeta.prototype, "totalPages", void 0);
+__decorate([
+    jsonProperty(Number),
+    __metadata("design:type", Number)
+], PageMeta.prototype, "totalElements", void 0);

package/dist/models/view-models/paged-list.vm.d.ts

@@ -0,0 +1,6 @@
+import { Serializable } from "ts-serializable";
+import { PageMeta } from "./page-meta.vm.js";
+export declare class PagedList<TEntity> extends Serializable {
+    pageMeta: PageMeta;
+    elements: TEntity[];
+}

package/dist/models/view-models/paged-list.vm.js

@@ -0,0 +1,26 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { jsonProperty, Serializable } from "ts-serializable";
+import { PageMeta } from "./page-meta.vm.js";
+export class PagedList extends Serializable {
+    constructor() {
+        super(...arguments);
+        this.pageMeta = new PageMeta();
+        this.elements = [];
+    }
+}
+__decorate([
+    jsonProperty(PageMeta),
+    __metadata("design:type", PageMeta)
+], PagedList.prototype, "pageMeta", void 0);
+__decorate([
+    jsonProperty([Object]),
+    __metadata("design:type", Array)
+], PagedList.prototype, "elements", void 0);

package/package.json

@@ -0,0 +1,59 @@
+{
+    "name": "@labeg/tfetch",
+    "version": "0.4.0",
+    "author": "Eugene Labutin",
+    "license": "MIT",
+    "homepage": "https://github.com/LabEG/ts-fetch#readme",
+    "description": "A small library for sending serialized data and receiving deserialized data with strict data type checking.",
+    "main": "./dist/index.js",
+    "type": "module",
+    "typings": "./dist/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": " git@github.com:LabEG/ts-fetch.git"
+    },
+    "bugs": {
+        "url": "https://github.com/LabEG/ts-fetch/issues"
+    },
+    "lint-staged": {
+        "./(src|tests)/**/*.(ts|tsx|js|jsx)": [
+            "eslint --fix"
+        ]
+    },
+    "scripts": {
+        "lint": "eslint --fix ./src/ ./tests/",
+        "test": "node --import ./ts-loader.js --test --test-reporter=spec --test-reporter-destination=stdout \"tests/**/*.spec.ts\"",
+        "test-watch": "node --watch --import ./ts-loader.js --test --test-reporter=spec --test-reporter-destination=stdout \"tests/**/*.spec.ts\"",
+        "coverage": "node --import ./ts-loader.js --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info \"tests/**/*.spec.ts\"",
+        "build": "tsc --project tsconfig.build.json && node ./dist/index.js",
+        "prepublishOnly": "npm run lint && npm run build && npm run test",
+        "upgrade": "ncu -u && rimraf node_modules package-lock.json && npm i",
+        "release": "cliff-jumper --name 'ts-fetch' --package-path '.' --no-skip-changelog --no-skip-tag",
+        "prepare": "husky install"
+    },
+    "peerDependencies": {
+        "ts-serializable": ">=3.0.0"
+    },
+    "devDependencies": {
+        "@commitlint/cli": "^19.6.1",
+        "@commitlint/config-conventional": "^19.6.0",
+        "@favware/cliff-jumper": "^6.0.0",
+        "@labeg/code-style": "^6.0.0",
+        "@swc-node/register": "^1.10.9",
+        "@types/chai": "^5.0.1",
+        "chai": "^5.1.2",
+        "husky": "^9.1.7",
+        "lint-staged": "^15.3.0",
+        "ts-serializable": "^3.7.3",
+        "rimraf": "^6.0.1",
+        "npm-check-updates": "^17.1.13",
+        "typescript": "^5.7.2"
+    },
+    "keywords": [
+        "serialization",
+        "deserialization",
+        "fetch",
+        "request",
+        "ajax"
+    ]
+}