@adaptabletools/adaptable 17.0.6 → 18.0.0-canary.0

package/src/Redux/ActionsReducers/ChartingRedux.js

@@ -1,108 +1,95 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChartingReducer = exports.ChartingGetExternalChartDefinitions = exports.ChartingGetChartModels = exports.initialState = exports.ChartingDeleteExternalChart = exports.ChartingAddExternalChart = exports.ChartingEditExternalChart = exports.ChartingDeleteChart = exports.ChartingAddChart = exports.ChartingEditChart = exports.ChartingReady = exports.ChartingSetChartModels = exports.CHARTING_DELETE_EXTERNAL_CHART = exports.CHARTING_ADD_EXTERNAL_CHART = exports.CHARTING_EDIT_EXTERNAL_CHART = exports.CHARTING_DELETE_CHART = exports.CHARTING_ADD_CHART = exports.CHARTING_EDIT_CHART = exports.CHARTING_READY = exports.SET_CHARTING_CHARTS = void 0;
-const Uuid_1 = require("../../PredefinedConfig/Uuid");
-const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
+import { createUuid } from '../../PredefinedConfig/Uuid';
+import { EMPTY_ARRAY } from '../../Utilities/Constants/GeneralConstants';
 /**
  * @ReduxAction Set AG Grid Charting Models
  */
-exports.SET_CHARTING_CHARTS = 'SET_CHARTING_CHARTS';
+export const SET_CHARTING_CHARTS = 'SET_CHARTING_CHARTS';
 /**
  * @ReduxAction Charting Module is ready
  */
-exports.CHARTING_READY = 'CHARTING_READY';
+export const CHARTING_READY = 'CHARTING_READY';
 /**
  * @ReduxAction Edit chart definition
  */
-exports.CHARTING_EDIT_CHART = 'CHARTING_EDIT_CHART';
+export const CHARTING_EDIT_CHART = 'CHARTING_EDIT_CHART';
 /**
  * @ReduxAction Add chart definition
  */
-exports.CHARTING_ADD_CHART = 'CHARTING_ADD_CHART';
+export const CHARTING_ADD_CHART = 'CHARTING_ADD_CHART';
 /**
  * @ReduxAction Deelte chart definition
  */
-exports.CHARTING_DELETE_CHART = 'CHARTING_DELETE_CHART';
+export const CHARTING_DELETE_CHART = 'CHARTING_DELETE_CHART';
 /**
  * @ReduxAction Edit chart definition
  */
-exports.CHARTING_EDIT_EXTERNAL_CHART = 'CHARTING_EDIT_EXTERNAL_CHART';
+export const CHARTING_EDIT_EXTERNAL_CHART = 'CHARTING_EDIT_EXTERNAL_CHART';
 /**
  * @ReduxAction Add chart definition
  */
-exports.CHARTING_ADD_EXTERNAL_CHART = 'CHARTING_ADD_EXTERNAL_CHART';
+export const CHARTING_ADD_EXTERNAL_CHART = 'CHARTING_ADD_EXTERNAL_CHART';
 /**
  * @ReduxAction Deelte chart definition
  */
-exports.CHARTING_DELETE_EXTERNAL_CHART = 'CHARTING_DELETE_EXTERNAL_CHART';
-const ChartingSetChartModels = (charts) => ({
+export const CHARTING_DELETE_EXTERNAL_CHART = 'CHARTING_DELETE_EXTERNAL_CHART';
+export const ChartingSetChartModels = (charts) => ({
     charts,
-    type: exports.SET_CHARTING_CHARTS,
+    type: SET_CHARTING_CHARTS,
 });
-exports.ChartingSetChartModels = ChartingSetChartModels;
-const ChartingReady = (chartingState) => ({
-    type: exports.CHARTING_READY,
+export const ChartingReady = (chartingState) => ({
+    type: CHARTING_READY,
     chartingState,
 });
-exports.ChartingReady = ChartingReady;
-const ChartingEditChart = (chartDefinition) => ({
-    type: exports.CHARTING_EDIT_CHART,
+export const ChartingEditChart = (chartDefinition) => ({
+    type: CHARTING_EDIT_CHART,
     chartDefinition,
 });
-exports.ChartingEditChart = ChartingEditChart;
-const ChartingAddChart = (chartDefinition) => ({
-    type: exports.CHARTING_ADD_CHART,
+export const ChartingAddChart = (chartDefinition) => ({
+    type: CHARTING_ADD_CHART,
     chartDefinition,
 });
-exports.ChartingAddChart = ChartingAddChart;
-const ChartingDeleteChart = (chartDefinition) => ({
-    type: exports.CHARTING_DELETE_CHART,
+export const ChartingDeleteChart = (chartDefinition) => ({
+    type: CHARTING_DELETE_CHART,
     chartDefinition,
 });
-exports.ChartingDeleteChart = ChartingDeleteChart;
-const ChartingEditExternalChart = (chartDefinition) => ({
-    type: exports.CHARTING_EDIT_EXTERNAL_CHART,
+export const ChartingEditExternalChart = (chartDefinition) => ({
+    type: CHARTING_EDIT_EXTERNAL_CHART,
     chartDefinition,
 });
-exports.ChartingEditExternalChart = ChartingEditExternalChart;
-const ChartingAddExternalChart = (chartDefinition) => ({
-    type: exports.CHARTING_ADD_EXTERNAL_CHART,
+export const ChartingAddExternalChart = (chartDefinition) => ({
+    type: CHARTING_ADD_EXTERNAL_CHART,
     chartDefinition,
 });
-exports.ChartingAddExternalChart = ChartingAddExternalChart;
-const ChartingDeleteExternalChart = (chartDefinition) => ({
-    type: exports.CHARTING_DELETE_EXTERNAL_CHART,
+export const ChartingDeleteExternalChart = (chartDefinition) => ({
+    type: CHARTING_DELETE_EXTERNAL_CHART,
     chartDefinition,
 });
-exports.ChartingDeleteExternalChart = ChartingDeleteExternalChart;
-exports.initialState = {
-    ChartDefinitions: GeneralConstants_1.EMPTY_ARRAY,
-    ExternalChartDefinitions: GeneralConstants_1.EMPTY_ARRAY,
+export const initialState = {
+    ChartDefinitions: EMPTY_ARRAY,
+    ExternalChartDefinitions: EMPTY_ARRAY,
 };
-const ChartingGetChartModels = (state) => { var _a; return (_a = state.Charting.ChartDefinitions) !== null && _a !== void 0 ? _a : []; };
-exports.ChartingGetChartModels = ChartingGetChartModels;
-const ChartingGetExternalChartDefinitions = (state) => { var _a; return (_a = state.Charting.ExternalChartDefinitions) !== null && _a !== void 0 ? _a : []; };
-exports.ChartingGetExternalChartDefinitions = ChartingGetExternalChartDefinitions;
-const ChartingReducer = (state = exports.initialState, action) => {
+export const ChartingGetChartModels = (state) => { var _a; return (_a = state.Charting.ChartDefinitions) !== null && _a !== void 0 ? _a : []; };
+export const ChartingGetExternalChartDefinitions = (state) => { var _a; return (_a = state.Charting.ExternalChartDefinitions) !== null && _a !== void 0 ? _a : []; };
+export const ChartingReducer = (state = initialState, action) => {
     switch (action.type) {
-        case exports.SET_CHARTING_CHARTS:
+        case SET_CHARTING_CHARTS:
             return Object.assign(Object.assign({}, state), { ChartDefinitions: action.charts });
-        case exports.CHARTING_EDIT_CHART:
+        case CHARTING_EDIT_CHART:
             return Object.assign(Object.assign({}, state), { ChartDefinitions: state.ChartDefinitions.map((chartDefinition) => {
                     if (chartDefinition.Uuid === action.chartDefinition.Uuid) {
                         return action.chartDefinition;
                     }
                     return chartDefinition;
                 }) });
-        case exports.CHARTING_ADD_CHART:
+        case CHARTING_ADD_CHART:
             let chartDefinition = action.chartDefinition;
             if (!('Uuid' in chartDefinition)) {
-                chartDefinition = Object.assign(Object.assign({}, chartDefinition), { Uuid: (0, Uuid_1.createUuid)() });
+                chartDefinition = Object.assign(Object.assign({}, chartDefinition), { Uuid: createUuid() });
             }
             return Object.assign(Object.assign({}, state), { ChartDefinitions: [...state.ChartDefinitions, chartDefinition] });
-        case exports.CHARTING_DELETE_CHART:
+        case CHARTING_DELETE_CHART:
             return Object.assign(Object.assign({}, state), { ChartDefinitions: state.ChartDefinitions.filter((chartDefinition) => chartDefinition.Name !== action.chartDefinition.Name) });
-        case exports.CHARTING_EDIT_EXTERNAL_CHART:
+        case CHARTING_EDIT_EXTERNAL_CHART:
             return Object.assign(Object.assign({}, state), { ExternalChartDefinitions: state.ExternalChartDefinitions.map((chartDefinition) => {
                     if (chartDefinition.Uuid ===
                         action.chartDefinition.Uuid) {
@@ -110,16 +97,15 @@ const ChartingReducer = (state = exports.initialState, action) => {
                     }
                     return chartDefinition;
                 }) });
-        case exports.CHARTING_ADD_EXTERNAL_CHART:
+        case CHARTING_ADD_EXTERNAL_CHART:
             let externalChartDefinition = action.chartDefinition;
             if (!('Uuid' in externalChartDefinition)) {
-                externalChartDefinition = Object.assign(Object.assign({}, externalChartDefinition), { Uuid: (0, Uuid_1.createUuid)() });
+                externalChartDefinition = Object.assign(Object.assign({}, externalChartDefinition), { Uuid: createUuid() });
             }
             return Object.assign(Object.assign({}, state), { ExternalChartDefinitions: [...state.ExternalChartDefinitions, externalChartDefinition] });
-        case exports.CHARTING_DELETE_EXTERNAL_CHART:
+        case CHARTING_DELETE_EXTERNAL_CHART:
             return Object.assign(Object.assign({}, state), { ExternalChartDefinitions: state.ExternalChartDefinitions.filter((chartDefinition) => chartDefinition.Name !==
                     action.chartDefinition.Name) });
     }
     return state;
 };
-exports.ChartingReducer = ChartingReducer;

package/src/Redux/ActionsReducers/CommentsRedux.d.ts

@@ -0,0 +1,79 @@
+import * as Redux from 'redux';
+import { CommentThread, AdaptableComment, CommentState } from '../../PredefinedConfig/CommentState';
+import { CellAddress } from '../../types';
+/**
+ * @ReduxAction A Comments has been added
+ */
+export declare const COMMENTS_ADD = "COMMENTS_ADD";
+/**
+ * @ReduxAction Cell Comments has been added
+ */
+export declare const COMMENTS_CELL_ADD = "COMMENTS_CELL_ADD";
+/**
+ * @ReduxAction Cell comments have been removed
+ */
+export declare const COMMENTS_CELL_DELETE = "COMMENTS_CELL_DELETE";
+/**
+ * @ReduxAction A Comments has been edited
+ */
+export declare const COMMENTS_EDIT = "COMMENTS_EDIT";
+/**
+ * @ReduxAction A Comments has been deleted
+ */
+export declare const COMMENTS_DELETE = "COMMENTS_DELETE";
+/**
+ * @ReduxAction Comments Module is ready
+ */
+export declare const COMMENTS_READY = "COMMENTS_READY";
+export declare const COMMENTS_LOAD = "COMMENTS_LOAD";
+export interface AdaptableCommentAction extends Redux.Action {
+    comment: AdaptableComment;
+    cellAddress: CellAddress;
+}
+export interface AdaptableCommentsAddAction extends AdaptableCommentAction {
+}
+export interface AdaptableCommentsCellAddAction extends Redux.Action {
+    commentThread: CommentThread;
+}
+export interface AdaptableCommentsSetAction extends Redux.Action {
+    commentThread: CommentThread[];
+}
+export interface AdaptableCommentsCellDeleteAction extends Redux.Action {
+    cellAddress: CellAddress;
+}
+export interface AdaptableCommentsEditAction extends AdaptableCommentAction {
+}
+export interface AdaptableCommentsDeleteAction extends Redux.Action {
+    commentUuid: AdaptableComment['Uuid'];
+    cellAddress: CellAddress;
+}
+export interface NoteReadyAction extends Redux.Action {
+    commentState: CommentState;
+}
+export declare const CommentsSet: ({ commentThread, }: {
+    commentThread: CommentThread[];
+}) => AdaptableCommentsSetAction;
+export declare const CommentsAdd: ({ comment, cellAddress, }: {
+    comment: AdaptableComment;
+    cellAddress: CellAddress;
+}) => AdaptableCommentsAddAction;
+export declare const CommentsCellAdd: ({ commentThread, }: {
+    commentThread: CommentThread;
+}) => AdaptableCommentsCellAddAction;
+export declare const CommentsCellDelete: ({ cellAddress: cellAddress, }: {
+    cellAddress: CellAddress;
+}) => AdaptableCommentsCellDeleteAction;
+export declare const CommentsEdit: ({ comment, cellAddress, }: {
+    comment: AdaptableComment;
+    cellAddress: CellAddress;
+}) => AdaptableCommentsEditAction;
+export declare const CommentsDelete: ({ commentUuid, cellAddress, }: {
+    commentUuid: AdaptableComment['Uuid'];
+    cellAddress: CellAddress;
+}) => AdaptableCommentsDeleteAction;
+export declare const CommentsReady: (commentstate: CommentState) => NoteReadyAction;
+export declare const GetGridCellCommentsSelector: (state: CommentState, address: CellAddress) => CommentThread;
+export declare const GetCommentsSelector: (state: CommentState, address: CellAddress) => AdaptableComment[] | undefined;
+export declare const GetGetCommentsByUuidSelector: (state: CommentState, uuid: string) => AdaptableComment | undefined;
+export declare const GetCellCommentSelector: (state: CommentState, address: CellAddress) => CommentThread | undefined;
+export declare const CommentsReducer: Redux.Reducer<CommentState>;

package/src/Redux/ActionsReducers/CommentsRedux.js

@@ -0,0 +1,173 @@
+import { EMPTY_ARRAY } from '../../Utilities/Constants/GeneralConstants';
+import ObjectFactory from '../../Utilities/ObjectFactory';
+import { CellPopupService } from '../../Utilities/Services/CellPopupService';
+/**
+ * @ReduxAction A Comments has been added
+ */
+export const COMMENTS_ADD = 'COMMENTS_ADD';
+/**
+ * @ReduxAction Cell Comments has been added
+ */
+export const COMMENTS_CELL_ADD = 'COMMENTS_CELL_ADD';
+/**
+ * @ReduxAction Cell comments have been removed
+ */
+export const COMMENTS_CELL_DELETE = 'COMMENTS_CELL_DELETE';
+/**
+ * @ReduxAction A Comments has been edited
+ */
+export const COMMENTS_EDIT = 'COMMENTS_EDIT';
+/**
+ * @ReduxAction A Comments has been deleted
+ */
+export const COMMENTS_DELETE = 'COMMENTS_DELETE';
+/**
+ * @ReduxAction Comments Module is ready
+ */
+export const COMMENTS_READY = 'COMMENTS_READY';
+export const COMMENTS_LOAD = 'COMMENTS_LOAD';
+export const CommentsSet = ({ commentThread, }) => ({
+    type: COMMENTS_LOAD,
+    commentThread,
+});
+export const CommentsAdd = ({ comment, cellAddress, }) => ({
+    type: COMMENTS_ADD,
+    comment,
+    cellAddress,
+});
+export const CommentsCellAdd = ({ commentThread, }) => ({
+    type: COMMENTS_CELL_ADD,
+    commentThread,
+});
+export const CommentsCellDelete = ({ cellAddress: cellAddress, }) => ({
+    type: COMMENTS_CELL_DELETE,
+    cellAddress: cellAddress,
+});
+export const CommentsEdit = ({ comment, cellAddress, }) => ({
+    type: COMMENTS_EDIT,
+    comment,
+    cellAddress,
+});
+export const CommentsDelete = ({ commentUuid, cellAddress, }) => ({
+    type: COMMENTS_DELETE,
+    cellAddress,
+    commentUuid,
+});
+export const CommentsReady = (commentstate) => ({
+    type: COMMENTS_READY,
+    commentState: commentstate,
+});
+export const GetGridCellCommentsSelector = (state, address) => {
+    var _a;
+    if (!address) {
+        return null;
+    }
+    return ((_a = state === null || state === void 0 ? void 0 : state.CommentThreads) !== null && _a !== void 0 ? _a : []).find((cellComments) => {
+        return CellPopupService.isSameAddress(cellComments, address);
+    });
+};
+export const GetCommentsSelector = (state, address) => {
+    var _a, _b;
+    if (!address) {
+        return [];
+    }
+    const comments = (_b = ((_a = state === null || state === void 0 ? void 0 : state.CommentThreads) !== null && _a !== void 0 ? _a : []).find((cellComments) => {
+        return CellPopupService.isSameAddress(cellComments, address);
+    })) === null || _b === void 0 ? void 0 : _b.Comments;
+    return comments;
+};
+export const GetGetCommentsByUuidSelector = (state, uuid) => {
+    var _a;
+    for (const commentThread of (_a = state.CommentThreads) !== null && _a !== void 0 ? _a : []) {
+        for (const comment of commentThread.Comments) {
+            if (comment.Uuid === uuid) {
+                return comment;
+            }
+        }
+    }
+    return undefined;
+};
+export const GetCellCommentSelector = (state, address) => {
+    var _a;
+    if (!address) {
+        return undefined;
+    }
+    return ((_a = state === null || state === void 0 ? void 0 : state.CommentThreads) !== null && _a !== void 0 ? _a : []).find((commentThread) => {
+        return CellPopupService.isSameAddress(commentThread, address);
+    });
+};
+const initialState = {
+    CommentThreads: EMPTY_ARRAY,
+};
+export const CommentsReducer = (state = initialState, action) => {
+    var _a, _b, _c, _d, _e;
+    switch (action.type) {
+        case COMMENTS_ADD: {
+            const addAction = action;
+            const commentThread = (_a = state.CommentThreads) !== null && _a !== void 0 ? _a : [];
+            const cellCommentIndex = commentThread.findIndex((cellComments) => {
+                return CellPopupService.isSameAddress(cellComments, addAction.cellAddress);
+            });
+            let comments = [...commentThread];
+            if (cellCommentIndex === -1) {
+                // new comments
+                comments.push(Object.assign(Object.assign({}, ObjectFactory.CreateEmptyCommentThread(addAction.cellAddress)), { Comments: [addAction.comment] }));
+            }
+            else {
+                const existing = Object.assign(Object.assign({}, commentThread[cellCommentIndex]), { Comments: [...commentThread[cellCommentIndex].Comments, addAction.comment] });
+                comments[cellCommentIndex] = existing;
+            }
+            return Object.assign(Object.assign({}, state), { CommentThreads: comments });
+        }
+        case COMMENTS_CELL_ADD: {
+            return Object.assign(Object.assign({}, state), { CommentThreads: [
+                    ...((_b = state.CommentThreads) !== null && _b !== void 0 ? _b : []),
+                    action.commentThread,
+                ] });
+        }
+        case COMMENTS_CELL_DELETE: {
+            const deleteAction = action;
+            return Object.assign(Object.assign({}, state), { CommentThreads: ((_c = state.CommentThreads) !== null && _c !== void 0 ? _c : []).filter((cellComments) => !CellPopupService.isSameAddress(cellComments, deleteAction.cellAddress)) });
+        }
+        case COMMENTS_EDIT: {
+            const editAction = action;
+            let edited = false;
+            const adaptableCellComments = ((_d = state.CommentThreads) !== null && _d !== void 0 ? _d : []).map((cellComments) => {
+                if (CellPopupService.isSameAddress(cellComments, editAction.cellAddress)) {
+                    // found the place
+                    edited = true;
+                    return Object.assign(Object.assign({}, cellComments), { Comments: cellComments.Comments.map((comment) => {
+                            if (comment.Uuid === editAction.comment.Uuid) {
+                                return editAction.comment;
+                            }
+                            return comment;
+                        }) });
+                }
+            });
+            return Object.assign(Object.assign({}, state), { CommentThreads: adaptableCellComments });
+        }
+        case COMMENTS_DELETE: {
+            const deleteAction = action;
+            const adaptableCellComments = ((_e = state.CommentThreads) !== null && _e !== void 0 ? _e : [])
+                .map((cellComments) => {
+                if (CellPopupService.isSameAddress(cellComments, deleteAction.cellAddress)) {
+                    // found the place
+                    const newComments = cellComments.Comments.filter((comment) => comment.Uuid !== deleteAction.commentUuid);
+                    if (newComments.length === 0) {
+                        return null;
+                    }
+                    const newCellComments = Object.assign(Object.assign({}, cellComments), { Comments: newComments });
+                    return newCellComments;
+                }
+                return cellComments;
+            })
+                .filter((cellComments) => cellComments !== null);
+            return Object.assign(Object.assign({}, state), { CommentThreads: adaptableCellComments });
+        }
+        case COMMENTS_LOAD: {
+            return Object.assign(Object.assign({}, state), { CommentThreads: action.commentThread });
+        }
+        default:
+            return state;
+    }
+};

package/src/Redux/ActionsReducers/CustomSortRedux.js

@@ -1,115 +1,102 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomSortReducer = exports.CustomSortReady = exports.CustomSortUnSuspendAll = exports.CustomSortSuspendAll = exports.CustomSortUnSuspend = exports.CustomSortSuspend = exports.CustomSortDelete = exports.CustomSortEdit = exports.CustomSortAdd = exports.CUSTOM_SORT_READY = exports.CUSTOM_SORT_UNSUSPEND_ALL = exports.CUSTOM_SORT_SUSPEND_ALL = exports.CUSTOM_SORT_UNSUSPEND = exports.CUSTOM_SORT_SUSPEND = exports.CUSTOM_SORT_DELETE = exports.CUSTOM_SORT_EDIT = exports.CUSTOM_SORT_ADD = void 0;
-const tslib_1 = require("tslib");
-const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
-const AdaptableHelper_1 = tslib_1.__importDefault(require("../../Utilities/Helpers/AdaptableHelper"));
-const utils_1 = require("./utils");
+import { EMPTY_ARRAY } from '../../Utilities/Constants/GeneralConstants';
+import AdaptableHelper from '../../Utilities/Helpers/AdaptableHelper';
+import { changeIsSuspendInList, suspendAllInList, unsuspendAllInList } from './utils';
 /**
  * @ReduxAction A Custom Sort has been added
  */
-exports.CUSTOM_SORT_ADD = 'CUSTOM_SORT_ADD';
+export const CUSTOM_SORT_ADD = 'CUSTOM_SORT_ADD';
 /**
  * @ReduxAction A Custom Sort has been edited
  */
-exports.CUSTOM_SORT_EDIT = 'CUSTOM_SORT_EDIT';
+export const CUSTOM_SORT_EDIT = 'CUSTOM_SORT_EDIT';
 /**
  * @ReduxAction A Custom Sort has been deleted
  */
-exports.CUSTOM_SORT_DELETE = 'CUSTOM_SORT_DELETE';
+export const CUSTOM_SORT_DELETE = 'CUSTOM_SORT_DELETE';
 /**
  * @ReduxAction A Custom Sort has been suspended
  */
-exports.CUSTOM_SORT_SUSPEND = 'CUSTOM_SORT_SUSPEND';
+export const CUSTOM_SORT_SUSPEND = 'CUSTOM_SORT_SUSPEND';
 /**
  * @ReduxAction A Custom Sort has been unsuspended (activated)
  */
-exports.CUSTOM_SORT_UNSUSPEND = 'CUSTOM_SORT_UNSUSPEND';
+export const CUSTOM_SORT_UNSUSPEND = 'CUSTOM_SORT_UNSUSPEND';
 /**
  * @ReduxAction Suspend all Custom Sorts
  */
-exports.CUSTOM_SORT_SUSPEND_ALL = 'CUSTOM_SORT_SUSPEND_ALL';
+export const CUSTOM_SORT_SUSPEND_ALL = 'CUSTOM_SORT_SUSPEND_ALL';
 /**
  * @ReduxAction Unsuspend all Custom Sorts
  */
-exports.CUSTOM_SORT_UNSUSPEND_ALL = 'CUSTOM_SORT_UNSUSPEND_ALL';
+export const CUSTOM_SORT_UNSUSPEND_ALL = 'CUSTOM_SORT_UNSUSPEND_ALL';
 /**
  * @ReduxAction Custom Sort Module is ready
  */
-exports.CUSTOM_SORT_READY = 'CUSTOM_SORT_READY';
-const CustomSortAdd = (customSort) => ({
-    type: exports.CUSTOM_SORT_ADD,
+export const CUSTOM_SORT_READY = 'CUSTOM_SORT_READY';
+export const CustomSortAdd = (customSort) => ({
+    type: CUSTOM_SORT_ADD,
     customSort,
 });
-exports.CustomSortAdd = CustomSortAdd;
-const CustomSortEdit = (customSort) => ({
-    type: exports.CUSTOM_SORT_EDIT,
+export const CustomSortEdit = (customSort) => ({
+    type: CUSTOM_SORT_EDIT,
     customSort,
 });
-exports.CustomSortEdit = CustomSortEdit;
-const CustomSortDelete = (customSort) => ({
-    type: exports.CUSTOM_SORT_DELETE,
+export const CustomSortDelete = (customSort) => ({
+    type: CUSTOM_SORT_DELETE,
     customSort,
 });
-exports.CustomSortDelete = CustomSortDelete;
-const CustomSortSuspend = (customSort) => ({
-    type: exports.CUSTOM_SORT_SUSPEND,
+export const CustomSortSuspend = (customSort) => ({
+    type: CUSTOM_SORT_SUSPEND,
     customSort,
 });
-exports.CustomSortSuspend = CustomSortSuspend;
-const CustomSortUnSuspend = (customSort) => ({
-    type: exports.CUSTOM_SORT_UNSUSPEND,
+export const CustomSortUnSuspend = (customSort) => ({
+    type: CUSTOM_SORT_UNSUSPEND,
     customSort,
 });
-exports.CustomSortUnSuspend = CustomSortUnSuspend;
-const CustomSortSuspendAll = () => ({
-    type: exports.CUSTOM_SORT_SUSPEND_ALL,
+export const CustomSortSuspendAll = () => ({
+    type: CUSTOM_SORT_SUSPEND_ALL,
 });
-exports.CustomSortSuspendAll = CustomSortSuspendAll;
-const CustomSortUnSuspendAll = () => ({
-    type: exports.CUSTOM_SORT_UNSUSPEND_ALL,
+export const CustomSortUnSuspendAll = () => ({
+    type: CUSTOM_SORT_UNSUSPEND_ALL,
 });
-exports.CustomSortUnSuspendAll = CustomSortUnSuspendAll;
-const CustomSortReady = (customSortState) => ({
-    type: exports.CUSTOM_SORT_READY,
+export const CustomSortReady = (customSortState) => ({
+    type: CUSTOM_SORT_READY,
     customSortState,
 });
-exports.CustomSortReady = CustomSortReady;
 const initialState = {
-    CustomSorts: GeneralConstants_1.EMPTY_ARRAY,
+    CustomSorts: EMPTY_ARRAY,
 };
-const CustomSortReducer = (state = initialState, action) => {
+export const CustomSortReducer = (state = initialState, action) => {
     let customSorts;
     switch (action.type) {
-        case exports.CUSTOM_SORT_ADD: {
+        case CUSTOM_SORT_ADD: {
             const actionCustomSort = action.customSort;
-            AdaptableHelper_1.default.addUuidAndSource(actionCustomSort);
+            AdaptableHelper.addUuidAndSource(actionCustomSort);
             customSorts = [].concat(state.CustomSorts);
             customSorts.push(actionCustomSort);
             return Object.assign(Object.assign({}, state), { CustomSorts: customSorts });
         }
-        case exports.CUSTOM_SORT_EDIT: {
+        case CUSTOM_SORT_EDIT: {
             const actionCustomSort = action.customSort;
             return Object.assign(Object.assign({}, state), { CustomSorts: state.CustomSorts.map((abObject) => abObject.Uuid === actionCustomSort.Uuid ? actionCustomSort : abObject) });
         }
-        case exports.CUSTOM_SORT_DELETE: {
+        case CUSTOM_SORT_DELETE: {
             const actionCustomSort = action.customSort;
             return Object.assign(Object.assign({}, state), { CustomSorts: state.CustomSorts.filter((abObject) => abObject.Uuid !== actionCustomSort.Uuid) });
         }
-        case exports.CUSTOM_SORT_SUSPEND: {
-            return Object.assign(Object.assign({}, state), { CustomSorts: (0, utils_1.changeIsSuspendInList)(action.customSort, state.CustomSorts, true) });
+        case CUSTOM_SORT_SUSPEND: {
+            return Object.assign(Object.assign({}, state), { CustomSorts: changeIsSuspendInList(action.customSort, state.CustomSorts, true) });
         }
-        case exports.CUSTOM_SORT_UNSUSPEND: {
-            return Object.assign(Object.assign({}, state), { CustomSorts: (0, utils_1.changeIsSuspendInList)(action.customSort, state.CustomSorts, false) });
+        case CUSTOM_SORT_UNSUSPEND: {
+            return Object.assign(Object.assign({}, state), { CustomSorts: changeIsSuspendInList(action.customSort, state.CustomSorts, false) });
         }
-        case exports.CUSTOM_SORT_SUSPEND_ALL: {
-            return Object.assign(Object.assign({}, state), { CustomSorts: (0, utils_1.suspendAllInList)(state.CustomSorts) });
+        case CUSTOM_SORT_SUSPEND_ALL: {
+            return Object.assign(Object.assign({}, state), { CustomSorts: suspendAllInList(state.CustomSorts) });
         }
-        case exports.CUSTOM_SORT_UNSUSPEND_ALL: {
-            return Object.assign(Object.assign({}, state), { CustomSorts: (0, utils_1.unsuspendAllInList)(state.CustomSorts) });
+        case CUSTOM_SORT_UNSUSPEND_ALL: {
+            return Object.assign(Object.assign({}, state), { CustomSorts: unsuspendAllInList(state.CustomSorts) });
         }
         default:
             return state;
     }
 };
-exports.CustomSortReducer = CustomSortReducer;