@singularsystems/neo-core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/Components/TaskRunner/TaskRunner.js

@@ -1,244 +1,253 @@
-import { __assign, __awaiter, __decorate, __extends, __generator, __metadata, __param } from "tslib";
-import { Observable } from '../../Model/Decorators';
-import NeoModel from '../../Model/NeoModel';
-import { ModalUtils } from '../..';
-import { injectable, inject } from 'inversify';
-import { ErrorDisplayType } from '../ErrorHandler';
-import { NeoTypes } from '../../AppServices';
-import { ProgressState } from './ProgressState';
-var TaskRunnerOptions = /** @class */ (function () {
-    function TaskRunnerOptions(taskRunner) {
-        this.taskRunner = taskRunner;
-        /** Specifies how the task runner must handle errors that are raised by your code. */
-        this.errorHandling = ErrorDisplayType.ShowModal;
-        /** Loading text to show in the loading bar */
-        this.loadingText = "";
-        this.variant = "primary";
-        /** Progress % to start on. */
-        this.initialProgress = 0;
-        /** Time in seconds for the progress to reach half way. */
-        this.halfLife = 1;
-        /** False if the progress will be progressed manually. */
-        this.autoProgress = true;
-    }
-    Object.defineProperty(TaskRunnerOptions.prototype, "progressState", {
-        get: function () {
-            return this.taskRunner.progressState;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    __decorate([
-        Observable(),
-        __metadata("design:type", Object)
-    ], TaskRunnerOptions.prototype, "loadingText", void 0);
-    __decorate([
-        Observable(),
-        __metadata("design:type", String)
-    ], TaskRunnerOptions.prototype, "variant", void 0);
-    TaskRunnerOptions = __decorate([
-        NeoModel,
-        __metadata("design:paramtypes", [TaskRunner])
-    ], TaskRunnerOptions);
-    return TaskRunnerOptions;
-}());
-export { TaskRunnerOptions };
-var WaitForTaskRunnerOptions = /** @class */ (function (_super) {
-    __extends(WaitForTaskRunnerOptions, _super);
-    function WaitForTaskRunnerOptions() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return WaitForTaskRunnerOptions;
-}(TaskRunnerOptions));
-export { WaitForTaskRunnerOptions };
-var defaultTaskName = "default";
-var TaskRunner = /** @class */ (function () {
-    function TaskRunner(errorHandler) {
-        this.errorHandler = errorHandler;
-        this.isBusy = false;
-        this.options = new TaskRunnerOptions(this);
-        this.progressState = new ProgressState();
-        this.runningTasks = [];
-    }
-    TaskRunner.prototype.run = function (loadingTextOrTask, taskOrNothing) {
-        if (!this.runningTasks.find(function (c) { return c.name == defaultTaskName; })) {
-            var pendingTask = void 0;
-            var options = new TaskRunnerOptions(this);
-            if (taskOrNothing === undefined) {
-                // Task only
-                pendingTask = loadingTextOrTask;
-            }
-            else {
-                // Loading text then task
-                options.loadingText = loadingTextOrTask;
-                pendingTask = taskOrNothing;
-            }
-            return this.runTask(defaultTaskName, pendingTask(options), options);
-        }
-        else {
-            throw "Cannot run more than 1 task at a time.";
-        }
-    };
-    /**
-     * Sets the isBusy property to true while the supplied promise is executing.
-     * @param task A promise which is busy executing.
-     * @param options Static options.
-     */
-    TaskRunner.prototype.waitFor = function (task, options) {
-        return this.runTask("", task, Object.assign(new WaitForTaskRunnerOptions(this), options));
-    };
-    /**
-     * Accepts a dictionary of promises, and waits for all of them to resolve.
-     * A dictionary with the same keys is returned with the results of each promise.
-     */
-    TaskRunner.prototype.waitForAll = function (promises, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var returnValue, promiseList, sharedOptions, errorHandling, key, waitingTask, results, index, key, e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        returnValue = {};
-                        promiseList = [];
-                        sharedOptions = Object.assign(new WaitForTaskRunnerOptions(this), options);
-                        errorHandling = sharedOptions.errorHandling;
-                        sharedOptions.errorHandling = ErrorDisplayType.ThrowError;
-                        for (key in promises) {
-                            waitingTask = this.runTask("", promises[key], sharedOptions);
-                            promiseList.push(waitingTask);
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, Promise.all(promiseList)];
-                    case 2:
-                        results = _a.sent();
-                        index = 0;
-                        for (key in promises) {
-                            returnValue[key] = results[index++];
-                        }
-                        return [2 /*return*/, returnValue];
-                    case 3:
-                        e_1 = _a.sent();
-                        if (errorHandling !== ErrorDisplayType.ThrowError) {
-                            this.errorHandler.showError(e_1, errorHandling);
-                        }
-                        throw e_1;
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    TaskRunner.prototype.waitForData = function (task, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var optionsNoDefault, result, e_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        optionsNoDefault = __assign(__assign({}, options), { defaultReturnValue: undefined });
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.waitFor(task, optionsNoDefault)];
-                    case 2:
-                        result = _a.sent();
-                        return [2 /*return*/, result.data];
-                    case 3:
-                        e_2 = _a.sent();
-                        if ((options === null || options === void 0 ? void 0 : options.defaultReturnValue) === undefined) {
-                            throw e_2;
-                        }
-                        else {
-                            return [2 /*return*/, options === null || options === void 0 ? void 0 : options.defaultReturnValue];
-                        }
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    TaskRunner.prototype.runTask = function (name, runningTask, options) {
-        var _this = this;
-        if (this.runningTasks.length === 0) {
-            if (options.autoProgress) {
-                this.progressState.resume(options.initialProgress, options.halfLife);
-            }
-            else {
-                this.progressState.progress = options.initialProgress;
-            }
-            this.isBusy = true;
-        }
-        this.options = options;
-        this.runningTasks.push({ name: name, promise: runningTask, options: options });
-        return new Promise(function (resolve, reject) {
-            runningTask.then(function (value) {
-                var axiosResponse = value;
-                var allowPosts = options.allowPost;
-                if (name === "" && !allowPosts && axiosResponse && axiosResponse.config) {
-                    if (axiosResponse.config.method !== "get") {
-                        var message = "The operation completed, but TaskRunner.waitFor() must only be used for get operations. Change your code to use TaskRunner.run()";
-                        ModalUtils.showMessage("Error", message);
-                        reject(message);
-                        return;
-                    }
-                }
-                resolve(value);
-            })
-                .catch(function (e) {
-                var _a;
-                var cancel = false;
-                if (options.onError !== undefined) {
-                    var errorInfo = _this.errorHandler.parseError(e);
-                    options.onError(errorInfo);
-                    cancel = (_a = errorInfo.cancelDisplay) !== null && _a !== void 0 ? _a : false;
-                }
-                if (!cancel && options.errorHandling !== ErrorDisplayType.ThrowError) {
-                    _this.errorHandler.showError(e, options.errorHandling);
-                }
-                if (options.defaultReturnValue === undefined) {
-                    reject(e);
-                }
-                else {
-                    resolve(options.defaultReturnValue);
-                }
-            }).finally(function () {
-                var task = _this.runningTasks.find(function (c) { return c.promise === runningTask; });
-                if (_this.runningTasks.length === 1) {
-                    // This was the last task to finish.
-                    _this.progressState.stop();
-                    _this.isBusy = false;
-                }
-                else {
-                    if (task === _this.runningTasks[_this.runningTasks.length - 1]) {
-                        // Task that just completed was the last one added, set the loading state to the previously added task.
-                        _this.options = _this.runningTasks[_this.runningTasks.length - 2].options;
-                    }
-                }
-                _this.runningTasks.splice(_this.runningTasks.indexOf(task), 1);
-            });
-        });
-    };
-    /** Waits the specified number of milliseconds. */
-    TaskRunner.delay = function (ms) {
-        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
-    };
-    __decorate([
-        Observable(),
-        __metadata("design:type", Boolean)
-    ], TaskRunner.prototype, "isBusy", void 0);
-    __decorate([
-        Observable(),
-        __metadata("design:type", Object)
-    ], TaskRunner.prototype, "options", void 0);
-    __decorate([
-        Observable(),
-        __metadata("design:type", Object)
-    ], TaskRunner.prototype, "progressState", void 0);
-    TaskRunner = __decorate([
-        injectable(),
-        NeoModel,
-        __param(0, inject(NeoTypes.UI.ErrorHandler.symbol)),
-        __metadata("design:paramtypes", [Object])
-    ], TaskRunner);
-    return TaskRunner;
-}());
-export default TaskRunner;
+import { __assign, __awaiter, __decorate, __extends, __generator, __metadata, __param } from "tslib";
+import { Observable } from '../../Model/Decorators';
+import NeoModel from '../../Model/NeoModel';
+import { ModalUtils } from '../..';
+import { injectable, inject } from 'inversify';
+import { ErrorDisplayType } from '../ErrorHandler';
+import { NeoTypes } from '../../AppServices';
+import { ProgressState } from './ProgressState';
+export var TaskRunnerOptions = /** @class */ (function () {
+    function TaskRunnerOptions(taskRunner) {
+        this.taskRunner = taskRunner;
+        /** Specifies how the task runner must handle errors that are raised by your code. */
+        this.errorHandling = ErrorDisplayType.ShowModal;
+        /** Loading text to show in the loading bar */
+        this.loadingText = "";
+        this.variant = "primary";
+        /** Progress % to start on. */
+        this.initialProgress = 0;
+        /** Time in seconds for the progress to reach half way. */
+        this.halfLife = 1;
+        /** False if the progress will be progressed manually. */
+        this.autoProgress = true;
+    }
+    Object.defineProperty(TaskRunnerOptions.prototype, "progressState", {
+        get: function () {
+            return this.taskRunner.progressState;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    __decorate([
+        Observable(),
+        __metadata("design:type", Object)
+    ], TaskRunnerOptions.prototype, "loadingText", void 0);
+    __decorate([
+        Observable(),
+        __metadata("design:type", String)
+    ], TaskRunnerOptions.prototype, "variant", void 0);
+    TaskRunnerOptions = __decorate([
+        NeoModel,
+        __metadata("design:paramtypes", [TaskRunner])
+    ], TaskRunnerOptions);
+    return TaskRunnerOptions;
+}());
+var WaitForTaskRunnerOptions = /** @class */ (function (_super) {
+    __extends(WaitForTaskRunnerOptions, _super);
+    function WaitForTaskRunnerOptions() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return WaitForTaskRunnerOptions;
+}(TaskRunnerOptions));
+export { WaitForTaskRunnerOptions };
+var defaultTaskName = "default";
+var TaskRunner = /** @class */ (function () {
+    function TaskRunner(errorHandler) {
+        this.errorHandler = errorHandler;
+        this.isBusy = false;
+        this.options = new TaskRunnerOptions(this);
+        this.progressState = new ProgressState();
+        this.runningTasks = [];
+    }
+    TaskRunner.prototype.run = function (loadingTextOrTask, taskOrNothing) {
+        if (!this.runningTasks.find(function (c) { return c.name == defaultTaskName; })) {
+            var pendingTask = void 0;
+            var options = new TaskRunnerOptions(this);
+            if (taskOrNothing === undefined) {
+                // Task only
+                pendingTask = loadingTextOrTask;
+            }
+            else {
+                // Loading text then task
+                options.loadingText = loadingTextOrTask;
+                pendingTask = taskOrNothing;
+            }
+            return this.runTask(defaultTaskName, pendingTask(options), options);
+        }
+        else {
+            throw "Cannot run more than 1 task at a time.";
+        }
+    };
+    /**
+     * Sets the isBusy property to true while the supplied promise is executing.
+     * @param task A promise which is busy executing.
+     * @param options Static options.
+     */
+    TaskRunner.prototype.waitFor = function (task, options) {
+        return this.runTask("", task, Object.assign(new WaitForTaskRunnerOptions(this), options));
+    };
+    /**
+     * Accepts a dictionary of promises, and waits for all of them to resolve.
+     * A dictionary with the same keys is returned with the results of each promise.
+     */
+    TaskRunner.prototype.waitForAll = function (promises, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var returnValue, promiseList, sharedOptions, errorHandling, key, waitingTask, results, index, key, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        returnValue = {};
+                        promiseList = [];
+                        sharedOptions = Object.assign(new WaitForTaskRunnerOptions(this), options);
+                        errorHandling = sharedOptions.errorHandling;
+                        sharedOptions.errorHandling = ErrorDisplayType.ThrowError;
+                        for (key in promises) {
+                            waitingTask = this.runTask("", promises[key], sharedOptions);
+                            promiseList.push(waitingTask);
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, Promise.all(promiseList)];
+                    case 2:
+                        results = _a.sent();
+                        index = 0;
+                        for (key in promises) {
+                            returnValue[key] = results[index++];
+                        }
+                        return [2 /*return*/, returnValue];
+                    case 3:
+                        e_1 = _a.sent();
+                        if (errorHandling !== ErrorDisplayType.ThrowError) {
+                            this.errorHandler.showError(e_1, errorHandling);
+                        }
+                        throw e_1;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TaskRunner.prototype.waitForData = function (task, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var optionsNoDefault, result, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        optionsNoDefault = __assign(__assign({}, options), { defaultReturnValue: undefined });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.waitFor(task, optionsNoDefault)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, result.data];
+                    case 3:
+                        e_2 = _a.sent();
+                        if ((options === null || options === void 0 ? void 0 : options.defaultReturnValue) === undefined) {
+                            throw e_2;
+                        }
+                        else {
+                            return [2 /*return*/, options === null || options === void 0 ? void 0 : options.defaultReturnValue];
+                        }
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TaskRunner.prototype.runTask = function (name, runningTask, options) {
+        var _this = this;
+        if (this.runningTasks.length === 0) {
+            if (options.autoProgress) {
+                this.progressState.resume(options.initialProgress, options.halfLife);
+            }
+            else {
+                this.progressState.progress = options.initialProgress;
+            }
+            this.isBusy = true;
+        }
+        this.options = options;
+        this.runningTasks.push({ name: name, promise: runningTask, options: options });
+        return new Promise(function (resolve, reject) {
+            runningTask.then(function (value) {
+                var axiosResponse = value;
+                var allowPosts = options.allowPost;
+                if (name === "" && !allowPosts && axiosResponse && axiosResponse.config) {
+                    if (axiosResponse.config.method !== "get") {
+                        var message = "The operation completed, but TaskRunner.waitFor() must only be used for get operations. Change your code to use TaskRunner.run()";
+                        ModalUtils.showMessage("Error", message);
+                        reject(message);
+                        return;
+                    }
+                }
+                resolve(value);
+            })
+                .catch(function (e) { return __awaiter(_this, void 0, void 0, function () {
+                var cancel, errorInfo;
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            cancel = false;
+                            if (!(options.onError !== undefined)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.errorHandler.parseError(e)];
+                        case 1:
+                            errorInfo = _b.sent();
+                            options.onError(errorInfo);
+                            cancel = (_a = errorInfo.cancelDisplay) !== null && _a !== void 0 ? _a : false;
+                            _b.label = 2;
+                        case 2:
+                            if (!cancel && options.errorHandling !== ErrorDisplayType.ThrowError) {
+                                this.errorHandler.showError(e, options.errorHandling);
+                            }
+                            if (options.defaultReturnValue === undefined) {
+                                reject(e);
+                            }
+                            else {
+                                resolve(options.defaultReturnValue);
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            }); }).finally(function () {
+                var task = _this.runningTasks.find(function (c) { return c.promise === runningTask; });
+                if (_this.runningTasks.length === 1) {
+                    // This was the last task to finish.
+                    _this.progressState.stop();
+                    _this.isBusy = false;
+                }
+                else {
+                    if (task === _this.runningTasks[_this.runningTasks.length - 1]) {
+                        // Task that just completed was the last one added, set the loading state to the previously added task.
+                        _this.options = _this.runningTasks[_this.runningTasks.length - 2].options;
+                    }
+                }
+                _this.runningTasks.splice(_this.runningTasks.indexOf(task), 1);
+            });
+        });
+    };
+    /** Waits the specified number of milliseconds. */
+    TaskRunner.delay = function (ms) {
+        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+    };
+    __decorate([
+        Observable(),
+        __metadata("design:type", Boolean)
+    ], TaskRunner.prototype, "isBusy", void 0);
+    __decorate([
+        Observable(),
+        __metadata("design:type", Object)
+    ], TaskRunner.prototype, "options", void 0);
+    __decorate([
+        Observable(),
+        __metadata("design:type", Object)
+    ], TaskRunner.prototype, "progressState", void 0);
+    TaskRunner = __decorate([
+        injectable(),
+        NeoModel,
+        __param(0, inject(NeoTypes.UI.ErrorHandler.symbol)),
+        __metadata("design:paramtypes", [Object])
+    ], TaskRunner);
+    return TaskRunner;
+}());
+export default TaskRunner;

package/dist/Components/TooltipOptions.d.ts

@@ -1,8 +1,8 @@
-export declare type Alignment = "start" | "start-edge" | "center" | "end" | "end-edge";
-export declare type Position = "top" | "right" | "bottom" | "left";
-export interface ITooltipOptions<TContent = string> {
-    content: TContent;
-    alignment?: Alignment;
-    position?: Position;
-    className?: string;
-}
+export type Alignment = "start" | "start-edge" | "center" | "end" | "end-edge";
+export type Position = "top" | "right" | "bottom" | "left";
+export interface ITooltipOptions<TContent = string> {
+    content: TContent;
+    alignment?: Alignment;
+    position?: Position;
+    className?: string;
+}

package/dist/Components/TooltipOptions.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/Components/index.d.ts

@@ -1,22 +1,22 @@
-export { default as AnimationHelper, CollapseAnimationHelper } from './AnimationHelper';
-export { default as BootstrapHelpers } from './BootstrapHelpers';
-export * from "./BootstrapTypes";
-export { IButtonOptions, IButtonDropDownItem } from './ButtonOptions';
-export { ICollapsableOptions } from './ICollapsableOptions';
-export { IMenuItem } from './ContextMenu/ContextMenu';
-export { default as DatePicker } from './DatePicker/DatePicker';
-export { default as DatePickerOptions, IPartialDateProps, YearsInYearView } from './DatePicker/DatePickerOptions';
-export { IErrorHandler, ErrorHandler, ErrorDisplayType, IErrorDisplay } from './ErrorHandler';
-export { default as FileManager, IFileManager, IFileManagerOptions } from './FileManager/FileManager';
-export { default as BoundFileManager, IBoundFileManagerOptions } from './FileManager/BoundFileManager';
-export { FileUploadBatch } from './FileManager/FileUploadBatch';
-export { IFileResponse } from './FileManager/IFileManagerOptions';
-export { IFormOptions, IFormContextOptions } from './FormOptions';
-export { ICodeModal } from './Modal/ModalStore';
-export { INotification, INotificationOptions } from './Notifications/Notification';
-export { INotificationStore } from './Notifications/NotificationStore';
-export { INotificationHelper } from './Notifications/INotificationHelper';
-export { ProgressState } from './TaskRunner/ProgressState';
-export { default as PositionHelper } from './PositionHelper';
-import * as Tooltip from './TooltipOptions';
-export { Tooltip };
+export { default as AnimationHelper, CollapseAnimationHelper } from './AnimationHelper';
+export { default as BootstrapHelpers } from './BootstrapHelpers';
+export * from "./BootstrapTypes";
+export { IButtonOptions, IButtonDropDownItem } from './ButtonOptions';
+export { ICollapsableOptions } from './ICollapsableOptions';
+export { IMenuItem } from './ContextMenu/ContextMenu';
+export { default as DatePicker } from './DatePicker/DatePicker';
+export { default as DatePickerOptions, IPartialDateProps, YearsInYearView } from './DatePicker/DatePickerOptions';
+export { IErrorHandler, ErrorHandler, ErrorDisplayType, IErrorDisplay } from './ErrorHandler';
+export { default as FileManager, IFileManager, IFileManagerOptions } from './FileManager/FileManager';
+export { default as BoundFileManager, IBoundFileManagerOptions } from './FileManager/BoundFileManager';
+export { FileUploadBatch } from './FileManager/FileUploadBatch';
+export { IFileResponse } from './FileManager/IFileManagerOptions';
+export { IFormOptions, IFormContextOptions } from './FormOptions';
+export { ICodeModal } from './Modal/ModalStore';
+export { INotification, INotificationOptions } from './Notifications/Notification';
+export { INotificationStore } from './Notifications/NotificationStore';
+export { INotificationHelper } from './Notifications/INotificationHelper';
+export { ProgressState } from './TaskRunner/ProgressState';
+export { default as PositionHelper } from './PositionHelper';
+import * as Tooltip from './TooltipOptions';
+export { Tooltip };

package/dist/Components/index.js

@@ -1,13 +1,13 @@
-export { default as AnimationHelper, CollapseAnimationHelper } from './AnimationHelper';
-export { default as BootstrapHelpers } from './BootstrapHelpers';
-export * from "./BootstrapTypes";
-export { default as DatePicker } from './DatePicker/DatePicker';
-export { default as DatePickerOptions, YearsInYearView } from './DatePicker/DatePickerOptions';
-export { ErrorHandler, ErrorDisplayType } from './ErrorHandler';
-export { default as FileManager } from './FileManager/FileManager';
-export { default as BoundFileManager } from './FileManager/BoundFileManager';
-export { FileUploadBatch } from './FileManager/FileUploadBatch';
-export { ProgressState } from './TaskRunner/ProgressState';
-export { default as PositionHelper } from './PositionHelper';
-import * as Tooltip from './TooltipOptions';
-export { Tooltip };
+export { default as AnimationHelper, CollapseAnimationHelper } from './AnimationHelper';
+export { default as BootstrapHelpers } from './BootstrapHelpers';
+export * from "./BootstrapTypes";
+export { default as DatePicker } from './DatePicker/DatePicker';
+export { default as DatePickerOptions, YearsInYearView } from './DatePicker/DatePickerOptions';
+export { ErrorHandler, ErrorDisplayType } from './ErrorHandler';
+export { default as FileManager } from './FileManager/FileManager';
+export { default as BoundFileManager } from './FileManager/BoundFileManager';
+export { FileUploadBatch } from './FileManager/FileUploadBatch';
+export { ProgressState } from './TaskRunner/ProgressState';
+export { default as PositionHelper } from './PositionHelper';
+import * as Tooltip from './TooltipOptions';
+export { Tooltip };