mosuk-ui 1.0.1

package/services/api/service.js

@@ -0,0 +1,166 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { alertsService } from '../alerts/service';
+import { authService } from '../auth/service';
+var ApiService = /** @class */ (function () {
+    function ApiService() {
+    }
+    ApiService.getInstance = function () {
+        if (!ApiService.instance) {
+            ApiService.instance = new ApiService();
+        }
+        return ApiService.instance;
+    };
+    ApiService.prototype.sendRequest = function (endpoint_1) {
+        return __awaiter(this, arguments, void 0, function (endpoint, config) {
+            var url, headers, auth, token, searchParams_1, queryString, body, response, contentType, data, _a, error_1;
+            if (config === void 0) { config = {}; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 6, , 7]);
+                        url = ApiService.url + endpoint;
+                        headers = __assign({ 'X-Requested-With': 'XMLHttpRequest', Accept: 'application/json', 'Content-Type': 'application/json' }, (config.headers || {}));
+                        auth = authService.read();
+                        token = auth === null || auth === void 0 ? void 0 : auth.token;
+                        if (token)
+                            headers['Authorization'] = "Bearer ".concat(token);
+                        if (config.params) {
+                            searchParams_1 = new URLSearchParams();
+                            Object.entries(config.params).forEach(function (_a) {
+                                var key = _a[0], value = _a[1];
+                                if (value !== undefined && value !== null) {
+                                    if (Array.isArray(value)) {
+                                        value.forEach(function (item) { return searchParams_1.append(key, String(item)); });
+                                    }
+                                    else {
+                                        searchParams_1.append(key, String(value));
+                                    }
+                                }
+                            });
+                            queryString = searchParams_1.toString();
+                            if (queryString) {
+                                url += "?".concat(queryString);
+                            }
+                        }
+                        body = config.body ? JSON.stringify(config.body) : undefined;
+                        return [4 /*yield*/, fetch(url, {
+                                method: config.method || 'GET',
+                                headers: headers,
+                                body: body,
+                                credentials: 'include',
+                                cache: config.cache,
+                            })];
+                    case 1:
+                        response = _b.sent();
+                        contentType = response.headers.get('content-type');
+                        if (!(contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/json'))) return [3 /*break*/, 3];
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, response.text()];
+                    case 4:
+                        _a = _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        data = _a;
+                        if (!response.ok) {
+                            if (response.status === 403) {
+                                alertsService.error('Недостаточно прав для выполнения данного действия');
+                            }
+                            throw __assign({ status: response.status }, data);
+                        }
+                        return [2 /*return*/, data];
+                    case 6:
+                        error_1 = _b.sent();
+                        throw error_1;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ApiService.prototype.get = function (endpoint, config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.sendRequest(endpoint, __assign(__assign({}, config), { method: 'GET' }))];
+            });
+        });
+    };
+    ApiService.prototype.post = function (endpoint, data, config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.sendRequest(endpoint, __assign(__assign({}, config), { method: 'POST', body: data }))];
+            });
+        });
+    };
+    ApiService.prototype.put = function (endpoint, data, config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.sendRequest(endpoint, __assign(__assign({}, config), { method: 'PUT', body: data }))];
+            });
+        });
+    };
+    ApiService.prototype.patch = function (endpoint, data, config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.sendRequest(endpoint, __assign(__assign({}, config), { method: 'PATCH', body: data }))];
+            });
+        });
+    };
+    ApiService.prototype.delete = function (endpoint, config) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.sendRequest(endpoint, __assign(__assign({}, config), { method: 'DELETE' }))];
+            });
+        });
+    };
+    ApiService.url = process.env.NEXT_PUBLIC_API_URL;
+    return ApiService;
+}());
+export { ApiService };

package/services/auth/index.d.ts

@@ -0,0 +1,4 @@
+import { authService } from './service';
+import type { Auth } from './service.interface';
+export { authService };
+export type { Auth };

package/services/auth/index.js

@@ -0,0 +1,2 @@
+import { authService } from './service';
+export { authService };

package/services/auth/service.d.ts

@@ -0,0 +1,7 @@
+import { Auth } from './service.interface';
+export declare const authService: {
+    create<U = any>(auth: Auth<U>): void;
+    read<U = any>(): Auth<U> | null;
+    update<U = any>(auth: Auth<U>): void;
+    delete(): void;
+};

package/services/auth/service.interface.d.ts

@@ -0,0 +1 @@
+export type Auth<U = any> = U;

package/services/auth/service.interface.js

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

package/services/auth/service.js

@@ -0,0 +1,33 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { storageCookieService } from '../storage/cookie';
+var AUTH_KEY = 'auth';
+export var authService = {
+    create: function (auth) {
+        storageCookieService.create(AUTH_KEY, auth);
+    },
+    read: function () {
+        return storageCookieService.read(AUTH_KEY);
+    },
+    update: function (auth) {
+        var data = this.read();
+        if (typeof auth === 'object' && auth !== null) {
+            this.create(__assign(__assign({}, data), auth));
+        }
+        else {
+            this.create(auth);
+        }
+    },
+    delete: function () {
+        storageCookieService.delete(AUTH_KEY);
+    },
+};

package/services/cart/index.d.ts

@@ -0,0 +1,4 @@
+import { cartService } from './service';
+import { Cart } from './service.interface';
+export { cartService };
+export type { Cart };

package/services/cart/index.js

@@ -0,0 +1,2 @@
+import { cartService } from './service';
+export { cartService };

package/services/cart/service.d.ts

@@ -0,0 +1,7 @@
+import { Cart } from './service.interface';
+export declare const cartService: {
+    create<U = any>(cart: Cart<U>): void;
+    read<U = any>(): Cart<U> | null;
+    update<U = any>(cart: Cart<U>): void;
+    delete(): void;
+};

package/services/cart/service.interface.d.ts

@@ -0,0 +1 @@
+export type Cart<U = any> = U;

package/services/cart/service.interface.js

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

package/services/cart/service.js

@@ -0,0 +1,36 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { storageLocalService } from '../storage/local';
+var CART_KEY = 'cart';
+export var cartService = {
+    create: function (cart) {
+        storageLocalService.create(CART_KEY, cart);
+    },
+    read: function () {
+        return storageLocalService.read(CART_KEY);
+    },
+    update: function (cart) {
+        var data = this.read();
+        if (Array.isArray(cart)) {
+            this.create(cart);
+        }
+        else if (typeof cart === 'object' && cart !== null) {
+            this.create(__assign(__assign({}, data), cart));
+        }
+        else {
+            this.create(cart);
+        }
+    },
+    delete: function () {
+        storageLocalService.delete(CART_KEY);
+    },
+};

package/services/data/data/index.d.ts

@@ -0,0 +1,5 @@
+import type { DataServiceInterface } from './service.interface';
+export declare const dataService: import("./service").DataService;
+export declare namespace dataService {
+    type Interface<T = unknown> = DataServiceInterface<T>;
+}

package/services/data/data/index.js

@@ -0,0 +1,2 @@
+import { dataService as BaseDataService } from './service';
+export var dataService = BaseDataService;

package/services/data/data/service.d.ts

@@ -0,0 +1,13 @@
+import { Key, SWRConfiguration } from 'swr';
+import { DataServiceInterface } from './service.interface';
+export declare class DataService {
+    private static instance;
+    private constructor();
+    static getInstance(): DataService;
+    private fetcher;
+    get<T>(key: Key | null, fetcherFn?: ([url, params]: [
+        string,
+        Record<string, any> | undefined
+    ]) => Promise<T>, options?: SWRConfiguration): DataServiceInterface<T>;
+}
+export declare const dataService: DataService;

package/services/data/data/service.interface.d.ts

@@ -0,0 +1,6 @@
+import { SWRResponse } from 'swr';
+export interface DataServiceInterface<T> extends Omit<SWRResponse<T, any>, 'data'> {
+    data: T | undefined;
+    isLoading: boolean;
+    isError: any;
+}

package/services/data/data/service.interface.js

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

package/services/data/data/service.js

@@ -0,0 +1,99 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import useSWR from 'swr';
+import { apiService } from '../../api';
+var DataService = /** @class */ (function () {
+    function DataService() {
+        var _this = this;
+        this.fetcher = function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+            var response, error_1;
+            var url = _b[0], params = _b[1];
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, apiService.get(url, {
+                                params: params,
+                            })];
+                    case 1:
+                        response = _c.sent();
+                        return [2 /*return*/, response];
+                    case 2:
+                        error_1 = _c.sent();
+                        throw error_1;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); };
+    }
+    DataService.getInstance = function () {
+        if (!DataService.instance) {
+            DataService.instance = new DataService();
+        }
+        return DataService.instance;
+    };
+    DataService.prototype.get = function (key, fetcherFn, options) {
+        if (options === void 0) { options = {}; }
+        var _a = useSWR(key, fetcherFn || this.fetcher, __assign({ errorRetryCount: 1, dedupingInterval: 1 * 60 * 1000, revalidateOnFocus: true, revalidateOnReconnect: true }, options)), data = _a.data, error = _a.error, isLoading = _a.isLoading, mutate = _a.mutate, rest = __rest(_a, ["data", "error", "isLoading", "mutate"]);
+        return __assign({ data: data, error: error, isLoading: isLoading, isError: error, mutate: mutate }, rest);
+    };
+    return DataService;
+}());
+export { DataService };
+export var dataService = DataService.getInstance();

package/services/data/pagination/index.d.ts

@@ -0,0 +1,9 @@
+import type { DataPaginationServiceInterface } from './service.interface';
+export declare const dataPaginationService: {
+    readonly fetcher: <T>(url: string) => Promise<T>;
+    createIntersectionObserver(setSize: (size: number | ((prev: number) => number)) => Promise<any>, isLoading: boolean, loadingRef: React.MutableRefObject<boolean>): IntersectionObserver;
+    get<TCollection>(endpoint: string | null | undefined, initialParams?: Record<string, any>, swrConfig?: import("swr/dist/infinite").SWRInfiniteConfiguration<TCollection, any>): DataPaginationServiceInterface<TCollection>;
+};
+export declare namespace dataPaginationService {
+    type Interface<T = unknown> = DataPaginationServiceInterface<T>;
+}

package/services/data/pagination/index.js

@@ -0,0 +1,2 @@
+import { dataPaginationService as BaseDataPaginationService } from './service';
+export var dataPaginationService = BaseDataPaginationService;

package/services/data/pagination/service.d.ts

@@ -0,0 +1,12 @@
+import { type SWRInfiniteConfiguration } from 'swr/infinite';
+import type { DataPaginationServiceInterface } from './service.interface';
+declare class DataPaginationService {
+    private static instance;
+    private constructor();
+    static getInstance(): DataPaginationService;
+    readonly fetcher: <T>(url: string) => Promise<T>;
+    createIntersectionObserver(setSize: (size: number | ((prev: number) => number)) => Promise<any>, isLoading: boolean, loadingRef: React.MutableRefObject<boolean>): IntersectionObserver;
+    get<TCollection>(endpoint: string | null | undefined, initialParams?: Record<string, any>, swrConfig?: SWRInfiniteConfiguration<TCollection, any>): DataPaginationServiceInterface<TCollection>;
+}
+export declare const dataPaginationService: DataPaginationService;
+export {};

package/services/data/pagination/service.interface.d.ts

@@ -0,0 +1,8 @@
+import type { SWRInfiniteResponse } from 'swr/infinite';
+export interface DataPaginationServiceInterface<TCollection> extends Omit<SWRInfiniteResponse<TCollection, any>, 'data'> {
+    data: TCollection;
+    params: Record<string, any>;
+    error: Error | undefined;
+    useObserver: (element: HTMLElement | null) => void;
+    updateParams: (params: Record<string, any>) => Promise<TCollection[] | undefined>;
+}

package/services/data/pagination/service.interface.js

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