@steroidsjs/core 2.0.0-rc.9 → 2.0.1-beta.112

package/dist/hooks/useDataSelect.js

@@ -0,0 +1,209 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var isEqual_1 = __importDefault(require("lodash-es/isEqual"));
+var isArray_1 = __importDefault(require("lodash-es/isArray"));
+var isNil_1 = __importDefault(require("lodash-es/isNil"));
+var react_1 = require("react");
+var react_use_1 = require("react-use");
+var defaultProps = {
+    primaryKey: 'id'
+};
+function useDataSelect(config) {
+    // Get primary key
+    var primaryKey = config.primaryKey || defaultProps.primaryKey;
+    // Initial select
+    var initialSelectedIds = react_1.useMemo(function () {
+        var _a;
+        if (((_a = config.selectedIds) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            return [].concat(config.selectedIds || []);
+        }
+        if (!isNil_1["default"](config.inputValue)) {
+            return [].concat(isArray_1["default"](config.inputValue) ? config.inputValue : [config.inputValue]);
+        }
+        return config.selectFirst && config.items.length > 0
+            ? [config.items[0][primaryKey]]
+            : [];
+    }, [config.items, config.selectFirst, config.selectedIds, primaryKey, config.inputValue]);
+    var initialSelectedItems = react_1.useMemo(function () { return config.items.length > 0
+        && initialSelectedIds.length > 0
+        ? initialSelectedIds
+            .map(function (selectedId) { return config.items.find(function (item) { return item.id === selectedId; }); })
+            .filter(Boolean)
+        : []; }, [initialSelectedIds, config.items]);
+    // State
+    var _a = react_1.useState(false), isOpened = _a[0], setIsOpened = _a[1];
+    var _b = react_1.useState(false), isFocused = _b[0], setIsFocused = _b[1];
+    var _c = react_1.useState(null), hoveredId = _c[0], setHoveredId = _c[1];
+    var _d = react_1.useState(initialSelectedIds), selectedIds = _d[0], setSelectedIdsInternal = _d[1];
+    var _e = react_1.useState(initialSelectedItems), selectedItems = _e[0], setSelectedItemsInternal = _e[1];
+    // Handler for select/toggle item by id
+    var setSelectedIds = react_1.useCallback(function (ids, skipToggle) {
+        if (skipToggle === void 0) { skipToggle = false; }
+        if (isArray_1["default"](ids)) {
+            if (!config.multiple && ids.length > 1) {
+                ids = [ids[0]];
+            }
+            setSelectedIdsInternal(ids.sort());
+        }
+        else {
+            var id_1 = ids;
+            if (!id_1) {
+                setSelectedIdsInternal([]);
+            }
+            else if (config.multiple) {
+                if (selectedIds.indexOf(id_1) !== -1) {
+                    if (!skipToggle) {
+                        setSelectedIdsInternal(selectedIds.filter(function (itemValue) { return itemValue !== id_1; }).sort());
+                    }
+                }
+                else {
+                    setSelectedIdsInternal(__spreadArray(__spreadArray([], selectedIds), [id_1]).sort());
+                }
+            }
+            else {
+                if (selectedIds.length !== 1 || selectedIds[0] !== id_1) {
+                    setSelectedIdsInternal([id_1]);
+                }
+                setIsOpened(false);
+            }
+        }
+    }, [config.multiple, selectedIds]);
+    // Update selected items on change selectedIds or items or source items
+    var prevSelectedIdsLength = react_use_1.usePrevious(selectedIds.length);
+    react_use_1.useUpdateEffect(function () {
+        var newSelectedItems = [];
+        var hasChanges = false;
+        selectedIds.forEach(function (selectedId) {
+            var finedItem = config.items.find(function (item) { return item[primaryKey] === selectedId; });
+            if (!finedItem && config.sourceItems) {
+                finedItem = config.sourceItems.find(function (item) { return item[primaryKey] === selectedId; });
+            }
+            var selectedItem = selectedItems.find(function (item) { return item[primaryKey] === selectedId; });
+            if (finedItem || selectedItem) {
+                newSelectedItems.push(finedItem || selectedItem);
+            }
+            if (finedItem
+                && (!selectedItem || selectedItem !== finedItem)) {
+                hasChanges = true;
+            }
+        });
+        if (hasChanges || prevSelectedIdsLength !== selectedIds.length) {
+            setSelectedItemsInternal(newSelectedItems);
+        }
+    }, [config.items, config.sourceItems, primaryKey, selectedIds, selectedItems, prevSelectedIdsLength]);
+    // Select first after fetch data
+    var prevItemsLength = react_use_1.usePrevious(config.items.length);
+    react_use_1.useUpdateEffect(function () {
+        if (config.selectFirst && prevItemsLength === 0 && config.items.length > 0) {
+            setSelectedIdsInternal([config.items[0][primaryKey]]);
+        }
+    }, [config.items, config.selectFirst, prevItemsLength, primaryKey]);
+    // Update selected items on change value
+    var prevConfigSelectedIds = react_use_1.usePrevious(config.selectedIds || []);
+    react_use_1.useUpdateEffect(function () {
+        var newSelectedIds = config.selectedIds;
+        selectedItems.forEach(function (selectedItem) {
+            if (!newSelectedIds.includes(selectedItem.id) && config.selectedIds
+                && config.selectedIds.includes(selectedItem.id)) {
+                newSelectedIds.push(selectedItem.id);
+            }
+        });
+        newSelectedIds.sort();
+        if (!isEqual_1["default"](prevConfigSelectedIds, newSelectedIds)
+            && !isEqual_1["default"](selectedIds, newSelectedIds) && newSelectedIds.length !== 0) {
+            setSelectedIdsInternal(newSelectedIds);
+        }
+    }, [config.items, config.selectedIds, primaryKey, prevConfigSelectedIds,
+        selectedItems, config.sourceItems, selectedIds]);
+    // Global key down handler for navigate on items
+    // Support keys:
+    // - tab
+    // - esc
+    // - enter
+    // - up/down arrows
+    // - space
+    var onKeyDown = react_1.useCallback(function (e) {
+        // Skip no active
+        if (!isFocused && !isOpened) {
+            return;
+        }
+        // Keys: tab, esc
+        if ([9, 27].includes(e.which)) {
+            e.preventDefault();
+            setIsOpened(false);
+        }
+        // Keys: enter (select and close)
+        if (e.which === 13 && isOpened) {
+            e.preventDefault();
+            if (hoveredId) {
+                // Select hovered
+                setSelectedIds(hoveredId, true);
+            }
+            else if (selectedIds.length > 0) {
+                // Select first selected
+                setSelectedIds(selectedIds[0], true);
+            }
+            else if (config.items.length > 0) {
+                // Select first result
+                setSelectedIds(config.items[0], true);
+            }
+            setIsOpened(false);
+        }
+        // Keys: space (toggle select)
+        if (e.which === 32 && isOpened) {
+            e.preventDefault();
+            if (hoveredId) {
+                // Select hovered
+                setSelectedIds(hoveredId);
+            }
+        }
+        // Keys: arrow up, arrow down
+        if ([38, 40].includes(e.which)) {
+            e.preventDefault();
+            var isDown = e.which === 40;
+            if (!isOpened) {
+                // Open on down key
+                if (isDown) {
+                    setIsOpened(true);
+                }
+            }
+            else {
+                // Navigate on items by keys
+                var direction = isDown ? 1 : -1;
+                var keys = config.items.map(function (item) { return item.id; });
+                // Get current index
+                var index = hoveredId ? keys.indexOf(hoveredId) : -1;
+                if (index === -1 && selectedIds.length === 1) {
+                    index = keys.indexOf(selectedIds[0]);
+                }
+                // Get next index
+                var newIndex = index !== -1
+                    ? Math.min(keys.length - 1, Math.max(0, index + direction))
+                    : 0;
+                // Set hovered
+                setHoveredId(keys[newIndex]);
+            }
+        }
+    }, [config.items, hoveredId, isFocused, isOpened, setSelectedIds, selectedIds]);
+    react_use_1.useEvent('keydown', onKeyDown);
+    return {
+        isOpened: isOpened,
+        setIsOpened: setIsOpened,
+        isFocused: isFocused,
+        setIsFocused: setIsFocused,
+        hoveredId: hoveredId,
+        setHoveredId: setHoveredId,
+        selectedIds: selectedIds,
+        setSelectedIds: setSelectedIds,
+        selectedItems: selectedItems
+    };
+}
+exports["default"] = useDataSelect;

package/dist/hooks/useDispatch.d.ts

@@ -0,0 +1 @@
+export default function useDispatch(): any;

package/dist/hooks/useDispatch.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+var react_redux_1 = require("react-redux");
+function useDispatch() {
+    return react_redux_1.useDispatch();
+}
+exports["default"] = useDispatch;

package/dist/hooks/useFetch.d.ts

@@ -0,0 +1,39 @@
+import { IComponents } from '../providers/ComponentsProvider';
+import { IApiMethod } from '../components/ApiComponent';
+declare global {
+    interface Window {
+        APP_PRELOADED_DATA: any;
+    }
+}
+export interface IFetchConfig {
+    id?: string | number;
+    url?: string | IApiMethod;
+    method?: 'get' | 'post' | string;
+    params?: Record<string, unknown>;
+    onFetch?: (config: IFetchConfig, components: IComponents, addCancelToken: (token: any) => any) => any;
+}
+export interface IFetchResult {
+    data?: {
+        providerData?: {
+            type: string;
+            value: string;
+        };
+        [key: string]: unknown;
+    };
+    isLoading: boolean;
+    fetch?: (newParams?: Record<string, unknown>) => void;
+}
+export declare const normalizeConfig: (config: any) => any;
+export declare const getConfigId: (config: any) => any;
+export declare const defaultFetchHandler: (config: any, components: any, addCancelToken: any) => any;
+export declare const fetchData: (config: any, components: any, addCancelToken: any) => any;
+/**
+ * Fetch
+ * Используется для подгрузки данных с бекенда перед рендером компонента, на котором он применяется.
+ * На вход ему передается один или несколько объектов конфигураций (id, key, url, method, params, ...),
+ * которые описывают откуда нужно подтянуть данные.
+ *
+ * В процесс загрузки HOC будет отображать "Загрузка...", а после уже отрендерит компонент, передав данные в указанный
+ * ключ `key`.
+ */
+export default function useFetch(rawConfig?: IFetchConfig): IFetchResult;

package/dist/hooks/useFetch.js

@@ -0,0 +1,155 @@
+"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 __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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.fetchData = exports.defaultFetchHandler = exports.getConfigId = exports.normalizeConfig = void 0;
+var react_1 = require("react");
+var react_use_1 = require("react-use");
+var trim_1 = __importDefault(require("lodash-es/trim"));
+var axios_1 = __importDefault(require("axios"));
+var index_1 = require("./index");
+var normalizeConfig = function (config) { return (config
+    ? __assign({ id: null, url: '', method: 'get', params: {}, options: null, onFetch: null }, config) : null); };
+exports.normalizeConfig = normalizeConfig;
+var getConfigId = function (config) {
+    if (config === null) {
+        return null;
+    }
+    var result = trim_1["default"](config.id || config.url, '/');
+    if (!result) {
+        // eslint-disable-next-line no-console
+        console.warn('Please set id for fetch config, it`s necessary for SSR to work properly');
+    }
+    return result;
+};
+exports.getConfigId = getConfigId;
+var defaultFetchHandler = function (config, components, addCancelToken) {
+    var cancelToken = new axios_1["default"].CancelToken(function (cancel) {
+        addCancelToken(cancel);
+    });
+    if (typeof config.url === 'function') {
+        return config.url(components.api, config.params, config.options).then(function (result) { return result.data; });
+    }
+    return components.http
+        .send(config.method, config.url, config.params, __assign(__assign({}, config.options), { cancelToken: cancelToken }))
+        .then(function (result) { return result.data; });
+};
+exports.defaultFetchHandler = defaultFetchHandler;
+var fetchData = function (config, components, addCancelToken) { return ((config.onFetch || exports.defaultFetchHandler).call(null, config, components, addCancelToken)); };
+exports.fetchData = fetchData;
+/**
+ * Fetch
+ * Используется для подгрузки данных с бекенда перед рендером компонента, на котором он применяется.
+ * На вход ему передается один или несколько объектов конфигураций (id, key, url, method, params, ...),
+ * которые описывают откуда нужно подтянуть данные.
+ *
+ * В процесс загрузки HOC будет отображать "Загрузка...", а после уже отрендерит компонент, передав данные в указанный
+ * ключ `key`.
+ */
+function useFetch(rawConfig) {
+    var _this = this;
+    if (rawConfig === void 0) { rawConfig = null; }
+    var components = index_1.useComponents();
+    // Store config in state
+    var _a = react_1.useState(exports.normalizeConfig(rawConfig)), config = _a[0], setConfig = _a[1];
+    // Update config in state on raw config updated
+    react_use_1.useUpdateEffect(function () {
+        setConfig(rawConfig);
+    }, [rawConfig]);
+    // Get preloaded data
+    var configId = exports.getConfigId(config);
+    var ssrValueContext = index_1.useSsr();
+    var preloadedData = process.env.IS_SSR ? ssrValueContext.preloadedData : window.APP_PRELOADED_DATA;
+    var preloadedDataByConfigId = (preloadedData && configId) ? preloadedData[configId] : null;
+    // State for data and loading flag
+    var _b = react_1.useState(preloadedDataByConfigId || null), data = _b[0], setData = _b[1];
+    var _c = react_1.useState(!!config && !data), isLoading = _c[0], setIsLoading = _c[1];
+    // Cancel tokens
+    var cancelTokens = react_1.useRef([]);
+    var addCancelToken = function (token) { return cancelTokens.current.push(token); };
+    react_use_1.useUnmount(function () { return cancelTokens.current.forEach(function (cancel) { return cancel('Canceled on unmount component'); }); });
+    // Fetch handler
+    var fetch = react_1.useCallback(function (newConfig) {
+        if (newConfig === void 0) { newConfig = null; }
+        return __awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (newConfig) {
+                            setConfig(__assign(__assign(__assign({}, config), newConfig), { params: __assign(__assign({}, config === null || config === void 0 ? void 0 : config.params), newConfig === null || newConfig === void 0 ? void 0 : newConfig.params) }));
+                        }
+                        setData(null);
+                        if (!config) return [3 /*break*/, 2];
+                        setIsLoading(true);
+                        _a = setData;
+                        return [4 /*yield*/, exports.fetchData(config, components, addCancelToken)];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]);
+                        setIsLoading(false);
+                        _b.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    }, [components, config]);
+    react_use_1.useEffectOnce(function () {
+        if (!data) {
+            fetch();
+        }
+    });
+    // Fetch data on config update
+    react_use_1.useUpdateEffect(function () {
+        fetch();
+    }, [fetch]);
+    return { data: data, isLoading: isLoading, fetch: fetch };
+}
+exports["default"] = useFetch;

package/dist/hooks/useFile.d.ts

@@ -0,0 +1,2 @@
+import { IFileHocInput, IFileHocOutput } from '../hoc/file';
+export default function useFile(props: IFileHocInput): IFileHocOutput;

package/dist/hooks/useFile.js

@@ -0,0 +1,206 @@
+"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("../hooks/useInitial"));
+var index_1 = require("../hooks/index");
+var imagesMimeTypes = [
+    'image/gif',
+    'image/jpeg',
+    'image/pjpeg',
+    'image/png',
+];
+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 uploader = useInitial_1["default"](function () { return new fileup_core_1["default"](__assign(__assign({ dropArea: {}, backendUrl: generateBackendUrl(props) }, 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) {
+            uploader.queue.add([].concat(initialFiles || [])
+                .filter(function (item) { return !!item.uid; })
+                .map(function (item) { return new File_1["default"]({
+                path: item.title || item.label || item.uid || item.id,
+                status: File_1["default"].STATUS_END,
+                result: File_1["default"].RESULT_SUCCESS,
+                resultHttpStatus: 200,
+                resultHttpMessage: {
+                    id: item.id || item.uid,
+                    images: item.thumbnailUrl
+                        ? [{ url: item.thumbnailUrl }]
+                        : null
+                },
+                uid: item.uid
+            }); }));
+            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 = 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);
+        }
+    };
+    /**
+     * Triggered by queue when file is removed from it
+     * @param {File[]} removedFiles
+     * @private
+     */
+    var onQueueRemove = 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();
+    };
+    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);
+        uploader.queue.on(QueueCollection_1["default"].EVENT_ITEM_END, onQueueItemEnd);
+        uploader.queue.on(QueueCollection_1["default"].EVENT_REMOVE, onQueueRemove);
+    });
+    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);
+        uploader.queue.off(QueueCollection_1["default"].EVENT_ITEM_END, onQueueItemEnd);
+        uploader.queue.off(QueueCollection_1["default"].EVENT_REMOVE, onQueueRemove);
+    });
+    // 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 (!isEqual_1["default"](prevInputValue !== props.input.value)) {
+            var toRemove_1 = difference_1["default"]([].concat(props.input.value || []), [].concat(prevInputValue || []));
+            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]);
+    /**
+     * 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/dist/hooks/useForm.d.ts

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

package/dist/hooks/useForm.js

@@ -0,0 +1,18 @@
+"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,
+            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/dist/hooks/useInitial.d.ts

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

package/dist/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;