@singularsystems/neo-core 1.6.3 → 1.6.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Neo core changelog
 
+## Version 1.6.4 (15 September 2026)
+
+- Added support for `AbortSignal` in ConfigService and AuthenticationService. Equivalent to CancellationToken.
+- Changes to AuthenticationService to allow deferred load of config (by passing a callback to the constructor).
+- Added methods to `IAppConnectionMonitor`.
+
 ## Version 1.6.3 (20 July 2026)
 
 - Fixed issue with `Utils.createInstance` not passing parameters correctly.

package/dist/AbortHelper.d.ts

@@ -0,0 +1,7 @@
+export default class AbortHelper {
+    /**
+     * Returns early if the abort signal is triggered, otherwise resolves with the result of the promise.
+     * Returns undefined if aborted.
+     */
+    static race<T>(promise: Promise<T>, abortSignal?: AbortSignal): Promise<T | undefined>;
+}

package/dist/AbortHelper.js

@@ -0,0 +1,39 @@
+import { __awaiter, __generator } from "tslib";
+var AbortHelper = /** @class */ (function () {
+    function AbortHelper() {
+    }
+    /**
+     * Returns early if the abort signal is triggered, otherwise resolves with the result of the promise.
+     * Returns undefined if aborted.
+     */
+    AbortHelper.race = function (promise, abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!abortSignal) return [3 /*break*/, 2];
+                        return [4 /*yield*/, promise];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        if (abortSignal.aborted) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                var onAbort = function () { return resolve(undefined); };
+                                abortSignal.addEventListener("abort", onAbort, { once: true });
+                                promise.then(function (result) {
+                                    abortSignal.removeEventListener("abort", onAbort);
+                                    resolve(result);
+                                }, function (error) {
+                                    abortSignal.removeEventListener("abort", onAbort);
+                                    reject(error);
+                                });
+                            })];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return AbortHelper;
+}());
+export default AbortHelper;

package/dist/AppServices/Config/ConfigService.d.ts

@@ -2,6 +2,11 @@ import { AxiosPromise } from "axios";
 import { IConfigModel, IConfigModelData } from './ConfigModel';
 import { IDbSet } from "../../IndexDb/IDbSet";
 export interface IConfigService {
+    readonly hasOfflineConfig: boolean;
+    /**
+     * Load and process the config file from the specified path.
+     */
+    loadConfig(options?: ILoadConfigOptions): Promise<IConfigModel>;
     /**
      * Load and process the config file from the specified path.
      * Path will default to [baseUrl]/config.json
@@ -16,13 +21,22 @@ export interface IConfigService {
      * Use this if `loadConfig` fails, and you have an offline copy of the config data. */
     setConfig(configData: any): IConfigModel;
 }
+interface ILoadConfigOptions {
+    /** Path to the config file. Defaults to [baseUrl]/config.json if not specified. */
+    path?: string;
+    /** Signal to abort the config loading request if needed. */
+    abortSignal?: AbortSignal;
+}
 export declare class ConfigService implements IConfigService {
     private config;
     constructor(config: IConfigModel);
+    get hasOfflineConfig(): boolean;
     loadConfig(path?: string, store?: IDbSet<IConfigModelData>): Promise<IConfigModel>;
-    fetchConfig(path?: string | undefined): AxiosPromise<any>;
+    loadConfig(options?: ILoadConfigOptions): Promise<IConfigModel>;
+    fetchConfig(path?: string | undefined, abortSignal?: AbortSignal): AxiosPromise<any>;
     setConfig(configData: any): IConfigModel;
     static get isDevelopment(): boolean;
     /** Throws the error if in development mode, otherwise logs it. */
     static tryShowError(e: any): void;
 }
+export {};

package/dist/AppServices/Config/ConfigService.js

@@ -8,17 +8,31 @@ var ConfigService = /** @class */ (function () {
     function ConfigService(config) {
         this.config = config;
     }
-    ConfigService.prototype.loadConfig = function (path, store) {
+    Object.defineProperty(ConfigService.prototype, "hasOfflineConfig", {
+        get: function () {
+            return localStorage.getItem(storageKey) !== null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ConfigService.prototype.loadConfig = function (pathOrOptions, store) {
         return __awaiter(this, void 0, void 0, function () {
-            var configData, e_1, storedConfig;
+            var options, configData, e_1, storedConfig;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        options = {};
+                        if (typeof pathOrOptions === "string") {
+                            options.path = pathOrOptions;
+                        }
+                        else if (typeof pathOrOptions === "object") {
+                            options = pathOrOptions;
+                        }
                         if (!(!this.config.supportsOffline || navigator.onLine)) return [3 /*break*/, 7];
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 6, , 7]);
-                        return [4 /*yield*/, this.fetchConfig(path)];
+                        return [4 /*yield*/, this.fetchConfig(options.path, options.abortSignal)];
                     case 2:
                         configData = (_a.sent()).data;
                         if (!store) return [3 /*break*/, 4];
@@ -63,11 +77,11 @@ var ConfigService = /** @class */ (function () {
             });
         });
     };
-    ConfigService.prototype.fetchConfig = function (path) {
+    ConfigService.prototype.fetchConfig = function (path, abortSignal) {
         path = path !== null && path !== void 0 ? path : "".concat(this.config.baseUrl, "/config.json");
         // Fetch config with timestamp to prevent caching
         var timestamp = new Date().getTime();
-        return Axios.get("".concat(path, "?").concat(timestamp));
+        return Axios.get("".concat(path, "?").concat(timestamp), { signal: abortSignal });
     };
     ConfigService.prototype.setConfig = function (configData) {
         // The raw parsed json objects properties are copied into the config model.

package/dist/AppServices/ServiceBinding.d.ts

@@ -0,0 +1,31 @@
+type Newable<T> = new () => T;
+/** Fluent syntax for setting the scope of a binding which creates a new instance (`to` / `toDynamicValue`). */
+export interface IBindingInSyntax {
+    /** The same instance will be returned for every request. This is the default for `toConstantValue`. */
+    inSingletonScope(): void;
+    /** A new instance will be created for every request. This is the default for `to` / `toDynamicValue`. */
+    inTransientScope(): void;
+}
+/** Fluent syntax for specifying how a service identifier should be resolved. */
+export interface IBindingToSyntax<T> {
+    /** Resolves the service by constructing a new instance of the given class (using its parameterless constructor). */
+    to(constructor: Newable<T>): IBindingInSyntax;
+    /** Resolves the service to a fixed value. */
+    toConstantValue(value: T): void;
+    /** Resolves the service using a factory function. */
+    toDynamicValue(factory: () => T): IBindingInSyntax;
+}
+/** @internal */
+export declare class ServiceBinding<T> implements IBindingToSyntax<T>, IBindingInSyntax {
+    private factory?;
+    private singleton;
+    private instance?;
+    private hasInstance;
+    to(constructor: Newable<T>): IBindingInSyntax;
+    toConstantValue(value: T): void;
+    toDynamicValue(factory: () => T): IBindingInSyntax;
+    inSingletonScope(): void;
+    inTransientScope(): void;
+    resolve(): T;
+}
+export {};

package/dist/AppServices/ServiceBinding.js

@@ -0,0 +1,35 @@
+/** @internal */
+export class ServiceBinding {
+    constructor() {
+        this.singleton = false;
+        this.hasInstance = false;
+    }
+    to(constructor) {
+        this.factory = () => new constructor();
+        return this;
+    }
+    toConstantValue(value) {
+        this.factory = () => value;
+        this.singleton = true;
+    }
+    toDynamicValue(factory) {
+        this.factory = factory;
+        return this;
+    }
+    inSingletonScope() {
+        this.singleton = true;
+    }
+    inTransientScope() {
+        this.singleton = false;
+    }
+    resolve() {
+        if (this.singleton) {
+            if (!this.hasInstance) {
+                this.instance = this.factory();
+                this.hasInstance = true;
+            }
+            return this.instance;
+        }
+        return this.factory();
+    }
+}

package/dist/DecoratorUtils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Wraps a property decorator body so the resulting decorator works both as a legacy (experimentalDecorators)
+ * decorator - called as (target, propertyKey) - and as a TC39 / "v3" decorator - called as (value, context).
+ * v3 decorators don't have access to the class constructor until an instance is created, so in that case
+ * `apply` is deferred to context.addInitializer, which fires once for every instance created (including
+ * instances of subclasses that don't redeclare the property). It's guarded to only run once per concrete
+ * class, since some decorators (e.g. Parent) push into arrays and aren't safe to re-apply.
+ */
+export declare function propertyDecorator(apply: (ctor: any, propertyKey: string) => void): (targetOrValue: any, propertyKeyOrContext: any) => void;
+/**
+ * Same as propertyDecorator, but for decorators that need the property descriptor (accessors / methods).
+ * For v3 decorators the descriptor is read from the prototype once the first instance is constructed,
+ * by which point the class body (and so the getter/setter pair) is fully defined.
+ */
+export declare function accessorDecorator(apply: (ctor: any, propertyKey: string, descriptor: PropertyDescriptor) => void): (targetOrValue: any, propertyKeyOrContext: any, legacyDescriptor?: PropertyDescriptor) => void;

package/dist/DecoratorUtils.js

@@ -0,0 +1,70 @@
+/**
+ * Wraps a property decorator body so the resulting decorator works both as a legacy (experimentalDecorators)
+ * decorator - called as (target, propertyKey) - and as a TC39 / "v3" decorator - called as (value, context).
+ * v3 decorators don't have access to the class constructor until an instance is created, so in that case
+ * `apply` is deferred to context.addInitializer, which fires once for every instance created (including
+ * instances of subclasses that don't redeclare the property). It's guarded to only run once per concrete
+ * class, since some decorators (e.g. Parent) push into arrays and aren't safe to re-apply.
+ */
+export function propertyDecorator(apply) {
+    return function (targetOrValue, propertyKeyOrContext) {
+        if (propertyKeyOrContext && typeof propertyKeyOrContext === "object") {
+            // v3 decorator: propertyKeyOrContext is a DecoratorContext.
+            const context = propertyKeyOrContext;
+            const propertyKey = context.name;
+            const appliedTo = new WeakSet();
+            context.addInitializer(function () {
+                const ctor = this.constructor;
+                if (!appliedTo.has(ctor)) {
+                    appliedTo.add(ctor);
+                    apply(ctor, propertyKey);
+                }
+            });
+        }
+        else {
+            // Legacy decorator: targetOrValue is the class prototype.
+            apply(targetOrValue.constructor, propertyKeyOrContext);
+        }
+    };
+}
+/**
+ * Walks up the prototype chain to find a property descriptor declared on a base class,
+ * since inherited accessors aren't own properties of a subclass' prototype.
+ */
+function getInheritedPropertyDescriptor(proto, propertyKey) {
+    while (proto) {
+        const descriptor = Object.getOwnPropertyDescriptor(proto, propertyKey);
+        if (descriptor) {
+            return descriptor;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+}
+/**
+ * Same as propertyDecorator, but for decorators that need the property descriptor (accessors / methods).
+ * For v3 decorators the descriptor is read from the prototype once the first instance is constructed,
+ * by which point the class body (and so the getter/setter pair) is fully defined.
+ */
+export function accessorDecorator(apply) {
+    return function (targetOrValue, propertyKeyOrContext, legacyDescriptor) {
+        if (propertyKeyOrContext && typeof propertyKeyOrContext === "object") {
+            // v3 decorator
+            const propertyKey = propertyKeyOrContext.name;
+            const appliedTo = new WeakSet();
+            propertyKeyOrContext.addInitializer(function () {
+                const ctor = this.constructor;
+                if (!appliedTo.has(ctor)) {
+                    appliedTo.add(ctor);
+                    // The accessor may be declared on a base class' prototype, not the concrete instance's own.
+                    const descriptor = getInheritedPropertyDescriptor(ctor.prototype, propertyKey);
+                    apply(ctor, propertyKey, descriptor);
+                }
+            });
+        }
+        else {
+            // Legacy decorator
+            apply(targetOrValue.constructor, propertyKeyOrContext, legacyDescriptor);
+        }
+    };
+}

package/dist/Network/AppConnectionMonitor.d.ts

@@ -1,9 +1,7 @@
-import { IAuthenticationService } from "../Security";
 import { ConnectionState } from "./IConnectionManager";
 import { IAppConnectionMonitor } from "./IAppConnectionMonitor";
 export default abstract class AppConnectionMonitor implements IAppConnectionMonitor {
-    protected authenticationService: IAuthenticationService;
-    constructor(authenticationService: IAuthenticationService);
+    constructor();
     protected reconnectDelayMs: number;
     private state;
     get isOnline(): boolean;
@@ -16,6 +14,6 @@ export default abstract class AppConnectionMonitor implements IAppConnectionMoni
      */
     protected onReconnected(): Promise<void> | void;
     private updateOnlineStatus;
-    private markOffline;
-    tryConnect(forceAllowRedirect?: boolean): Promise<void>;
+    markOffline(): void;
+    tryConnect(): Promise<void>;
 }

package/dist/Network/AppConnectionMonitor.js

@@ -1,14 +1,12 @@
-import { __awaiter, __decorate, __extends, __generator, __metadata, __param } from "tslib";
+import { __awaiter, __extends, __generator } from "tslib";
 import { Utils } from '../Utils';
 import NeoTypes from '../AppServices/NeoTypes';
-import { inject } from 'inversify';
 import { ConnectionState } from "./IConnectionManager";
 import Globals from "../Globals";
 import ModelBase from "../Model/ModelBase";
 var AppConnectionMonitor = /** @class */ (function () {
-    function AppConnectionMonitor(authenticationService) {
+    function AppConnectionMonitor() {
         var _this = this;
-        this.authenticationService = authenticationService;
         this.reconnectDelayMs = 5000;
         this.updateOnlineStatus = this.updateOnlineStatus.bind(this);
         this.state = new State();
@@ -55,7 +53,7 @@ var AppConnectionMonitor = /** @class */ (function () {
             var _this = this;
             return __generator(this, function (_a) {
                 if (navigator.onLine) {
-                    Utils.debounce(this, function () { return _this.tryConnect(false); }, this.reconnectDelayMs);
+                    Utils.debounce(this, function () { return _this.tryConnect(); }, this.reconnectDelayMs);
                 }
                 else {
                     this.markOffline();
@@ -68,67 +66,56 @@ var AppConnectionMonitor = /** @class */ (function () {
         this.state.connectionState = ConnectionState.Disconnected;
     };
     AppConnectionMonitor.prototype.tryConnect = function () {
-        return __awaiter(this, arguments, void 0, function (forceAllowRedirect) {
-            var user, _a, canRedirect, _b, e_1;
-            if (forceAllowRedirect === void 0) { forceAllowRedirect = false; }
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+        return __awaiter(this, void 0, void 0, function () {
+            var authenticationService, user, _a, canRedirect, e_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         Utils.clearDebounce(this);
                         if (this.state.connectionState === ConnectionState.Connected) {
                             return [2 /*return*/];
                         }
                         this.state.connectionState = ConnectionState.ReConnecting;
-                        _c.label = 1;
+                        _b.label = 1;
                     case 1:
-                        _c.trys.push([1, 13, , 14]);
+                        _b.trys.push([1, 11, , 12]);
+                        authenticationService = Globals.appService.get(NeoTypes.Security.AuthenticationService);
                         if (!this.state.requiresSignInRedirect) return [3 /*break*/, 2];
                         _a = null;
                         return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.authenticationService.signinSilent()];
+                    case 2: return [4 /*yield*/, authenticationService.signinSilent()];
                     case 3:
-                        _a = _c.sent();
-                        _c.label = 4;
+                        _a = _b.sent();
+                        _b.label = 4;
                     case 4:
                         user = _a;
                         if (!user) return [3 /*break*/, 6];
                         this.state.connectionState = ConnectionState.Connected;
                         return [4 /*yield*/, this.onReconnected()];
                     case 5:
-                        _c.sent();
-                        return [3 /*break*/, 12];
-                    case 6:
-                        if (!forceAllowRedirect) return [3 /*break*/, 7];
-                        _b = true;
-                        return [3 /*break*/, 9];
-                    case 7: return [4 /*yield*/, this.beforeSigninRedirect()];
+                        _b.sent();
+                        return [3 /*break*/, 10];
+                    case 6: return [4 /*yield*/, this.beforeSigninRedirect()];
+                    case 7:
+                        canRedirect = _b.sent();
+                        if (!canRedirect) return [3 /*break*/, 9];
+                        return [4 /*yield*/, authenticationService.beginSignIn()];
                     case 8:
-                        _b = _c.sent();
-                        _c.label = 9;
-                    case 9:
-                        canRedirect = _b;
-                        if (!canRedirect) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this.authenticationService.beginSignIn()];
-                    case 10:
-                        _c.sent();
+                        _b.sent();
                         return [2 /*return*/];
-                    case 11:
+                    case 9:
                         this.state.requiresSignInRedirect = true;
-                        _c.label = 12;
-                    case 12: return [3 /*break*/, 14];
-                    case 13:
-                        e_1 = _c.sent();
+                        _b.label = 10;
+                    case 10: return [3 /*break*/, 12];
+                    case 11:
+                        e_1 = _b.sent();
                         this.state.connectionState = ConnectionState.Disconnected;
-                        return [3 /*break*/, 14];
-                    case 14: return [2 /*return*/];
+                        return [3 /*break*/, 12];
+                    case 12: return [2 /*return*/];
                 }
             });
         });
     };
-    AppConnectionMonitor = __decorate([
-        __param(0, inject(NeoTypes.Security.AuthenticationService.symbol)),
-        __metadata("design:paramtypes", [Object])
-    ], AppConnectionMonitor);
     return AppConnectionMonitor;
 }());
 export default AppConnectionMonitor;

package/dist/Network/IAppConnectionMonitor.d.ts

@@ -3,4 +3,8 @@ export interface IAppConnectionMonitor {
     readonly isOnline: boolean;
     readonly requiresSignInRedirect: boolean;
     readonly connectionState: ConnectionState;
+    /** Attempts to reconnect the application. */
+    tryConnect(): Promise<void>;
+    /** Sets the connection state to offline. Causes NetworkUtils.isOnline to return false. */
+    markOffline(): void;
 }

package/dist/Security/IAuthenticationService.d.ts

@@ -1,11 +1,17 @@
 import { IUser } from './IUser';
 import { ISignInResult } from './SignInResult';
+export interface IRestoreSessionOptions {
+    /** Whether to attempt a silent sign in if a session exists. */
+    silentSignIn?: boolean;
+    /** Signal to abort the session restoration request if needed. */
+    abortSignal?: AbortSignal;
+}
 export default interface IAuthenticationService {
     /**
      * Load a user from session storage if there is a stored token.
      * Will also try perform a silent sign in if opened from another window.
      */
-    loadUserFromSession(): Promise<IUser | null>;
+    loadUserFromSession(options?: IRestoreSessionOptions): Promise<IUser | null>;
     /**
      * Checks if the user is signed in, and if not, redirects to login.
      * Returns true if the user is logged in.
@@ -30,6 +36,8 @@ export default interface IAuthenticationService {
     endSignInSilent(): Promise<any>;
     beginSignOut(): void;
     endSignOut(): Promise<any>;
+    /** Returns the offline user if available */
+    getOfflineUser(): IUser | null;
     /** Returns true if there is a user, and the token has not expired */
     readonly isAuthenticated: boolean;
     /** Returns the current user */

package/dist/Security/Oidc/OidcAuthService.d.ts

@@ -1,6 +1,6 @@
 import { IOidcUser, IUserManager } from './OidcTypes';
 import OidcUser from './OidcUser';
-import IAuthenticationService from '../IAuthenticationService';
+import IAuthenticationService, { IRestoreSessionOptions } from '../IAuthenticationService';
 import { AxiosInstance } from 'axios';
 import { SignInResult } from '../SignInResult';
 /**
@@ -8,20 +8,23 @@ import { SignInResult } from '../SignInResult';
  * You must override this class and provide the user manager implementation from the oidc library.
  */
 export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser> implements IAuthenticationService {
-    protected userManager: IUserManager;
     private axios;
     private config;
     private _user;
     private isRedirecting;
     private afterUserLoadedPromise;
+    private userManagerSetup;
+    private _userManager?;
     /**
      * Creates an Oidc auth service
      * @param userManager Oidc-client user manager instance
      * @param user User which existed in storage at startup
      */
-    constructor(userManager: IUserManager, axios: AxiosInstance, config?: import("../../AppServices").IConfigModel);
+    constructor(userManager: IUserManager | (() => IUserManager), axios: AxiosInstance, config?: import("../../AppServices").IConfigModel);
     isSigningOut: boolean;
-    loadUserFromSession(): Promise<TUser | null>;
+    /** Oidc-client user manager instance */
+    protected get userManager(): IUserManager;
+    loadUserFromSession(options?: IRestoreSessionOptions): Promise<TUser | null>;
     ensureSignedIn(redirectLocal?: string): boolean;
     beginSignIn(redirectPath?: string): Promise<any>;
     /**
@@ -34,11 +37,12 @@ export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser>
      */
     tryCompleteSignIn(): Promise<SignInResult>;
     endSignInSilent(): Promise<any>;
+    getOfflineUser(): TUser | null;
     protected setUserDataAsync(userData: IOidcUser): Promise<void>;
     private onUserLoaded;
     protected afterUserLoaded(): Promise<void> | void;
     private awaitAfterUserLoadedAsync;
-    protected createUser(user: IOidcUser): OidcUser;
+    protected createUser(user: IOidcUser): TUser;
     private onUserUnloaded;
     private setUser;
     signinSilent(): Promise<TUser | null>;

package/dist/Security/Oidc/OidcAuthService.js

@@ -2,7 +2,7 @@ import { __awaiter, __decorate, __generator, __metadata } from "tslib";
 import { Observable } from '../../Model/Decorators';
 import OidcUser from './OidcUser';
 import { SignInResult } from '../SignInResult';
-import { Misc } from '../../';
+import { AbortHelper, Misc } from '../../';
 import { NeoTypes } from '../../AppServices';
 import NetworkUtils from "../../Network/NetworkUtils";
 var storageKey = "neo-app-user-data";
@@ -18,50 +18,70 @@ var OidcAuthService = /** @class */ (function () {
      */
     function OidcAuthService(userManager, axios, config) {
         if (config === void 0) { config = Misc.Globals.appService.get(NeoTypes.Config.ConfigModel); }
-        var _this = this;
-        this.userManager = userManager;
         this.axios = axios;
         this.config = config;
         this._user = null;
         this.isRedirecting = false;
         this.isSigningOut = false;
-        this.userManager = userManager;
-        this.userManager.events.addUserLoaded(this.onUserLoaded.bind(this));
-        this.userManager.events.addUserUnloaded(this.onUserUnloaded.bind(this));
-        if (!this.userManager.settings.automaticSilentRenew) {
-            // If automaticSilentRenew is set to true, then the user manager will handle automatic renewal.
-            this.userManager.events.addAccessTokenExpiring(function () { return _this.userManager.signinSilent(); });
-        }
+        this.userManagerSetup = userManager;
     }
-    OidcAuthService.prototype.loadUserFromSession = function () {
+    Object.defineProperty(OidcAuthService.prototype, "userManager", {
+        /** Oidc-client user manager instance */
+        get: function () {
+            var _this = this;
+            if (!this._userManager) {
+                this._userManager = typeof this.userManagerSetup === 'function' ? this.userManagerSetup() : this.userManagerSetup;
+                this._userManager.events.addUserLoaded(this.onUserLoaded.bind(this));
+                this._userManager.events.addUserUnloaded(this.onUserUnloaded.bind(this));
+                if (!this._userManager.settings.automaticSilentRenew) {
+                    // If automaticSilentRenew is set to true, then the user manager will handle automatic renewal.
+                    this._userManager.events.addAccessTokenExpiring(function () { return _this.userManager.signinSilent(); });
+                }
+            }
+            return this._userManager;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OidcAuthService.prototype.loadUserFromSession = function (options) {
         return __awaiter(this, void 0, void 0, function () {
-            var userData, user;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!NetworkUtils.useCachedData(this.config)) return [3 /*break*/, 3];
-                        userData = localStorage.getItem(storageKey);
-                        if (!userData) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.setUserDataAsync(JSON.parse(userData))];
+            var userData, userDataJson;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userManager.getUser()];
                     case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/, this.user];
-                    case 3: return [4 /*yield*/, this.userManager.getUser()];
-                    case 4:
-                        user = _a.sent();
-                        if (!(user && !user.expired)) return [3 /*break*/, 6];
+                        userData = _c.sent();
+                        if (!(userData && !userData.expired)) return [3 /*break*/, 3];
                         // Get user does not raise the onUserLoaded event, so we call it manually.
-                        return [4 /*yield*/, this.setUserDataAsync(user)];
-                    case 5:
+                        return [4 /*yield*/, this.setUserDataAsync(userData)];
+                    case 2:
                         // Get user does not raise the onUserLoaded event, so we call it manually.
-                        _a.sent();
+                        _c.sent();
                         return [2 /*return*/, this.user];
+                    case 3:
+                        userDataJson = localStorage.getItem(storageKey);
+                        if (userDataJson) {
+                            userData = JSON.parse(userDataJson);
+                        }
+                        if (!NetworkUtils.useCachedData(this.config)) return [3 /*break*/, 6];
+                        if (!userData) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.setUserDataAsync(userData)];
+                    case 4:
+                        _c.sent();
+                        _c.label = 5;
+                    case 5: return [2 /*return*/, this.user];
                     case 6:
-                        if (!!!window.opener) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.signinSilent()];
-                    case 7: return [2 /*return*/, _a.sent()];
-                    case 8: return [2 /*return*/, null];
+                        if (!((_a = options === null || options === void 0 ? void 0 : options.silentSignIn) !== null && _a !== void 0 ? _a : !!window.opener)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, AbortHelper.race(this.signinSilent(), options === null || options === void 0 ? void 0 : options.abortSignal)];
+                    case 7:
+                        _c.sent();
+                        if (!(((_b = options === null || options === void 0 ? void 0 : options.abortSignal) === null || _b === void 0 ? void 0 : _b.aborted) && !this.user && userData)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.setUserDataAsync(userData)];
+                    case 8:
+                        _c.sent();
+                        _c.label = 9;
+                    case 9: return [2 /*return*/, this.user];
                 }
             });
         });
@@ -148,6 +168,14 @@ var OidcAuthService = /** @class */ (function () {
     OidcAuthService.prototype.endSignInSilent = function () {
         return this.userManager.signinSilentCallback();
     };
+    OidcAuthService.prototype.getOfflineUser = function () {
+        var userDataJson = localStorage.getItem(storageKey);
+        if (userDataJson) {
+            var userData = JSON.parse(userDataJson);
+            return this.createUser(userData);
+        }
+        return null;
+    };
     OidcAuthService.prototype.setUserDataAsync = function (userData) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import "reflect-metadata";
 import './Extensions';
+import AbortHelper from './AbortHelper';
 import AxiosUtils from "./AxiosUtils";
 import List from './Model/List';
 import NeoModel from './Model/NeoModel';
@@ -31,7 +32,7 @@ import * as SignalR from './SignalR';
 import * as Validation from './Validation';
 import * as Views from './Views/IViewBase';
 declare const NotifyUtils: Components.INotificationHelper;
-export { AxiosUtils, 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 { AbortHelper, AxiosUtils, 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';

package/dist/index.js

@@ -1,6 +1,7 @@
 import "reflect-metadata";
 import './Extensions';
 // Individual exports
+import AbortHelper from './AbortHelper';
 import AxiosUtils from "./AxiosUtils";
 import List from './Model/List';
 import NeoModel from './Model/NeoModel';
@@ -36,7 +37,7 @@ import * as Views from './Views/IViewBase';
 import { NotificationHelper } from './Components/Notifications/NotificationHelper';
 var NotifyUtils = new NotificationHelper();
 // Types
-export { AxiosUtils, 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 { AbortHelper, AxiosUtils, 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.6.3",
+  "version": "1.6.4",
   "description": "Core functionality for the Neo client library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/ConnectionManager.d.ts

@@ -1,45 +0,0 @@
-export declare enum ConnectionState {
-    /** Has not tried to connect yet. */
-    NotStarted = 0,
-    /** Is connected. */
-    Connected = 1,
-    /** Is reconnecting after failing to connect, or being disconnected. */
-    ReConnecting = 2,
-    /** Is disconnected and not trying to reconnect. */
-    Disconnected = 3
-}
-export declare enum ConnectionType {
-    SignalR = 0
-}
-export interface IConnection {
-    readonly connectionState: ConnectionState;
-}
-export declare class ConnectionInfo {
-    readonly connection: IConnection;
-    readonly connectionName: string;
-    readonly connectionType: ConnectionType;
-    constructor(connection: IConnection, connectionName: string, connectionType: ConnectionType);
-}
-/** A connection manager is used to display the connection state of multiple connected services to the user. */
-export interface IConnectionManager {
-    /**
-     * Returns the max state of all the connections.
-     */
-    readonly connectionState: ConnectionState;
-    /**
-     * Gets a list of connections that have been registered.
-     */
-    readonly connections: ConnectionInfo[];
-    /**
-     * Registers a connection to be monitored.
-     * @param connection The connection to monitor.
-     * @param connectionName The display name of the connection.
-     */
-    registerConnection(connection: IConnection, connectionName: string, connectionType: ConnectionType): void;
-}
-export declare class ConnectionManager implements IConnectionManager {
-    private _connections;
-    registerConnection(connection: IConnection, connectionName: string, connectionType: ConnectionType): void;
-    get connectionState(): ConnectionState;
-    get connections(): ConnectionInfo[];
-}

package/dist/ConnectionManager.js

@@ -1,61 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { Computed } from './Model/Decorators';
-import { injectable } from 'inversify';
-export var ConnectionState;
-(function (ConnectionState) {
-    /** Has not tried to connect yet. */
-    ConnectionState[ConnectionState["NotStarted"] = 0] = "NotStarted";
-    /** Is connected. */
-    ConnectionState[ConnectionState["Connected"] = 1] = "Connected";
-    /** Is reconnecting after failing to connect, or being disconnected. */
-    ConnectionState[ConnectionState["ReConnecting"] = 2] = "ReConnecting";
-    /** Is disconnected and not trying to reconnect. */
-    ConnectionState[ConnectionState["Disconnected"] = 3] = "Disconnected";
-})(ConnectionState || (ConnectionState = {}));
-export var ConnectionType;
-(function (ConnectionType) {
-    ConnectionType[ConnectionType["SignalR"] = 0] = "SignalR";
-})(ConnectionType || (ConnectionType = {}));
-var ConnectionInfo = /** @class */ (function () {
-    function ConnectionInfo(connection, connectionName, connectionType) {
-        this.connection = connection;
-        this.connectionName = connectionName;
-        this.connectionType = connectionType;
-    }
-    return ConnectionInfo;
-}());
-export { ConnectionInfo };
-var ConnectionManager = /** @class */ (function () {
-    function ConnectionManager() {
-        this._connections = new Map();
-    }
-    ConnectionManager.prototype.registerConnection = function (connection, connectionName, connectionType) {
-        if (!this._connections.has(connectionName)) {
-            this._connections.set(connectionName, new ConnectionInfo(connection, connectionName, connectionType));
-        }
-    };
-    Object.defineProperty(ConnectionManager.prototype, "connectionState", {
-        get: function () {
-            return this.connections.reduce(function (p, c) { return Math.max(p, c.connection.connectionState); }, ConnectionState.NotStarted);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConnectionManager.prototype, "connections", {
-        get: function () {
-            return Array.from(this._connections.values());
-        },
-        enumerable: false,
-        configurable: true
-    });
-    __decorate([
-        Computed(),
-        __metadata("design:type", Number),
-        __metadata("design:paramtypes", [])
-    ], ConnectionManager.prototype, "connectionState", null);
-    ConnectionManager = __decorate([
-        injectable()
-    ], ConnectionManager);
-    return ConnectionManager;
-}());
-export { ConnectionManager };