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

package/dist/Data/AsyncDataSource.d.ts

@@ -1,35 +1,35 @@
-/** Interface for classes which can fetch their own data, and provide it asynchronously. */
-export interface IAsyncDataSource<T> {
-    /** True if the data is being fetched. */
-    readonly isLoading: boolean;
-    /** True if the data is being fetched, or hasn't fetched yet. */
-    readonly willLoad: boolean;
-    /** Current data. This will return default data or previous data if isLoading is true. */
-    readonly data: T;
-    /**
-     * Begin fetch of the data. If you only want to fetch data if it has not already been fetched, use fetchInitial().
-     * @param clearPreviousError True if a previous fetch error must be cleared before fetch. By default fetch errors will prevent the datasource from fetching data again.
-     */
-    fetchDataAsync(clearPreviousError?: boolean): Promise<T>;
-    /** Fetches data if data has not been fetched before. */
-    fetchInitial(): Promise<T>;
-    /** Last error which occured during fetch. */
-    readonly fetchError: string | null;
-    /** Current promise created as a result of fetchData being called. */
-    readonly promise: Promise<T> | null;
-    copy(): IAsyncDataSource<T>;
-}
-export declare abstract class AsyncDataSource<T> implements IAsyncDataSource<T> {
-    isLoading: boolean;
-    get willLoad(): boolean;
-    data: T;
-    fetchError: string | null;
-    promise: Promise<T> | null;
-    protected hasFetched: boolean;
-    constructor(defaultData: T);
-    protected abstract getDataAsync(): Promise<T>;
-    private executeFetchAsync;
-    fetchDataAsync(clearPreviousError?: boolean): Promise<T>;
-    fetchInitial(): Promise<T>;
-    abstract copy(): IAsyncDataSource<T>;
-}
+/** Interface for classes which can fetch their own data, and provide it asynchronously. */
+export interface IAsyncDataSource<T> {
+    /** True if the data is being fetched. */
+    readonly isLoading: boolean;
+    /** True if the data is being fetched, or hasn't fetched yet. */
+    readonly willLoad: boolean;
+    /** Current data. This will return default data or previous data if isLoading is true. */
+    readonly data: T;
+    /**
+     * Begin fetch of the data. If you only want to fetch data if it has not already been fetched, use fetchInitial().
+     * @param clearPreviousError True if a previous fetch error must be cleared before fetch. By default fetch errors will prevent the datasource from fetching data again.
+     */
+    fetchDataAsync(clearPreviousError?: boolean): Promise<T>;
+    /** Fetches data if data has not been fetched before. */
+    fetchInitial(): Promise<T>;
+    /** Last error which occured during fetch. */
+    readonly fetchError: string | null;
+    /** Current promise created as a result of fetchData being called. */
+    readonly promise: Promise<T> | null;
+    copy(): IAsyncDataSource<T>;
+}
+export declare abstract class AsyncDataSource<T> implements IAsyncDataSource<T> {
+    isLoading: boolean;
+    get willLoad(): boolean;
+    data: T;
+    fetchError: string | null;
+    promise: Promise<T> | null;
+    protected hasFetched: boolean;
+    constructor(defaultData: T);
+    protected abstract getDataAsync(): Promise<T>;
+    private executeFetchAsync;
+    fetchDataAsync(clearPreviousError?: boolean): Promise<T>;
+    fetchInitial(): Promise<T>;
+    abstract copy(): IAsyncDataSource<T>;
+}

package/dist/Data/AsyncDataSource.js

@@ -1,80 +1,79 @@
-import { __awaiter, __decorate, __generator, __metadata } from "tslib";
-import { Utils } from '../Utils';
-import { Observable } from '../Model/Decorators';
-var AsyncDataSource = /** @class */ (function () {
-    function AsyncDataSource(defaultData) {
-        this.isLoading = false;
-        this.fetchError = null;
-        this.promise = null;
-        this.hasFetched = false;
-        this.data = defaultData;
-    }
-    Object.defineProperty(AsyncDataSource.prototype, "willLoad", {
-        get: function () {
-            return this.isLoading || !this.hasFetched;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    AsyncDataSource.prototype.executeFetchAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var data_1, e_1;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(!this.isLoading && !this.fetchError)) return [3 /*break*/, 4];
-                        this.isLoading = true;
-                        this.promise = this.getDataAsync();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.promise];
-                    case 2:
-                        data_1 = _a.sent();
-                        Utils.batchUpdate(function () {
-                            _this.data = data_1;
-                            _this.isLoading = false;
-                        });
-                        return [2 /*return*/, data_1];
-                    case 3:
-                        e_1 = _a.sent();
-                        this.isLoading = false;
-                        this.fetchError = e_1;
-                        console.log(e_1);
-                        throw e_1;
-                    case 4: return [2 /*return*/, this.promise];
-                }
-            });
-        });
-    };
-    AsyncDataSource.prototype.fetchDataAsync = function (clearPreviousError) {
-        if (clearPreviousError === void 0) { clearPreviousError = false; }
-        this.hasFetched = true;
-        if (clearPreviousError) {
-            this.fetchError = null;
-        }
-        this.executeFetchAsync();
-        return this.promise;
-    };
-    AsyncDataSource.prototype.fetchInitial = function () {
-        if (!this.hasFetched) {
-            this.fetchDataAsync();
-        }
-        return this.promise;
-    };
-    __decorate([
-        Observable(),
-        __metadata("design:type", Boolean)
-    ], AsyncDataSource.prototype, "isLoading", void 0);
-    __decorate([
-        Observable(),
-        __metadata("design:type", Object)
-    ], AsyncDataSource.prototype, "data", void 0);
-    __decorate([
-        Observable(),
-        __metadata("design:type", Object)
-    ], AsyncDataSource.prototype, "fetchError", void 0);
-    return AsyncDataSource;
-}());
-export { AsyncDataSource };
+import { __awaiter, __decorate, __generator, __metadata } from "tslib";
+import { Utils } from '../Utils';
+import { Observable } from '../Model/Decorators';
+export var AsyncDataSource = /** @class */ (function () {
+    function AsyncDataSource(defaultData) {
+        this.isLoading = false;
+        this.fetchError = null;
+        this.promise = null;
+        this.hasFetched = false;
+        this.data = defaultData;
+    }
+    Object.defineProperty(AsyncDataSource.prototype, "willLoad", {
+        get: function () {
+            return this.isLoading || !this.hasFetched;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AsyncDataSource.prototype.executeFetchAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data_1, e_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(!this.isLoading && !this.fetchError)) return [3 /*break*/, 4];
+                        this.isLoading = true;
+                        this.promise = this.getDataAsync();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.promise];
+                    case 2:
+                        data_1 = _a.sent();
+                        Utils.batchUpdate(function () {
+                            _this.data = data_1;
+                            _this.isLoading = false;
+                        });
+                        return [2 /*return*/, data_1];
+                    case 3:
+                        e_1 = _a.sent();
+                        this.isLoading = false;
+                        this.fetchError = e_1;
+                        console.log(e_1);
+                        throw e_1;
+                    case 4: return [2 /*return*/, this.promise];
+                }
+            });
+        });
+    };
+    AsyncDataSource.prototype.fetchDataAsync = function (clearPreviousError) {
+        if (clearPreviousError === void 0) { clearPreviousError = false; }
+        this.hasFetched = true;
+        if (clearPreviousError) {
+            this.fetchError = null;
+        }
+        this.executeFetchAsync();
+        return this.promise;
+    };
+    AsyncDataSource.prototype.fetchInitial = function () {
+        if (!this.hasFetched) {
+            this.fetchDataAsync();
+        }
+        return this.promise;
+    };
+    __decorate([
+        Observable(),
+        __metadata("design:type", Boolean)
+    ], AsyncDataSource.prototype, "isLoading", void 0);
+    __decorate([
+        Observable(),
+        __metadata("design:type", Object)
+    ], AsyncDataSource.prototype, "data", void 0);
+    __decorate([
+        Observable(),
+        __metadata("design:type", Object)
+    ], AsyncDataSource.prototype, "fetchError", void 0);
+    return AsyncDataSource;
+}());

package/dist/Data/CacheService.d.ts

@@ -1,40 +1,40 @@
-import { IAsyncDataSource } from './AsyncDataSource';
-import { AxiosPromise } from 'axios';
-import { DataCacheEntry } from './DataCacheEntry';
-import { PlainObject } from '../Model/IModelBase';
-export interface ICachedDataService {
-    expireAll(expireDescendants?: boolean): void;
-}
-/** Service for managing cached data. */
-export declare class CachedDataService implements ICachedDataService {
-    private dataSources;
-    private children;
-    constructor(base?: CachedDataService);
-    /**
-     * Registers an api datasource.
-     * @param apiEndpoint Api endpoint from which to get data.
-     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
-     */
-    protected register<T>(apiEndpoint: string, lifeTimeMinutes: number, defaultData?: T): DataCacheEntry<T>;
-    /**
-     * Registers an api datasource.
-     * @param apiEndpoint ClientApi method from which to get data.
-     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
-     */
-    protected register<T>(apiMethod: () => AxiosPromise<T>, lifeTimeMinutes: number, defaultData?: T): DataCacheEntry<T>;
-    /**
-     * Registers a datasource.
-     * @param dataSource An async data source.
-     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
-     */
-    protected register<T>(dataSource: IAsyncDataSource<T>, lifeTimeMinutes: number): DataCacheEntry<T>;
-    /**
-     * Registers an api datasource which contains a list of data. The data from the api endpoint will be deserialised into models of the provided child type.
-     * @param childType Child type to create when deserialising data.
-     * @param apiMethod Api client method from which to get data.
-     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
-     */
-    protected registerList<T>(childType: (new () => T), apiMethod: () => AxiosPromise<PlainObject<T>[]>, lifeTimeMinutes: number): DataCacheEntry<T[]>;
-    /** Expires all data */
-    expireAll(expireDescendants?: boolean): void;
-}
+import { IAsyncDataSource } from './AsyncDataSource';
+import { AxiosPromise } from 'axios';
+import { DataCacheEntry } from './DataCacheEntry';
+import { PlainObject } from '../Model/IModelBase';
+export interface ICachedDataService {
+    expireAll(expireDescendants?: boolean): void;
+}
+/** Service for managing cached data. */
+export declare class CachedDataService implements ICachedDataService {
+    private dataSources;
+    private children;
+    constructor(base?: CachedDataService);
+    /**
+     * Registers an api datasource.
+     * @param apiEndpoint Api endpoint from which to get data.
+     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
+     */
+    protected register<T>(apiEndpoint: string, lifeTimeMinutes: number, defaultData?: T): DataCacheEntry<T>;
+    /**
+     * Registers an api datasource.
+     * @param apiEndpoint ClientApi method from which to get data.
+     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
+     */
+    protected register<T>(apiMethod: () => AxiosPromise<T>, lifeTimeMinutes: number, defaultData?: T): DataCacheEntry<T>;
+    /**
+     * Registers a datasource.
+     * @param dataSource An async data source.
+     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
+     */
+    protected register<T>(dataSource: IAsyncDataSource<T>, lifeTimeMinutes: number): DataCacheEntry<T>;
+    /**
+     * Registers an api datasource which contains a list of data. The data from the api endpoint will be deserialised into models of the provided child type.
+     * @param childType Child type to create when deserialising data.
+     * @param apiMethod Api client method from which to get data.
+     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
+     */
+    protected registerList<T>(childType: (new () => T), apiMethod: () => AxiosPromise<PlainObject<T>[]>, lifeTimeMinutes: number): DataCacheEntry<T[]>;
+    /** Expires all data */
+    expireAll(expireDescendants?: boolean): void;
+}

package/dist/Data/CacheService.js

@@ -1,64 +1,63 @@
-import { __decorate, __metadata } from "tslib";
-import { ApiDataSource, ApiClientDataSource, ApiClientLookupDataSource } from './ApiDataSource';
-import { injectable } from 'inversify';
-import { DataCacheEntry } from './DataCacheEntry';
-/** Service for managing cached data. */
-var CachedDataService = /** @class */ (function () {
-    function CachedDataService(base) {
-        this.dataSources = [];
-        this.children = [];
-        if (base) {
-            base.children.push(this);
-        }
-    }
-    CachedDataService.prototype.register = function (apiEndpointOrDataSource, lifeTimeMinutes, defaultData) {
-        if (defaultData === void 0) { defaultData = []; }
-        var apiSource;
-        if (apiEndpointOrDataSource.fetchDataAsync !== undefined) {
-            apiSource = apiEndpointOrDataSource;
-        }
-        else if (apiEndpointOrDataSource instanceof Function) {
-            apiSource = new ApiClientDataSource(apiEndpointOrDataSource, defaultData);
-        }
-        else {
-            apiSource = new ApiDataSource(apiEndpointOrDataSource, defaultData);
-        }
-        var cacheEntry = new DataCacheEntry(apiSource, lifeTimeMinutes);
-        ;
-        this.dataSources.push(cacheEntry);
-        return cacheEntry;
-    };
-    /**
-     * Registers an api datasource which contains a list of data. The data from the api endpoint will be deserialised into models of the provided child type.
-     * @param childType Child type to create when deserialising data.
-     * @param apiMethod Api client method from which to get data.
-     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
-     */
-    CachedDataService.prototype.registerList = function (childType, apiMethod, lifeTimeMinutes) {
-        var dataSource = new ApiClientLookupDataSource(apiMethod, childType);
-        var cacheEntry = new DataCacheEntry(dataSource, lifeTimeMinutes);
-        ;
-        this.dataSources.push(cacheEntry);
-        return cacheEntry;
-    };
-    /** Expires all data */
-    CachedDataService.prototype.expireAll = function (expireDescendants) {
-        if (expireDescendants === void 0) { expireDescendants = false; }
-        for (var _i = 0, _a = this.dataSources; _i < _a.length; _i++) {
-            var datasource = _a[_i];
-            datasource.expire();
-        }
-        if (expireDescendants) {
-            for (var _b = 0, _c = this.children; _b < _c.length; _b++) {
-                var dataCache = _c[_b];
-                dataCache.expireAll(expireDescendants);
-            }
-        }
-    };
-    CachedDataService = __decorate([
-        injectable(),
-        __metadata("design:paramtypes", [CachedDataService])
-    ], CachedDataService);
-    return CachedDataService;
-}());
-export { CachedDataService };
+import { __decorate, __metadata } from "tslib";
+import { ApiDataSource, ApiClientDataSource, ApiClientLookupDataSource } from './ApiDataSource';
+import { injectable } from 'inversify';
+import { DataCacheEntry } from './DataCacheEntry';
+/** Service for managing cached data. */
+export var CachedDataService = /** @class */ (function () {
+    function CachedDataService(base) {
+        this.dataSources = [];
+        this.children = [];
+        if (base) {
+            base.children.push(this);
+        }
+    }
+    CachedDataService.prototype.register = function (apiEndpointOrDataSource, lifeTimeMinutes, defaultData) {
+        if (defaultData === void 0) { defaultData = []; }
+        var apiSource;
+        if (apiEndpointOrDataSource.fetchDataAsync !== undefined) {
+            apiSource = apiEndpointOrDataSource;
+        }
+        else if (apiEndpointOrDataSource instanceof Function) {
+            apiSource = new ApiClientDataSource(apiEndpointOrDataSource, defaultData);
+        }
+        else {
+            apiSource = new ApiDataSource(apiEndpointOrDataSource, defaultData);
+        }
+        var cacheEntry = new DataCacheEntry(apiSource, lifeTimeMinutes);
+        ;
+        this.dataSources.push(cacheEntry);
+        return cacheEntry;
+    };
+    /**
+     * Registers an api datasource which contains a list of data. The data from the api endpoint will be deserialised into models of the provided child type.
+     * @param childType Child type to create when deserialising data.
+     * @param apiMethod Api client method from which to get data.
+     * @param lifeTimeMinutes No of minutes from the data retrieval time that the cache is valid for.
+     */
+    CachedDataService.prototype.registerList = function (childType, apiMethod, lifeTimeMinutes) {
+        var dataSource = new ApiClientLookupDataSource(apiMethod, childType);
+        var cacheEntry = new DataCacheEntry(dataSource, lifeTimeMinutes);
+        ;
+        this.dataSources.push(cacheEntry);
+        return cacheEntry;
+    };
+    /** Expires all data */
+    CachedDataService.prototype.expireAll = function (expireDescendants) {
+        if (expireDescendants === void 0) { expireDescendants = false; }
+        for (var _i = 0, _a = this.dataSources; _i < _a.length; _i++) {
+            var datasource = _a[_i];
+            datasource.expire();
+        }
+        if (expireDescendants) {
+            for (var _b = 0, _c = this.children; _b < _c.length; _b++) {
+                var dataCache = _c[_b];
+                dataCache.expireAll(expireDescendants);
+            }
+        }
+    };
+    CachedDataService = __decorate([
+        injectable(),
+        __metadata("design:paramtypes", [CachedDataService])
+    ], CachedDataService);
+    return CachedDataService;
+}());

package/dist/Data/DataCacheEntry.d.ts

@@ -1,42 +1,42 @@
-import { IAsyncDataSource } from "./AsyncDataSource";
-export interface IDataCacheEntry {
-    expire(refetch?: boolean): void;
-    get(): IAsyncDataSource<any>;
-    /**
-     * Will return true if the data has expired, or the data source is loading.
-     */
-    readonly willLoad: boolean;
-}
-export declare type IArrayCacheEntry<T> = DataCacheEntry<T[]>;
-export declare class DataCacheEntry<T> implements IDataCacheEntry {
-    private dataSource;
-    private lifeTimeMinutes;
-    private expiryDate;
-    constructor(dataSource: IAsyncDataSource<T>, lifeTimeMinutes: number);
-    get isExpired(): boolean;
-    get willLoad(): boolean;
-    /**
-     * Returns the latest fetched data, or default if the data has never been fetched.
-     * Will not re-fetch if the lifetime has been exceeded.
-     */
-    get currentData(): T;
-    /**
-     * Gets an api datasource which was previously registered. Datasource will re-fetch its data if the data lifetime has been exceeded.
-     */
-    get(clearPreviousError?: boolean): IAsyncDataSource<T>;
-    /**
-     * Returns a promise from which data can be obtained. Data will be re-fetched if the lifetime has been exceeded.
-     */
-    getDataAsync(): Promise<T>;
-    /**
-     * Returns a new instance of the api datasource which is not cached. Fetch will not be initiated.
-     */
-    getNew(): IAsyncDataSource<T>;
-    /**
-     * Expires the datasource.
-     * @param refetch True if the datasource must be refetched. This will cause any consumers of this datasource to rebind to the updated data.
-     */
-    expire(refetch?: boolean): void;
-    private expireNow;
-    private fetchIfExpired;
-}
+import { IAsyncDataSource } from "./AsyncDataSource";
+export interface IDataCacheEntry {
+    expire(refetch?: boolean): void;
+    get(): IAsyncDataSource<any>;
+    /**
+     * Will return true if the data has expired, or the data source is loading.
+     */
+    readonly willLoad: boolean;
+}
+export type IArrayCacheEntry<T> = DataCacheEntry<T[]>;
+export declare class DataCacheEntry<T> implements IDataCacheEntry {
+    private dataSource;
+    private lifeTimeMinutes;
+    private expiryDate;
+    constructor(dataSource: IAsyncDataSource<T>, lifeTimeMinutes: number);
+    get isExpired(): boolean;
+    get willLoad(): boolean;
+    /**
+     * Returns the latest fetched data, or default if the data has never been fetched.
+     * Will not re-fetch if the lifetime has been exceeded.
+     */
+    get currentData(): T;
+    /**
+     * Gets an api datasource which was previously registered. Datasource will re-fetch its data if the data lifetime has been exceeded.
+     */
+    get(clearPreviousError?: boolean): IAsyncDataSource<T>;
+    /**
+     * Returns a promise from which data can be obtained. Data will be re-fetched if the lifetime has been exceeded.
+     */
+    getDataAsync(): Promise<T>;
+    /**
+     * Returns a new instance of the api datasource which is not cached. Fetch will not be initiated.
+     */
+    getNew(): IAsyncDataSource<T>;
+    /**
+     * Expires the datasource.
+     * @param refetch True if the datasource must be refetched. This will cause any consumers of this datasource to rebind to the updated data.
+     */
+    expire(refetch?: boolean): void;
+    private expireNow;
+    private fetchIfExpired;
+}