@steroidsjs/core 2.3.0-beta.5 → 2.3.0-beta.6

package/hooks/useFile.js

@@ -0,0 +1,247 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var react_1 = require("react");
+var react_use_1 = require("react-use");
+var fileup_core_1 = __importDefault(require("fileup-core"));
+var File_1 = __importDefault(require("fileup-core/lib/models/File"));
+var QueueCollection_1 = __importDefault(require("fileup-core/lib/models/QueueCollection"));
+var get_1 = __importDefault(require("lodash-es/get"));
+var isEqual_1 = __importDefault(require("lodash-es/isEqual"));
+var difference_1 = __importDefault(require("lodash-es/difference"));
+var buildURL_1 = __importDefault(require("axios/lib/helpers/buildURL"));
+var useInitial_1 = __importDefault(require("./useInitial"));
+var index_1 = require("./index");
+var imagesMimeTypes = [
+    'image/gif',
+    'image/jpeg',
+    'image/pjpeg',
+    'image/png',
+    'image/heif',
+    'image/heic',
+    'image/heif-sequence',
+    'image/heic-sequence',
+];
+function generateBackendUrl(props) {
+    return buildURL_1["default"](props.backendUrl, {
+        mimeTypes: props.imagesOnly ? imagesMimeTypes : props.mimeTypes,
+        imagesProcessor: props.imagesProcessor,
+        imagesExactSize: props.imagesExactSize
+    });
+}
+function useFile(props) {
+    var http = index_1.useComponents().http;
+    http.getAccessToken(); // TODO Run promise..
+    var uploader = useInitial_1["default"](function () {
+        var _a;
+        return new fileup_core_1["default"](__assign(__assign({ dropArea: {}, backendUrl: generateBackendUrl(props), uploaderConfig: __assign(__assign({}, props.uploaderConfig), { headers: __assign(__assign({}, (_a = props.uploaderConfig) === null || _a === void 0 ? void 0 : _a.headers), { Authorization: 'Bearer ' + http._accessToken }) }) }, props.uploader), { form: __assign(__assign({}, (props.uploader && props.uploader.form)), { multiple: props.multiple }) }));
+    });
+    /**
+     * Force component update when file status or progress changes
+     * @private
+     */
+    var forceUpdate = react_use_1.useUpdate();
+    // Check for initial files
+    var form = index_1.useForm();
+    var initialFiles = props.initialFiles;
+    if (!initialFiles) {
+        // Find in form values
+        initialFiles = form.formSelector(function (state) { return get_1["default"](state, 'values.' + props.input.name.replace(/Ids?$/, '')); });
+    }
+    react_1.useEffect(function () {
+        if (initialFiles) {
+            var normalizedInitialFiles_1 = [].concat(initialFiles || [])
+                .filter(function (item) { return !!item.uid; });
+            // Remove not exists
+            var toDelete = uploader.queue.getFiles()
+                .filter(function (file) { return !normalizedInitialFiles_1.find(function (item) { return item.uid === file.getUid(); }); });
+            if (toDelete.length > 0) {
+                uploader.queue.remove(toDelete);
+            }
+            // Add or update
+            uploader.queue.add(normalizedInitialFiles_1
+                .map(function (item) {
+                var path = item.title || item.label || item.uid || item.id;
+                var resultHttpMessage = __assign(__assign({}, item), { id: item.id || item.uid, images: item.thumbnailUrl
+                        ? [{ url: item.thumbnailUrl }]
+                        : null });
+                var file = uploader.queue.getByUid(item.uid);
+                if (file) {
+                    file.setPath(path);
+                    file.setResultHttpMessage(resultHttpMessage);
+                    return false;
+                }
+                return new File_1["default"]({
+                    path: path,
+                    status: File_1["default"].STATUS_END,
+                    result: File_1["default"].RESULT_SUCCESS,
+                    resultHttpStatus: 200,
+                    resultHttpMessage: resultHttpMessage,
+                    uid: item.uid
+                });
+            })
+                .filter(Boolean));
+            forceUpdate();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [initialFiles]);
+    /**
+     * Trigger by queue when file is uploaded or error
+     * @param {File} file
+     * @private
+     */
+    var onQueueItemEnd = react_1.useCallback(function (file) {
+        forceUpdate();
+        // Check successfully
+        if (file.getResult() !== File_1["default"].RESULT_SUCCESS) {
+            return;
+        }
+        // Check file id exists
+        var id = get_1["default"](file.getResultHttpMessage(), 'id');
+        if (!id) {
+            return;
+        }
+        // Update value
+        if (props.multiple) {
+            props.input.onChange([].concat(props.input.value || []).concat([id]));
+        }
+        else {
+            props.input.onChange(id);
+        }
+    }, [forceUpdate, props.input, props.multiple]);
+    var prevOnQueueItemEnd = react_use_1.usePrevious(onQueueItemEnd);
+    react_1.useEffect(function () {
+        if (prevOnQueueItemEnd) {
+            uploader.queue.off(QueueCollection_1["default"].EVENT_ITEM_END, prevOnQueueItemEnd);
+        }
+        uploader.queue.on(QueueCollection_1["default"].EVENT_ITEM_END, onQueueItemEnd);
+    }, [onQueueItemEnd, prevOnQueueItemEnd, uploader.queue]);
+    react_use_1.useUnmount(function () {
+        uploader.queue.off(QueueCollection_1["default"].EVENT_ITEM_END, onQueueItemEnd);
+    });
+    /**
+     * Triggered by queue when file is removed from it
+     * @param {File[]} removedFiles
+     * @private
+     */
+    var onQueueRemove = react_1.useCallback(function (removedFiles) {
+        var toRemove = removedFiles
+            .map(function (file) { return get_1["default"](file.getResultHttpMessage(), 'id'); })
+            .filter(Boolean);
+        if (toRemove.length === 0) {
+            return;
+        }
+        // Update value
+        if (props.multiple) {
+            props.input.onChange([]
+                .concat(props.input.value || [])
+                .filter(function (id) { return toRemove.indexOf(Number(id)) === -1; }));
+        }
+        else if (toRemove.indexOf(props.input.value) !== -1) {
+            props.input.onChange(null);
+        }
+        forceUpdate();
+    }, [forceUpdate, props.input, props.multiple]);
+    var prevOnQueueRemove = react_use_1.usePrevious(onQueueRemove);
+    react_1.useEffect(function () {
+        if (prevOnQueueRemove) {
+            uploader.queue.off(QueueCollection_1["default"].EVENT_REMOVE, prevOnQueueRemove);
+        }
+        uploader.queue.on(QueueCollection_1["default"].EVENT_REMOVE, onQueueRemove);
+    }, [onQueueRemove, prevOnQueueRemove, uploader.queue]);
+    react_use_1.useUnmount(function () {
+        uploader.queue.off(QueueCollection_1["default"].EVENT_REMOVE, onQueueRemove);
+    });
+    react_use_1.useMount(function () {
+        uploader.queue.on(QueueCollection_1["default"].EVENT_ITEM_STATUS, forceUpdate);
+        uploader.queue.on(QueueCollection_1["default"].EVENT_ITEM_PROGRESS, forceUpdate);
+    });
+    react_use_1.useUnmount(function () {
+        uploader.queue.off(QueueCollection_1["default"].EVENT_ITEM_STATUS, forceUpdate);
+        uploader.queue.off(QueueCollection_1["default"].EVENT_ITEM_PROGRESS, forceUpdate);
+    });
+    // Check backend url changes
+    react_1.useEffect(function () {
+        uploader.backendUrl = generateBackendUrl({
+            backendUrl: props.backendUrl,
+            imagesOnly: props.imagesOnly,
+            mimeTypes: props.mimeTypes,
+            imagesProcessor: props.imagesProcessor,
+            imagesExactSize: props.imagesExactSize
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.backendUrl, props.imagesExactSize, props.imagesOnly, props.imagesProcessor, props.mimeTypes]);
+    // Check multiple flag update
+    react_1.useEffect(function () {
+        uploader.form.multiple = props.multiple;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.multiple]);
+    // TODO Check uploader config update
+    //useEffect(() => {
+    //    _merge(uploader, props.uploader);
+    //}, [props.uploader, uploader]);
+    // Check remove keys from value
+    var prevInputValue = react_use_1.usePrevious(props.input.value);
+    //todo refactoring
+    react_1.useEffect(function () {
+        if (prevInputValue && !isEqual_1["default"](prevInputValue !== props.input.value)) {
+            var toRemove_1 = difference_1["default"]([].concat(prevInputValue || []), [].concat(props.input.value || []));
+            if (toRemove_1.length > 0) {
+                uploader.queue.remove(uploader.queue.getFiles().filter(function (file) { return (toRemove_1.indexOf(get_1["default"](file.getResultHttpMessage(), 'id')) !== -1); }));
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [prevInputValue, props.input.value]);
+    /**
+     * Show browse dialog in user browser
+     * @param {object} event
+     * @private
+     */
+    var onBrowse = function (event) {
+        if (event) {
+            event.preventDefault();
+        }
+        uploader.browse();
+    };
+    /**
+     * Remove selected file from uploader
+     * @param {File} fileToRemove
+     */
+    var onRemove = function (fileToRemove) {
+        uploader.queue.remove([fileToRemove]);
+        forceUpdate();
+    };
+    var files = [].concat(uploader.queue.getFiles());
+    /**
+     * Add file to uploader
+     * @param {File} newFile
+     */
+    var onAdd = function (newFile) {
+        if (!props.multiple) {
+            uploader.queue.remove(files);
+        }
+        uploader.queue.add([newFile]);
+        forceUpdate();
+    };
+    return {
+        uploader: uploader,
+        files: files,
+        onBrowse: onBrowse,
+        onRemove: onRemove,
+        onAdd: onAdd
+    };
+}
+exports["default"] = useFile;

package/hooks/useForm.d.ts

@@ -0,0 +1,9 @@
+export default function useForm(): {
+    formId: string;
+    model: any;
+    prefix: string | boolean;
+    size: string;
+    layout: FormLayout;
+    formDispatch: any;
+    formSelector: (selector: (state: any, setValue: any) => any) => any;
+};

package/hooks/useForm.js

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+var react_1 = require("react");
+var Form_1 = require("../ui/form/Form/Form");
+function useForm() {
+    var context = react_1.useContext(Form_1.FormContext);
+    return react_1.useMemo(function () { return (context
+        ? {
+            formId: context.formId,
+            model: context.model,
+            prefix: context.prefix,
+            size: context.size,
+            layout: context.layout,
+            formDispatch: context === null || context === void 0 ? void 0 : context.dispatch,
+            formSelector: function (selector) { var _a; return (_a = context === null || context === void 0 ? void 0 : context.provider) === null || _a === void 0 ? void 0 : _a.select(context.formId, selector); }
+        }
+        : null); }, [context]);
+}
+exports["default"] = useForm;

package/hooks/useInitial.d.ts

@@ -0,0 +1 @@
+export default function useInitial<T>(creator: () => T): T;

package/hooks/useInitial.js

@@ -0,0 +1,11 @@
+"use strict";
+exports.__esModule = true;
+var react_1 = require("react");
+function useInitial(creator) {
+    var initialRef = react_1.useRef(null);
+    if (!initialRef.current) {
+        initialRef.current = creator();
+    }
+    return initialRef.current;
+}
+exports["default"] = useInitial;

package/hooks/useLayout.d.ts

@@ -0,0 +1,21 @@
+import { Dispatch } from 'redux';
+import { IComponents } from '../providers/ComponentsProvider';
+export interface ILayout {
+    status?: string;
+    error?: any;
+    data?: any;
+}
+export declare const STATUS_LOADING = "loading";
+export declare const STATUS_NOT_FOUND = "not_found";
+export declare const STATUS_RENDER_ERROR = "render_error";
+export declare const STATUS_HTTP_ERROR = "render_error";
+export declare const STATUS_ACCESS_DENIED = "access_denied";
+export declare const STATUS_OK = "ok";
+export declare const HTTP_STATUS_CODES: {
+    not_found: number;
+    access_denied: number;
+    ok: number;
+    render_error: number;
+};
+export declare const runInitAction: (initAction: (...args: any[]) => Promise<any>, components: IComponents, dispatch: Dispatch<any>) => Promise<void>;
+export default function useLayout(initAction?: any): ILayout;

package/hooks/useLayout.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+exports.__esModule = true;
+exports.runInitAction = exports.HTTP_STATUS_CODES = exports.STATUS_OK = exports.STATUS_ACCESS_DENIED = exports.STATUS_HTTP_ERROR = exports.STATUS_RENDER_ERROR = exports.STATUS_NOT_FOUND = exports.STATUS_LOADING = void 0;
+var react_1 = require("react");
+var isFunction_1 = __importDefault(require("lodash-es/isFunction"));
+var isObject_1 = __importDefault(require("lodash-es/isObject"));
+var upperFirst_1 = __importDefault(require("lodash-es/upperFirst"));
+var merge_1 = __importDefault(require("lodash-es/merge"));
+var intersection_1 = __importDefault(require("lodash-es/intersection"));
+var react_use_1 = require("react-use");
+var Router_1 = require("../ui/nav/Router/Router");
+var useSsr_1 = __importDefault(require("./useSsr"));
+var useComponents_1 = __importDefault(require("./useComponents"));
+var router_1 = require("../reducers/router");
+var auth_1 = require("../reducers/auth");
+var useSelector_1 = __importDefault(require("./useSelector"));
+var auth_2 = require("../actions/auth");
+var useDispatch_1 = __importDefault(require("./useDispatch"));
+var fields_1 = require("../actions/fields");
+var router_2 = require("../actions/router");
+exports.STATUS_LOADING = 'loading';
+exports.STATUS_NOT_FOUND = 'not_found';
+exports.STATUS_RENDER_ERROR = 'render_error';
+exports.STATUS_HTTP_ERROR = 'render_error';
+exports.STATUS_ACCESS_DENIED = 'access_denied';
+exports.STATUS_OK = 'ok';
+exports.HTTP_STATUS_CODES = (_a = {},
+    _a[exports.STATUS_NOT_FOUND] = 404,
+    _a[exports.STATUS_ACCESS_DENIED] = 403,
+    _a[exports.STATUS_OK] = 200,
+    _a[exports.STATUS_RENDER_ERROR] = 500,
+    _a[exports.STATUS_HTTP_ERROR] = 500,
+    _a);
+var runInitAction = function (initAction, components, dispatch) { return (initAction(null, dispatch, components)
+    .then(function (result) {
+    // Configure components
+    if (isObject_1["default"](result.config)) {
+        Object.keys(result.config).forEach(function (name) {
+            if (!components[name]) {
+                return;
+            }
+            Object.keys(result.config[name]).forEach(function (key) {
+                var value = result.config[name][key];
+                var setter = 'set' + upperFirst_1["default"](key);
+                if (isFunction_1["default"](components[name][setter])) {
+                    components[name][setter](value);
+                }
+                else if (isObject_1["default"](components[name][key])
+                    && isObject_1["default"](value)) {
+                    merge_1["default"](components[name][key], value);
+                }
+                else {
+                    components[name][key] = value;
+                }
+            });
+        });
+    }
+    var resultMeta = result.meta;
+    var resultUser = result.user;
+    delete result.user;
+    delete result.meta;
+    if (resultMeta) {
+        Object.keys(resultMeta).forEach(function (modelName) {
+            if (resultMeta[modelName].attributes) {
+                components.meta.setModel(modelName, resultMeta[modelName]);
+            }
+        });
+    }
+    dispatch([
+        // Meta models & enums
+        Boolean(resultMeta) && fields_1.setMeta(resultMeta),
+        // User auth
+        auth_2.setData(result),
+        // User auth
+        auth_2.setUser(resultUser),
+    ].filter(Boolean));
+})); };
+exports.runInitAction = runInitAction;
+function useLayout(initAction) {
+    if (initAction === void 0) { initAction = null; }
+    var _a = useSelector_1["default"](function (state) {
+        var routesMap = router_1.getRoutesMap(state);
+        return {
+            route: router_1.getRoute(state),
+            user: auth_1.getUser(state),
+            data: auth_1.getData(state),
+            isInitialized: auth_1.isInitialized(state),
+            initializeCounter: auth_1.getInitializeCounter(state),
+            redirectPageId: state.auth.redirectPageId,
+            loginRouteId: routesMap && Object.keys(routesMap).find(function (name) { return routesMap[name].role === Router_1.ROUTER_ROLE_LOGIN; })
+        };
+    }), route = _a.route, user = _a.user, data = _a.data, isInitialized = _a.isInitialized, initializeCounter = _a.initializeCounter, redirectPageId = _a.redirectPageId, loginRouteId = _a.loginRouteId;
+    var _b = react_1.useState(null), error = _b[0], setError = _b[1];
+    var dispatch = useDispatch_1["default"]();
+    var components = useComponents_1["default"]();
+    react_use_1.useMount(function () {
+        // Callback for load initial page data (return promise)
+        if (isFunction_1["default"](initAction)) {
+            dispatch(auth_2.init(true));
+        }
+        else {
+            dispatch(auth_2.setUser(null));
+        }
+    });
+    var initializeCounterPrev = react_use_1.usePrevious(initializeCounter);
+    react_use_1.useUpdateEffect(function () {
+        if (!isFunction_1["default"](initAction) || initializeCounter <= initializeCounterPrev) {
+            return;
+        }
+        exports.runInitAction(initAction, components, dispatch)
+            .then(function () {
+            if (redirectPageId) {
+                dispatch(router_2.goToRoute(redirectPageId));
+            }
+        })["catch"](function (e) {
+            setError(e);
+            throw e;
+        });
+    });
+    var status = exports.STATUS_OK;
+    if (!isInitialized) {
+        status = exports.STATUS_LOADING;
+    }
+    else if (error) {
+        status = exports.STATUS_HTTP_ERROR;
+    }
+    else if (!route) {
+        status = exports.STATUS_NOT_FOUND;
+    }
+    else {
+        var pageRoles = (route === null || route === void 0 ? void 0 : route.roles) || [];
+        var userRoles = [].concat((user === null || user === void 0 ? void 0 : user.role) || []).concat((user === null || user === void 0 ? void 0 : user.roles) || []);
+        if (userRoles.length === 0) {
+            userRoles.push(null); // Guest
+        }
+        if (intersection_1["default"](pageRoles, userRoles).length === 0) {
+            if (loginRouteId && route.id !== loginRouteId) {
+                dispatch(router_2.goToRoute(loginRouteId));
+            }
+            else {
+                status = exports.STATUS_ACCESS_DENIED;
+                if (process.env.NODE_ENV !== 'production') {
+                    // eslint-disable-next-line no-console
+                    console.log('Access denied. Page roles: ', pageRoles, 'User roles:', userRoles.join(), 'Route:', route);
+                }
+            }
+        }
+    }
+    //save status code for ssr
+    var ssrContextValue = useSsr_1["default"]();
+    if (process.env.IS_SSR) {
+        ssrContextValue.staticContext.statusCode = exports.HTTP_STATUS_CODES[status];
+    }
+    return {
+        status: status,
+        error: error,
+        data: data
+    };
+}
+exports["default"] = useLayout;

package/hooks/useList.d.ts

@@ -0,0 +1,201 @@
+import { IApiMethod } from '../components/ApiComponent';
+import { IAddressBarConfig } from '../hooks/useAddressBar';
+import { IList } from '../actions/list';
+import { ILayoutNamesProps } from '../ui/list/LayoutNames/LayoutNames';
+import { IPaginationProps } from '../ui/list/Pagination/Pagination';
+import { IPaginationSizeProps } from '../ui/list/PaginationSize/PaginationSize';
+import { IEmptyProps } from '../ui/list/Empty/Empty';
+import { IFormProps } from '../ui/form/Form/Form';
+import { Model } from '../components/MetaComponent';
+export declare type ListControlPosition = 'top' | 'bottom' | 'both' | string;
+interface ISortProps {
+    /**
+     * Включить сортировку
+     * @example false
+     */
+    enable?: boolean;
+    /**
+     * Аттрибут (название) поля сортировки в форме
+     * @example sort
+     */
+    attribute?: string;
+    /**
+     * Значение сортировки по умолчанию. Нужно указать название свойства, по которому items будут сортироваться,
+     * а с помощью знака "-" задать тип сортировки (со знаком минус - сортировать по убыванию, иначе по возрастанию).
+     * @example -price
+     */
+    defaultValue?: string | string[] | null;
+}
+export interface IListConfig {
+    /**
+     * Идентификатор списка
+     * @example ArticlesList
+     */
+    listId?: string;
+    /**
+     * Первичный ключ для item
+     * @example id
+     */
+    primaryKey?: string;
+    /**
+     * Url, который вернет коллекцию элементов
+     * @example api/v1/articles
+     */
+    action?: string | IApiMethod;
+    /**
+     * Тип HTTP запроса (GET | POST | PUT | DELETE)
+     * @example GET
+     */
+    actionMethod?: HttpMethod;
+    /**
+     * Подключение пагинации
+     * @example {loadMore: true}
+     */
+    pagination?: boolean | IPaginationProps;
+    /**
+     * Переключение количества элементов в списке
+     * @example {sizes: [3, 6, 9], defaultValue: 3}
+     */
+    paginationSize?: boolean | IPaginationSizeProps;
+    /**
+     * Подключение сортировки
+     * @example {enable: true, defaultSort: 'startDate'}
+     */
+    sort?: boolean | ISortProps;
+    /**
+     * Варианты расположения элементов коллекции
+     * @example {items: [{id: 'list', label: 'List'}, {id: 'grid', label: 'Grid'}]}
+     */
+    layout?: boolean | ILayoutNamesProps;
+    /**
+     * Заглушка в случае отсутствия элементов
+     * @example {text: 'Записи не найдены'}
+     */
+    empty?: boolean | string | IEmptyProps;
+    /**
+     * Форма для поиска элементов
+     * @example {fields: ['title'], model: {attributes: ['title:string:Название']}}
+     */
+    searchForm?: Omit<IFormProps, 'formId'> & {
+        formId?: string;
+    };
+    /**
+     * Удаление данных списка из хранилища Redux при размонтировании компонента
+     * @example true
+     */
+    autoDestroy?: boolean;
+    /**
+     * Отправлять запрос на обновление данных при изменении данных формы. По-умолчанию - включено.
+     * @example false
+     */
+    autoFetchOnFormChanges?: boolean;
+    /**
+     * Обработчик, который вызывается при изменении значений формы, и нужен для подгрузки новых элементов коллекции
+     * @param {IList} list
+     * @param {Object} query
+     * @param {*} http
+     * @return {Promise}
+     */
+    onFetch?: (list: IList, query: Record<string, unknown>, http: any) => Promise<any>;
+    /**
+     * Обработчик, который составляет список условий для локальной фильтрации элементов коллекции
+     * @param {Object} query
+     * @return {Array} ['>=', 'age', 18]
+     */
+    condition?: (query: Record<string, unknown>) => any[];
+    /**
+     * Синхронизация значений формы списка с адресной строкой
+     * @example true
+     */
+    addressBar?: boolean | IAddressBarConfig;
+    scope?: string[];
+    /**
+     * Дополнительные параметры, значения которых нужно передавать в запросе для получения данных
+     * @example {tagName: 'MarketReviews'}
+     */
+    query?: Record<string, unknown>;
+    model?: string;
+    /**
+     * Модель для синхронизации значений формы с адресной строкой
+     * @example {attributes: [{attribute: 'isMilesAvailable', type: boolean}]}
+     */
+    searchModel?: string;
+    /**
+     * Элементы коллекции
+     */
+    items?: Array<any>;
+    /**
+     * Начальные элементы. Используется для подгрузки нескольких списков в один запрос, при этом не отменяя пагинацию
+     * и последующие запросы на бекенд для 2-й и следующих страниц
+     */
+    initialItems?: Array<any>;
+    /**
+     * Количество элементов всего в списке (для отрисовки пагинации), заданное вручную
+     */
+    initialTotal?: number;
+}
+export interface IListOutput {
+    list: IList;
+    model: Model;
+    searchModel: Model;
+    paginationPosition: ListControlPosition;
+    paginationSizePosition: ListControlPosition;
+    layoutNamesPosition: ListControlPosition;
+    renderList: (children: any) => any;
+    renderEmpty: () => any;
+    renderPagination: () => any;
+    renderPaginationSize: () => any;
+    renderLayoutNames: () => any;
+    renderSearchForm: () => any;
+    onFetch: (params?: Record<string, unknown>) => void;
+    onSort: (value: any) => void;
+}
+export declare const defaultConfig: {
+    actionMethod: string;
+    primaryKey: string;
+    autoDestroy: boolean;
+    sort: {
+        enable: boolean;
+        attribute: string;
+        defaultValue: any;
+    };
+};
+export declare const normalizeSortProps: (props: IListConfig['sort']) => {
+    enable: boolean;
+    attribute: string;
+    defaultValue: any;
+};
+export declare const getDefaultSearchModel: ({ paginationProps, paginationSizeProps, sort, layoutNamesProps, }: {
+    paginationProps: any;
+    paginationSizeProps: any;
+    sort: any;
+    layoutNamesProps: any;
+}) => {
+    attributes: ({
+        type: string;
+        attribute: any;
+        defaultValue: any;
+        jsType?: undefined;
+    } | {
+        type: string;
+        jsType: string;
+        attribute: any;
+        defaultValue: any;
+    })[];
+};
+export declare const createInitialValues: ({ paginationProps, paginationSizeProps, sort, layoutNamesProps, initialQuery, configQuery, }: {
+    paginationProps: any;
+    paginationSizeProps: any;
+    sort: any;
+    layoutNamesProps: any;
+    initialQuery: any;
+    configQuery: any;
+}) => any;
+/**
+ * useList
+ * Добавляет массу возможностей для взаимодействия с коллекциями. Коллекции можно получать как с бекенда,
+ * так и передавать статичным массивом. В обоих случаях поддерживается пагинация, сортировка, фильтрация данных.
+ * Выбранные фильтры синхронизируются с адресной строкой.
+ */
+export default function useList(config: IListConfig): IListOutput;
+export {};