@singularsystems/neo-core 1.4.1 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Neo core changelog
 
+## Version 1.5.0 (20 May 2026)
+
+- Better offline support (see wiki "PWA Offline" guide for more details).
+    - Added `supportsOffline` to ConfigModel.
+    - Config service will now cache config data if `supportsOffline` is true.
+    - Network services
+        - Added `NetworkUtils` class for helping to identify whether the app can communicate with the server or not. Extends basic `navigator.onLine` property.
+        - Added `AppConnectionMonitor` base class for monitoring app connection, and allowing the app to reconnect when back online.
+- OIDC Authentication service
+    - Will now redirect back to the current path if no path is specified.
+    - Will cache user data if `supportsOffline` is true.
+    - Current user and isAuthenticated properties will use cached data if available and if `supportsOffline` is true.
+
+## Version 1.4.2 (11 May 2026)
+
+- Authentication service
+    - Changed `loadUserFromSession` to try perform a silent sign in when the app is opened from another window.
+    - Change your startup code accordingly:
+        ```diff
+        -if (config.isDevelopment) {
+        -    await authService.loadUserFromSession();
+        -}
+        +await authService.loadUserFromSession();
+        ```
+
 ## Version 1.4.1 (20 April 2026)
 
 - Navigation helper

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

@@ -11,6 +11,11 @@ export interface IConfigModelData {
 }
 export interface IConfigModel extends IConfigModelData {
     readonly isTestOrDevelopment: boolean;
+    /**
+     * Indicates that this app supports offline usage.
+     * If true, config and user data will be cached on fetch, and used when offline.
+     */
+    readonly supportsOffline: boolean;
     initialise(): void;
 }
 export default class ConfigModel implements IConfigModel {
@@ -18,6 +23,7 @@ export default class ConfigModel implements IConfigModel {
     isDevelopment: boolean;
     isTest: boolean;
     get isTestOrDevelopment(): boolean;
+    get supportsOffline(): boolean;
     get baseUrl(): string;
     initialise(): void;
 }

package/dist/AppServices/Config/ConfigModel.js

@@ -10,6 +10,13 @@ var ConfigModel = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ConfigModel.prototype, "supportsOffline", {
+        get: function () {
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(ConfigModel.prototype, "baseUrl", {
         get: function () {
             if (!this._baseUrl) {

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

@@ -6,7 +6,7 @@ export interface IConfigService {
      * Load and process the config file from the specified path.
      * Path will default to [baseUrl]/config.json
      * @param path Optional path.
-     * @param store Offline store to allow offline retrieval.
+     * @param store Offline store to allow offline retrieval. Not necessary if you have set `supportsOffline` to true in the config model.
      */
     loadConfig(path?: string, store?: IDbSet<IConfigModelData>): Promise<IConfigModel>;
     /** Fetch the raw config data from the server. */

package/dist/AppServices/Config/ConfigService.js

@@ -3,40 +3,62 @@ import { injectable, inject } from 'inversify';
 import Axios from "axios";
 import NeoTypes from '../NeoTypes';
 import AxiosUtils from "../../AxiosUtils";
+var storageKey = "neo-app-config-data";
 var ConfigService = /** @class */ (function () {
     function ConfigService(config) {
         this.config = config;
     }
     ConfigService.prototype.loadConfig = function (path, store) {
         return __awaiter(this, void 0, void 0, function () {
-            var configData, e_1;
+            var configData, e_1, storedConfig;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 4, , 7]);
-                        return [4 /*yield*/, this.fetchConfig(path)];
+                        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)];
+                    case 2:
                         configData = (_a.sent()).data;
-                        if (!store) return [3 /*break*/, 3];
+                        if (!store) return [3 /*break*/, 4];
                         return [4 /*yield*/, store.putAsync(configData, 1)];
-                    case 2:
+                    case 3:
                         _a.sent();
-                        _a.label = 3;
-                    case 3: return [3 /*break*/, 7];
+                        return [3 /*break*/, 5];
                     case 4:
+                        if (this.config.supportsOffline) {
+                            localStorage.setItem(storageKey, JSON.stringify(configData));
+                        }
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
                         e_1 = _a.sent();
-                        if (!(store && AxiosUtils.isNetworkError(e_1) && !window.navigator.onLine)) return [3 /*break*/, 6];
+                        if (!AxiosUtils.isNetworkError(e_1) || !(this.config.supportsOffline || store)) {
+                            throw new Error("ConfigService - Error loading configuration: ".concat(e_1));
+                        }
+                        return [3 /*break*/, 7];
+                    case 7:
+                        if (!!configData) return [3 /*break*/, 11];
+                        if (!store) return [3 /*break*/, 9];
                         return [4 /*yield*/, store.getAsync(1)];
-                    case 5:
-                        // get config from index db
+                    case 8:
                         configData = _a.sent();
-                        _a.label = 6;
-                    case 6:
+                        return [3 /*break*/, 10];
+                    case 9:
+                        if (this.config.supportsOffline) {
+                            storedConfig = localStorage.getItem(storageKey);
+                            if (storedConfig) {
+                                configData = JSON.parse(storedConfig);
+                            }
+                        }
+                        _a.label = 10;
+                    case 10:
                         if (!configData) {
-                            throw new Error("ConfigService - Error loading configuration: ".concat(e_1));
+                            throw new Error("ConfigService - Unable to load config data from offline storage.");
                         }
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/, this.setConfig(configData)];
+                        _a.label = 11;
+                    case 11: return [2 /*return*/, this.setConfig(configData)];
                 }
             });
         });

package/dist/AppServices/NeoModule.js

@@ -6,7 +6,7 @@ import { TaskRunner, NotifyUtils } from '../';
 import ModalStore from '../Components/Modal/ModalStore';
 import { MenuItemProvider } from '../Routing/MenuItemProvider';
 import { ErrorHandler } from '../Components/ErrorHandler';
-import { ConnectionManager } from '../ConnectionManager';
+import { ConnectionManager } from '../Network/ConnectionManager';
 import LocalisationService from '../Localisation/LocalisationService';
 import { NotificationHelper } from '../Components/Notifications/NotificationHelper';
 import { RouteSecurityService } from "../Routing/RouteSecurityService";

package/dist/AppServices/NeoTypes.d.ts

@@ -10,7 +10,7 @@ import { IMenuItemProvider } from '../Routing/IMenuItemProvider';
 import { IModalStore } from '../Components/Modal/ModalStore';
 import { INotificationStore, INotificationHelper } from '../Components';
 import { IErrorHandler } from '../Components/ErrorHandler';
-import { IConnectionManager } from '../ConnectionManager';
+import { IConnectionManager } from '../Network/IConnectionManager';
 import { IAutoRunnerFactory } from '../Model/IAutoRunner';
 import { ILocalisationService } from '../Localisation/ILocalisationService';
 import { IRouteSecurityService } from '../Routing/IRouteSecurityService';
@@ -19,6 +19,7 @@ import { INavigationHelper } from '../Routing/INavigationHelper';
 import { ILoginErrorHandler } from '../Security/ILoginErrorHandler';
 import { IDecimalService } from "../Numeric";
 import { IServerMessageSubscriber } from "../SignalR/IServerMessageSubscriber";
+import { IAppConnectionMonitor } from "../Network/IAppConnectionMonitor";
 declare const NeoTypes: {
     Axios: ServiceIdentifier<import("axios").AxiosStatic>;
     Config: {
@@ -27,7 +28,6 @@ declare const NeoTypes: {
     };
     Core: {
         AutoRunnerFactory: ServiceIdentifier<IAutoRunnerFactory>;
-        /** @deprecated Use Messaging.ConnectionManager */
         ConnectionManager: ServiceIdentifier<IConnectionManager>;
         DecimalService: ServiceIdentifier<IDecimalService<import("../Numeric").IDecimal>>;
         ModelCreator: ServiceIdentifier<IModelCreatorBase>;
@@ -39,6 +39,10 @@ declare const NeoTypes: {
         ConnectionManager: ServiceIdentifier<IConnectionManager>;
         ServerMessageSubscriber: ServiceIdentifier<IServerMessageSubscriber>;
     };
+    Network: {
+        AppConnectionMonitor: ServiceIdentifier<IAppConnectionMonitor>;
+        ConnectionManager: ServiceIdentifier<IConnectionManager>;
+    };
     Routing: {
         MenuItemProvider: ServiceIdentifier<IMenuItemProvider<import("../Routing").IMenuRoute>>;
         NavigationHelper: ServiceIdentifier<INavigationHelper>;

package/dist/AppServices/NeoTypes.js

@@ -9,7 +9,6 @@ var NeoTypes = {
     },
     Core: {
         AutoRunnerFactory: new ServiceIdentifier("Neo.AutoRunnerFactory"),
-        /** @deprecated Use Messaging.ConnectionManager */
         ConnectionManager: connectionManagerType,
         DecimalService: new ServiceIdentifier("Neo.DecimalService"),
         ModelCreator: new ServiceIdentifier("Neo.ModelCreator")
@@ -21,6 +20,10 @@ var NeoTypes = {
         ConnectionManager: connectionManagerType,
         ServerMessageSubscriber: new ServiceIdentifier("Neo.ServerMessageSubscriber"),
     },
+    Network: {
+        AppConnectionMonitor: new ServiceIdentifier("Neo.AppConnectionMonitor"),
+        ConnectionManager: connectionManagerType,
+    },
     Routing: {
         MenuItemProvider: new ServiceIdentifier("Neo.MenuItemProvider"),
         NavigationHelper: new ServiceIdentifier("Neo.NavigationHelper"),

package/dist/AppServices/index.d.ts

@@ -4,4 +4,4 @@ export { Module } from './Module';
 export { default as NeoModule } from './NeoModule';
 export { ServiceIdentifier } from './ServiceIdentifier';
 export { ConfigService } from './Config/ConfigService';
-export { default as ConfigModel, IConfigModel } from './Config/ConfigModel';
+export { default as ConfigModel, IConfigModelData, IConfigModel } from './Config/ConfigModel';

package/dist/Data/ApiDataSource.js

@@ -3,6 +3,7 @@ import { AsyncDataSource } from './AsyncDataSource';
 import NeoModel from '../Model/NeoModel';
 import List from '../Model/List';
 import AxiosUtils from "../AxiosUtils";
+import NetworkUtils from "../Network/NetworkUtils";
 /**
  * Allows an api endpoint to be used directly by a consumer such as a drop down element.
  * If you need the data to be deserialised into a specific lookup model, use ApiClientLookupDataSource.
@@ -46,7 +47,7 @@ var ConvertingApiClientDataSource = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!navigator.onLine) return [3 /*break*/, 2];
+                        if (!(NetworkUtils.isOnline || !this.supportOffline)) return [3 /*break*/, 2];
                         return [4 /*yield*/, AxiosUtils.catchErrors(this.getMethod())];
                     case 1:
                         result = _a.sent();

package/dist/Network/AppConnectionMonitor.d.ts

@@ -0,0 +1,21 @@
+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);
+    protected reconnectDelayMs: number;
+    private state;
+    get isOnline(): boolean;
+    get requiresSignInRedirect(): boolean;
+    get connectionState(): ConnectionState;
+    /** Determines if a redirect can be performed to sign the user in. Return false to prevent the redirect. */
+    protected abstract beforeSigninRedirect(): Promise<boolean> | boolean;
+    /**
+     * Called once reconnected, after authenticationService.afterUserLoaded() has completed.
+     */
+    protected onReconnected(): Promise<void> | void;
+    private updateOnlineStatus;
+    private markOffline;
+    tryConnect(forceAllowRedirect?: boolean): Promise<void>;
+}

package/dist/Network/AppConnectionMonitor.js

@@ -0,0 +1,145 @@
+import { __awaiter, __decorate, __extends, __generator, __metadata, __param } 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) {
+        var _this = this;
+        this.authenticationService = authenticationService;
+        this.reconnectDelayMs = 5000;
+        this.updateOnlineStatus = this.updateOnlineStatus.bind(this);
+        this.state = new State();
+        window.addEventListener("online", this.updateOnlineStatus);
+        window.addEventListener("offline", this.updateOnlineStatus);
+        var axiosInstance = Globals.appService.get(NeoTypes.Axios);
+        axiosInstance.interceptors.response.use(function (response) { return response; }, function (error) {
+            // Network error occurred
+            if (error.response === undefined && _this.state.connectionState === ConnectionState.Connected) {
+                // Server is unreachable but browser thinks we're online
+                _this.markOffline();
+            }
+            return Promise.reject(error);
+        });
+    }
+    Object.defineProperty(AppConnectionMonitor.prototype, "isOnline", {
+        get: function () {
+            return this.state.connectionState === ConnectionState.Connected;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AppConnectionMonitor.prototype, "requiresSignInRedirect", {
+        get: function () {
+            return this.state.requiresSignInRedirect;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AppConnectionMonitor.prototype, "connectionState", {
+        get: function () {
+            return this.state.connectionState;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Called once reconnected, after authenticationService.afterUserLoaded() has completed.
+     */
+    AppConnectionMonitor.prototype.onReconnected = function () {
+    };
+    AppConnectionMonitor.prototype.updateOnlineStatus = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (navigator.onLine) {
+                    Utils.debounce(this, function () { return _this.tryConnect(false); }, this.reconnectDelayMs);
+                }
+                else {
+                    this.markOffline();
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    AppConnectionMonitor.prototype.markOffline = 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) {
+                    case 0:
+                        Utils.clearDebounce(this);
+                        if (this.state.connectionState === ConnectionState.Connected) {
+                            return [2 /*return*/];
+                        }
+                        this.state.connectionState = ConnectionState.ReConnecting;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 13, , 14]);
+                        if (!this.state.requiresSignInRedirect) return [3 /*break*/, 2];
+                        _a = null;
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.authenticationService.signinSilent()];
+                    case 3:
+                        _a = _c.sent();
+                        _c.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()];
+                    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();
+                        return [2 /*return*/];
+                    case 11:
+                        this.state.requiresSignInRedirect = true;
+                        _c.label = 12;
+                    case 12: return [3 /*break*/, 14];
+                    case 13:
+                        e_1 = _c.sent();
+                        this.state.connectionState = ConnectionState.Disconnected;
+                        return [3 /*break*/, 14];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AppConnectionMonitor = __decorate([
+        __param(0, inject(NeoTypes.Security.AuthenticationService.symbol)),
+        __metadata("design:paramtypes", [Object])
+    ], AppConnectionMonitor);
+    return AppConnectionMonitor;
+}());
+export default AppConnectionMonitor;
+var State = /** @class */ (function (_super) {
+    __extends(State, _super);
+    function State() {
+        var _this = _super.call(this) || this;
+        _this.connectionState = navigator.onLine ? ConnectionState.Connected : ConnectionState.Disconnected;
+        _this.requiresSignInRedirect = false;
+        _this.makeObservable();
+        return _this;
+    }
+    return State;
+}(ModelBase));

package/dist/Network/ConnectionManager.d.ts

@@ -0,0 +1,7 @@
+import { ConnectionInfo, ConnectionState, ConnectionType, IConnection, IConnectionManager } from "./IConnectionManager";
+export declare class ConnectionManager implements IConnectionManager {
+    private _connections;
+    registerConnection(connection: IConnection, connectionName: string, connectionType: ConnectionType): void;
+    get connectionState(): ConnectionState;
+    get connections(): ConnectionInfo[];
+}

package/dist/Network/ConnectionManager.js

@@ -0,0 +1,38 @@
+import { __decorate, __metadata } from "tslib";
+import { Computed } from '../Model/Decorators';
+import { injectable } from 'inversify';
+import { ConnectionInfo, ConnectionState } from "./IConnectionManager";
+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 };

package/dist/Network/IAppConnectionMonitor.d.ts

@@ -0,0 +1,6 @@
+import { ConnectionState } from "./IConnectionManager";
+export interface IAppConnectionMonitor {
+    readonly isOnline: boolean;
+    readonly requiresSignInRedirect: boolean;
+    readonly connectionState: ConnectionState;
+}

package/dist/Network/IAppConnectionMonitor.js

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

package/dist/Network/IConnectionManager.d.ts

@@ -0,0 +1,39 @@
+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;
+}

package/dist/Network/IConnectionManager.js

@@ -0,0 +1,24 @@
+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 };

package/dist/Network/NetworkUtils.d.ts

@@ -0,0 +1,11 @@
+import { IConfigModel } from "../AppServices";
+export default class NetworkUtils {
+    private static _monitorInstance?;
+    /**
+     * Indicates whether the app is online and ready to send requests to the server.
+     * Even if `navigator.onLine` reports true, the app may not have re-authenticated after a connection loss.
+     */
+    static get isOnline(): boolean;
+    static canFetch(config: IConfigModel): boolean;
+    static useCachedData(config: IConfigModel): boolean;
+}

package/dist/Network/NetworkUtils.js

@@ -0,0 +1,29 @@
+import Globals from "../Globals";
+import NeoTypes from "../AppServices/NeoTypes";
+var NetworkUtils = /** @class */ (function () {
+    function NetworkUtils() {
+    }
+    Object.defineProperty(NetworkUtils, "isOnline", {
+        /**
+         * Indicates whether the app is online and ready to send requests to the server.
+         * Even if `navigator.onLine` reports true, the app may not have re-authenticated after a connection loss.
+         */
+        get: function () {
+            var _a, _b;
+            if (this._monitorInstance === undefined) {
+                this._monitorInstance = Globals.appService.tryGet(NeoTypes.Network.AppConnectionMonitor);
+            }
+            return (_b = (_a = this._monitorInstance) === null || _a === void 0 ? void 0 : _a.isOnline) !== null && _b !== void 0 ? _b : navigator.onLine;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NetworkUtils.canFetch = function (config) {
+        return !config.supportsOffline || this.isOnline;
+    };
+    NetworkUtils.useCachedData = function (config) {
+        return config.supportsOffline && !this.isOnline;
+    };
+    return NetworkUtils;
+}());
+export default NetworkUtils;

package/dist/Network/index.d.ts

@@ -0,0 +1,5 @@
+import { ConnectionInfo, ConnectionState, ConnectionType, IConnection, IConnectionManager } from "./IConnectionManager";
+import AppConnectionMonitor from "./AppConnectionMonitor";
+import NetworkUtils from "./NetworkUtils";
+import { ConnectionManager } from "./ConnectionManager";
+export { ConnectionInfo, ConnectionState, ConnectionType, IConnection, IConnectionManager, ConnectionManager, AppConnectionMonitor, NetworkUtils as Utils };

package/dist/Network/index.js

@@ -0,0 +1,5 @@
+import { ConnectionInfo, ConnectionState, ConnectionType } from "./IConnectionManager";
+import AppConnectionMonitor from "./AppConnectionMonitor";
+import NetworkUtils from "./NetworkUtils";
+import { ConnectionManager } from "./ConnectionManager";
+export { ConnectionInfo, ConnectionState, ConnectionType, ConnectionManager, AppConnectionMonitor, NetworkUtils as Utils };

package/dist/Security/IAuthenticationService.d.ts

@@ -3,16 +3,18 @@ import { ISignInResult } from './SignInResult';
 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>;
     /**
      * Checks if the user is signed in, and if not, redirects to login.
      * Returns true if the user is logged in.
+     * @param redirectLocal Redirect path. If this is not supplied, the current path will be used.
      */
     ensureSignedIn(redirectLocal?: string): boolean;
     /**
      * Starts the sign in process
-     * @param redirectLocal The path to redirect to after calling endSignIn
+     * @param redirectLocal The path to redirect to after calling endSignIn. If this is not supplied, the current path will be used.
      */
     beginSignIn(redirectLocal?: string): Promise<any>;
     /**
@@ -24,7 +26,7 @@ export default interface IAuthenticationService {
      * Result.success will be false if an error occurs. Errors will be handled by the service bound to NeoTypes.Security.LoginErrorHandler.
      */
     tryCompleteSignIn(): Promise<ISignInResult>;
-    signinSilent(): Promise<any>;
+    signinSilent(): Promise<IUser | null>;
     endSignInSilent(): Promise<any>;
     beginSignOut(): void;
     endSignOut(): Promise<any>;

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

@@ -10,6 +10,7 @@ import { SignInResult } from '../SignInResult';
 export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser> implements IAuthenticationService {
     protected userManager: IUserManager;
     private axios;
+    private config;
     private _user;
     private isRedirecting;
     private afterUserLoadedPromise;
@@ -18,15 +19,10 @@ export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser>
      * @param userManager Oidc-client user manager instance
      * @param user User which existed in storage at startup
      */
-    constructor(userManager: IUserManager, axios: AxiosInstance);
+    constructor(userManager: IUserManager, axios: AxiosInstance, config?: import("../../AppServices").IConfigModel);
     isSigningOut: boolean;
-    loadUserFromToken(): Promise<TUser | null>;
     loadUserFromSession(): Promise<TUser | null>;
     ensureSignedIn(redirectLocal?: string): boolean;
-    /**
-     * Redirect to identity server to get the auth token.
-     * @param redirectPath Local path to redirect to once login is complete.
-     */
     beginSignIn(redirectPath?: string): Promise<any>;
     /**
      * Reads the access token from the query string and returns the redirect path.
@@ -38,13 +34,14 @@ export default abstract class OidcAuthService<TUser extends OidcUser = OidcUser>
      */
     tryCompleteSignIn(): Promise<SignInResult>;
     endSignInSilent(): Promise<any>;
+    protected setUserDataAsync(userData: IOidcUser): Promise<void>;
     private onUserLoaded;
     protected afterUserLoaded(): Promise<void> | void;
-    private completeAfterUserLoaded;
+    private awaitAfterUserLoadedAsync;
     protected createUser(user: IOidcUser): OidcUser;
     private onUserUnloaded;
     private setUser;
-    signinSilent(): Promise<IOidcUser | null>;
+    signinSilent(): Promise<TUser | null>;
     beginSignOut(): void;
     endSignOut(): Promise<any>;
     private signOutLocal;

package/dist/Security/Oidc/OidcAuthService.js

@@ -4,6 +4,8 @@ import OidcUser from './OidcUser';
 import { SignInResult } from '../SignInResult';
 import { Misc } from '../../';
 import { NeoTypes } from '../../AppServices';
+import NetworkUtils from "../../Network/NetworkUtils";
+var storageKey = "neo-app-user-data";
 /**
  * Oidc authentication service base class.
  * You must override this class and provide the user manager implementation from the oidc library.
@@ -14,9 +16,12 @@ var OidcAuthService = /** @class */ (function () {
      * @param userManager Oidc-client user manager instance
      * @param user User which existed in storage at startup
      */
-    function OidcAuthService(userManager, axios) {
+    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;
@@ -25,28 +30,38 @@ var OidcAuthService = /** @class */ (function () {
         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(this.signinSilent.bind(this));
+            this.userManager.events.addAccessTokenExpiring(function () { return _this.userManager.signinSilent(); });
         }
     }
-    OidcAuthService.prototype.loadUserFromToken = function () {
-        return this.loadUserFromSession();
-    };
     OidcAuthService.prototype.loadUserFromSession = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var user;
+            var userData, user;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.userManager.getUser()];
+                    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))];
                     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*/, 3];
+                        if (!(user && !user.expired)) return [3 /*break*/, 6];
+                        // Get user does not raise the onUserLoaded event, so we call it manually.
+                        return [4 /*yield*/, this.setUserDataAsync(user)];
+                    case 5:
                         // Get user does not raise the onUserLoaded event, so we call it manually.
-                        this.onUserLoaded(user);
-                        return [4 /*yield*/, this.completeAfterUserLoaded()];
-                    case 2:
                         _a.sent();
-                        _a.label = 3;
-                    case 3: return [2 /*return*/, this.user];
+                        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];
                 }
             });
         });
@@ -61,11 +76,10 @@ var OidcAuthService = /** @class */ (function () {
         }
         return true;
     };
-    /**
-     * Redirect to identity server to get the auth token.
-     * @param redirectPath Local path to redirect to once login is complete.
-     */
     OidcAuthService.prototype.beginSignIn = function (redirectPath) {
+        if (redirectPath === undefined) {
+            redirectPath = (window.location.pathname + window.location.search).substring(this.config.baseUrl.length);
+        }
         if (!this.isRedirecting) {
             this.isRedirecting = true;
             return this.userManager.signinRedirect({ state: redirectPath });
@@ -118,7 +132,7 @@ var OidcAuthService = /** @class */ (function () {
                         return [4 /*yield*/, this.endSignIn()];
                     case 2:
                         redirectPath = _a.sent();
-                        return [4 /*yield*/, this.completeAfterUserLoaded()];
+                        return [4 /*yield*/, this.awaitAfterUserLoadedAsync()];
                     case 3:
                         _a.sent();
                         return [2 /*return*/, new SignInResult(true, redirectPath)];
@@ -134,13 +148,31 @@ var OidcAuthService = /** @class */ (function () {
     OidcAuthService.prototype.endSignInSilent = function () {
         return this.userManager.signinSilentCallback();
     };
-    OidcAuthService.prototype.onUserLoaded = function (user) {
-        this.setUser(this.createUser(user));
+    OidcAuthService.prototype.setUserDataAsync = function (userData) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.onUserLoaded(userData, false);
+                        return [4 /*yield*/, this.awaitAfterUserLoadedAsync()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OidcAuthService.prototype.onUserLoaded = function (userData, store) {
+        if (store === void 0) { store = true; }
+        this.setUser(this.createUser(userData));
+        if (store && this.config.supportsOffline) {
+            localStorage.setItem(storageKey, JSON.stringify(userData));
+        }
         this.afterUserLoadedPromise = this.afterUserLoaded();
     };
     OidcAuthService.prototype.afterUserLoaded = function () {
     };
-    OidcAuthService.prototype.completeAfterUserLoaded = function () {
+    OidcAuthService.prototype.awaitAfterUserLoadedAsync = function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -172,7 +204,29 @@ var OidcAuthService = /** @class */ (function () {
         this._user = user;
     };
     OidcAuthService.prototype.signinSilent = function () {
-        return this.userManager.signinSilent();
+        return __awaiter(this, void 0, void 0, function () {
+            var e_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.userManager.signinSilent()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_3 = _a.sent();
+                        if (e_3.error === "login_required" || e_3.error === "consent_required" || e_3.error === "interaction_required") {
+                            return [2 /*return*/, null];
+                        }
+                        return [3 /*break*/, 3];
+                    case 3: return [4 /*yield*/, this.awaitAfterUserLoadedAsync()];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/, this.user];
+                }
+            });
+        });
     };
     OidcAuthService.prototype.beginSignOut = function () {
         if (!this.isRedirecting) {
@@ -204,6 +258,10 @@ var OidcAuthService = /** @class */ (function () {
     });
     Object.defineProperty(OidcAuthService.prototype, "isAuthenticated", {
         get: function () {
+            if (NetworkUtils.useCachedData(this.config)) {
+                // Ignore expiry when offline.
+                return this._user !== null;
+            }
             return this.user !== null && !this.user.hasExpired;
         },
         enumerable: false,

package/dist/SignalR/HubBase.d.ts

@@ -1,7 +1,7 @@
 import * as signalR from '@microsoft/signalr';
 import { IHubReceiver } from "./HubReceiver";
 import { AppServices } from '../';
-import { IConnection, ConnectionState } from '../ConnectionManager';
+import { IConnection, ConnectionState } from '../Network/IConnectionManager';
 import { IDisposable } from '../Misc';
 export interface IHubBase extends IConnection, IDisposable {
     /**

package/dist/SignalR/HubBase.js

@@ -2,7 +2,7 @@ import { __awaiter, __generator, __spreadArray } from "tslib";
 import * as signalR from '@microsoft/signalr';
 import HubReceiver from "./HubReceiver";
 import { AppServices, Misc, TaskRunner } from '../';
-import { ConnectionState } from '../ConnectionManager';
+import { ConnectionState } from '../Network/IConnectionManager';
 import { ObservableValue } from '../Model';
 import { Utils } from '../Utils';
 var HubBase = /** @class */ (function () {

package/dist/index.d.ts

@@ -23,7 +23,7 @@ import * as JsonSchema from './JsonSchema';
 import * as Localisation from './Localisation';
 import * as Misc from './Misc';
 import * as Model from './Model';
-import * as Network from './ConnectionManager';
+import * as Network from './Network';
 import * as Numeric from './Numeric';
 import * as Routing from './Routing';
 import * as Security from './Security';

package/dist/index.js

@@ -26,7 +26,7 @@ import * as JsonSchema from './JsonSchema';
 import * as Localisation from './Localisation';
 import * as Misc from './Misc';
 import * as Model from './Model';
-import * as Network from './ConnectionManager';
+import * as Network from './Network';
 import * as Numeric from './Numeric';
 import * as Routing from './Routing';
 import * as Security from './Security';

package/package.json

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