@singularsystems/neo-core 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/AppServices/NeoTypes.d.ts

@@ -18,7 +18,7 @@ import { IRouteSecurityService } from '../Routing/IRouteSecurityService';
 import { IContextMenuState } from '../Components/ContextMenu/ContextMenu';
 import { INavigationHelper } from '../Routing/INavigationHelper';
 import { ILoginErrorHandler } from '../Security/ILoginErrorHandler';
-import Decimal from 'decimal.js-light';
+import { IDecimalService } from "../Numeric";
 declare const NeoTypes: {
     Axios: ServiceIdentifier<import("axios").AxiosStatic>;
     Config: {
@@ -28,14 +28,12 @@ declare const NeoTypes: {
     Core: {
         AutoRunnerFactory: ServiceIdentifier<IAutoRunnerFactory>;
         ConnectionManager: ServiceIdentifier<IConnectionManager>;
+        DecimalService: ServiceIdentifier<IDecimalService<import("../Numeric").IDecimal>>;
         ModelCreator: ServiceIdentifier<IModelCreatorBase>;
     };
     Localisation: {
         LocalisationService: ServiceIdentifier<ILocalisationService>;
     };
-    Misc: {
-        DecimalType: ServiceIdentifier<typeof Decimal>;
-    };
     Routing: {
         MenuItemProvider: ServiceIdentifier<IMenuItemProvider<import("../Routing").IMenuRoute>>;
         NavigationHelper: ServiceIdentifier<INavigationHelper>;

package/dist/AppServices/NeoTypes.js

@@ -9,14 +9,12 @@ var NeoTypes = {
     Core: {
         AutoRunnerFactory: new ServiceIdentifier("Neo.AutoRunnerFactory"),
         ConnectionManager: new ServiceIdentifier("Neo.ConnectionManager"),
+        DecimalService: new ServiceIdentifier("Neo.DecimalService"),
         ModelCreator: new ServiceIdentifier("Neo.ModelCreator")
     },
     Localisation: {
         LocalisationService: new ServiceIdentifier("Neo.Localisation")
     },
-    Misc: {
-        DecimalType: new ServiceIdentifier("Neo.Decimal")
-    },
     Routing: {
         MenuItemProvider: new ServiceIdentifier("Neo.MenuItemProvider"),
         NavigationHelper: new ServiceIdentifier("Neo.NavigationHelper"),

package/dist/Data/DataView.js

@@ -115,7 +115,7 @@ export var DataViewBase = /** @class */ (function () {
                 }
                 DataViewBase.unTrackedSort(function () {
                     for (var i = sortFns_1.length - 1; i >= 0; i--) {
-                        itemsToSort_1.sortBy(sortFns_1[i].valueFn, sortFns_1[i].direction, sortFns_1[i].property.propertyType);
+                        itemsToSort_1 = itemsToSort_1.sortBy(sortFns_1[i].valueFn, sortFns_1[i].direction, sortFns_1[i].property.propertyType);
                     }
                 });
                 return __spreadArray(__spreadArray([], itemsToSort_1, true), endItems, true);

package/dist/Data/Deserialiser.js

@@ -1,6 +1,6 @@
 import { TrackingState, SerialiseType, DataType, RelationType } from '../Model/Misc';
 import { Utils } from '../Utils';
-import Decimal from 'decimal.js-light';
+import NumberUtils from "../NumberUtils";
 var Deserialiser = /** @class */ (function () {
     function Deserialiser() {
         this.objectRefs = {};
@@ -169,7 +169,7 @@ var Deserialiser = /** @class */ (function () {
                                 to[key] = new Date(fromValue);
                             }
                             else if (fromValue !== null && propertyInfo.propertyType === DataType.Decimal) {
-                                to[key] = new Decimal(fromValue);
+                                to[key] = NumberUtils.decimalService.createDecimal(fromValue);
                             }
                             else {
                                 if (fromValue instanceof Array && !propertyInfo.assignOnDeserialise) {

package/dist/Data/Serialiser.js

@@ -2,7 +2,7 @@ import { TrackingState, SerialiseType, RelationType, TimeZoneFormat, DataType }
 import { Deserialiser } from './Deserialiser';
 import ValueObject from '../Model/ValueObject';
 import DateUtils from '../Dates/DateUtils';
-import Globals from '../Globals';
+import NumberUtils from "../NumberUtils";
 var referenceIdKey = Symbol("referenceId");
 var JSFormatter = /** @class */ (function () {
     function JSFormatter() {
@@ -116,7 +116,7 @@ var Serialiser = /** @class */ (function () {
                         propertyInfo.serialise !== SerialiseType.MappingOnly &&
                         (propertyInfo.serialise !== SerialiseType.FullOnly || this.options.includeClean)) {
                         var fromValue = from[key];
-                        var isChildObject = (fromValue && fromValue instanceof Object && !(fromValue instanceof Date) && !(fromValue instanceof Globals.decimalType)) || propertyInfo.relationType === RelationType.ChildObject;
+                        var isChildObject = (fromValue && fromValue instanceof Object && !(fromValue instanceof Date) && !(NumberUtils.decimalService.isDecimal(fromValue))) || propertyInfo.relationType === RelationType.ChildObject;
                         if (fromValue instanceof Array) {
                             // Arrays of simple types are always included.
                             if (!this.options.suppressChildren || (fromValue.length > 0 && !(fromValue[0] instanceof Object))) {
@@ -144,7 +144,7 @@ var Serialiser = /** @class */ (function () {
                             // Simple values and dates
                             if (fromValue !== null || propertyInfo.serialise !== SerialiseType.NotNull) {
                                 if (fromValue !== null && propertyInfo.propertyType === DataType.Decimal) {
-                                    to[key] = fromValue.toNumber();
+                                    to[key] = NumberUtils.decimalService.toNumber(fromValue);
                                 }
                                 else if (propertyInfo.timeZoneSerialisation === TimeZoneFormat.None && fromValue instanceof Date) {
                                     to[key] = DateUtils.format(fromValue, "yyyy-MM-dd") + "T00:00:00";

package/dist/Decimal/DecimalService.d.ts

@@ -0,0 +1,23 @@
+import { IDecimal, IDecimalService } from "./IDecimal";
+interface IMikeMCLDecimal extends IDecimal {
+    toNumber(): number;
+    round(precision: number, roundingType: number): IMikeMCLDecimal;
+    cmp(to: IMikeMCLDecimal): 0 | 1 | -1;
+    plus(number: IMikeMCLDecimal): IMikeMCLDecimal;
+    div(number: IMikeMCLDecimal | number): IMikeMCLDecimal;
+}
+export declare class DecimalService<T extends IMikeMCLDecimal> implements IDecimalService<T> {
+    private decimalType;
+    private roundHalfUpValue;
+    private roundDownValue;
+    constructor(decimalType: T, roundHalfUpValue: number, roundDownValue: number);
+    isDecimal(value: any): value is IMikeMCLDecimal;
+    createDecimal(value: number | string): T;
+    toNumber(value: number | T): number;
+    round(value: T, precision: number): T;
+    truncate(value: T): T;
+    compare(value1: T, value2: T): 0 | 1 | -1;
+    sum(values: T[]): T;
+    divideBy(value: T, divisor: number | T): T;
+}
+export {};

package/dist/Decimal/DecimalService.js

@@ -0,0 +1,38 @@
+var DecimalService = /** @class */ (function () {
+    function DecimalService(decimalType, roundHalfUpValue, roundDownValue) {
+        this.decimalType = decimalType;
+        this.roundHalfUpValue = roundHalfUpValue;
+        this.roundDownValue = roundDownValue;
+    }
+    DecimalService.prototype.isDecimal = function (value) {
+        return value instanceof this.decimalType;
+    };
+    DecimalService.prototype.createDecimal = function (value) {
+        return new this.decimalType(value);
+    };
+    DecimalService.prototype.toNumber = function (value) {
+        if (this.isDecimal(value)) {
+            return value.toNumber();
+        }
+        else {
+            return value;
+        }
+    };
+    DecimalService.prototype.round = function (value, precision) {
+        return value.round(precision, this.roundHalfUpValue);
+    };
+    DecimalService.prototype.truncate = function (value) {
+        return value.round(0, this.roundDownValue);
+    };
+    DecimalService.prototype.compare = function (value1, value2) {
+        return value1.cmp(value2);
+    };
+    DecimalService.prototype.sum = function (values) {
+        return values.reduce(function (total, item) { return total.plus(item); }, this.createDecimal(0));
+    };
+    DecimalService.prototype.divideBy = function (value, divisor) {
+        return value.div(divisor);
+    };
+    return DecimalService;
+}());
+export { DecimalService };

package/dist/Decimal/IDecimal.d.ts

@@ -0,0 +1,25 @@
+export interface IDecimal {
+    new (value: number | string): IDecimal;
+}
+export interface IDecimalService<T extends IDecimal = IDecimal> {
+    /** Returns true if the provided value is a decimal instance. */
+    isDecimal(value: any): value is IDecimal;
+    /** Creates a decimal instance from a javascript number. */
+    createDecimal(value: number | string): T;
+    /** If the provided value is a decimal, converts it to a number, otherwise returns the number passed in. */
+    toNumber(value: number | T): number;
+    /** Rounds a number. */
+    round(value: T, precision: number): T;
+    /** Removes decimal places from the value. Equivalent to round down with zero decimal places. */
+    truncate(value: T): T;
+    /** Compares 2 decimals.
+     * Returns 1 if value1 > value2
+     * Returns -1 if value1 < value2
+     * Returns 0 if equal
+     */
+    compare(value1: T, value2: T): 0 | 1 | -1;
+    /** Sums a list of decimals and returns the total as a decimal. */
+    sum(values: T[]): T;
+    /** Divides value by divisor and returns the result. */
+    divideBy(value: T, divisor: number | T): T;
+}

package/dist/Decimal/IDecimal.js

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

package/dist/Extensions.d.ts

@@ -1,7 +1,7 @@
 import { IPropertyInstance } from './Model/PropertyInstance';
 import PropertyInfo from './Model/PropertyInfo';
 import { DataType } from './Misc';
-import Decimal from 'decimal.js-light';
+import { IDecimal } from "./Numeric/IDecimalService";
 type Group<T> = {
     item: T;
     details: T[];
@@ -34,11 +34,11 @@ declare global {
         /**
          * Returns the sum for a given property.
          */
-        sum<V extends number | Decimal = number>(propertyName: keyof T | IPropertyInstance<V> | PropertyInfo | ((item: T) => number)): V;
+        sum<V extends number | IDecimal = number>(propertyName: keyof T | IPropertyInstance<V> | PropertyInfo | ((item: T) => V)): V;
         /**
          * Returns the sum for a given property.
          */
-        sumDecimal(propertyName: keyof T | IPropertyInstance<Decimal> | PropertyInfo | ((item: T) => Decimal)): Decimal;
+        sumDecimal(propertyName: keyof T | IPropertyInstance<IDecimal> | PropertyInfo | ((item: T) => IDecimal)): IDecimal;
         /**
          * Returns the average for a given property.
          */

package/dist/Extensions.js

@@ -1,6 +1,6 @@
 import { __spreadArray } from "tslib";
 import { DataType } from './Misc';
-import Decimal from 'decimal.js-light';
+import { NumberUtils, Utils } from ".";
 //#region Strings
 String.prototype.format = function () {
     var args = [];
@@ -84,16 +84,12 @@ Array.prototype.sortBy = function (valueFnOrKey, direction, dataType) {
                 return delta;
             }
             else {
-                return bValue.comparedTo(aValue) * delta;
+                return NumberUtils.decimalService.compare(aValue, bValue) * delta; // TODO: check this! bValue!.comparedTo(aValue!) * delta;
             }
         };
     }
     var array = this;
-    if (this.addNew) {
-        // Mobx6 doesn't allow the array to be sorted in place, must create a new one.
-        array = this.slice();
-    }
-    return array.sort(comparer);
+    return Utils.sortableArray(array).sort(comparer);
 };
 Array.prototype.remove = function (item) {
     var index = this.indexOf(item);
@@ -102,43 +98,38 @@ Array.prototype.remove = function (item) {
     }
 };
 function getPropertyName(property) {
-    if (property instanceof String) {
-        return { key: property };
+    if (typeof property === "string") {
+        return property;
     }
     else {
         var propertyInfo = property;
         if (property.propertyInfo) {
             propertyInfo = property.propertyInfo;
         }
-        return { key: propertyInfo.propertyName, isDecimal: propertyInfo.propertyType === DataType.Decimal };
+        return propertyInfo.propertyName;
     }
 }
-Array.prototype.sum = function (property) {
-    if (property instanceof Function) {
-        return this.reduce(function (total, item) { return total + property(item); }, 0);
+function map(list, property) {
+    if (typeof property === "function") {
+        return list.map(property);
     }
     else {
-        var propertyInfo_1 = getPropertyName(property);
-        if (propertyInfo_1.isDecimal) {
-            return sumDecimal(this, propertyInfo_1.key);
-        }
-        else {
-            return this.reduce(function (total, item) { return total + item[propertyInfo_1.key]; }, 0);
-        }
+        var propertyName_1 = getPropertyName(property);
+        return list.map(function (item) { return item[propertyName_1]; });
     }
-};
-Array.prototype.sumDecimal = function (property) {
-    if (property instanceof Function) {
-        return this.reduce(function (total, item) { return total.add(property(item)); }, new Decimal(0));
+}
+Array.prototype.sum = function (property) {
+    if (this.length === 0) {
+        return 0;
+    }
+    var values = map(this, property);
+    if (NumberUtils.decimalService.isDecimal(values[0])) {
+        return NumberUtils.decimalService.sum(values);
     }
     else {
-        var propertyInfo = getPropertyName(property);
-        return sumDecimal(this, propertyInfo.key);
+        return values.reduce(function (total, number) { return total + number; }, 0);
     }
 };
-function sumDecimal(items, propertyName) {
-    return items.reduce(function (total, item) { return total.add(item[propertyName]); }, new Decimal(0));
-}
 Array.prototype.average = function (property) {
     return this.length === 0 ? 0 : this.sum(property) / this.length;
 };

package/dist/Globals.d.ts

@@ -1,5 +1,4 @@
 import { IAppService } from './AppServices/AppService';
-import Decimal from 'decimal.js-light';
 export default class Globals {
     /** Global app service which hosts the DI container. */
     static appService: IAppService;
@@ -14,6 +13,4 @@ export default class Globals {
      * Use this for adding elements to the root level.
      */
     static get rootElement(): HTMLElement | ShadowRoot;
-    private static _decimalType;
-    static get decimalType(): typeof Decimal;
 }

package/dist/Globals.js

@@ -1,4 +1,3 @@
-import { NeoTypes } from './AppServices';
 var Globals = /** @class */ (function () {
     function Globals() {
     }
@@ -26,16 +25,6 @@ var Globals = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(Globals, "decimalType", {
-        get: function () {
-            if (this._decimalType === undefined) {
-                this._decimalType = this.appService.get(NeoTypes.Misc.DecimalType);
-            }
-            return this._decimalType;
-        },
-        enumerable: false,
-        configurable: true
-    });
     return Globals;
 }());
 export default Globals;

package/dist/Model/LookupBase.d.ts

@@ -1,13 +1,6 @@
-import { IDeserialiseOptions } from '../Data/Deserialiser';
 import { BindableBase } from './BindableBase';
-import { IBindableBase, PartialPlainObject } from './IModelBase';
+import { IBindableBase } from './IModelBase';
 export interface ILookupBase extends IBindableBase {
 }
 export declare abstract class LookupBase extends BindableBase implements ILookupBase {
-    /**
-     * @deprecated Models that extend LookupBase are designed to be immutable.
-     * Calling set() on an instance that is already being observed will not cause the ui to update.
-     * Rather deserialise on create using `MyLookup.fromJSObject<MyLookup>(data)`.
-     * */
-    set(jsObject: PartialPlainObject<this>, options?: IDeserialiseOptions): void;
 }

package/dist/Model/LookupBase.js

@@ -5,15 +5,6 @@ var LookupBase = /** @class */ (function (_super) {
     function LookupBase() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    /**
-     * @deprecated Models that extend LookupBase are designed to be immutable.
-     * Calling set() on an instance that is already being observed will not cause the ui to update.
-     * Rather deserialise on create using `MyLookup.fromJSObject<MyLookup>(data)`.
-     * */
-    LookupBase.prototype.set = function (jsObject, options) {
-        console.warn("Do not use the set() method on lookup models. Rather use the static fromJSObject().");
-        _super.prototype.set.call(this, jsObject, options);
-    };
     return LookupBase;
 }(BindableBase));
 export { LookupBase };

package/dist/Model/PropertyInfo.js

@@ -1,6 +1,6 @@
 import { __spreadArray } from "tslib";
 import { SerialiseType, RelationType, DataType } from './Misc';
-import Globals from '../Globals';
+import NumberUtils from "../NumberUtils";
 var PropertyInfo = /** @class */ (function () {
     function PropertyInfo(propertyName) {
         this.propertyName = propertyName;
@@ -127,7 +127,7 @@ var PropertyInfo = /** @class */ (function () {
     PropertyInfo.prototype.setupFromInstance = function (instance) {
         var value = instance[this.propertyName];
         if (value) {
-            if (value instanceof Globals.decimalType) {
+            if (NumberUtils.decimalService.isDecimal(value)) {
                 this.propertyType = DataType.Decimal;
             }
         }

package/dist/NumberUtils.d.ts

@@ -1,5 +1,5 @@
-import Decimal from "decimal.js-light";
 import { IPropertyInstance } from "./Model";
+import { IDecimal, IDecimalService } from "./Numeric/IDecimalService";
 export declare enum NumberFormat {
     None = 0,
     NoDecimals = 4096,
@@ -10,6 +10,9 @@ export declare enum NumberFormat {
     CurrencyDecimals = 4353
 }
 export default class NumberUtils {
+    private static _decimalService?;
+    /** Decimal service used internally by neo. Project code should use the chosen decimal package directly. */
+    static get decimalService(): IDecimalService;
     static thousandsSeparator: string;
     static decimalSeparator?: string;
     /** Set this to `","` if you want to allow a comma as a decimal separator when parsing string input. */
@@ -41,7 +44,7 @@ export default class NumberUtils {
     /**
      * Rounds a number to the nearest no of decimals.
      */
-    static round<T extends number | Decimal>(number: T, decimals: number): T;
+    static round<T extends number | IDecimal>(number: T, decimals: number): T;
     /**
      * Returns the number of decimal places in a format string.
      * @param formatString Format string.
@@ -53,15 +56,15 @@ export default class NumberUtils {
      * Converts a number to a string using the specified format.
      * E.g. #,##0.00;(#,##0.00)
      */
-    static format(number: number | Decimal, formatString: string): string;
+    static format(number: number | IDecimal, formatString: string): string;
     /**
      * Converts a number to a string using the specified format.
      */
-    static format(number: number | Decimal, format: NumberFormat, currencySymbol?: string): string;
+    static format(number: number | IDecimal, format: NumberFormat, currencySymbol?: string): string;
     /**
      * Converts the properties value to a string based on the float / integer decorator.
      */
-    static format(property: IPropertyInstance<number | Decimal>): string;
+    static format(property: IPropertyInstance<number | IDecimal>): string;
     private static formatUsingEnum;
     private static formatInternal;
 }

package/dist/NumberUtils.js

@@ -1,6 +1,6 @@
-import Decimal from "decimal.js-light";
+import { Misc } from ".";
+import { NeoTypes } from "./AppServices";
 import { DataType } from "./Model/Misc";
-import Globals from './Globals';
 export var NumberFormat;
 (function (NumberFormat) {
     // Mask is [Thousands Separator, Decimals (2 places), Percent, Currency Symbol]
@@ -15,6 +15,17 @@ export var NumberFormat;
 var NumberUtils = /** @class */ (function () {
     function NumberUtils() {
     }
+    Object.defineProperty(NumberUtils, "decimalService", {
+        /** Decimal service used internally by neo. Project code should use the chosen decimal package directly. */
+        get: function () {
+            if (!this._decimalService) {
+                this._decimalService = Misc.Globals.appService.get(NeoTypes.Core.DecimalService);
+            }
+            return this._decimalService;
+        },
+        enumerable: false,
+        configurable: true
+    });
     NumberUtils.initialise = function () {
         NumberUtils.numberFormats[NumberFormat.None] = "#";
         NumberUtils.numberFormats[NumberFormat.NoDecimals] = "#,##0;(#,##0)";
@@ -85,13 +96,13 @@ var NumberUtils = /** @class */ (function () {
      * Rounds a number to the nearest no of decimals.
      */
     NumberUtils.round = function (number, decimals) {
-        if (number instanceof Globals.decimalType) {
+        if (this.decimalService.isDecimal(number)) {
             // Round away from zero.
-            return number.toDecimalPlaces(decimals, Decimal.ROUND_HALF_UP);
+            return this.decimalService.round(number, decimals);
         }
         else {
             if (decimals > 0) {
-                return parseFloat((number).toFixed(decimals));
+                return parseFloat(number.toFixed(decimals));
             }
             else {
                 return parseInt(number.toFixed(0));
@@ -135,19 +146,19 @@ var NumberUtils = /** @class */ (function () {
         }
         return decimalsPart;
     };
-    NumberUtils.format = function (number, format, currencySymbol) {
-        if (number instanceof Globals.decimalType) {
-            number = number.toNumber();
+    NumberUtils.format = function (value, format, currencySymbol) {
+        if (this.decimalService.isDecimal(value)) {
+            value = this.decimalService.toNumber(value);
         }
-        if (number !== null && typeof number === "object") {
-            var numberValue = number.propertyInfo.propertyType === DataType.Decimal ? number.value.toNumber() : number.value;
-            return NumberUtils.formatUsingEnum(numberValue, number.propertyInfo.propertyType === DataType.Float || number.propertyInfo.propertyType === DataType.Decimal ? NumberFormat.Decimals : NumberFormat.NoDecimals);
+        if (value !== null && typeof value === "object") {
+            var numberValue = this.decimalService.toNumber(value.value);
+            return NumberUtils.formatUsingEnum(numberValue, value.propertyInfo.propertyType === DataType.Float || value.propertyInfo.propertyType === DataType.Decimal ? NumberFormat.Decimals : NumberFormat.NoDecimals);
         }
         else if (typeof format === "string") {
-            return NumberUtils.formatInternal(number, format);
+            return NumberUtils.formatInternal(value, format);
         }
         else {
-            return NumberUtils.formatUsingEnum(number, format, currencySymbol);
+            return NumberUtils.formatUsingEnum(value, format, currencySymbol);
         }
     };
     NumberUtils.formatUsingEnum = function (number, format, currencySymbol) {

package/dist/Numeric/DecimalService.d.ts

@@ -0,0 +1,35 @@
+import { IDecimal, IDecimalService } from "./IDecimalService";
+/** Constructor representing Big, or Decimal from the big.js or decimal.js packages. */
+interface IBigDecimalConstructor {
+    new (value: number | string): IBigDecimal;
+}
+/** Instance representing Big, or Decimal from the big.js or decimal.js packages. */
+interface IBigDecimal extends IDecimal {
+    toNumber(): number;
+    toDecimalPlaces?(precision: number, roundingType: number): IBigDecimal;
+    round?(precision?: number, roundingType?: number): IBigDecimal;
+    cmp(to: IBigDecimal | number | string): 0 | 1 | -1;
+    plus(number: IBigDecimal | number | string): IBigDecimal;
+    div(number: IBigDecimal | number | string): IBigDecimal;
+}
+/**
+ * Service used by neo to perform decimal operations.
+ * This class can be used by any of the decimal packages in the repos under https://github.com/MikeMcl.
+ * `big.js` is the smallest package, `decimal.js-light` is slightly larger, but newer with a slightly easier api.
+ */
+export declare class DecimalService<T extends IBigDecimal> implements IDecimalService<T> {
+    private decimalType;
+    private roundHalfUpValue;
+    private roundDownValue;
+    private roundFn;
+    constructor(decimalType: IBigDecimalConstructor, roundHalfUpValue: number, roundDownValue: number);
+    isDecimal(value: any): value is IBigDecimal;
+    createDecimal(value: number | string): T;
+    toNumber(value: number | T): number;
+    round(value: T, precision: number): T;
+    truncate(value: T): T;
+    compare(value1: T, value2: T): 0 | 1 | -1;
+    sum(values: T[]): T;
+    divideBy(value: T, divisor: number | T): T;
+}
+export {};

package/dist/Numeric/DecimalService.js

@@ -0,0 +1,53 @@
+/**
+ * Service used by neo to perform decimal operations.
+ * This class can be used by any of the decimal packages in the repos under https://github.com/MikeMcl.
+ * `big.js` is the smallest package, `decimal.js-light` is slightly larger, but newer with a slightly easier api.
+ */
+var DecimalService = /** @class */ (function () {
+    function DecimalService(decimalType, roundHalfUpValue, roundDownValue) {
+        this.decimalType = decimalType;
+        this.roundHalfUpValue = roundHalfUpValue;
+        this.roundDownValue = roundDownValue;
+        var prototype = decimalType.prototype;
+        if (prototype.round) {
+            this.roundFn = prototype.round;
+        }
+        else if (prototype.toDecimalPlaces) {
+            this.roundFn = prototype.toDecimalPlaces;
+        }
+        else {
+            throw "Decimal type doesn't provide rounding function";
+        }
+    }
+    DecimalService.prototype.isDecimal = function (value) {
+        return value instanceof this.decimalType;
+    };
+    DecimalService.prototype.createDecimal = function (value) {
+        return new this.decimalType(value);
+    };
+    DecimalService.prototype.toNumber = function (value) {
+        if (this.isDecimal(value)) {
+            return value.toNumber();
+        }
+        else {
+            return value;
+        }
+    };
+    DecimalService.prototype.round = function (value, precision) {
+        return this.roundFn.call(value, precision, this.roundHalfUpValue);
+    };
+    DecimalService.prototype.truncate = function (value) {
+        return this.roundFn.call(value, 0, this.roundDownValue);
+    };
+    DecimalService.prototype.compare = function (value1, value2) {
+        return value1.cmp(value2);
+    };
+    DecimalService.prototype.sum = function (values) {
+        return values.reduce(function (total, item) { return total.plus(item); }, this.createDecimal(0));
+    };
+    DecimalService.prototype.divideBy = function (value, divisor) {
+        return value.div(divisor);
+    };
+    return DecimalService;
+}());
+export { DecimalService };

package/dist/Numeric/IDecimal.d.ts

@@ -0,0 +1,25 @@
+export interface IDecimal {
+    toNumber(): number;
+}
+export interface IDecimalService<T = IDecimal> {
+    /** Returns true if the provided value is a decimal instance. */
+    isDecimal(value: any): value is IDecimal;
+    /** Creates a decimal instance from a javascript number. */
+    createDecimal(value: number | string): T;
+    /** If the provided value is a decimal, converts it to a number, otherwise returns the number passed in. */
+    toNumber(value: number | T): number;
+    /** Rounds a number using .net like midpoint away from zero rounding. */
+    round(value: T, precision: number): T;
+    /** Removes decimal places from the value. Equivalent to round down with zero decimal places. */
+    truncate(value: T): T;
+    /** Compares 2 decimals.
+     * Returns 1 if value1 > value2
+     * Returns -1 if value1 < value2
+     * Returns 0 if equal
+     */
+    compare(value1: T, value2: T): 0 | 1 | -1;
+    /** Sums a list of decimals and returns the total as a decimal. */
+    sum(values: T[]): T;
+    /** Divides value by divisor and returns the result. */
+    divideBy(value: T, divisor: number | T): T;
+}

package/dist/Numeric/IDecimal.js

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

package/dist/Numeric/IDecimalService.d.ts

@@ -0,0 +1,25 @@
+export interface IDecimal {
+    toNumber(): number;
+}
+export interface IDecimalService<T = IDecimal> {
+    /** Returns true if the provided value is a decimal instance. */
+    isDecimal(value: any): value is IDecimal;
+    /** Creates a decimal instance from a javascript number. */
+    createDecimal(value: number | string): T;
+    /** If the provided value is a decimal, converts it to a number, otherwise returns the number passed in. */
+    toNumber(value: number | T): number;
+    /** Rounds a number using .net like midpoint away from zero rounding. */
+    round(value: T, precision: number): T;
+    /** Removes decimal places from the value. Equivalent to round down with zero decimal places. */
+    truncate(value: T): T;
+    /** Compares 2 decimals.
+     * Returns 1 if value1 > value2
+     * Returns -1 if value1 < value2
+     * Returns 0 if equal
+     */
+    compare(value1: T, value2: T): 0 | 1 | -1;
+    /** Sums a list of decimals and returns the total as a decimal. */
+    sum(values: T[]): T;
+    /** Divides value by divisor and returns the result. */
+    divideBy(value: T, divisor: number | T): T;
+}

package/dist/Numeric/IDecimalService.js

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

package/dist/Numeric/index.d.ts

@@ -0,0 +1,2 @@
+export type { IDecimal, IDecimalService } from './IDecimalService';
+export { DecimalService } from './DecimalService';

package/dist/Numeric/index.js

@@ -0,0 +1 @@
+export { DecimalService } from './DecimalService';

package/dist/Security/IAuthenticationService.d.ts

@@ -1,10 +1,6 @@
 import { IUser } from './IUser';
 import { ISignInResult } from './SignInResult';
 export default interface IAuthenticationService {
-    /**
-     * @deprecated Use loadUserFromSession() instead.
-     */
-    loadUserFromToken(): Promise<IUser | null>;
     /**
      * Load a user from session storage if there is a stored token.
      */

package/dist/Security/IUser.d.ts

@@ -3,8 +3,6 @@ export interface IUser {
     readonly userName: string;
     /** Name to display in UI components. */
     readonly displayName: string;
-    /** True if the access token has expired. */
-    readonly hasExpired: boolean;
     /** Access token for requesting protected resources. */
     readonly accessToken: string;
 }

package/dist/Utils.d.ts

@@ -31,6 +31,11 @@ export declare class Utils {
      * Runs the callback in the context of a batch transaction. E.g. a mobx action in react.
      */
     static batchUpdate<T>(unitOfWork: () => T): T;
+    /**
+     * Returns an array that can be sorted using the built in Array.sort method.
+     * Mobx dissallows in place sorting on observable arrays.
+     */
+    static sortableArray<T>(array: T[]): T[];
     /**
      * Instructs the ui not to encode the provided html text.
      * Returns a new element containing the html.

package/dist/Utils.js

@@ -46,6 +46,13 @@ var Utils = /** @class */ (function () {
     Utils.batchUpdate = function (unitOfWork) {
         return unitOfWork();
     };
+    /**
+     * Returns an array that can be sorted using the built in Array.sort method.
+     * Mobx dissallows in place sorting on observable arrays.
+     */
+    Utils.sortableArray = function (array) {
+        return array;
+    };
     /**
      * Instructs the ui not to encode the provided html text.
      * Returns a new element containing the html.

package/dist/index.d.ts

@@ -23,16 +23,18 @@ import * as Localisation from './Localisation';
 import * as Misc from './Misc';
 import * as Model from './Model';
 import * as Network from './ConnectionManager';
+import * as Numeric from './Numeric';
 import * as Routing from './Routing';
 import * as Security from './Security';
 import * as SignalR from './SignalR';
 import * as Validation from './Validation';
 import * as Views from './Views/IViewBase';
 declare const NotifyUtils: Components.INotificationHelper;
-export { AppServices, Attributes, Components, Data, DateUtils, DebounceHelper, EnumHelper, FileUtils, JsonSchema, Localisation, List, MenuUtils, Misc, ModalUtils, Model, NeoModel, NeoStrings, Network, NotifyUtils, NumberUtils, Routing, Rules, Security, SignalR, StringUtils, Validation, Views, };
+export { AppServices, Attributes, Components, Data, DateUtils, DebounceHelper, EnumHelper, FileUtils, JsonSchema, Localisation, List, MenuUtils, Misc, ModalUtils, Model, NeoModel, NeoStrings, Network, NotifyUtils, Numeric, NumberUtils, Routing, Rules, Security, SignalR, StringUtils, Validation, Views, };
 export { runInTask, createProperty };
 export { default as ModelBase } from './Model/ModelBase';
 export { default as ValueObject } from './Model/ValueObject';
 export { LookupBase } from './Model/LookupBase';
-export { default as TaskRunner, ITaskRunner } from './Components/TaskRunner/TaskRunner';
+export { default as TaskRunner } from './Components/TaskRunner/TaskRunner';
+export type { ITaskRunner } from './Components/TaskRunner/TaskRunner';
 export { Utils } from './Utils';

package/dist/index.js

@@ -26,6 +26,7 @@ import * as Localisation from './Localisation';
 import * as Misc from './Misc';
 import * as Model from './Model';
 import * as Network from './ConnectionManager';
+import * as Numeric from './Numeric';
 import * as Routing from './Routing';
 import * as Security from './Security';
 import * as SignalR from './SignalR';
@@ -34,7 +35,7 @@ import * as Views from './Views/IViewBase';
 import { NotificationHelper } from './Components/Notifications/NotificationHelper';
 var NotifyUtils = new NotificationHelper();
 // Types
-export { AppServices, Attributes, Components, Data, DateUtils, DebounceHelper, EnumHelper, FileUtils, JsonSchema, Localisation, List, MenuUtils, Misc, ModalUtils, Model, NeoModel, NeoStrings, Network, NotifyUtils, NumberUtils, Routing, Rules, Security, SignalR, StringUtils, Validation, Views, };
+export { AppServices, Attributes, Components, Data, DateUtils, DebounceHelper, EnumHelper, FileUtils, JsonSchema, Localisation, List, MenuUtils, Misc, ModalUtils, Model, NeoModel, NeoStrings, Network, NotifyUtils, Numeric, NumberUtils, Routing, Rules, Security, SignalR, StringUtils, Validation, Views, };
 // Functions
 export { runInTask, createProperty };
 export { default as ModelBase } from './Model/ModelBase';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@singularsystems/neo-core",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.6",
   "description": "Core functionality for the Neo client library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,7 +24,6 @@
   "dependencies": {
     "@microsoft/signalr": "^6.0.1",
     "axios": "1.4.0",
-    "decimal.js-light": "^2.5.1",
     "inversify": "^6.0.1",
     "reflect-metadata": "0.1.13",
     "tslib": "2.5.0"