@steroidsjs/core 3.0.0-beta.1 → 3.0.0-beta.100

package/ui/content/Kanban/enums/KanbanPrioritiesEnum.js

@@ -0,0 +1,78 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var find_1 = __importDefault(require("lodash-es/find"));
+var Enum_1 = __importDefault(require("../../../../base/Enum"));
+var KanbanPrioritiesEnum = /** @class */ (function (_super) {
+    __extends(KanbanPrioritiesEnum, _super);
+    function KanbanPrioritiesEnum() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    KanbanPrioritiesEnum.getLabels = function () {
+        var _a;
+        return _a = {},
+            _a[this.HIGH] = __('Высокий'),
+            _a[this.MIDDLE] = __('Средний'),
+            _a[this.DEFAULT] = __('Без приоритета'),
+            _a;
+    };
+    KanbanPrioritiesEnum.getLabel = function (id) {
+        return this.getLabels()[id || this.DEFAULT] || '';
+    };
+    KanbanPrioritiesEnum.getColorsByType = function () {
+        var _a;
+        return _a = {},
+            _a[this.HIGH] = 'danger',
+            _a[this.MIDDLE] = 'warning',
+            _a[this.DEFAULT] = 'light-gray',
+            _a;
+    };
+    KanbanPrioritiesEnum.getColorByType = function (type) {
+        return this.getColorsByType()[type || this.DEFAULT] || '';
+    };
+    KanbanPrioritiesEnum.getPrioritiesArray = function () {
+        return [
+            {
+                id: 1,
+                type: this.HIGH
+            },
+            {
+                id: 2,
+                type: this.MIDDLE
+            },
+            {
+                id: 3,
+                type: this.DEFAULT
+            },
+        ];
+    };
+    KanbanPrioritiesEnum.getPriorityById = function (id) {
+        return (0, find_1["default"])(this.getPrioritiesArray(), { id: id }) || null;
+    };
+    KanbanPrioritiesEnum.getDefaultSelectedPriorityId = function () {
+        var defaultPriority = (0, find_1["default"])(this.getPrioritiesArray(), { type: this.DEFAULT });
+        return defaultPriority ? defaultPriority.id : null;
+    };
+    KanbanPrioritiesEnum.HIGH = 'high';
+    KanbanPrioritiesEnum.MIDDLE = 'middle';
+    KanbanPrioritiesEnum.DEFAULT = 'default';
+    return KanbanPrioritiesEnum;
+}(Enum_1["default"]));
+exports["default"] = KanbanPrioritiesEnum;

package/ui/content/Kanban/enums/index.d.ts

@@ -0,0 +1,3 @@
+import KanbanPrioritiesEnum from './KanbanPrioritiesEnum';
+import KanbanModalTypeEnum from './KanbanModalTypeEnum';
+export { KanbanPrioritiesEnum, KanbanModalTypeEnum, };

package/ui/content/Kanban/enums/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.KanbanModalTypeEnum = exports.KanbanPrioritiesEnum = void 0;
+var KanbanPrioritiesEnum_1 = __importDefault(require("./KanbanPrioritiesEnum"));
+exports.KanbanPrioritiesEnum = KanbanPrioritiesEnum_1["default"];
+var KanbanModalTypeEnum_1 = __importDefault(require("./KanbanModalTypeEnum"));
+exports.KanbanModalTypeEnum = KanbanModalTypeEnum_1["default"];

package/ui/content/Kanban/hooks/index.d.ts

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

package/ui/content/Kanban/hooks/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.useKanban = void 0;
+var useKanban_1 = __importDefault(require("./useKanban"));
+exports.useKanban = useKanban_1["default"];

package/ui/content/Kanban/hooks/useKanban.d.ts

@@ -0,0 +1,70 @@
+import { IDragEndResult, IKanbanColumn, IKanbanTask, ITaskAssigner, ITaskTag } from '../Kanban';
+export interface IKanbanConfig {
+    /**
+     * Идентификатор канбан доски
+     * @example TasksKanban
+     */
+    kanbanId?: string;
+    /**
+     * Коллекция с наименованиями и свойствами колонок в таблице
+     * @example [
+     *             {
+     *              id: 1,
+     *              title: 'column 1',
+     *              tasks: [{ content: 'item 1', id: 1 }],
+     *             },
+     *             {
+     *              id: 2,
+     *              title: 'column 2',
+     *              tasks: [],
+     *             }
+     *          ]
+     */
+    columns: IKanbanColumn[];
+    /**
+     * Массив тегов для задач
+     */
+    tags?: ITaskTag[];
+    /**
+     * Массив исполнителей, которых можно назначить для выполнения задачи
+     */
+    assigners?: ITaskAssigner[];
+    /**
+     * Обработчик события окончания перетаскивания карточки или колонки
+     * В result передается объект с информацией о событии
+     * @example {
+     *     draggableId: 1,
+     *     type: 'task',
+     *     source: {
+     *         index: 0,
+     *         droppableId: 2
+     *     },
+     *     reason: 'DROP',
+     *     mode: 'FLUID',
+     *     destination: {
+     *         droppableId: 2,
+     *         index: 1
+     *     },
+     *     combine: null
+     * }
+     */
+    onDragEnd?: (result: IDragEndResult) => void;
+    /**
+     * Обработчик события создания карточки
+     */
+    onCreateTask?: (kanbanId: string, columnId: number, task: IKanbanTask) => void;
+    /**
+     * Обработчик события редактирования карточки
+     */
+    onEditTask?: (kanbanId: string, columnId: number, task: IKanbanTask) => void;
+    /**
+     * Идентификатор последней созданной задачи, нужен для определения последовательности id для новых задач
+     */
+    lastTaskId?: number;
+}
+export default function useKanban(config: IKanbanConfig): {
+    columns: any;
+    onDragEnd: (result: any) => void;
+    onOpenTaskDetailsModal: (task: any, columnId: any) => void;
+    onOpenCreateTaskModal: (columnId: any) => void;
+};

package/ui/content/Kanban/hooks/useKanban.js

@@ -0,0 +1,174 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+exports.__esModule = true;
+var react_1 = __importStar(require("react"));
+var react_use_1 = require("react-use");
+var modal_1 = require("../../../../actions/modal");
+var hooks_1 = require("../../../../hooks");
+var enums_1 = require("../enums");
+var reducers_1 = require("../reducers");
+var actions_1 = require("../actions");
+var modalAndFormIds_1 = require("../constants/modalAndFormIds");
+var COLUMNS_DROPPABLE_ID = 'all-columns';
+var INITIAL_TASK_ID = 1;
+var normalizeAssignersForDropDownItems = function (assigners) { return assigners.map(function (assigner) {
+    var _a, _b;
+    return ({
+        id: assigner.id,
+        label: "".concat(assigner.firstName || '', " ").concat(assigner.lastName || ''),
+        contentType: assigner.avatar ? 'img' : 'icon',
+        contentSrc: (_b = (_a = assigner.avatar) === null || _a === void 0 ? void 0 : _a.src) !== null && _b !== void 0 ? _b : 'user'
+    });
+}); };
+var normalizeEditTaskFormForState = function (id, data, assigners, tags) { return ({
+    id: id,
+    title: data.title || '',
+    description: data.description || '',
+    fullDescription: data.fullDescription || '',
+    priority: enums_1.KanbanPrioritiesEnum.getPriorityById(data.priority),
+    assigner: assigners.find(function (user) { return user.id === data.assigner; }) || null,
+    tags: data.tags && tags && tags.filter(function (tag) { return data.tags.includes(tag.id); })
+}); };
+function useKanban(config) {
+    var _a = (0, hooks_1.useSelector)(function (state) { return ({
+        kanban: (0, reducers_1.getKanban)(state, config.kanbanId),
+        lastTaskId: (0, reducers_1.getLastTaskId)(state, config.kanbanId),
+        tags: (0, reducers_1.getKanbanTags)(state, config.kanbanId)
+    }); }), kanban = _a.kanban, lastTaskId = _a.lastTaskId, tags = _a.tags;
+    var dispatch = (0, hooks_1.useDispatch)();
+    // move card
+    var moveCard = (0, react_1.useCallback)(function (source, destination) {
+        dispatch((0, actions_1.kanbanMoveTask)(config.kanbanId, source, destination));
+    }, [config.kanbanId, dispatch]);
+    // move column
+    var moveColumn = (0, react_1.useCallback)(function (source, destination) {
+        dispatch((0, actions_1.kanbanMoveColumn)(config.kanbanId, source, destination));
+    }, [config.kanbanId, dispatch]);
+    var components = (0, hooks_1.useComponents)();
+    var onCreateTask = react_1["default"].useCallback(function (_, data) {
+        var newTaskId = lastTaskId ? lastTaskId + 1 : INITIAL_TASK_ID;
+        var newTask = normalizeEditTaskFormForState(newTaskId, data, config.assigners, tags);
+        if (config.onCreateTask) {
+            config.onCreateTask(config.kanbanId, data.columnId, newTask);
+        }
+        var toDispatch = [
+            (0, actions_1.kanbanAddTask)(config.kanbanId, data.columnId, newTask),
+            (0, actions_1.kanbanIncreaseTaskId)(config.kanbanId, newTaskId),
+            (0, modal_1.closeModal)(modalAndFormIds_1.CREATE_TASK_MODAL_ID),
+        ];
+        dispatch(toDispatch);
+    }, [config, dispatch, lastTaskId, tags]);
+    var onEditTask = react_1["default"].useCallback(function (id, data, prevColumnId) {
+        var editedTask = normalizeEditTaskFormForState(id, data, config.assigners, tags);
+        if (config.onEditTask) {
+            config.onEditTask(config.kanbanId, data.columnId, editedTask);
+        }
+        var toDispatch = [
+            (0, actions_1.kanbanEditTask)(config.kanbanId, data.columnId, prevColumnId, editedTask),
+            (0, modal_1.closeModal)(modalAndFormIds_1.EDIT_TASK_MODAL_ID),
+        ];
+        dispatch(toDispatch);
+    }, [config, dispatch, tags]);
+    // common modal
+    var KanbanModalView = components.ui.getView('content.KanbanModalView');
+    var createOrEditTaskCommonModalProps = react_1["default"].useMemo(function () { return ({
+        columns: kanban === null || kanban === void 0 ? void 0 : kanban.columns,
+        assigners: normalizeAssignersForDropDownItems(config.assigners || []),
+        tags: tags
+    }); }, [config.assigners, kanban === null || kanban === void 0 ? void 0 : kanban.columns, tags]);
+    // create task modal
+    var onOpenCreateTaskModal = react_1["default"].useCallback(function (columnId) {
+        if (columnId) {
+            dispatch((0, modal_1.openModal)(KanbanModalView, __assign(__assign({}, createOrEditTaskCommonModalProps), { modalId: modalAndFormIds_1.CREATE_TASK_MODAL_ID, modalType: enums_1.KanbanModalTypeEnum.CREATE, title: enums_1.KanbanModalTypeEnum.getLabel(enums_1.KanbanModalTypeEnum.CREATE), formId: modalAndFormIds_1.CREATE_TASK_FORM_ID, columnId: columnId, onSubmit: onCreateTask })));
+        }
+    }, [KanbanModalView, createOrEditTaskCommonModalProps, dispatch, onCreateTask]);
+    // task details modal
+    var onOpenTaskDetailsModal = react_1["default"].useCallback(function (task, columnId) {
+        if (task && columnId) {
+            dispatch((0, modal_1.openModal)(KanbanModalView, {
+                modalId: modalAndFormIds_1.EDIT_TASK_MODAL_ID,
+                modalType: enums_1.KanbanModalTypeEnum.DETAILS,
+                title: "#".concat(task.id, " ").concat(task.title),
+                task: task,
+                tags: tags,
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                onToggleModalType: function () { return onOpenEditTaskModal(task, columnId); }
+            }));
+        }
+    }, [KanbanModalView, dispatch, kanban]);
+    // edit task modal
+    var onOpenEditTaskModal = react_1["default"].useCallback(function (task, columnId) {
+        if (task && columnId) {
+            dispatch((0, modal_1.openModal)(KanbanModalView, __assign(__assign({}, createOrEditTaskCommonModalProps), { modalId: modalAndFormIds_1.EDIT_TASK_MODAL_ID, modalType: enums_1.KanbanModalTypeEnum.EDIT, title: enums_1.KanbanModalTypeEnum.getLabel(enums_1.KanbanModalTypeEnum.EDIT), formId: modalAndFormIds_1.EDIT_TASK_FORM_ID, columnId: columnId, onSubmit: onEditTask, onToggleModalType: function () { return onOpenTaskDetailsModal(task, columnId); } })));
+        }
+    }, [KanbanModalView, createOrEditTaskCommonModalProps, dispatch, onEditTask, onOpenTaskDetailsModal]);
+    var onDragEnd = function (result) {
+        if (config.onDragEnd) {
+            config.onDragEnd(result);
+        }
+        // drop outside the column
+        if (!result.destination) {
+            return;
+        }
+        var source = result.source, destination = result.destination;
+        if (source.droppableId === COLUMNS_DROPPABLE_ID) {
+            // handle the column movement
+            moveColumn(source, destination);
+        }
+        else {
+            // handle the task card movement
+            moveCard(source, destination);
+        }
+    };
+    // Init kanban in redux store
+    (0, react_use_1.useMount)(function () {
+        if (!kanban) {
+            dispatch((0, actions_1.kanbanInit)(config.kanbanId, {
+                kanbanId: config.kanbanId,
+                columns: config.columns || null,
+                tags: config.tags || null,
+                lastTaskId: config.lastTaskId || null
+            }));
+        }
+    });
+    return {
+        columns: kanban === null || kanban === void 0 ? void 0 : kanban.columns,
+        onDragEnd: onDragEnd,
+        onOpenTaskDetailsModal: onOpenTaskDetailsModal,
+        onOpenCreateTaskModal: onOpenCreateTaskModal
+    };
+}
+exports["default"] = useKanban;

package/ui/content/Kanban/index.d.ts

@@ -0,0 +1,2 @@
+import Kanban from './Kanban';
+export default Kanban;

package/ui/content/Kanban/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var Kanban_1 = __importDefault(require("./Kanban"));
+exports["default"] = Kanban_1["default"];

package/ui/content/Kanban/reducers/index.d.ts

@@ -0,0 +1,3 @@
+import kanban, { getKanban, getLastTaskId, getKanbanTags } from './kanban';
+export { getKanban, getLastTaskId, getKanbanTags };
+export default kanban;

package/ui/{form/DateTimeRangeField/demo/disabled.js → content/Kanban/reducers/index.js}

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -18,15 +22,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 exports.__esModule = true;
-var React = __importStar(require("react"));
-var DateTimeRangeField_1 = __importDefault(require("../DateTimeRangeField"));
-/**
- * Оключён и без рамок
- * @order 2
- * @col 6
- */
-exports["default"] = (function () { return (React.createElement(DateTimeRangeField_1["default"], { disabled: true, noBorder: true })); });
+exports.getKanbanTags = exports.getLastTaskId = exports.getKanban = void 0;
+var kanban_1 = __importStar(require("./kanban"));
+exports.getKanban = kanban_1.getKanban;
+exports.getLastTaskId = kanban_1.getLastTaskId;
+exports.getKanbanTags = kanban_1.getKanbanTags;
+exports["default"] = kanban_1["default"];

package/ui/content/Kanban/reducers/kanban.d.ts

@@ -0,0 +1,8 @@
+export declare const getKanbanColumns: (state: any, kanbanId: any) => any;
+declare const _default: (state: {
+    kanbans: {};
+}, action: any) => any;
+export default _default;
+export declare const getKanban: (state: any, kanbanId: any) => any;
+export declare const getLastTaskId: (state: any, kanbanId: any) => any;
+export declare const getKanbanTags: (state: any, kanbanId: any) => any;

package/ui/content/Kanban/reducers/kanban.js

@@ -0,0 +1,120 @@
+"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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+exports.__esModule = true;
+exports.getKanbanTags = exports.getLastTaskId = exports.getKanban = exports.getKanbanColumns = void 0;
+var get_1 = __importDefault(require("lodash-es/get"));
+var actions_1 = require("../actions");
+var initialState = {
+    kanbans: {}
+};
+var getKanbanColumns = function (state, kanbanId) { return (0, get_1["default"])(state, ['kanbans', kanbanId, 'columns']) || []; };
+exports.getKanbanColumns = getKanbanColumns;
+var reducerMap = (_a = {},
+    _a[actions_1.KANBAN_INIT] = function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { kanbans: __assign(__assign({}, state.kanbans), (_a = {}, _a[action.payload.kanbanId] = __assign({}, action.payload), _a)) }));
+    },
+    _a[actions_1.KANBAN_MOVE_TASK] = function (state, action) {
+        var _a;
+        if (state.kanbans[action.kanbanId]) {
+            var columns = (0, exports.getKanbanColumns)(state, action.kanbanId);
+            var sourceColumn = columns.find(function (column) { return column.id === Number(action.source.droppableId); });
+            var sourceTasks = sourceColumn.tasks;
+            var removedTask = sourceTasks.splice(action.source.index, 1)[0];
+            // move task to different column
+            if (action.source.droppableId !== action.destination.droppableId) {
+                var destinationColumn = columns.find(function (column) { return column.id === Number(action.destination.droppableId); });
+                var destinationTasks = destinationColumn.tasks;
+                destinationTasks.splice(action.destination.index, 0, removedTask);
+            }
+            else {
+                sourceTasks.splice(action.destination.index, 0, removedTask);
+            }
+            return __assign(__assign({}, state), { kanbans: __assign(__assign({}, state.kanbans), (_a = {}, _a[action.kanbanId] = __assign(__assign({}, state.kanbans[action.kanbanId]), { columns: __spreadArray([], columns, true) }), _a)) });
+        }
+        return [];
+    },
+    _a[actions_1.KANBAN_MOVE_COLUMN] = function (state, action) {
+        var _a;
+        if (state.kanbans[action.kanbanId]) {
+            var columns = (0, exports.getKanbanColumns)(state, action.kanbanId);
+            var removedColumn = columns.splice(action.source.index, 1)[0];
+            columns.splice(action.destination.index, 0, removedColumn);
+            return __assign(__assign({}, state), { kanbans: __assign(__assign({}, state.kanbans), (_a = {}, _a[action.kanbanId] = __assign(__assign({}, state.kanbans[action.kanbanId]), { columns: __spreadArray([], columns, true) }), _a)) });
+        }
+        return [];
+    },
+    _a[actions_1.KANBAN_ADD_TASK] = function (state, action) {
+        var _a;
+        if (state.kanbans[action.kanbanId]) {
+            var columns = (0, exports.getKanbanColumns)(state, action.kanbanId);
+            var sourceColumn = columns.find(function (column) { return column.id === action.columnId; });
+            var sourceTasks = sourceColumn.tasks;
+            sourceTasks.unshift(action.task);
+            return __assign(__assign({}, state), { kanbans: __assign(__assign({}, state.kanbans), (_a = {}, _a[action.kanbanId] = __assign(__assign({}, state.kanbans[action.kanbanId]), { columns: __spreadArray([], columns, true) }), _a)) });
+        }
+        return [];
+    },
+    _a[actions_1.KANBAN_EDIT_TASK] = function (state, action) {
+        var _a;
+        if (state.kanbans[action.kanbanId]) {
+            var columns = (0, exports.getKanbanColumns)(state, action.kanbanId);
+            var sourceColumn = columns.find(function (column) { return column.tasks.find(function (task) { return task.id === action.task.id; }); });
+            var sourceTasks = sourceColumn.tasks;
+            // move to different column
+            if (action.columnId !== action.prevColumnId) {
+                var destinationColumn = columns.find(function (column) { return column.id === action.columnId; });
+                var destinationTasks = destinationColumn.tasks;
+                var taskIndex = sourceTasks.findIndex(function (task) { return task.id === action.task.id; });
+                var removedTask = sourceTasks.splice(taskIndex, 1)[0];
+                destinationTasks.unshift(removedTask);
+                Object.assign(removedTask, action.task);
+            }
+            else {
+                var sourceTask = sourceTasks.find(function (task) { return task.id === action.task.id; });
+                Object.assign(sourceTask, action.task);
+            }
+            return __assign(__assign({}, state), { kanbans: __assign(__assign({}, state.kanbans), (_a = {}, _a[action.kanbanId] = __assign(__assign({}, state.kanbans[action.kanbanId]), { columns: __spreadArray([], columns, true) }), _a)) });
+        }
+        return [];
+    },
+    _a[actions_1.KANBAN_INCREASE_TASK_ID] = function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { kanbans: __assign(__assign({}, state.kanbans), (_a = {}, _a[action.kanbanId] = __assign(__assign({}, state.kanbans[action.kanbanId]), { lastTaskId: action.lastTaskId }), _a)) }));
+    },
+    _a);
+exports["default"] = (function (state, action) {
+    if (state === void 0) { state = initialState; }
+    return reducerMap[action.type]
+        ? reducerMap[action.type](state, action)
+        : state;
+});
+var getKanban = function (state, kanbanId) { return (0, get_1["default"])(state, ['kanban', 'kanbans', kanbanId]) || null; };
+exports.getKanban = getKanban;
+var getLastTaskId = function (state, kanbanId) { return (0, get_1["default"])(state, ['kanban', 'kanbans', kanbanId, 'lastTaskId']) || null; };
+exports.getLastTaskId = getLastTaskId;
+var getKanbanTags = function (state, kanbanId) { return (0, get_1["default"])(state, ['kanban', 'kanbans', kanbanId, 'tags']) || null; };
+exports.getKanbanTags = getKanbanTags;

package/ui/content/Menu/Menu.d.ts

@@ -0,0 +1,56 @@
+import React from 'react';
+import { IDropDownProps } from '../DropDown/DropDown';
+export interface IMenuItem {
+    /**
+     * Заголовок элемента меню
+     */
+    label: string;
+    /**
+     * Функция вызываемая при клике
+     */
+    onClick: VoidFunction;
+    /**
+     * Кастомная иконка
+     */
+    icon?: string | React.ReactElement;
+    /**
+     * Нижний border
+     */
+    hasBorder?: boolean;
+}
+/**
+ * Menu
+ *
+ * Компонент-меню позволяет создавать выпадающие списки с элементами, которые могут быть выбраны
+ * или выполнить определенные действия при клике на них.
+ *
+ * Компонент `Menu` обычно используется для создания навигационных меню или контекстных меню,
+ * где пользователь может выбирать опции или выполнять определенные действия в зависимости от выбранного элемента.
+ *
+ * Компонент `Menu` принимает массив `items`, каждый элемент которого представляет собой отдельный пункт меню.
+ * Каждый пункт меню имеет заголовок `label`, функцию `onClick`, которая будет вызываться при клике на элемент,
+ * кастомную иконку `icon` (необязательно) и флаг `hasBorder`, определяющий наличие нижней границы у элемента.
+ *
+ * Примечание: Компонент `Menu` требует указания хотя бы одного элемента меню в свойстве `items`.
+ */
+export interface IMenuProps extends IUiComponent {
+    /**
+    *   Элементы меню
+    */
+    items: IMenuItem[];
+    /**
+    * Кастомная иконка, по клику на которую открывается меню
+    */
+    icon?: string | React.ReactElement;
+    /**
+     * Пропсы для DropDown
+     */
+    dropDownProps?: IDropDownProps;
+    /**
+     * Переопределение view React элемента меню для кастомизации отображения
+     */
+    itemView?: CustomView | any;
+}
+export type IMenuViewProps = IMenuProps;
+declare function Menu(props: IMenuProps): JSX.Element;
+export default Menu;

package/ui/content/Menu/Menu.js

@@ -0,0 +1,23 @@
+"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 useComponents_1 = __importDefault(require("../../../hooks/useComponents"));
+function Menu(props) {
+    var components = (0, useComponents_1["default"])();
+    var MenuItemView = components.ui.getView(props.itemView || 'content.MenuItemView');
+    return components.ui.renderView(props.view || 'content.MenuView', __assign(__assign({}, props), { itemView: MenuItemView }));
+}
+exports["default"] = Menu;

package/ui/content/Menu/index.d.ts

@@ -0,0 +1,2 @@
+import Menu from './Menu';
+export default Menu;

package/ui/content/Menu/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var Menu_1 = __importDefault(require("./Menu"));
+exports["default"] = Menu_1["default"];

package/ui/content/Slider/Slider.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { Options, SplideProps } from '@splidejs/react-splide';
+/**
+ * Slider
+ *
+ * Компонент слайдера позволяет создавать слайдшоу, где элементы могут быть пролистаны
+ * с помощью прокрутки или перетаскивания.
+ **/
+export interface ISliderProps extends IUiComponent, Omit<SplideProps, 'items'> {
+    /**
+     * Опции слайдера.
+     */
+    sliderOptions: Options;
+    /**
+     * Элементы слайдера.
+     */
+    items: Record<string, any>[];
+    /**
+     * Представление элемента слайдера.
+     */
+    itemView: CustomView | any;
+    /**
+     * Дополнительные свойства.
+     */
+    [key: string]: any;
+}
+export type ISliderViewProps = ISliderProps;
+export default function Slider(props: ISliderProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;