mosuk-ui 1.0.1

package/services/data/pagination/service.js

@@ -0,0 +1,206 @@
+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 { useCallback, useEffect, useMemo, useRef } from 'react';
+import useSWRInfinite from 'swr/infinite';
+import { authService } from '../../auth/service';
+var DataPaginationService = /** @class */ (function () {
+    function DataPaginationService() {
+        var _this = this;
+        this.fetcher = function (url) { return __awaiter(_this, void 0, void 0, function () {
+            var token, headers, response;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        token = (_a = authService.read()) === null || _a === void 0 ? void 0 : _a.token;
+                        headers = __assign({ Accept: 'application/json', 'Content-Type': 'application/json' }, (token && { Authorization: "Bearer ".concat(token) }));
+                        return [4 /*yield*/, fetch(url, { headers: headers })];
+                    case 1:
+                        response = _b.sent();
+                        if (!response.ok) {
+                            throw new Error("HTTP ".concat(response.status, ": ").concat(response.statusText));
+                        }
+                        return [2 /*return*/, response.json()];
+                }
+            });
+        }); };
+    }
+    DataPaginationService.getInstance = function () {
+        if (!DataPaginationService.instance) {
+            DataPaginationService.instance = new DataPaginationService();
+        }
+        return DataPaginationService.instance;
+    };
+    DataPaginationService.prototype.createIntersectionObserver = function (setSize, isLoading, loadingRef) {
+        return new IntersectionObserver(function (_a) {
+            var entry = _a[0];
+            if (entry.isIntersecting && !loadingRef.current && !isLoading) {
+                loadingRef.current = true;
+                setSize(function (prev) { return prev + 1; }).finally(function () {
+                    loadingRef.current = false;
+                });
+            }
+        }, {
+            threshold: 0,
+            rootMargin: '0px 0px 200px 0px',
+        });
+    };
+    DataPaginationService.prototype.get = function (endpoint, initialParams, swrConfig) {
+        var _this = this;
+        if (initialParams === void 0) { initialParams = {}; }
+        var baseUrl = process.env.NEXT_PUBLIC_API_URL;
+        var paramsRef = useRef(initialParams);
+        var getKey = useCallback(function (pageIndex, previousData) {
+            if (!endpoint || !baseUrl)
+                return null;
+            // Если предыдущая страница пустая, больше данных нет
+            if (previousData &&
+                Array.isArray(previousData) &&
+                previousData.length === 0) {
+                return null;
+            }
+            var searchParams = new URLSearchParams(__assign({ page: pageIndex.toString() }, Object.fromEntries(Object.entries(paramsRef.current)
+                .filter(function (_a) {
+                var key = _a[0];
+                return key !== 'page';
+            }) // Исключаем page, используем pageIndex
+                .map(function (_a) {
+                var key = _a[0], value = _a[1];
+                return [key, String(value)];
+            }))));
+            return "".concat(baseUrl).concat(endpoint, "?").concat(searchParams.toString());
+        }, [endpoint, baseUrl]);
+        var swrState = useSWRInfinite(getKey, this.fetcher, __assign({ revalidateFirstPage: false, revalidateAll: false }, swrConfig));
+        var data = swrState.data, size = swrState.size, isLoading = swrState.isLoading, error = swrState.error, mutate = swrState.mutate, setSize = swrState.setSize, isValidating = swrState.isValidating;
+        // Объединение и дедупликация данных
+        var mergedData = useMemo(function () {
+            if (!(data === null || data === void 0 ? void 0 : data.length))
+                return [];
+            var firstPage = data[0];
+            if (!Array.isArray(firstPage)) {
+                // Если данные не массив, возвращаем последнюю страницу
+                return data[data.length - 1];
+            }
+            // Объединяем все страницы и дедуплицируем по ID
+            var flatData = data.flat();
+            var seenIds = new Set();
+            var uniqueItems = [];
+            for (var _i = 0, flatData_1 = flatData; _i < flatData_1.length; _i++) {
+                var item = flatData_1[_i];
+                if (!item || typeof item !== 'object')
+                    continue;
+                var id = 'id' in item &&
+                    (typeof item.id === 'string' || typeof item.id === 'number')
+                    ? item.id
+                    : JSON.stringify(item);
+                if (!seenIds.has(id)) {
+                    seenIds.add(id);
+                    uniqueItems.push(item);
+                }
+            }
+            return uniqueItems;
+        }, [data]);
+        var updateParams = useCallback(function (newParams) { return __awaiter(_this, void 0, void 0, function () {
+            var page, filteredParams;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        page = newParams.page, filteredParams = __rest(newParams, ["page"]);
+                        // Обновляем параметры
+                        paramsRef.current = __assign(__assign({}, paramsRef.current), filteredParams);
+                        // Очищаем кеш и сбрасываем пагинацию
+                        return [4 /*yield*/, mutate(undefined, { revalidate: false })];
+                    case 1:
+                        // Очищаем кеш и сбрасываем пагинацию
+                        _a.sent();
+                        return [4 /*yield*/, setSize(1)];
+                    case 2:
+                        _a.sent();
+                        // Перезагружаем данные с новыми параметрами
+                        return [2 /*return*/, mutate()];
+                }
+            });
+        }); }, [mutate, setSize]);
+        // Intersection Observer для бесконечной прокрутки
+        var observerRef = useRef(null);
+        var loadingRef = useRef(false);
+        var elementRef = useRef(null);
+        var lastPage = data === null || data === void 0 ? void 0 : data[data.length - 1];
+        var isEmpty = Array.isArray(lastPage) ? lastPage.length === 0 : !lastPage;
+        var canLoadMore = !isEmpty && !isLoading && !isValidating;
+        var useObserver = useCallback(function (element) {
+            elementRef.current = element;
+        }, []);
+        useEffect(function () {
+            var _a, _b;
+            var element = elementRef.current;
+            if (!element || !canLoadMore) {
+                (_a = observerRef.current) === null || _a === void 0 ? void 0 : _a.disconnect();
+                return;
+            }
+            (_b = observerRef.current) === null || _b === void 0 ? void 0 : _b.disconnect();
+            observerRef.current = _this.createIntersectionObserver(setSize, isLoading, loadingRef);
+            observerRef.current.observe(element);
+            return function () { var _a; return (_a = observerRef.current) === null || _a === void 0 ? void 0 : _a.disconnect(); };
+        }, [canLoadMore, isLoading, setSize]);
+        return __assign(__assign({}, swrState), { data: mergedData, params: paramsRef.current, error: error !== null && error !== void 0 ? error : undefined, updateParams: updateParams, useObserver: useObserver });
+    };
+    return DataPaginationService;
+}());
+export var dataPaginationService = DataPaginationService.getInstance();

package/services/form/errors/index.d.ts

@@ -0,0 +1 @@
+export declare const formErrorsService: import("./service").FormErrorsService;

package/services/form/errors/index.js

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

package/services/form/errors/service.d.ts

@@ -0,0 +1,5 @@
+import { FieldValues, UseFormSetError } from 'react-hook-form';
+export declare class FormErrorsService {
+    create<T extends FieldValues>(errors: Record<string, string[]> | undefined, setError: UseFormSetError<T>, parentPath?: string): void;
+}
+export declare const formErrorsService: FormErrorsService;

package/services/form/errors/service.js

@@ -0,0 +1,21 @@
+var FormErrorsService = /** @class */ (function () {
+    function FormErrorsService() {
+    }
+    FormErrorsService.prototype.create = function (errors, setError, parentPath) {
+        if (parentPath === void 0) { parentPath = ''; }
+        if (!errors || typeof errors !== 'object')
+            return;
+        Object.entries(errors).forEach(function (_a) {
+            var field = _a[0], messages = _a[1];
+            if (Array.isArray(messages) && messages.length > 0) {
+                var path = parentPath ? "".concat(parentPath, ".").concat(field) : field;
+                setError(path, {
+                    message: messages[0],
+                });
+            }
+        });
+    };
+    return FormErrorsService;
+}());
+export { FormErrorsService };
+export var formErrorsService = new FormErrorsService();

package/services/form/form/index.d.ts

@@ -0,0 +1,6 @@
+import type { FieldValues } from 'react-hook-form';
+import type { FormServiceInterface } from './service.interface';
+export declare const formService: import("./service").FormService;
+export declare namespace FormService {
+    type Interface<T extends FieldValues = FieldValues> = FormServiceInterface<T>;
+}

package/services/form/form/index.js

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

package/services/form/form/service.d.ts

@@ -0,0 +1,9 @@
+import { type FieldValues, type UseFormProps } from 'react-hook-form';
+import { FormServiceInterface } from './service.interface';
+export declare class FormService {
+    private static instance;
+    private constructor();
+    static getInstance(): FormService;
+    useForm<T extends FieldValues>(options?: UseFormProps<T>): FormServiceInterface<T>;
+}
+export declare const formService: FormService;

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

@@ -0,0 +1,8 @@
+import { FieldValues, UseFormReturn } from 'react-hook-form';
+export interface FormServiceInterface<T extends FieldValues> extends UseFormReturn<T> {
+    data: T;
+    onDirty: (callback: (isDirty: boolean) => void) => void;
+    onSubmitting: (callback: (isSubmitting: boolean) => void) => void;
+    onSubmitSuccessful: (callback: (isSubmitSuccessful: boolean) => void) => void;
+    onErrors: (callback: (errors: Record<string, any>) => void) => void;
+}

package/services/form/form/service.interface.js

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

package/services/form/form/service.js

@@ -0,0 +1,58 @@
+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 { useEffect } from 'react';
+import { useForm } from 'react-hook-form';
+var FormService = /** @class */ (function () {
+    function FormService() {
+    }
+    FormService.getInstance = function () {
+        if (!FormService.instance) {
+            FormService.instance = new FormService();
+        }
+        return FormService.instance;
+    };
+    FormService.prototype.useForm = function (options) {
+        if (options === void 0) { options = {}; }
+        var formMethods = useForm(options);
+        var formState = formMethods.formState;
+        var isDirty = formState.isDirty, isSubmitting = formState.isSubmitting, isSubmitSuccessful = formState.isSubmitSuccessful, errors = formState.errors;
+        // Создаем данные с помощью watch
+        var data = formMethods.watch();
+        // Функции для подписки на события формы
+        var onDirty = function (callback) {
+            useEffect(function () {
+                callback(isDirty);
+            }, [isDirty]);
+        };
+        var onSubmitting = function (callback) {
+            useEffect(function () {
+                callback(isSubmitting);
+            }, [isSubmitting]);
+        };
+        var onSubmitSuccessful = function (callback) {
+            useEffect(function () {
+                callback(isSubmitSuccessful);
+            }, [isSubmitSuccessful]);
+        };
+        var onErrors = function (callback) {
+            useEffect(function () {
+                if (Object.keys(errors).length > 0) {
+                    callback(errors);
+                }
+            }, [errors]);
+        };
+        return __assign(__assign({}, formMethods), { data: data, onDirty: onDirty, onSubmitting: onSubmitting, onSubmitSuccessful: onSubmitSuccessful, onErrors: onErrors });
+    };
+    return FormService;
+}());
+export { FormService };
+export var formService = FormService.getInstance();

package/services/gdpr/index.d.ts

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

package/services/gdpr/index.js

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

package/services/gdpr/service.d.ts

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

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

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

package/services/gdpr/service.interface.js

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

package/services/gdpr/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 GDPR_KEY = 'gdpr';
+export var gdprService = {
+    create: function (gdpr) {
+        storageCookieService.create(GDPR_KEY, gdpr);
+    },
+    read: function () {
+        return storageCookieService.read(GDPR_KEY);
+    },
+    update: function (gdpr) {
+        var data = this.read();
+        if (typeof gdpr === 'object' && gdpr !== null) {
+            this.create(__assign(__assign({}, data), gdpr));
+        }
+        else {
+            this.create(gdpr);
+        }
+    },
+    delete: function () {
+        storageCookieService.delete(GDPR_KEY);
+    },
+};

package/services/storage/cookie/index.d.ts

@@ -0,0 +1,7 @@
+import { StorageCookieService } from './service';
+import type { StorageCookieServiceConfig, StorageCookieServiceInterface } from './service.interface';
+export declare const storageCookieService: StorageCookieService;
+export declare namespace storageCookieService {
+    type Interface = StorageCookieServiceInterface;
+    type Config = StorageCookieServiceConfig;
+}

package/services/storage/cookie/index.js

@@ -0,0 +1,2 @@
+import { StorageCookieService } from './service';
+export var storageCookieService = StorageCookieService.getInstance();

package/services/storage/cookie/service.d.ts

@@ -0,0 +1,10 @@
+import { StorageCookieServiceConfig, StorageCookieServiceInterface } from './service.interface';
+export declare class StorageCookieService implements StorageCookieServiceInterface {
+    private static instance;
+    static getInstance(): StorageCookieService;
+    private createConfig;
+    create<T = any>(key: string, value: T, config?: Partial<StorageCookieServiceConfig>): void;
+    read<T = any>(key: string): T | null;
+    update<T = any>(key: string, value: Partial<T>, config?: Partial<StorageCookieServiceConfig>): void;
+    delete(key: string, config?: Partial<StorageCookieServiceConfig>): void;
+}

package/services/storage/cookie/service.interface.d.ts

@@ -0,0 +1,13 @@
+export interface StorageCookieServiceConfig {
+    secure: boolean;
+    sameSite: 'Lax' | 'Strict' | 'None';
+    expires: number;
+    path: string;
+    domain?: string;
+}
+export interface StorageCookieServiceInterface {
+    create<T = any>(key: string, value: T, config?: Partial<StorageCookieServiceConfig>): void;
+    read<T = any>(key: string): T | null;
+    update<T = any>(key: string, value: Partial<T>, config?: Partial<StorageCookieServiceConfig>): void;
+    delete(key: string, config?: Partial<StorageCookieServiceConfig>): void;
+}

package/services/storage/cookie/service.interface.js

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

package/services/storage/cookie/service.js

@@ -0,0 +1,123 @@
+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 DEFAULT_CONFIG = {
+    expires: 180,
+    path: '/',
+    secure: false,
+    sameSite: 'Lax',
+};
+var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
+var StorageCookieService = /** @class */ (function () {
+    function StorageCookieService() {
+    }
+    StorageCookieService.getInstance = function () {
+        if (!StorageCookieService.instance) {
+            StorageCookieService.instance = new StorageCookieService();
+        }
+        return StorageCookieService.instance;
+    };
+    StorageCookieService.prototype.createConfig = function (config) {
+        return __assign(__assign({}, DEFAULT_CONFIG), config);
+    };
+    StorageCookieService.prototype.create = function (key, value, config) {
+        if (!isBrowser)
+            return;
+        var cfg = this.createConfig(config);
+        var encodedKey = encodeURIComponent(key);
+        var stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        var encodedValue = encodeURIComponent(stringValue);
+        var cookieString = "".concat(encodedKey, "=").concat(encodedValue);
+        if (cfg.expires !== undefined) {
+            var date = new Date();
+            date.setTime(date.getTime() + cfg.expires * 24 * 60 * 60 * 1000);
+            cookieString += "; Expires=".concat(date.toUTCString());
+        }
+        if (cfg.path) {
+            cookieString += "; Path=".concat(cfg.path);
+        }
+        if (cfg.domain) {
+            cookieString += "; Domain=".concat(cfg.domain);
+        }
+        if (cfg.secure) {
+            cookieString += "; Secure";
+        }
+        if (cfg.sameSite) {
+            cookieString += "; SameSite=".concat(cfg.sameSite);
+        }
+        document.cookie = cookieString;
+    };
+    StorageCookieService.prototype.read = function (key) {
+        if (!isBrowser)
+            return null;
+        var encodedKey = encodeURIComponent(key);
+        var nameEQ = "".concat(encodedKey, "=");
+        var cookies = document.cookie ? document.cookie.split('; ') : [];
+        for (var _i = 0, cookies_1 = cookies; _i < cookies_1.length; _i++) {
+            var c = cookies_1[_i];
+            if (c.indexOf(nameEQ) === 0) {
+                var raw = decodeURIComponent(c.substring(nameEQ.length));
+                if (!raw)
+                    return null;
+                // Сначала пытаемся JSON (для объектов/массивов)
+                try {
+                    return JSON.parse(raw);
+                }
+                catch (_a) {
+                    // Число (включая отрицательные и дробные)
+                    if (/^-?\d+(\.\d+)?$/.test(raw)) {
+                        return Number(raw);
+                    }
+                    // Булево
+                    if (raw === 'true' || raw === 'false') {
+                        return (raw === 'true');
+                    }
+                    // Строка
+                    return raw;
+                }
+            }
+        }
+        return null;
+    };
+    StorageCookieService.prototype.update = function (key, value, config) {
+        if (!isBrowser)
+            return;
+        var data = this.read(key);
+        if (data && typeof data === 'object' && typeof value === 'object') {
+            this.create(key, __assign(__assign({}, data), value), config);
+        }
+        else {
+            this.create(key, value, config);
+        }
+    };
+    StorageCookieService.prototype.delete = function (key, config) {
+        if (!isBrowser)
+            return;
+        var cfg = this.createConfig(config);
+        var encodedKey = encodeURIComponent(key);
+        var cookieString = "".concat(encodedKey, "=; Expires=Thu, 01 Jan 1970 00:00:00 GMT");
+        if (cfg.path) {
+            cookieString += "; Path=".concat(cfg.path);
+        }
+        if (cfg.domain) {
+            cookieString += "; Domain=".concat(cfg.domain);
+        }
+        if (cfg.sameSite) {
+            cookieString += "; SameSite=".concat(cfg.sameSite);
+        }
+        if (cfg.secure) {
+            cookieString += "; Secure";
+        }
+        document.cookie = cookieString;
+    };
+    return StorageCookieService;
+}());
+export { StorageCookieService };

package/services/storage/local/index.d.ts

@@ -0,0 +1,6 @@
+import { StorageLocalService } from './service';
+import type { StorageLocalServiceInterface } from './service.interface';
+export declare const storageLocalService: StorageLocalService;
+export declare namespace storageLocalService {
+    type Interface = StorageLocalServiceInterface;
+}

package/services/storage/local/index.js

@@ -0,0 +1,2 @@
+import { StorageLocalService } from './service';
+export var storageLocalService = StorageLocalService.getInstance();

package/services/storage/local/service.d.ts

@@ -0,0 +1,10 @@
+import { StorageLocalServiceInterface } from './service.interface';
+export declare class StorageLocalService implements StorageLocalServiceInterface {
+    private static instance;
+    static getInstance(): StorageLocalService;
+    create<T = any>(key: string, value: T): void;
+    read<T = any>(key: string): T | null;
+    update<T = any>(key: string, value: Partial<T>): void;
+    delete(key: string): void;
+}
+export declare const storageLocalService: StorageLocalService;

package/services/storage/local/service.interface.d.ts

@@ -0,0 +1,6 @@
+export interface StorageLocalServiceInterface {
+    create<T = any>(key: string, value: T): void;
+    read<T = any>(key: string): T | null;
+    update<T = any>(key: string, value: Partial<T>): void;
+    delete(key: string): void;
+}

package/services/storage/local/service.interface.js

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