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

package/dist/DebounceHelper.d.ts

@@ -1,38 +1,44 @@
-export interface IDebounceResult<T> {
-    /** True if the operation was cancelled due to a subsequent call. */
-    cancelled: boolean;
-    value?: T;
-}
-export declare class DebounceHelper<T = void, TState = any> {
-    private callback;
-    private delayMs;
-    private timer;
-    private state;
-    private currentResolver?;
-    /**
-     * 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.
-     * @param delayMs Delay in milliseconds.
-     */
-    constructor(callback: (state: TState[]) => T | Promise<T>, delayMs?: number);
-    /**
-     * Debounce a function so that it is only called after a period of inactivity.
-     * @param syncInstance The instance to synchronize against.
-     *  This should always be the same object for the function you are debouncing.
-     *  Do not debounce different functions on the same sync instance. Rather create a DebounceHelper instance for each function.
-     * @param fn Function to call when the delay has elapsed.
-     * @param delayMs Delay in milliseconds.
-     * @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. */
-    static cancelPending<TState = any>(syncInstance: any): TState[];
-    /**
-     * 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. */
-    cancelPending(): TState[];
-}
+export interface IDebounceResult<T> {
+    /** True if the operation was cancelled due to a subsequent call. */
+    cancelled: boolean;
+    value?: T;
+}
+export declare class DebounceHelper<T = void, TState = any> {
+    private callback;
+    private delayMs;
+    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.
+     * @param delayMs Delay in milliseconds.
+     */
+    constructor(callback: (state: TState[]) => T | Promise<T>, delayMs?: number);
+    /**
+     * Debounce a function so that it is only called after a period of inactivity.
+     * @param syncInstance The instance to synchronize against.
+     *  This should always be the same object for the function you are debouncing.
+     *  Do not debounce different functions on the same sync instance. Rather create a DebounceHelper instance for each function.
+     * @param fn Function to call when the delay has elapsed.
+     * @param delayMs Delay in milliseconds.
+     * @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. 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>>;
+    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

@@ -1,95 +1,122 @@
-import { __awaiter, __generator } from "tslib";
-var stateSymbol = Symbol("neo.debounce.helper");
-var DebounceHelper = /** @class */ (function () {
-    /**
-     * 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.
-     * @param delayMs Delay in milliseconds.
-     */
-    function DebounceHelper(callback, delayMs) {
-        if (delayMs === void 0) { delayMs = 0; }
-        this.callback = callback;
-        this.delayMs = delayMs;
-        this.state = [];
-    }
-    /**
-     * Debounce a function so that it is only called after a period of inactivity.
-     * @param syncInstance The instance to synchronize against.
-     *  This should always be the same object for the function you are debouncing.
-     *  Do not debounce different functions on the same sync instance. Rather create a DebounceHelper instance for each function.
-     * @param fn Function to call when the delay has elapsed.
-     * @param delayMs Delay in milliseconds.
-     * @param state State to pass to debounced method as an array of values for each time debounce was called.
-     */
-    DebounceHelper.debounce = function (syncInstance, callback, delayMs, state) {
-        var helper = syncInstance[stateSymbol];
-        if (!helper) {
-            helper = new DebounceHelper(callback, delayMs);
-            syncInstance[stateSymbol] = helper;
-        }
-        helper.callback = callback;
-        helper.delayMs = delayMs;
-        return helper.execute(state);
-    };
-    /** Cancels pending execution of the callback. Any pending promises will be resolved with cancelled: true. */
-    DebounceHelper.cancelPending = function (syncInstance) {
-        var helper = syncInstance[stateSymbol];
-        if (helper) {
-            return helper.cancelPending();
-        }
-        else {
-            return [];
-        }
-    };
-    /**
-     * 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.
-     */
-    DebounceHelper.prototype.execute = function (state) {
-        var _this = this;
-        this.cancelPending();
-        if (state !== undefined)
-            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);
-        });
-    };
-    /** Cancels pending execution of the callback. Any pending promises will be resolved with cancelled: true. */
-    DebounceHelper.prototype.cancelPending = function () {
-        if (this.timer)
-            clearTimeout(this.timer);
-        var state = this.state;
-        if (this.currentResolver) {
-            this.currentResolver({ cancelled: true });
-            this.currentResolver = undefined;
-            this.state = [];
-        }
-        return state;
-    };
-    return DebounceHelper;
-}());
-export { DebounceHelper };
+import { __awaiter, __generator } from "tslib";
+var stateSymbol = Symbol("neo.debounce.helper");
+var DebounceHelper = /** @class */ (function () {
+    /**
+     * 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.
+     * @param delayMs Delay in milliseconds.
+     */
+    function DebounceHelper(callback, delayMs) {
+        if (delayMs === void 0) { delayMs = 0; }
+        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.
+     * @param syncInstance The instance to synchronize against.
+     *  This should always be the same object for the function you are debouncing.
+     *  Do not debounce different functions on the same sync instance. Rather create a DebounceHelper instance for each function.
+     * @param fn Function to call when the delay has elapsed.
+     * @param delayMs Delay in milliseconds.
+     * @param state State to pass to debounced method as an array of values for each time debounce was called.
+     */
+    DebounceHelper.debounce = function (syncInstance, callback, delayMs, state) {
+        var helper = syncInstance[stateSymbol];
+        if (!helper) {
+            helper = new DebounceHelper(callback, delayMs);
+            syncInstance[stateSymbol] = helper;
+        }
+        helper.callback = callback;
+        helper.delayMs = delayMs;
+        return helper.execute(state);
+    };
+    /** Cancels pending execution of the callback. Pending promise will be resolved with cancelled: true. */
+    DebounceHelper.cancelPending = function (syncInstance) {
+        var helper = syncInstance[stateSymbol];
+        if (helper) {
+            return helper.cancelPending();
+        }
+        else {
+            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.
+     * @param state State to pass to the callback.
+     */
+    DebounceHelper.prototype.execute = function (state) {
+        var _this = this;
+        this.cancelPending();
+        if (state !== undefined)
+            this.state.push(state);
+        return new Promise(function (resolve, reject) {
+            _this.currentResolver = resolve;
+            _this.currentRejection = reject;
+            _this.timer = setTimeout(_this.executeCallback, _this.delayMs);
+        });
+    };
+    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);
+        var state = this.state;
+        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/Extensions.d.ts

@@ -1,82 +1,82 @@
-import { IPropertyInstance } from './Model/PropertyInstance';
-import PropertyInfo from './Model/PropertyInfo';
-import { DataType } from './Misc';
-import Decimal from 'decimal.js-light';
-declare type Group<T> = {
-    item: T;
-    details: T[];
-};
-declare global {
-    interface String {
-        /** .Net like string.format. E.g. "{0} world".format("hello") */
-        format(...args: string[]): string;
-        /** Capitalises the first letter of a string, and adds spaces before other capitals. */
-        readable(): string;
-    }
-    interface NumberConstructor {
-        ignorePrecision: number;
-    }
-    interface Number {
-        compareGT(y: number): boolean;
-        compareGTE(y: number): boolean;
-        compareLT(y: number): boolean;
-        compareLTE(y: number): boolean;
-        compareE(y: number): boolean;
-        compareNE(y: number): boolean;
-    }
-    interface Array<T> {
-        /** Sorts an array by the property name. */
-        sortBy(propertyName: keyof T, direction?: "asc" | "desc", dataType?: DataType): Array<T>;
-        /** Sorts an array using the value returned for each item by valueFn. */
-        sortBy(valueFn: (item: T) => any, direction?: "asc" | "desc", dataType?: DataType): Array<T>;
-        /** Removes the item if found in the array. */
-        remove(item: T): void;
-        /**
-         * Returns the sum for a given property.
-         */
-        sum<V extends number | Decimal = number>(propertyName: keyof T | IPropertyInstance<V> | PropertyInfo | ((item: T) => number)): V;
-        /**
-         * Returns the sum for a given property.
-         */
-        sumDecimal(propertyName: keyof T | IPropertyInstance<Decimal> | PropertyInfo | ((item: T) => Decimal)): Decimal;
-        /**
-         * Returns the average for a given property.
-         */
-        average(propertyName: keyof T | IPropertyInstance | PropertyInfo | ((item: T) => number)): number;
-        /**
-         * Group a list by the provided key.
-         * @param keyFn Function which returns the key for grouping.
-         * @param selector Callback which returns a grouped record. The arguments are the key value, first item with this key, and array of items under this key.
-         */
-        groupBy<G>(keyFn: (item: T) => string | number, selector: (key: string, item: T, details: T[]) => G): G[];
-        /**
-         * Group a list by the provided key.
-         * @param keyFn Function which returns the key for grouping.
-         */
-        groupBy(keyFn: (item: T) => string | number): Group<T>[];
-        /**
-         * Group a list by the provided key.
-         * @param key Key property.
-         * @param selector Callback which returns a grouped record. The arguments are the key value, first item with this key, and array of items under this key.
-         */
-        groupBy<G>(key: keyof T, selector: (key: string, item: T, details: T[]) => G): G[];
-        /**
-         * Create an index from the array. Items with duplicate keys will result in the last item being added to the index.
-         * @param keyFn Function which returns the key value from each item.
-         */
-        toDictionary<K extends string | number>(keyFn: (item: T) => K): {
-            [index in K]: T;
-        };
-        toDictionary<K extends string | number, V>(keyFn: (item: T) => K, valueFn: (item: T) => V): {
-            [index in K]: V;
-        };
-    }
-    interface Map<K, V> {
-        /**
-         * Adds the value if it does not exists, and returns it.
-         * @param valueCallback Callback function which returns a value for the key.
-         */
-        getOrAdd?(key: K, valueCallback: (key: K) => V): V;
-    }
-}
-export {};
+import { IPropertyInstance } from './Model/PropertyInstance';
+import PropertyInfo from './Model/PropertyInfo';
+import { DataType } from './Misc';
+import Decimal from 'decimal.js-light';
+type Group<T> = {
+    item: T;
+    details: T[];
+};
+declare global {
+    interface String {
+        /** .Net like string.format. E.g. "{0} world".format("hello") */
+        format(...args: string[]): string;
+        /** Capitalises the first letter of a string, and adds spaces before other capitals. */
+        readable(): string;
+    }
+    interface NumberConstructor {
+        ignorePrecision: number;
+    }
+    interface Number {
+        compareGT(y: number): boolean;
+        compareGTE(y: number): boolean;
+        compareLT(y: number): boolean;
+        compareLTE(y: number): boolean;
+        compareE(y: number): boolean;
+        compareNE(y: number): boolean;
+    }
+    interface Array<T> {
+        /** Sorts an array by the property name. */
+        sortBy(propertyName: keyof T, direction?: "asc" | "desc", dataType?: DataType): Array<T>;
+        /** Sorts an array using the value returned for each item by valueFn. */
+        sortBy(valueFn: (item: T) => any, direction?: "asc" | "desc", dataType?: DataType): Array<T>;
+        /** Removes the item if found in the array. */
+        remove(item: T): void;
+        /**
+         * Returns the sum for a given property.
+         */
+        sum<V extends number | Decimal = number>(propertyName: keyof T | IPropertyInstance<V> | PropertyInfo | ((item: T) => number)): V;
+        /**
+         * Returns the sum for a given property.
+         */
+        sumDecimal(propertyName: keyof T | IPropertyInstance<Decimal> | PropertyInfo | ((item: T) => Decimal)): Decimal;
+        /**
+         * Returns the average for a given property.
+         */
+        average(propertyName: keyof T | IPropertyInstance | PropertyInfo | ((item: T) => number)): number;
+        /**
+         * Group a list by the provided key.
+         * @param keyFn Function which returns the key for grouping.
+         * @param selector Callback which returns a grouped record. The arguments are the key value, first item with this key, and array of items under this key.
+         */
+        groupBy<G>(keyFn: (item: T) => string | number, selector: (key: string, item: T, details: T[]) => G): G[];
+        /**
+         * Group a list by the provided key.
+         * @param keyFn Function which returns the key for grouping.
+         */
+        groupBy(keyFn: (item: T) => string | number): Group<T>[];
+        /**
+         * Group a list by the provided key.
+         * @param key Key property.
+         * @param selector Callback which returns a grouped record. The arguments are the key value, first item with this key, and array of items under this key.
+         */
+        groupBy<G>(key: keyof T, selector: (key: string, item: T, details: T[]) => G): G[];
+        /**
+         * Create an index from the array. Items with duplicate keys will result in the last item being added to the index.
+         * @param keyFn Function which returns the key value from each item.
+         */
+        toDictionary<K extends string | number>(keyFn: (item: T) => K): {
+            [index in K]: T;
+        };
+        toDictionary<K extends string | number, V>(keyFn: (item: T) => K, valueFn: (item: T) => V): {
+            [index in K]: V;
+        };
+    }
+    interface Map<K, V> {
+        /**
+         * Adds the value if it does not exists, and returns it.
+         * @param valueCallback Callback function which returns a value for the key.
+         */
+        getOrAdd?(key: K, valueCallback: (key: K) => V): V;
+    }
+}
+export {};