Allow to remove context value specifiers

Author: surol

src/context-registry.spec.ts

@@ -1,7 +1,7 @@
 import { AIterable } from 'a-iterable';
+import { ContextKeyError } from './context-key-error';
 import { ContextRegistry } from './context-registry';
 import { ContextValues } from './context-values';
-import { ContextKeyError } from './context-key-error';
 import { MultiContextKey, SingleContextKey } from './simple-context-key';
 import Mock = jest.Mock;
 
@@ -59,6 +59,41 @@ describe('ContextRegistry', () => {
 
       expect(values.get(key)).toBe(value);
     });
+    it('selects the last value if more than one provided', () => {
+
+      const value1 = 'value1';
+      const value2 = 'value2';
+
+      registry.provide({ a: key, is: value1 });
+      registry.provide({ a: key, is: value2 });
+
+      expect(values.get(key)).toBe(value2);
+    });
+    it('removes the value specifier', () => {
+
+      const value1 = 'value1';
+      const value2 = 'value2';
+
+      registry.provide({ a: key, is: value1 });
+      registry.provide({ a: key, is: value2 })();
+
+      expect(values.get(key)).toBe(value1);
+    });
+    it('retains the constructed value when specifier removed', () => {
+
+      const value1 = 'value1';
+      const value2 = 'value2';
+
+      registry.provide({ a: key, is: value1 });
+
+      const remove = registry.provide({ a: key, is: value2 });
+
+      expect(values.get(key)).toBe(value2);
+
+      remove();
+      remove();
+      expect(values.get(key)).toBe(value2);
+    });
     it('throws if there is neither default nor fallback value', () => {
       expect(() => values.get(new SingleContextKey(key.name))).toThrowError(ContextKeyError);
       expect(() => values.get(new SingleContextKey(key.name), {})).toThrowError(ContextKeyError);

src/context-registry.ts

@@ -54,13 +54,15 @@ export class ContextRegistry<Ctx extends ContextValues = ContextValues> {
    * @typeparam Src  Source value type.
    * @typeparam Seed  Value seed type.
    * @param spec  Context value specifier.
+   *
+   * @returns A function that removes the given context value specifier when called.
    */
-  provide<Deps extends any[], Src, Seed>(spec: ContextValueSpec<Ctx, any, Deps, Src, Seed>): void {
+  provide<Deps extends any[], Src, Seed>(spec: ContextValueSpec<Ctx, any, Deps, Src, Seed>): () => void {
 
     const { a: { [ContextKey__symbol]: { seedKey } }, by } = contextValueSpec(spec);
     const [seeder] = this._seeding<Src, Seed>(seedKey);
 
-    seeder.provide(by);
+    return seeder.provide(by);
   }
 
   /**

src/context-seeder.ts

@@ -23,8 +23,10 @@ export interface ContextSeeder<Ctx extends ContextValues, Src, Seed> {
    * Provides context value.
    *
    * @param provider  Context value provider.
+   *
+   * @returns A function that removes the given context value `provider` when called.
    */
-  provide(provider: ContextValueProvider<Ctx, Src>): void;
+  provide(provider: ContextValueProvider<Ctx, Src>): () => void;
 
   /**
    * Creates context value seed for target `context`.

src/context-up-key.spec.ts

@@ -36,6 +36,41 @@ describe('ContextUpKey', () => {
       registry.provide({ a: key, is: afterEventOf(value) });
       expect(readValue(values.get(key))).toBe(value);
     });
+    it('selects the last value if more than one provided', () => {
+
+      const value1 = 'value1';
+      const value2 = 'value2';
+
+      registry.provide({ a: key, is: value1 });
+      registry.provide({ a: key, is: value2 });
+
+      expect(readValue(values.get(key))).toBe(value2);
+    });
+    it('removes the value specifier', () => {
+
+      const value1 = 'value1';
+      const value2 = 'value2';
+
+      registry.provide({ a: key, is: value1 });
+      registry.provide({ a: key, is: value2 })();
+
+      expect(readValue(values.get(key))).toBe(value1);
+    });
+    it('updates the value when specifier removed', () => {
+
+      const value1 = 'value1';
+      const value2 = 'value2';
+
+      registry.provide({ a: key, is: value1 });
+
+      const remove = registry.provide({ a: key, is: value2 });
+
+      expect(readValue(values.get(key))).toBe(value2);
+
+      remove();
+      remove();
+      expect(readValue(values.get(key))).toBe(value1);
+    });
     it('throws if there is neither default nor fallback value', () => {
       expect(() => readValue(values.get(key))).toThrowError(ContextKeyError);
       expect(() => readValue(values.get(key, {})!)).toThrowError(ContextKeyError);

src/context-up-key.ts

@@ -22,8 +22,17 @@ class ContextUpSeeder<Ctx extends ContextValues, Src>
 
   private readonly _providers: ValueTracker<ContextValueProvider<Ctx, Src | EventKeeper<Src[]>>[]> = trackValue([]);
 
-  provide(provider: ContextValueProvider<Ctx, Src | EventKeeper<Src[]>>): void {
+  provide(provider: ContextValueProvider<Ctx, Src | EventKeeper<Src[]>>): () => void {
     this._providers.it = [...this._providers.it, provider];
+    return () => {
+
+      const providers = this._providers.it;
+      const found = providers.indexOf(provider);
+
+      if (found >= 0) {
+        this._providers.it = providers.slice(0, found).concat(providers.slice(found + 1));
+      }
+    };
   }
 
   seed(context: Ctx, initial: AfterEvent<Src[]> = afterEventOf<Src[]>()): AfterEvent<Src[]> {

src/simple-context-key.ts

@@ -13,8 +13,16 @@ class SimpleContextSeeder<Ctx extends ContextValues, Src> implements ContextSeed
 
   private readonly _providers: ContextValueProvider<Ctx, Src>[] = [];
 
-  provide(provider: ContextValueProvider<Ctx, Src>): void {
+  provide(provider: ContextValueProvider<Ctx, Src>): () => void {
     this._providers.push(provider);
+    return () => {
+
+      const found = this._providers.indexOf(provider);
+
+      if (found >= 0) {
+        this._providers.splice(found, 1);
+      }
+    };
   }
 
   seed(context: Ctx, initial: AIterable<Src> = AIterable.from(overNone())): AIterable<Src> {