Ps/introduce single user state (#7053)

* Specify state provider for currently active user

* Split active and single user States

UserStateProvider is still the mechanism to build each State object.
The SingleUserState is basically a repeat of GlobalState, but with
additional scoping.

* Fixup global state cache

* fix fakers to new interface

* Make userId available in single user state

* Split providers by dependency requirements

This allows usage of the single state provider in contexts that would
otherwise form circular dependencies.

* Offer convenience wrapper classes for common use

* Import for docs

* Bind wrapped methods

libs/common/src/platform/state/implementations/default-state.provider.spec.ts

@@ -0,0 +1,56 @@
+import {
+  FakeActiveUserStateProvider,
+  FakeGlobalStateProvider,
+  FakeSingleUserStateProvider,
+} from "../../../../spec/fake-state-provider";
+import { UserId } from "../../../types/guid";
+import { KeyDefinition } from "../key-definition";
+import { StateDefinition } from "../state-definition";
+
+import { DefaultStateProvider } from "./default-state.provider";
+
+describe("DefaultStateProvider", () => {
+  let sut: DefaultStateProvider;
+  let activeUserStateProvider: FakeActiveUserStateProvider;
+  let singleUserStateProvider: FakeSingleUserStateProvider;
+  let globalStateProvider: FakeGlobalStateProvider;
+
+  beforeEach(() => {
+    activeUserStateProvider = new FakeActiveUserStateProvider();
+    singleUserStateProvider = new FakeSingleUserStateProvider();
+    globalStateProvider = new FakeGlobalStateProvider();
+    sut = new DefaultStateProvider(
+      activeUserStateProvider,
+      singleUserStateProvider,
+      globalStateProvider,
+    );
+  });
+
+  it("should bind the activeUserStateProvider", () => {
+    const keyDefinition = new KeyDefinition(new StateDefinition("test", "disk"), "test", {
+      deserializer: () => null,
+    });
+    const existing = activeUserStateProvider.get(keyDefinition);
+    const actual = sut.getActive(keyDefinition);
+    expect(actual).toBe(existing);
+  });
+
+  it("should bind the singleUserStateProvider", () => {
+    const userId = "user" as UserId;
+    const keyDefinition = new KeyDefinition(new StateDefinition("test", "disk"), "test", {
+      deserializer: () => null,
+    });
+    const existing = singleUserStateProvider.get(userId, keyDefinition);
+    const actual = sut.getUser(userId, keyDefinition);
+    expect(actual).toBe(existing);
+  });
+
+  it("should bind the globalStateProvider", () => {
+    const keyDefinition = new KeyDefinition(new StateDefinition("test", "disk"), "test", {
+      deserializer: () => null,
+    });
+    const existing = globalStateProvider.get(keyDefinition);
+    const actual = sut.getGlobal(keyDefinition);
+    expect(actual).toBe(existing);
+  });
+});