@singularsystems/neo-core 1.0.0-beta.8 → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+
+
+# Breaking changes
+
+## 0.10.65 (6 March 2023)
+
+* `IErrorHandler` now requires the return type to be `Promise<IErrorDisplay>` instead of `IErrorDisplay`.
+* Most of the protected methods in `ErrorHandler` have been changed to `async`.
+* These changes were required in order to be able to read errors from axios blob responses.
+
+# Change Log
+
+## 0.10.65 (6 March 2023)
+
+* Fixed error handler not parsing axios responses when response type is `blob`.

package/README.md

@@ -2,6 +2,10 @@
 
 This project contains the core functionality of the neo client library. 
 
+## Building
+
+Run `yarn dlx @yarnpkg/sdks vscode` to enable typescript for yarn in vscode.
+
 ## Testing
 
 To debug the tests, you need to add the following to .vscode\launch.json

package/dist/AppServices/Config/ConfigModel.d.ts

@@ -1,4 +1,4 @@
-export interface IConfigModel {
+export interface IConfigModelData {
     readonly baseUrl: string;
     /**
      * True by default if the NODE_ENV environment variable is "development".
@@ -8,6 +8,8 @@ export interface IConfigModel {
      * This must be specified in your config file to be set to true.
      */
     isTest: boolean;
+}
+export interface IConfigModel extends IConfigModelData {
     readonly isTestOrDevelopment: boolean;
     initialise(): void;
 }

package/dist/AppServices/Config/ConfigService.d.ts

@@ -1,15 +1,26 @@
-import { IConfigModel } from './ConfigModel';
+import { AxiosPromise } from "axios";
+import { IConfigModel, IConfigModelData } from './ConfigModel';
+import { IDbSet } from "../../IndexDb/IDbSet";
 export interface IConfigService {
     /**
-     * Load the config file from the specified path.
+     * Load and process the config file from the specified path.
      * Path will default to [baseUrl]/config.json
      * @param path Optional path.
+     * @param store Offline store to allow offline retrieval.
      */
-    loadConfig(path?: string): Promise<IConfigModel>;
+    loadConfig(path?: string, store?: IDbSet<IConfigModelData>): Promise<IConfigModel>;
+    /** Fetch the raw config data from the server. */
+    fetchConfig(path?: string): Promise<any>;
+    /**
+     * Sets the raw config data.
+     * Use this if `loadConfig` fails, and you have an offline copy of the config data. */
+    setConfig(configData: any): IConfigModel;
 }
 export declare class ConfigService implements IConfigService {
     private config;
     constructor(config: IConfigModel);
-    loadConfig(path?: string): Promise<IConfigModel>;
+    loadConfig(path?: string, store?: IDbSet<IConfigModelData>): Promise<IConfigModel>;
+    fetchConfig(path?: string | undefined): AxiosPromise<any>;
+    setConfig(configData: any): IConfigModel;
     static get isDevelopment(): boolean;
 }

package/dist/AppServices/Config/ConfigService.js

@@ -2,37 +2,58 @@ import { __awaiter, __decorate, __generator, __metadata, __param } from "tslib";
 import { injectable, inject } from 'inversify';
 import Axios from "axios";
 import NeoTypes from '../NeoTypes';
-export var ConfigService = /** @class */ (function () {
+import AxiosUtils from "../../AxiosUtils";
+var ConfigService = /** @class */ (function () {
     function ConfigService(config) {
         this.config = config;
     }
-    ConfigService.prototype.loadConfig = function (path) {
+    ConfigService.prototype.loadConfig = function (path, store) {
         return __awaiter(this, void 0, void 0, function () {
-            var timestamp, response, error_1;
+            var configData, e_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        path = path !== null && path !== void 0 ? path : "".concat(this.config.baseUrl, "/config.json");
-                        _a.label = 1;
+                        _a.trys.push([0, 4, , 7]);
+                        return [4 /*yield*/, this.fetchConfig(path)];
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        timestamp = new Date().getTime();
-                        return [4 /*yield*/, Axios.get("".concat(path, "?").concat(timestamp))];
+                        configData = (_a.sent()).data;
+                        if (!store) return [3 /*break*/, 3];
+                        return [4 /*yield*/, store.putAsync(configData, 1)];
                     case 2:
-                        response = _a.sent();
-                        // The raw parsed json objects properties are copied into the config model.
-                        // It is up to the config model to transform its properties if required (in the initialise method). 
-                        Object.assign(this.config, response.data);
-                        this.config.initialise();
-                        return [2 /*return*/, this.config];
-                    case 3:
-                        error_1 = _a.sent();
-                        throw new Error("ConfigService - Error loading configuration: ".concat(error_1));
-                    case 4: return [2 /*return*/];
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [3 /*break*/, 7];
+                    case 4:
+                        e_1 = _a.sent();
+                        if (!(store && AxiosUtils.isNetworkError(e_1) && !window.navigator.onLine)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, store.getAsync(1)];
+                    case 5:
+                        // get config from index db
+                        configData = _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        if (!configData) {
+                            throw new Error("ConfigService - Error loading configuration: ".concat(e_1));
+                        }
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/, this.setConfig(configData)];
                 }
             });
         });
     };
+    ConfigService.prototype.fetchConfig = function (path) {
+        path = path !== null && path !== void 0 ? path : "".concat(this.config.baseUrl, "/config.json");
+        // Fetch config with timestamp to prevent caching
+        var timestamp = new Date().getTime();
+        return Axios.get("".concat(path, "?").concat(timestamp));
+    };
+    ConfigService.prototype.setConfig = function (configData) {
+        // The raw parsed json objects properties are copied into the config model.
+        // It is up to the config model to transform its properties if required (in the initialise method). 
+        Object.assign(this.config, configData);
+        this.config.initialise();
+        return this.config;
+    };
     Object.defineProperty(ConfigService, "isDevelopment", {
         get: function () {
             return process.env.NODE_ENV === "development";
@@ -47,3 +68,4 @@ export var ConfigService = /** @class */ (function () {
     ], ConfigService);
     return ConfigService;
 }());
+export { ConfigService };

package/dist/AppServices/NeoTypes.d.ts

@@ -19,6 +19,7 @@ import { IContextMenuState } from '../Components/ContextMenu/ContextMenu';
 import { INavigationHelper } from '../Routing/INavigationHelper';
 import { ILoginErrorHandler } from '../Security/ILoginErrorHandler';
 import { IDecimalService } from "../Numeric";
+import { IServerMessageSubscriber } from "../SignalR/IServerMessageSubscriber";
 declare const NeoTypes: {
     Axios: ServiceIdentifier<import("axios").AxiosStatic>;
     Config: {
@@ -27,6 +28,7 @@ declare const NeoTypes: {
     };
     Core: {
         AutoRunnerFactory: ServiceIdentifier<IAutoRunnerFactory>;
+        /** @deprecated Use Messaging.ConnectionManager */
         ConnectionManager: ServiceIdentifier<IConnectionManager>;
         DecimalService: ServiceIdentifier<IDecimalService<import("../Numeric").IDecimal>>;
         ModelCreator: ServiceIdentifier<IModelCreatorBase>;
@@ -34,6 +36,10 @@ declare const NeoTypes: {
     Localisation: {
         LocalisationService: ServiceIdentifier<ILocalisationService>;
     };
+    Messaging: {
+        ConnectionManager: ServiceIdentifier<IConnectionManager>;
+        ServerMessageSubscriber: ServiceIdentifier<IServerMessageSubscriber>;
+    };
     Routing: {
         MenuItemProvider: ServiceIdentifier<IMenuItemProvider<import("../Routing").IMenuRoute>>;
         NavigationHelper: ServiceIdentifier<INavigationHelper>;

package/dist/AppServices/NeoTypes.js

@@ -1,4 +1,5 @@
 import { ServiceIdentifier } from './ServiceIdentifier';
+var connectionManagerType = new ServiceIdentifier("Neo.ConnectionManager");
 // Neo Module Type Symbols
 var NeoTypes = {
     Axios: new ServiceIdentifier("Neo.Axios"),
@@ -8,13 +9,18 @@ var NeoTypes = {
     },
     Core: {
         AutoRunnerFactory: new ServiceIdentifier("Neo.AutoRunnerFactory"),
-        ConnectionManager: new ServiceIdentifier("Neo.ConnectionManager"),
+        /** @deprecated Use Messaging.ConnectionManager */
+        ConnectionManager: connectionManagerType,
         DecimalService: new ServiceIdentifier("Neo.DecimalService"),
         ModelCreator: new ServiceIdentifier("Neo.ModelCreator")
     },
     Localisation: {
         LocalisationService: new ServiceIdentifier("Neo.Localisation")
     },
+    Messaging: {
+        ConnectionManager: connectionManagerType,
+        ServerMessageSubscriber: new ServiceIdentifier("Neo.ServerMessageSubscriber"),
+    },
     Routing: {
         MenuItemProvider: new ServiceIdentifier("Neo.MenuItemProvider"),
         NavigationHelper: new ServiceIdentifier("Neo.NavigationHelper"),

package/dist/AppServices/ServiceIdentifier.js

@@ -1,7 +1,7 @@
 /**
  * Strongly typed identifier for a service.
  */
-export var ServiceIdentifier = /** @class */ (function () {
+var ServiceIdentifier = /** @class */ (function () {
     /**
      * Creates a service identifier.
      * @param name Name used for debugging, not required to be unique.
@@ -36,3 +36,4 @@ export var ServiceIdentifier = /** @class */ (function () {
     ServiceIdentifier.typeNames = new Set();
     return ServiceIdentifier;
 }());
+export { ServiceIdentifier };

package/dist/AxiosUtils.d.ts

@@ -0,0 +1,27 @@
+import { AxiosError, AxiosPromise, AxiosResponse } from "axios";
+import { IErrorDetails } from "./Components/ErrorHandler";
+interface ISuccessResponse<TData> {
+    success: true;
+    data: TData;
+}
+interface IFailedResponse<TData> extends IErrorDetails<TData> {
+    success: false;
+}
+export default class AxiosUtils {
+    /**
+     * Awaits an axios promise and returns an object indicating success or failure.
+     * @param filter Only errors matching this filter will be caught.
+     */
+    static catchErrors<TData>(request: AxiosPromise<TData>, filter?: (r?: AxiosResponse) => boolean): Promise<ISuccessResponse<TData> | IFailedResponse<any>>;
+    /** Reads the properties of an axios error. */
+    static readError(e: AxiosError): Promise<IFailedResponse<any>>;
+    /**
+     * Checks if the error data is a blob object, and reads from it if that is the case.
+     */
+    static ensureAxiosErrorData(responseData: any): Promise<any>;
+    static isClientError(response?: AxiosResponse): boolean;
+    static isServerError(response?: AxiosResponse): boolean;
+    /** Returns true if the error was raised from axios, and is a network error. E.g. no response was received from the server. */
+    static isNetworkError(e: any): boolean;
+}
+export {};

package/dist/AxiosUtils.js

@@ -0,0 +1,103 @@
+import { __awaiter, __generator } from "tslib";
+import { isAxiosError } from "axios";
+var AxiosUtils = /** @class */ (function () {
+    function AxiosUtils() {
+    }
+    /**
+     * Awaits an axios promise and returns an object indicating success or failure.
+     * @param filter Only errors matching this filter will be caught.
+     */
+    AxiosUtils.catchErrors = function (request, filter) {
+        return __awaiter(this, void 0, void 0, function () {
+            var waited, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 5]);
+                        return [4 /*yield*/, request];
+                    case 1:
+                        waited = _a.sent();
+                        return [2 /*return*/, {
+                                data: waited.data,
+                                success: true,
+                            }];
+                    case 2:
+                        e_1 = _a.sent();
+                        if (!isAxiosError(e_1)) return [3 /*break*/, 4];
+                        if (!(filter === undefined || filter(e_1.response))) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.readError(e_1)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4: throw e_1;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Reads the properties of an axios error. */
+    AxiosUtils.readError = function (e) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, isServerError;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        data = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!data) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.ensureAxiosErrorData(data)];
+                    case 1:
+                        data = _c.sent();
+                        _c.label = 2;
+                    case 2:
+                        isServerError = false;
+                        if ((_b = e.response) === null || _b === void 0 ? void 0 : _b.status) {
+                            isServerError = this.isServerError(e.response);
+                        }
+                        return [2 /*return*/, {
+                                success: false,
+                                isServerError: isServerError,
+                                isNetworkError: e.response === undefined,
+                                data: data,
+                                error: e,
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Checks if the error data is a blob object, and reads from it if that is the case.
+     */
+    AxiosUtils.ensureAxiosErrorData = function (responseData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var errorText;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(responseData instanceof Blob)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, responseData.text()];
+                    case 1:
+                        errorText = _a.sent();
+                        if (responseData.type.toLowerCase().includes('json')) {
+                            return [2 /*return*/, JSON.parse(errorText)];
+                        }
+                        else {
+                            return [2 /*return*/, errorText];
+                        }
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, responseData];
+                }
+            });
+        });
+    };
+    AxiosUtils.isClientError = function (response) {
+        return response !== undefined && response.status >= 400 && response.status < 500;
+    };
+    AxiosUtils.isServerError = function (response) {
+        return response !== undefined && response.status >= 500 && response.status < 600;
+    };
+    /** Returns true if the error was raised from axios, and is a network error. E.g. no response was received from the server. */
+    AxiosUtils.isNetworkError = function (e) {
+        return isAxiosError(e) && e.response === undefined;
+    };
+    return AxiosUtils;
+}());
+export default AxiosUtils;

package/dist/Components/ErrorHandler.d.ts

@@ -1,13 +1,19 @@
 import { AxiosError, AxiosResponse } from 'axios';
 import { INotificationHelper } from './Notifications/INotificationHelper';
-export interface IErrorDisplay {
-    header: string;
+export interface IErrorDetails<TData> {
     statusCode?: number;
     statusText?: string;
-    body: any;
-    data?: IErrorData;
+    data?: TData;
     /** True if this is a 500 type error from the server. */
     isServerError?: boolean;
+    /** True if the server could not be reached. */
+    isNetworkError?: boolean;
+    /** Original axios error. */
+    error: AxiosError;
+}
+export interface IErrorDisplay extends IErrorDetails<IErrorData> {
+    header: string;
+    body: any;
     /** Cancels displaying of the error. */
     cancelDisplay?: boolean;
 }
@@ -33,11 +39,7 @@ export declare enum ErrorDisplayType {
 }
 export declare class ErrorHandler implements IErrorHandler {
     private notifications;
-    private blobType;
-    constructor(notifications: INotificationHelper, blobType?: {
-        new (blobParts?: BlobPart[] | undefined, options?: BlobPropertyBag | undefined): Blob;
-        prototype: Blob;
-    });
+    constructor(notifications: INotificationHelper);
     showError(error: any, displayType: ErrorDisplayType): Promise<void>;
     parseError(error: any): Promise<IErrorDisplay>;
     protected getAxiosError(error: AxiosError, response?: AxiosResponse): Promise<IErrorDisplay>;
@@ -52,11 +54,7 @@ export declare class ErrorHandler implements IErrorHandler {
      * @param error Axios error.
      */
     parseAxiosError(header: string, body: string, error: AxiosError): Promise<IErrorDisplay>;
-    /**
-     * Checks if the error data is a blob object, and reads from it if that is the case.
-     */
-    protected ensureAxiosErrorData(responseData: any): Promise<any>;
-    protected getGeneralError(error: any): IErrorDisplay;
+    protected getGeneralError(error: AxiosError): IErrorDisplay;
     protected displayError(displayType: ErrorDisplayType, error: any, errorDisplay: IErrorDisplay): void;
     protected displayModal(error: any, errorDisplay: IErrorDisplay): void;
     protected displayNotification(error: any, errorDisplay: IErrorDisplay): void;

package/dist/Components/ErrorHandler.js

@@ -1,8 +1,10 @@
 import { __awaiter, __decorate, __generator, __metadata, __param } from "tslib";
 import { injectable, inject } from 'inversify';
+import { isAxiosError } from 'axios';
 import { ModalUtils } from './Modal/ModalUtils';
 import NeoTypes from '../AppServices/NeoTypes';
 import NeoStrings from '../Localisation/NeoStrings';
+import AxiosUtils from "../AxiosUtils";
 export var ErrorDisplayType;
 (function (ErrorDisplayType) {
     /** Show the error text in a modal. */
@@ -12,11 +14,9 @@ export var ErrorDisplayType;
     /** Do nothing, error will be re-thrown. */
     ErrorDisplayType[ErrorDisplayType["ThrowError"] = 2] = "ThrowError";
 })(ErrorDisplayType || (ErrorDisplayType = {}));
-export var ErrorHandler = /** @class */ (function () {
-    function ErrorHandler(notifications, blobType) {
-        if (blobType === void 0) { blobType = Blob; }
+var ErrorHandler = /** @class */ (function () {
+    function ErrorHandler(notifications) {
         this.notifications = notifications;
-        this.blobType = blobType;
     }
     ErrorHandler.prototype.showError = function (error, displayType) {
         return __awaiter(this, void 0, void 0, function () {
@@ -41,7 +41,7 @@ export var ErrorHandler = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!error.isAxiosError) return [3 /*break*/, 2];
+                        if (!isAxiosError(error)) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.getAxiosError(error, error.response)];
                     case 1: return [2 /*return*/, _a.sent()];
                     case 2: return [2 /*return*/, this.getGeneralError(error)];
@@ -90,6 +90,7 @@ export var ErrorHandler = /** @class */ (function () {
                         errorDisplay = this.getGeneralError(error);
                         // Add status code of -1 to differentiate network errors from code exceptions.
                         errorDisplay.statusCode = -1;
+                        errorDisplay.isNetworkError = true;
                         _b.label = 13;
                     case 13: return [2 /*return*/, errorDisplay];
                 }
@@ -97,7 +98,9 @@ export var ErrorHandler = /** @class */ (function () {
         });
     };
     ErrorHandler.prototype.get400Error = function (error) {
-        return this.parseAxiosError(NeoStrings.errors.invalidDataTitle, NeoStrings.errors.invalidDataBody, error);
+        var _a;
+        var isGet = ((_a = error.response) === null || _a === void 0 ? void 0 : _a.config.method) === "get";
+        return this.parseAxiosError(NeoStrings.errors.invalidDataTitle, isGet ? NeoStrings.errors.invalidDataBodyGet : NeoStrings.errors.invalidDataBody, error);
     };
     ErrorHandler.prototype.get401Error = function (error) {
         return this.parseAxiosError(NeoStrings.errors.notAuthenticatedTitle, NeoStrings.errors.notAuthenticatedBody, error);
@@ -115,15 +118,15 @@ export var ErrorHandler = /** @class */ (function () {
      * @param error Axios error.
      */
     ErrorHandler.prototype.parseAxiosError = function (header, body, error) {
-        var _a;
         return __awaiter(this, void 0, void 0, function () {
             var errorDisplay, rawErrorData_1, errorData_1;
+            var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        errorDisplay = { header: header, body: body, statusText: error.message, statusCode: (_a = error.response) === null || _a === void 0 ? void 0 : _a.status };
+                        errorDisplay = { header: header, body: body, statusText: error.message, statusCode: (_a = error.response) === null || _a === void 0 ? void 0 : _a.status, error: error };
                         if (!error.response.data) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.ensureAxiosErrorData(error.response.data)];
+                        return [4 /*yield*/, AxiosUtils.ensureAxiosErrorData(error.response.data)];
                     case 1:
                         rawErrorData_1 = _b.sent();
                         if (rawErrorData_1.title) {
@@ -156,34 +159,9 @@ export var ErrorHandler = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Checks if the error data is a blob object, and reads from it if that is the case.
-     */
-    ErrorHandler.prototype.ensureAxiosErrorData = function (responseData) {
-        return __awaiter(this, void 0, void 0, function () {
-            var errorText;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(responseData instanceof this.blobType)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, responseData.text()];
-                    case 1:
-                        errorText = _a.sent();
-                        if (responseData.type.toLowerCase().includes('json')) {
-                            return [2 /*return*/, JSON.parse(errorText)];
-                        }
-                        else {
-                            return [2 /*return*/, errorText];
-                        }
-                        _a.label = 2;
-                    case 2: return [2 /*return*/, responseData];
-                }
-            });
-        });
-    };
     ErrorHandler.prototype.getGeneralError = function (error) {
         var errorDescription = error.message ? error.message : error;
-        return { header: NeoStrings.errors.generalTitle, body: errorDescription };
+        return { header: NeoStrings.errors.generalTitle, body: errorDescription, error: error };
     };
     ErrorHandler.prototype.displayError = function (displayType, error, errorDisplay) {
         if (error instanceof Error) {
@@ -206,7 +184,8 @@ export var ErrorHandler = /** @class */ (function () {
     ErrorHandler = __decorate([
         injectable(),
         __param(0, inject(NeoTypes.UI.GlobalNotifications.symbol)),
-        __metadata("design:paramtypes", [Object, Object])
+        __metadata("design:paramtypes", [Object])
     ], ErrorHandler);
     return ErrorHandler;
 }());
+export { ErrorHandler };

package/dist/Components/FileManager/FileManager.js

@@ -9,7 +9,7 @@ import { Settings } from '../../Settings';
 import { FileUploadBatch } from './FileUploadBatch';
 import NeoStrings from '../../Localisation/NeoStrings';
 var fileInputSymbol = Symbol("FileInput");
-export var FileManagerBase = /** @class */ (function () {
+var FileManagerBase = /** @class */ (function () {
     function FileManagerBase(uploadEndpointOrOptions, options) {
         this.currentUploads = [];
         if (uploadEndpointOrOptions === undefined || typeof uploadEndpointOrOptions === "string") {
@@ -97,9 +97,9 @@ export var FileManagerBase = /** @class */ (function () {
     /**
      * Checks if file extensions are allowed, then calls onFilesSelected, or uploadFiles
      */
-    FileManagerBase.prototype.processFiles = function (files, options) {
-        if (options === void 0) { options = {}; }
-        return __awaiter(this, void 0, void 0, function () {
+    FileManagerBase.prototype.processFiles = function (files_1) {
+        return __awaiter(this, arguments, void 0, function (files, options) {
+            if (options === void 0) { options = {}; }
             return __generator(this, function (_a) {
                 if (files.length > 1 && !this.allowMultiple) {
                     files = [Array.from(files)[0]];
@@ -252,6 +252,7 @@ export var FileManagerBase = /** @class */ (function () {
     ], FileManagerBase.prototype, "currentUploads", void 0);
     return FileManagerBase;
 }());
+export { FileManagerBase };
 var FileManager = /** @class */ (function (_super) {
     __extends(FileManager, _super);
     function FileManager() {

package/dist/Components/FileManager/FileUploadBatch.js

@@ -2,7 +2,7 @@ import { __decorate, __metadata } from "tslib";
 import { Utils } from "../../Utils";
 import NeoModel from "../../Model/NeoModel";
 import { Observable } from "../../Model/Decorators";
-export var FileUploadBatch = /** @class */ (function () {
+var FileUploadBatch = /** @class */ (function () {
     function FileUploadBatch(files) {
         this.recordIndex = {};
         this.key = Utils.uuidv4();
@@ -81,3 +81,4 @@ export var FileUploadBatch = /** @class */ (function () {
     ], FileUploadBatch);
     return FileUploadBatch;
 }());
+export { FileUploadBatch };

package/dist/Components/Notifications/Notification.js

@@ -2,7 +2,7 @@ import { __decorate, __metadata } from "tslib";
 import { Utils } from "../../Utils";
 import { Observable } from '../../Model/Decorators';
 import NeoModel from '../../Model/NeoModel';
-export var Notification = /** @class */ (function () {
+var Notification = /** @class */ (function () {
     function Notification(options, body) {
         this.options = options;
         this.body = body;
@@ -24,3 +24,4 @@ export var Notification = /** @class */ (function () {
     ], Notification);
     return Notification;
 }());
+export { Notification };

package/dist/Components/Notifications/NotificationHelper.js

@@ -3,7 +3,7 @@ import { Globals } from '../../Misc';
 import NeoTypes from '../../AppServices/NeoTypes';
 import { ModalUtils } from '../Modal/ModalUtils';
 import { injectable, inject } from 'inversify';
-export var NotificationHelper = /** @class */ (function () {
+var NotificationHelper = /** @class */ (function () {
     /**
      * Creates a new notification helper which can be bound to a ToastContainer / other alert ui component.
      * @param store Optional store which contains the notification message objects.
@@ -109,3 +109,4 @@ export var NotificationHelper = /** @class */ (function () {
     ], NotificationHelper);
     return NotificationHelper;
 }());
+export { NotificationHelper };

package/dist/Components/Notifications/NotificationStore.js

@@ -4,7 +4,7 @@ import { Notification } from './Notification';
 import { Observable } from '../../Model/Decorators';
 import NeoModel from '../../Model/NeoModel';
 import { injectable } from 'inversify';
-export var NotificationStore = /** @class */ (function () {
+var NotificationStore = /** @class */ (function () {
     function NotificationStore() {
         this.notifications = [];
     }
@@ -76,3 +76,4 @@ export var NotificationStore = /** @class */ (function () {
     ], NotificationStore);
     return NotificationStore;
 }());
+export { NotificationStore };

package/dist/Components/TaskRunner/ProgressState.js

@@ -1,7 +1,7 @@
 import { __decorate, __metadata } from "tslib";
 import NeoModel from '../../Model/NeoModel';
 import { Observable } from '../../Model/Decorators';
-export var ProgressState = /** @class */ (function () {
+var ProgressState = /** @class */ (function () {
     function ProgressState() {
         this._progress = 0;
         /** Animation state used by UI components. */
@@ -69,3 +69,4 @@ export var ProgressState = /** @class */ (function () {
     ], ProgressState);
     return ProgressState;
 }());
+export { ProgressState };

package/dist/Components/TaskRunner/TaskRunner.js

@@ -6,7 +6,7 @@ import { injectable, inject } from 'inversify';
 import { ErrorDisplayType } from '../ErrorHandler';
 import { NeoTypes } from '../../AppServices';
 import { ProgressState } from './ProgressState';
-export var TaskRunnerOptions = /** @class */ (function () {
+var TaskRunnerOptions = /** @class */ (function () {
     function TaskRunnerOptions(taskRunner) {
         this.taskRunner = taskRunner;
         /** Specifies how the task runner must handle errors that are raised by your code. */
@@ -42,6 +42,7 @@ export var TaskRunnerOptions = /** @class */ (function () {
     ], TaskRunnerOptions);
     return TaskRunnerOptions;
 }());
+export { TaskRunnerOptions };
 var WaitForTaskRunnerOptions = /** @class */ (function (_super) {
     __extends(WaitForTaskRunnerOptions, _super);
     function WaitForTaskRunnerOptions() {