@adaptabletools/adaptable 10.0.0-canary.0

package/src/PredefinedConfig/TeamSharingState.d.ts

@@ -0,0 +1,88 @@
+import { InternalState } from './InternalState';
+import { AdaptableObject } from './Common/AdaptableObject';
+import { AdaptableModule } from '../types';
+import { TypeUuid } from './Uuid';
+import * as Redux from 'redux';
+/**
+ * State for Team Sharing; this is internal so not designed to be provided as part of Predefined Config
+ */
+export interface TeamSharingState extends InternalState {
+    /**
+     * List of objects currently being Team Shared
+     */
+    SharedEntities: SharedEntity[];
+    /**
+     * Mapping of active AdaptableObjects which are shared with the local state.
+     * Maps UUIDs of local AdaptableObjects to a snapshot of the latest synchronized SharedEntity
+     */
+    ActiveSharedEntityMap: Record<TypeUuid, SharedEntity>;
+    /**
+     * TRUE if an import is in progress, FALSE otherwise.
+     * This is required to skip the TEAMSHARING_UPDATE_ITEM action as a result of the import
+     */
+    importProcessInProgress: boolean;
+}
+/**
+ * Defines an object used in Team Sharing
+ */
+export interface SharedEntity extends AdaptableObject {
+    /**
+     * Actual Adaptable Object being shared
+     */
+    Entity: AdaptableObject;
+    /**
+     * Ids of direct entity dependencies
+     */
+    EntityDependencyIds: TypeUuid[];
+    /**
+     * Adaptable Module to which object belongs
+     */
+    Module: AdaptableModule;
+    /**
+     * When the object was shared
+     */
+    Timestamp: number;
+    /**
+     * User who shared the object
+     */
+    UserName: string;
+    /**
+     * Description of object being shared
+     */
+    Description: string;
+    /**
+     * Revision - incremental for 'Active', always 1 for 'Snapshot'
+     */
+    Revision: number;
+    /**
+     * Last User who changed the object
+     */
+    ChangedBy: string;
+    /**
+     * Last time when the object was changed
+     */
+    ChangedAt: number;
+    /**
+     * 'Snapshot' (for 1-time sharing) or 'Active' (for continuous sharing between local state & Team Share)
+     */
+    Type: SharedEntityType;
+}
+export interface TeamSharingImportInfo<T extends AdaptableObject> {
+    ModuleEntities: T[];
+    AddAction: (entity: T) => any;
+    EditAction: (entity: T) => any;
+}
+export interface SharedEntityConfig {
+    description: string;
+    type: SharedEntityType;
+}
+export declare type SharedEntityType = 'Snapshot' | 'Active';
+export interface TeamSharingImportStep {
+    sharedEntity: SharedEntity;
+    importAction: Redux.Action;
+}
+export declare type SharedEntityActiveStatus = Record<TypeUuid, {
+    sharedEntity: SharedEntity;
+    importedRevision: number;
+    sharedRevision: number;
+}>;

package/src/PredefinedConfig/TeamSharingState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/PredefinedConfig/ThemeState.d.ts

@@ -0,0 +1,36 @@
+import { ConfigState } from './ConfigState';
+import { AdaptableObject } from './Common/AdaptableObject';
+/**
+ * Theme section of Adaptable State
+ */
+export interface ThemeState extends ConfigState {
+    /**
+     * Name of current theme (or theme to set at startup); leave blank if using 'Light Theme', set to 'dark' for 'Dark Theme' or provide name of Custom Theme
+     */
+    CurrentTheme?: string;
+    /**
+     * Which, if any, of the 2 themes shipped by Adaptable should be available; leave unset to provide both, or an empty array to provide neither.
+     */
+    SystemThemes?: (AdaptableTheme | string)[];
+    /**
+     * Custom themes (of type AdaptableTheme) provided by developers
+     */
+    UserThemes?: AdaptableTheme[];
+}
+/**
+ * Used for creating User (i.e. Custom) Themes
+ */
+export interface AdaptableTheme extends AdaptableObject {
+    /**
+     * Name of the Theme
+     */
+    Name: string;
+    /**
+     * Description of Theme - will appear in Theme Toolbar and Toolpanel
+     */
+    Description: string;
+    /**
+     * Vendor Grid related css className to be applied
+     */
+    VendorGridClassName?: string;
+}

package/src/PredefinedConfig/ThemeState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/PredefinedConfig/ToolPanelState.d.ts

@@ -0,0 +1,32 @@
+import { ConfigState } from './ConfigState';
+import { AdaptableModuleButtons, AdaptableToolPanel } from './Common/Types';
+/**
+ * Predefined Configuration for the Adaptable ToolPanel
+ */
+export interface ToolPanelState extends ConfigState {
+    /**
+     * ToolPanels visible
+     * @defaultValue ToolPanels for all available Modules (subject to Entitlement rules)
+     */
+    ToolPanels?: AdaptableToolPanelDefinition[];
+    /**
+     * AdapTable Module Buttons visible in ToolPanel
+     * @defaultValue Empty Array
+     */
+    ModuleButtons?: AdaptableModuleButtons;
+}
+/**
+ * Defines a ToolPanel - Name and VisibilityMode (Expanded / Collapsed)
+ */
+export interface AdaptableToolPanelDefinition {
+    /**
+     * ToolPanel name - either an Adaptable Module or a Custom ToolPanel (defined in ToolPanel Options)
+     */
+    Name: AdaptableToolPanel | string;
+    /**
+     * Whether the ToolPanel is 'expanded' or 'collapsed'
+     * @defaultValue 'collapsed'
+     */
+    VisibilityMode?: 'expanded' | 'collapsed';
+}
+export declare type ToolPanelVisibilityMode = 'expanded' | 'collapsed';

package/src/PredefinedConfig/ToolPanelState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/PredefinedConfig/Uuid.d.ts

@@ -0,0 +1,2 @@
+export declare type TypeUuid = string;
+export declare const createUuid: () => TypeUuid;

package/src/PredefinedConfig/Uuid.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUuid = void 0;
+const uuid_1 = require("uuid");
+exports.createUuid = () => uuid_1.v4();

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

@@ -0,0 +1,88 @@
+import { AlertState, AlertDefinition } from '../../PredefinedConfig/AlertState';
+import * as Redux from 'redux';
+import { FlashingAlertDefinition } from '../../PredefinedConfig/AlertState';
+/**
+ * @ReduxAction An Alert Definition has been added
+ */
+export declare const ALERT_DEFINITION_ADD = "ALERT_DEFINITION_ADD";
+/**
+ * @ReduxAction An Alert Definition has been edited
+ */
+export declare const ALERT_DEFINITION_EDIT = "ALERT_DEFINITION_EDIT";
+/**
+ * @ReduxAction An Alert Definition has been deleted
+ */
+export declare const ALERT_DEFINITION_DELETE = "ALERT_DEFINITION_DELETE";
+/**
+ * @ReduxAction Alert Definition is suspended
+ */
+export declare const ALERT_DEFINITION_SUSPEND = "ALERT_DEFINITION_SUSPEND";
+/**
+ * @ReduxAction Alert Definition is un-suspended, or activated
+ */
+export declare const ALERT_DEFINITION_UN_SUSPEND = "ALERT_DEFINITION_UN_SUSPEND";
+/**
+ * @ReduxAction A Flashing Alert Definition has been added
+ */
+export declare const FLASHING_ALERT_DEFINITION_ADD = "FLASHING_ALERT_DEFINITION_ADD";
+/**
+ * @ReduxAction A Flashing Alert Definition has been edited
+ */
+export declare const FLASHING_ALERT_DEFINITION_EDIT = "FLASHING_ALERT_DEFINITION_EDIT";
+/**
+ * @ReduxAction A Flashing Alert Definition has been deleted
+ */
+export declare const FLASHING_ALERT_DEFINITION_DELETE = "FLASHING_ALERT_DEFINITION_DELETE";
+/**
+ * @ReduxAction Flashing Alert Definition Style is suspended
+ */
+export declare const FLASHING_ALERT_DEFINITION_SUSPEND = "FLASHING_ALERT_DEFINITION_SUSPEND";
+/**
+ * @ReduxAction Flashing Alert Definition is un-suspended, or activated
+ */
+export declare const FLASHING_ALERT_DEFINITION_UN_SUSPEND = "FLASHING_ALERT_DEFINITION_UN_SUSPEND";
+/**
+ * @ReduxAction Alert Module is ready
+ */
+export declare const ALERT_READY = "ALERT_READY";
+export interface AlertDefinitionAction extends Redux.Action {
+    alertDefinition: AlertDefinition;
+}
+export interface FlashingAlertDefinitionAction extends Redux.Action {
+    flashingAlertDefinition: FlashingAlertDefinition;
+}
+export interface AlertDefinitionAddAction extends AlertDefinitionAction {
+}
+export interface AlertDefinitionEditAction extends AlertDefinitionAction {
+}
+export interface AlertDefinitionDeleteAction extends AlertDefinitionAction {
+}
+export interface AlertDefinitionSuspendAction extends AlertDefinitionAction {
+}
+export interface AlertDefinitionUnSuspendAction extends AlertDefinitionAction {
+}
+export interface FlashingAlertDefinitionAddAction extends FlashingAlertDefinitionAction {
+}
+export interface FlashingAlertDefinitionEditAction extends FlashingAlertDefinitionAction {
+}
+export interface FlashingAlertDefinitionDeleteAction extends FlashingAlertDefinitionAction {
+}
+export interface FlashingAlertDefinitionSuspendAction extends FlashingAlertDefinitionAction {
+}
+export interface FlashingAlertDefinitionUnSuspendAction extends FlashingAlertDefinitionAction {
+}
+export interface AlertReadyAction extends Redux.Action {
+    alertState: AlertState;
+}
+export declare const AlertDefinitionAdd: (alertDefinition: AlertDefinition) => AlertDefinitionAddAction;
+export declare const AlertDefinitionEdit: (alertDefinition: AlertDefinition) => AlertDefinitionEditAction;
+export declare const AlertDefinitionDelete: (alertDefinition: AlertDefinition) => AlertDefinitionDeleteAction;
+export declare const AlertDefinitionSuspend: (alertDefinition: AlertDefinition) => AlertDefinitionSuspendAction;
+export declare const AlertDefinitionUnSuspend: (alertDefinition: AlertDefinition) => AlertDefinitionUnSuspendAction;
+export declare const FlashingAlertDefinitionAdd: (flashingAlertDefinition: FlashingAlertDefinition) => FlashingAlertDefinitionAddAction;
+export declare const FlashingAlertDefinitionEdit: (flashingAlertDefinition: FlashingAlertDefinition) => FlashingAlertDefinitionEditAction;
+export declare const FlashingAlertDefinitionDelete: (flashingAlertDefinition: FlashingAlertDefinition) => FlashingAlertDefinitionDeleteAction;
+export declare const FlashingAlertDefinitionSuspend: (flashingAlertDefinition: FlashingAlertDefinition) => FlashingAlertDefinitionEditAction;
+export declare const FlashingAlertDefinitionUnSuspend: (flashingAlertDefinition: FlashingAlertDefinition) => FlashingAlertDefinitionEditAction;
+export declare const AlertReady: (alertState: AlertState) => AlertReadyAction;
+export declare const AlertReducer: Redux.Reducer<AlertState>;

package/src/Redux/ActionsReducers/AlertRedux.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertReducer = exports.AlertReady = exports.FlashingAlertDefinitionUnSuspend = exports.FlashingAlertDefinitionSuspend = exports.FlashingAlertDefinitionDelete = exports.FlashingAlertDefinitionEdit = exports.FlashingAlertDefinitionAdd = exports.AlertDefinitionUnSuspend = exports.AlertDefinitionSuspend = exports.AlertDefinitionDelete = exports.AlertDefinitionEdit = exports.AlertDefinitionAdd = exports.ALERT_READY = exports.FLASHING_ALERT_DEFINITION_UN_SUSPEND = exports.FLASHING_ALERT_DEFINITION_SUSPEND = exports.FLASHING_ALERT_DEFINITION_DELETE = exports.FLASHING_ALERT_DEFINITION_EDIT = exports.FLASHING_ALERT_DEFINITION_ADD = exports.ALERT_DEFINITION_UN_SUSPEND = exports.ALERT_DEFINITION_SUSPEND = exports.ALERT_DEFINITION_DELETE = exports.ALERT_DEFINITION_EDIT = exports.ALERT_DEFINITION_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");
+/**
+ * @ReduxAction An Alert Definition has been added
+ */
+exports.ALERT_DEFINITION_ADD = 'ALERT_DEFINITION_ADD';
+/**
+ * @ReduxAction An Alert Definition has been edited
+ */
+exports.ALERT_DEFINITION_EDIT = 'ALERT_DEFINITION_EDIT';
+/**
+ * @ReduxAction An Alert Definition has been deleted
+ */
+exports.ALERT_DEFINITION_DELETE = 'ALERT_DEFINITION_DELETE';
+/**
+ * @ReduxAction Alert Definition is suspended
+ */
+exports.ALERT_DEFINITION_SUSPEND = 'ALERT_DEFINITION_SUSPEND';
+/**
+ * @ReduxAction Alert Definition is un-suspended, or activated
+ */
+exports.ALERT_DEFINITION_UN_SUSPEND = 'ALERT_DEFINITION_UN_SUSPEND';
+/**
+ * @ReduxAction A Flashing Alert Definition has been added
+ */
+exports.FLASHING_ALERT_DEFINITION_ADD = 'FLASHING_ALERT_DEFINITION_ADD';
+/**
+ * @ReduxAction A Flashing Alert Definition has been edited
+ */
+exports.FLASHING_ALERT_DEFINITION_EDIT = 'FLASHING_ALERT_DEFINITION_EDIT';
+/**
+ * @ReduxAction A Flashing Alert Definition has been deleted
+ */
+exports.FLASHING_ALERT_DEFINITION_DELETE = 'FLASHING_ALERT_DEFINITION_DELETE';
+/**
+ * @ReduxAction Flashing Alert Definition Style is suspended
+ */
+exports.FLASHING_ALERT_DEFINITION_SUSPEND = 'FLASHING_ALERT_DEFINITION_SUSPEND';
+/**
+ * @ReduxAction Flashing Alert Definition is un-suspended, or activated
+ */
+exports.FLASHING_ALERT_DEFINITION_UN_SUSPEND = 'FLASHING_ALERT_DEFINITION_UN_SUSPEND';
+/**
+ * @ReduxAction Alert Module is ready
+ */
+exports.ALERT_READY = 'ALERT_READY';
+exports.AlertDefinitionAdd = (alertDefinition) => ({
+    type: exports.ALERT_DEFINITION_ADD,
+    alertDefinition,
+});
+exports.AlertDefinitionEdit = (alertDefinition) => ({
+    type: exports.ALERT_DEFINITION_EDIT,
+    alertDefinition,
+});
+exports.AlertDefinitionDelete = (alertDefinition) => ({
+    type: exports.ALERT_DEFINITION_DELETE,
+    alertDefinition,
+});
+exports.AlertDefinitionSuspend = (alertDefinition) => ({
+    type: exports.ALERT_DEFINITION_SUSPEND,
+    alertDefinition,
+});
+exports.AlertDefinitionUnSuspend = (alertDefinition) => ({
+    type: exports.ALERT_DEFINITION_UN_SUSPEND,
+    alertDefinition,
+});
+exports.FlashingAlertDefinitionAdd = (flashingAlertDefinition) => ({
+    type: exports.FLASHING_ALERT_DEFINITION_ADD,
+    flashingAlertDefinition,
+});
+exports.FlashingAlertDefinitionEdit = (flashingAlertDefinition) => ({
+    type: exports.FLASHING_ALERT_DEFINITION_EDIT,
+    flashingAlertDefinition,
+});
+exports.FlashingAlertDefinitionDelete = (flashingAlertDefinition) => ({
+    type: exports.FLASHING_ALERT_DEFINITION_DELETE,
+    flashingAlertDefinition,
+});
+exports.FlashingAlertDefinitionSuspend = (flashingAlertDefinition) => ({
+    type: exports.FLASHING_ALERT_DEFINITION_SUSPEND,
+    flashingAlertDefinition,
+});
+exports.FlashingAlertDefinitionUnSuspend = (flashingAlertDefinition) => ({
+    type: exports.FLASHING_ALERT_DEFINITION_UN_SUSPEND,
+    flashingAlertDefinition,
+});
+exports.AlertReady = (alertState) => ({
+    type: exports.ALERT_READY,
+    alertState,
+});
+const initialState = {
+    AlertDefinitions: GeneralConstants_1.EMPTY_ARRAY,
+    FlashingAlertDefinitions: [],
+};
+exports.AlertReducer = (state = initialState, action) => {
+    let alertDefinitions;
+    let flashingAlertDefinitions;
+    switch (action.type) {
+        case exports.ALERT_DEFINITION_ADD: {
+            const actionAlertDefinition = action
+                .alertDefinition;
+            AdaptableHelper_1.default.addUuidAndSource(actionAlertDefinition);
+            alertDefinitions = [].concat(state.AlertDefinitions);
+            alertDefinitions.push(actionAlertDefinition);
+            return Object.assign(Object.assign({}, state), { AlertDefinitions: alertDefinitions });
+        }
+        case exports.ALERT_DEFINITION_EDIT: {
+            const actionAlertDefinition = action
+                .alertDefinition;
+            return Object.assign(Object.assign({}, state), { AlertDefinitions: state.AlertDefinitions.map((abObject) => abObject.Uuid === actionAlertDefinition.Uuid ? actionAlertDefinition : abObject) });
+        }
+        case exports.ALERT_DEFINITION_DELETE: {
+            const actionAlertDefinition = action
+                .alertDefinition;
+            return Object.assign(Object.assign({}, state), { AlertDefinitions: state.AlertDefinitions.filter((abObject) => abObject.Uuid !== actionAlertDefinition.Uuid) });
+        }
+        case exports.ALERT_DEFINITION_SUSPEND: {
+            return Object.assign(Object.assign({}, state), { AlertDefinitions: utils_1.changeIsSuspendInList(action.alertDefinition, state.AlertDefinitions, true) });
+        }
+        case exports.ALERT_DEFINITION_UN_SUSPEND: {
+            return Object.assign(Object.assign({}, state), { AlertDefinitions: utils_1.changeIsSuspendInList(action.alertDefinition, state.AlertDefinitions, false) });
+        }
+        case exports.FLASHING_ALERT_DEFINITION_ADD: {
+            const actionFlashingAlertDefinition = action
+                .flashingAlertDefinition;
+            AdaptableHelper_1.default.addUuidAndSource(actionFlashingAlertDefinition);
+            flashingAlertDefinitions = [].concat(state.FlashingAlertDefinitions);
+            flashingAlertDefinitions.push(actionFlashingAlertDefinition);
+            return Object.assign(Object.assign({}, state), { FlashingAlertDefinitions: flashingAlertDefinitions });
+        }
+        case exports.FLASHING_ALERT_DEFINITION_EDIT: {
+            const actionFlashingAlertDefinition = action
+                .flashingAlertDefinition;
+            return Object.assign(Object.assign({}, state), { FlashingAlertDefinitions: state.FlashingAlertDefinitions.map((abObject) => abObject.Uuid === actionFlashingAlertDefinition.Uuid
+                    ? actionFlashingAlertDefinition
+                    : abObject) });
+        }
+        case exports.FLASHING_ALERT_DEFINITION_DELETE: {
+            const actionFlashingAlertDefinition = action
+                .flashingAlertDefinition;
+            return Object.assign(Object.assign({}, state), { FlashingAlertDefinitions: state.FlashingAlertDefinitions.filter((abObject) => abObject.Uuid !== actionFlashingAlertDefinition.Uuid) });
+        }
+        case exports.FLASHING_ALERT_DEFINITION_SUSPEND: {
+            return Object.assign(Object.assign({}, state), { FlashingAlertDefinitions: utils_1.changeIsSuspendInList(action.flashingAlertDefinition, state.FlashingAlertDefinitions, true) });
+        }
+        case exports.FLASHING_ALERT_DEFINITION_UN_SUSPEND: {
+            return Object.assign(Object.assign({}, state), { FlashingAlertDefinitions: utils_1.changeIsSuspendInList(action.flashingAlertDefinition, state.FlashingAlertDefinitions, false) });
+        }
+        default:
+            return state;
+    }
+};

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

@@ -0,0 +1,27 @@
+import * as Redux from 'redux';
+import { ApplicationState, ApplicationDataEntry } from '../../PredefinedConfig/ApplicationState';
+/**
+ * @ReduxAction An Application Data Entry has been added
+ */
+export declare const APPLICATION_DATA_ENTRY_ADD = "APPLICATION_DATA_ENTRY_ADD";
+/**
+ * @ReduxAction An Application Data Entry has been edited
+ */
+export declare const APPLICATION_DATA_ENTRY_EDIT = "APPLICATION_DATA_ENTRY_EDIT";
+/**
+ * @ReduxAction An Application Data Entry has been deleted
+ */
+export declare const APPLICATION_DATA_ENTRY_DELETE = "APPLICATION_DATA_ENTRY_DELETE";
+export interface ApplicationDataEntryAddAction extends Redux.Action {
+    applicationDataEntry: ApplicationDataEntry;
+}
+export interface ApplicationDataEntryEditAction extends Redux.Action {
+    applicationDataEntry: ApplicationDataEntry;
+}
+export interface ApplicationDataEntryDeleteAction extends Redux.Action {
+    applicationDataEntry: ApplicationDataEntry;
+}
+export declare const ApplicationDataEntryAdd: (applicationDataEntry: ApplicationDataEntry) => ApplicationDataEntryAddAction;
+export declare const ApplicationDataEntryEdit: (applicationDataEntry: ApplicationDataEntry) => ApplicationDataEntryEditAction;
+export declare const ApplicationDataEntryDelete: (applicationDataEntry: ApplicationDataEntry) => ApplicationDataEntryDeleteAction;
+export declare const ApplicationReducer: Redux.Reducer<ApplicationState>;

package/src/Redux/ActionsReducers/ApplicationRedux.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationReducer = exports.ApplicationDataEntryDelete = exports.ApplicationDataEntryEdit = exports.ApplicationDataEntryAdd = exports.APPLICATION_DATA_ENTRY_DELETE = exports.APPLICATION_DATA_ENTRY_EDIT = exports.APPLICATION_DATA_ENTRY_ADD = void 0;
+const GeneralConstants_1 = require("../../Utilities/Constants/GeneralConstants");
+/**
+ * @ReduxAction An Application Data Entry has been added
+ */
+exports.APPLICATION_DATA_ENTRY_ADD = 'APPLICATION_DATA_ENTRY_ADD';
+/**
+ * @ReduxAction An Application Data Entry has been edited
+ */
+exports.APPLICATION_DATA_ENTRY_EDIT = 'APPLICATION_DATA_ENTRY_EDIT';
+/**
+ * @ReduxAction An Application Data Entry has been deleted
+ */
+exports.APPLICATION_DATA_ENTRY_DELETE = 'APPLICATION_DATA_ENTRY_DELETE';
+exports.ApplicationDataEntryAdd = (applicationDataEntry) => ({
+    type: exports.APPLICATION_DATA_ENTRY_ADD,
+    applicationDataEntry,
+});
+exports.ApplicationDataEntryEdit = (applicationDataEntry) => ({
+    type: exports.APPLICATION_DATA_ENTRY_EDIT,
+    applicationDataEntry,
+});
+exports.ApplicationDataEntryDelete = (applicationDataEntry) => ({
+    type: exports.APPLICATION_DATA_ENTRY_DELETE,
+    applicationDataEntry,
+});
+const initialState = {
+    ApplicationDataEntries: GeneralConstants_1.EMPTY_ARRAY,
+};
+exports.ApplicationReducer = (state = initialState, action) => {
+    let applicationDataEntries;
+    let index;
+    switch (action.type) {
+        case exports.APPLICATION_DATA_ENTRY_ADD:
+            const actionTypedAdd = action;
+            applicationDataEntries = [].concat(state.ApplicationDataEntries);
+            applicationDataEntries.push(actionTypedAdd.applicationDataEntry);
+            return Object.assign({}, state, { ApplicationDataEntries: applicationDataEntries });
+        case exports.APPLICATION_DATA_ENTRY_EDIT:
+            const actionTypedUpdate = action;
+            applicationDataEntries = [].concat(state.ApplicationDataEntries);
+            index = applicationDataEntries.findIndex((fe) => fe.Key == actionTypedUpdate.applicationDataEntry.Key);
+            applicationDataEntries[index] = actionTypedUpdate.applicationDataEntry;
+            return Object.assign({}, state, { ApplicationDataEntries: applicationDataEntries });
+        case exports.APPLICATION_DATA_ENTRY_DELETE:
+            const actionTypedDelete = action;
+            applicationDataEntries = [].concat(state.ApplicationDataEntries);
+            index = applicationDataEntries.findIndex((a) => a.Key == actionTypedDelete.applicationDataEntry.Key);
+            applicationDataEntries.splice(index, 1);
+            return Object.assign({}, state, { ApplicationDataEntries: applicationDataEntries });
+        default:
+            return state;
+    }
+};

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

@@ -0,0 +1,25 @@
+import * as Redux from 'redux';
+import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
+/**
+ * @ReduxAction Bulk Update has been completed
+ */
+export declare const BULK_UPDATE_COMPLETE = "BULK_UPDATE_COMPLETE";
+/**
+ * @ReduxAction Bulk Update is being applied
+ */
+export declare const BULK_UPDATE_APPLY = "BULK_UPDATE_APPLY";
+/**
+ * @ReduxAction Bulk Update Module is ready
+ */
+export declare const BULK_UPDATE_READY = "BULK_UPDATE_READY";
+export interface BulkUpdateCompleteAction extends Redux.Action {
+    bypassValidationWarnings: boolean;
+}
+export interface BulkUpdateApplyAction extends Redux.Action {
+    gridCells: GridCell[];
+}
+export interface BulkUpdateReadyAction extends Redux.Action {
+}
+export declare const BulkUpdateComplete: (bypassValidationWarnings: boolean) => BulkUpdateCompleteAction;
+export declare const BulkUpdateApply: (gridCells: GridCell[]) => BulkUpdateApplyAction;
+export declare const BulkUpdateReady: () => BulkUpdateReadyAction;

package/src/Redux/ActionsReducers/BulkUpdateRedux.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkUpdateReady = exports.BulkUpdateApply = exports.BulkUpdateComplete = exports.BULK_UPDATE_READY = exports.BULK_UPDATE_APPLY = exports.BULK_UPDATE_COMPLETE = void 0;
+/**
+ * @ReduxAction Bulk Update has been completed
+ */
+exports.BULK_UPDATE_COMPLETE = 'BULK_UPDATE_COMPLETE';
+/**
+ * @ReduxAction Bulk Update is being applied
+ */
+exports.BULK_UPDATE_APPLY = 'BULK_UPDATE_APPLY';
+/**
+ * @ReduxAction Bulk Update Module is ready
+ */
+exports.BULK_UPDATE_READY = 'BULK_UPDATE_READY';
+exports.BulkUpdateComplete = (bypassValidationWarnings) => ({
+    type: exports.BULK_UPDATE_COMPLETE,
+    bypassValidationWarnings: bypassValidationWarnings,
+});
+exports.BulkUpdateApply = (gridCells) => ({
+    type: exports.BULK_UPDATE_APPLY,
+    gridCells,
+});
+exports.BulkUpdateReady = () => ({
+    type: exports.BULK_UPDATE_READY,
+});

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

@@ -0,0 +1,35 @@
+import { CalculatedColumnState, CalculatedColumn } from '../../PredefinedConfig/CalculatedColumnState';
+import * as Redux from 'redux';
+/**
+ * @ReduxAction A Calculated Column has been added
+ */
+export declare const CALCULATED_COLUMN_ADD = "CALCULATED_COLUMN_ADD";
+/**
+ * @ReduxAction A Calculated Column has been edited
+ */
+export declare const CALCULATED_COLUMN_EDIT = "CALCULATED_COLUMN_EDIT";
+/**
+ * @ReduxAction A Calculated Column has been deleted
+ */
+export declare const CALCULATED_COLUMN_DELETE = "CALCULATED_COLUMN_DELETE";
+/**
+ * @ReduxAction Calculated Column Module is ready
+ */
+export declare const CALCULATED_COLUMN_READY = "CALCULATED_COLUMN_READY";
+export interface CalculatedColumnAction extends Redux.Action {
+    calculatedColumn: CalculatedColumn;
+}
+export interface CalculatedColumnAddAction extends CalculatedColumnAction {
+}
+export interface CalculatedColumnEditAction extends CalculatedColumnAction {
+}
+export interface CalculatedColumnDeleteAction extends CalculatedColumnAction {
+}
+export interface CalculatedColumnReadyAction extends Redux.Action {
+    calculatedColumnState: CalculatedColumnState;
+}
+export declare const CalculatedColumnAdd: (calculatedColumn: CalculatedColumn) => CalculatedColumnAddAction;
+export declare const CalculatedColumnEdit: (calculatedColumn: CalculatedColumn) => CalculatedColumnEditAction;
+export declare const CalculatedColumnDelete: (calculatedColumn: CalculatedColumn) => CalculatedColumnDeleteAction;
+export declare const CalculatedColumnReady: (calculatedColumnState: CalculatedColumnState) => CalculatedColumnReadyAction;
+export declare const CalculatedColumnReducer: Redux.Reducer<CalculatedColumnState>;