refactor state handling to make application available independent of the state

src/application/ApplicationFactory.ts

@@ -0,0 +1,21 @@
+import { IApplication } from '@/domain/IApplication';
+import { AsyncLazy } from '@/infrastructure/Threading/AsyncLazy';
+import { IApplicationFactory } from './IApplicationFactory';
+import { parseApplication } from './Parser/ApplicationParser';
+
+export type ApplicationGetter = () => IApplication;
+const ApplicationGetter: ApplicationGetter = parseApplication;
+
+export class ApplicationFactory implements IApplicationFactory {
+    public static readonly Current: IApplicationFactory = new ApplicationFactory(ApplicationGetter);
+    private readonly getter: AsyncLazy<IApplication>;
+    protected constructor(costlyGetter: ApplicationGetter) {
+        if (!costlyGetter) {
+            throw new Error('undefined getter');
+        }
+        this.getter = new AsyncLazy<IApplication>(() => Promise.resolve(costlyGetter()));
+    }
+    public getAppAsync(): Promise<IApplication> {
+        return this.getter.getValueAsync();
+    }
+}

src/application/Context/ApplicationContextFactory.ts

@@ -4,15 +4,15 @@ import { OperatingSystem } from '@/domain/OperatingSystem';
 import { Environment } from '../Environment/Environment';
 import { IApplication } from '@/domain/IApplication';
 import { IEnvironment } from '../Environment/IEnvironment';
-import { parseApplication } from '../Parser/ApplicationParser';
+import { IApplicationFactory } from '../IApplicationFactory';
+import { ApplicationFactory } from '../ApplicationFactory';
 
-export type ApplicationParserType = () => IApplication;
-const ApplicationParser: ApplicationParserType = parseApplication;
-
-export function buildContext(
-    parser = ApplicationParser,
-    environment = Environment.CurrentEnvironment): IApplicationContext {
-    const app = parser();
+export async function buildContextAsync(
+    factory: IApplicationFactory = ApplicationFactory.Current,
+    environment = Environment.CurrentEnvironment): Promise<IApplicationContext> {
+    if (!factory) { throw new Error('undefined factory'); }
+    if (!environment) { throw new Error('undefined environment'); }
+    const app = await factory.getAppAsync();
     const os = getInitialOs(app, environment);
     return new ApplicationContext(app, os);
 }

src/application/IApplicationFactory.ts

@@ -0,0 +1,5 @@
+import { IApplication } from '@/domain/IApplication';
+
+export interface IApplicationFactory {
+    getAppAsync(): Promise<IApplication>;
+}