@singularsystems/neo-core 0.10.51 → 0.10.53

package/dist/Components/FileManager/FileManager.d.ts

@@ -43,6 +43,7 @@ export declare abstract class FileManagerBase<TOptions extends IBaseFileManagerO
     constructor(options: TOptions);
     get uploadEndpoint(): string | undefined;
     options: TOptions;
+    protected get allowMultiple(): boolean;
     /**
      * Shows a file dialog and then calls processFiles.
      * onFilesSelected will be called if you need to handle the event.
@@ -74,5 +75,6 @@ export interface IFileManagerOptions extends IBaseFileManagerOptions {
 }
 export default class FileManager extends FileManagerBase<IFileManagerOptions> {
     getFileInputProps(): Partial<HTMLInputElement>;
+    protected get allowMultiple(): boolean;
 }
 export {};

package/dist/Components/FileManager/FileManager.js

@@ -47,6 +47,13 @@ var FileManagerBase = /** @class */ (function () {
         enumerable: true,
         configurable: true
     });
+    Object.defineProperty(FileManagerBase.prototype, "allowMultiple", {
+        get: function () {
+            return false;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Shows a file dialog and then calls processFiles.
      * onFilesSelected will be called if you need to handle the event.
@@ -91,6 +98,9 @@ var FileManagerBase = /** @class */ (function () {
         if (options === void 0) { options = {}; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
+                if (files.length > 1 && !this.allowMultiple) {
+                    files = [Array.from(files)[0]];
+                }
                 if (this.validateFiles(files)) {
                     if (this.options.onFilesSelected) {
                         this.options.onFilesSelected(files, this);
@@ -249,6 +259,14 @@ var FileManager = /** @class */ (function (_super) {
         props.multiple = this.options.multiple === true;
         return props;
     };
+    Object.defineProperty(FileManager.prototype, "allowMultiple", {
+        get: function () {
+            var _a;
+            return _a = this.options.multiple, (_a !== null && _a !== void 0 ? _a : false);
+        },
+        enumerable: true,
+        configurable: true
+    });
     FileManager = __decorate([
         NeoModel
     ], FileManager);

package/dist/Data/Paging/PageManager.js

@@ -230,6 +230,7 @@ var PageManager = /** @class */ (function (_super) {
     PageManager.prototype.reset = function () {
         this.initialFetchState = "none";
         this.data.set([]);
+        this._totalRecords = 0;
     };
     /**
      * Resets the sort properties. A new sort property can be provided.

package/dist/DebounceHelper.d.ts

@@ -9,6 +9,7 @@ export declare class DebounceHelper<T = void, TState = any> {
     private timer;
     private state;
     private currentResolver?;
+    private currentRejection?;
     /**
      * Creates a debounce helper instance.
      * @param callback Callback function to run. All state passed to the execute method from current and previous calls will be passed to the callback.
@@ -25,14 +26,19 @@ export declare class DebounceHelper<T = void, TState = any> {
      * @param state State to pass to debounced method as an array of values for each time debounce was called.
      */
     static debounce<T = any, TState = any>(syncInstance: any, callback: (state: TState[]) => T | Promise<T>, delayMs: number, state?: TState): Promise<IDebounceResult<T>>;
-    /** Cancels pending execution of the callback. Any pending promises will be resolved with cancelled: true. */
+    /** Cancels pending execution of the callback. Pending promise will be resolved with cancelled: true. */
     static cancelPending<TState = any>(syncInstance: any): TState[];
+    /** Fires the latest callback immediately. Pending promise from execute() will also be resolved with the return value of the callback. */
+    static executeImmediate(syncInstance: any): Promise<void>;
     /**
      * Waits the interval defined in the constructor, then executes the callback.
      * The callback will not execute if execute is called again within the interval.
      * @param state State to pass to the callback.
      */
     execute(state?: TState): Promise<IDebounceResult<T>>;
-    /** Cancels pending execution of the callback. Any pending promises will be resolved with cancelled: true. */
+    private executeCallback;
+    /** Cancels pending execution of the callback. Pending promise will be resolved with cancelled: true. */
     cancelPending(): TState[];
+    /** Fires the latest callback immediately. Pending promise from execute() will also be resolved with the return value of the callback. */
+    executeImmediate(): Promise<void>;
 }

package/dist/DebounceHelper.js

@@ -11,6 +11,7 @@ var DebounceHelper = /** @class */ (function () {
         this.callback = callback;
         this.delayMs = delayMs;
         this.state = [];
+        this.executeCallback = this.executeCallback.bind(this);
     }
     /**
      * Debounce a function so that it is only called after a period of inactivity.
@@ -31,7 +32,7 @@ var DebounceHelper = /** @class */ (function () {
         helper.delayMs = delayMs;
         return helper.execute(state);
     };
-    /** Cancels pending execution of the callback. Any pending promises will be resolved with cancelled: true. */
+    /** Cancels pending execution of the callback. Pending promise will be resolved with cancelled: true. */
     DebounceHelper.cancelPending = function (syncInstance) {
         var helper = syncInstance[stateSymbol];
         if (helper) {
@@ -41,6 +42,16 @@ var DebounceHelper = /** @class */ (function () {
             return [];
         }
     };
+    /** Fires the latest callback immediately. Pending promise from execute() will also be resolved with the return value of the callback. */
+    DebounceHelper.executeImmediate = function (syncInstance) {
+        var helper = syncInstance[stateSymbol];
+        if (helper) {
+            return helper.executeImmediate();
+        }
+        else {
+            return Promise.resolve();
+        }
+    };
     /**
      * Waits the interval defined in the constructor, then executes the callback.
      * The callback will not execute if execute is called again within the interval.
@@ -53,32 +64,41 @@ var DebounceHelper = /** @class */ (function () {
             this.state.push(state);
         return new Promise(function (resolve, reject) {
             _this.currentResolver = resolve;
-            _this.timer = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                var returnValue, e_1;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            _a.trys.push([0, 2, 3, 4]);
-                            return [4 /*yield*/, Promise.resolve(this.callback(this.state))];
-                        case 1:
-                            returnValue = _a.sent();
-                            resolve({ cancelled: false, value: returnValue });
-                            return [3 /*break*/, 4];
-                        case 2:
-                            e_1 = _a.sent();
-                            reject(e_1);
-                            return [3 /*break*/, 4];
-                        case 3:
-                            this.currentResolver = undefined;
-                            this.state = [];
-                            return [7 /*endfinally*/];
-                        case 4: return [2 /*return*/];
-                    }
-                });
-            }); }, _this.delayMs);
+            _this.currentRejection = reject;
+            _this.timer = setTimeout(_this.executeCallback, _this.delayMs);
         });
     };
-    /** Cancels pending execution of the callback. Any pending promises will be resolved with cancelled: true. */
+    DebounceHelper.prototype.executeCallback = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var returnValue, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        return [4 /*yield*/, Promise.resolve(this.callback(this.state))];
+                    case 1:
+                        returnValue = _a.sent();
+                        if (this.currentResolver) {
+                            this.currentResolver({ cancelled: false, value: returnValue });
+                        }
+                        return [3 /*break*/, 4];
+                    case 2:
+                        e_1 = _a.sent();
+                        if (this.currentRejection) {
+                            this.currentRejection(e_1);
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this.currentResolver = undefined;
+                        this.currentRejection = undefined;
+                        this.state = [];
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Cancels pending execution of the callback. Pending promise will be resolved with cancelled: true. */
     DebounceHelper.prototype.cancelPending = function () {
         if (this.timer)
             clearTimeout(this.timer);
@@ -86,10 +106,17 @@ var DebounceHelper = /** @class */ (function () {
         if (this.currentResolver) {
             this.currentResolver({ cancelled: true });
             this.currentResolver = undefined;
+            this.currentRejection = undefined;
             this.state = [];
         }
         return state;
     };
+    /** Fires the latest callback immediately. Pending promise from execute() will also be resolved with the return value of the callback. */
+    DebounceHelper.prototype.executeImmediate = function () {
+        if (this.timer)
+            clearTimeout(this.timer);
+        return this.executeCallback();
+    };
     return DebounceHelper;
 }());
 export { DebounceHelper };

package/dist/Model/BaseModels/ReasonedUserEvent.d.ts

@@ -1,4 +1,5 @@
 import { UserEventBase } from './UserEvent';
 export declare class ReasonedUserEvent extends UserEventBase {
     reason: string;
+    static None(): ReasonedUserEvent;
 }

package/dist/Model/BaseModels/ReasonedUserEvent.js

@@ -7,11 +7,16 @@ var ReasonedUserEvent = /** @class */ (function (_super) {
     function ReasonedUserEvent() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    ReasonedUserEvent_1 = ReasonedUserEvent;
+    ReasonedUserEvent.None = function () {
+        return new ReasonedUserEvent_1();
+    };
+    var ReasonedUserEvent_1;
     __decorate([
         StringLength(255),
         __metadata("design:type", String)
     ], ReasonedUserEvent.prototype, "reason", void 0);
-    ReasonedUserEvent = __decorate([
+    ReasonedUserEvent = ReasonedUserEvent_1 = __decorate([
         NeoModel
     ], ReasonedUserEvent);
     return ReasonedUserEvent;

package/dist/Model/BaseModels/UserEvent.d.ts

@@ -5,4 +5,5 @@ export declare abstract class UserEventBase extends ValueObject {
     get isCompleted(): boolean;
 }
 export declare class UserEvent extends UserEventBase {
+    static None(): UserEvent;
 }

package/dist/Model/BaseModels/UserEvent.js

@@ -24,7 +24,12 @@ var UserEvent = /** @class */ (function (_super) {
     function UserEvent() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    UserEvent = __decorate([
+    UserEvent_1 = UserEvent;
+    UserEvent.None = function () {
+        return new UserEvent_1();
+    };
+    var UserEvent_1;
+    UserEvent = UserEvent_1 = __decorate([
         NeoModel
     ], UserEvent);
     return UserEvent;

package/dist/Model/Misc.d.ts

@@ -58,6 +58,8 @@ export interface IAutoRunner extends IDisposable {
     dispose(): void;
     /** Cancels any pending callbacks. */
     cancelPending(): void;
+    /** Cancels any pending callbacks, and fires the callback immediately. */
+    fireImmediate(): void;
 }
 export interface IAutoRunnerOptions<T> extends IDebounceOptions {
     /**

package/dist/Utils.d.ts

@@ -71,6 +71,7 @@ export declare class Utils {
      * @param state State to pass to debounced method as an array of values for each time debounce was called.
      */
     static debounce<T = any, TState = any>(syncInstance: any, callback: (state: TState[]) => T | Promise<T>, delayMs: number, state?: TState): Promise<IDebounceResult<T>>;
+    /** Cancels pending execution of the callback. */
     static clearDebounce<TState = any>(syncInstance: any): TState[];
     /**
      * Gets a list of property values in query string format. Does not include the leading ?.

package/dist/Utils.js

@@ -151,6 +151,7 @@ var Utils = /** @class */ (function () {
     Utils.debounce = function (syncInstance, callback, delayMs, state) {
         return DebounceHelper.debounce(syncInstance, callback, delayMs, state);
     };
+    /** Cancels pending execution of the callback. */
     Utils.clearDebounce = function (syncInstance) {
         return DebounceHelper.cancelPending(syncInstance);
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@singularsystems/neo-core",
-  "version": "0.10.51",
+  "version": "0.10.53",
   "description": "Core functionality for the Neo client library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",