Implement MultiContextUpKey

Author: surol

src/context-up-key.spec.ts

@@ -1,7 +1,7 @@
 import { AfterEvent, afterEventOf } from 'fun-events';
 import { ContextKeyError } from './context-key-error';
 import { ContextRegistry } from './context-registry';
-import { SingleContextUpKey } from './context-up-key';
+import { MultiContextUpKey, SingleContextUpKey } from './context-up-key';
 import { ContextValues } from './context-values';
 
 describe('ContextUpKey', () => {
@@ -93,15 +93,85 @@ describe('ContextUpKey', () => {
 
       expect(readValue(values.get(keyWithDefaults))).toBe(defaultValue);
     });
+
+    function readValue<Value>(from: AfterEvent<[Value]>): Value {
+
+      let received: Value = undefined!;
+
+      from.once(value => received = value);
+
+      return received;
+    }
   });
 
-});
+  describe('MultiContextUpKey', () => {
 
-function readValue<Value>(from: AfterEvent<[Value]>): Value {
+    let key: MultiContextUpKey<string>;
 
-  let received: Value = undefined!;
+    beforeEach(() => {
+      key = new MultiContextUpKey('values');
+    });
+
+    it('is associated with empty array by default', () => {
+      expect(readValue(values.get(key))).toHaveLength(0);
+    });
+    it('is associated with default value if there is no provider', () => {
 
-  from.once(value => received = value);
+      const defaultValue = ['default'];
+      const keyWithDefaults = new MultiContextUpKey('key', { byDefault: () => defaultValue });
 
-  return received;
-}
+      expect(readValue(values.get(keyWithDefaults))).toEqual(defaultValue);
+    });
+    it('is associated with default value if providers did not return any values', () => {
+
+      const defaultValue = ['default'];
+      const keyWithDefaults = new MultiContextUpKey('key', { byDefault: () => defaultValue });
+
+      registry.provide({ a: keyWithDefaults, is: null });
+      registry.provide({ a: keyWithDefaults, is: undefined });
+
+      expect(readValue(values.get(keyWithDefaults))).toEqual(defaultValue);
+    });
+    it('is associated with provided values array', () => {
+      registry.provide({ a: key, is: 'a' });
+      registry.provide({ a: key, is: undefined });
+      registry.provide({ a: key, is: 'c' });
+
+      expect(readValue(values.get(key))).toEqual(['a', 'c']);
+    });
+    it('is associated with value', () => {
+      registry.provide({ a: key, is: 'value' });
+
+      expect(readValue(values.get(key))).toEqual(['value']);
+    });
+    it('is associated with fallback value if there is no value provided', () => {
+      expect(readValue(values.get(key, { or: afterEventOf('fallback') }))).toEqual(['fallback']);
+    });
+    it('prefers fallback value over default one', () => {
+      expect(readValue(
+          values.get(
+              new MultiContextUpKey<string>(
+                  key.name,
+                  { byDefault: () => ['default', 'value'] }
+              ),
+              { or: afterEventOf('fallback', 'value') },
+          )
+      )).toEqual(['fallback', 'value']);
+    });
+    it('throws if fallback value is `null`', () => {
+      expect(() => readValue(values.get(key, { or: null })!)).toThrowError(ContextKeyError);
+    });
+    it('throws if fallback value is `undefined`', () => {
+      expect(() => readValue(values.get(key, { or: undefined })!)).toThrowError(ContextKeyError);
+    });
+
+    function readValue<Src>(from: AfterEvent<Src[]>): Src[] {
+
+      let received: Src[] = undefined!;
+
+      from.once((...value) => received = value);
+
+      return received;
+    }
+  });
+});

src/context-up-key.ts

@@ -181,11 +181,80 @@ export class SingleContextUpKey<Value> extends ContextUpKey<AfterEvent<[Value]>,
         return backup; // Backup value found.
       }
 
-      // Backup value is absent. Construct a error response.
+      // Backup value is absent. Construct an error response.
       return afterEventBy<[Value]>(() => {
         throw new ContextKeyError(this);
       });
     });
   }
 
 }
+
+/**
+ * Multiple updatable context values key.
+ *
+ * The associated value is an `AfterEvent` registrar of receivers of the source values array. It is always present,
+ * even though the array can be empty.
+ *
+ * It is an error to provide a `null` or `undefined` {@link ContextRequest.Opts.or fallback value} when requesting
+ * an associated value. Use an `afterEventOf()` result as a fallback instead.
+ *
+ * @typeparam Value  Context value type.
+ */
+export class MultiContextUpKey<Src> extends ContextUpKey<AfterEvent<Src[]>, Src> {
+
+  /**
+   * A provider of context value used when there is no value associated with this key.
+   */
+  readonly byDefault: ContextValueProvider<ContextValues, readonly Src[]>;
+
+  /**
+   * Constructs multiple updatable context value key.
+   *
+   * @param name  Human-readable key name.
+   * @param seedKey  Value seed key. A new one will be constructed when omitted.
+   * @param byDefault  Optional default value provider. If unspecified or `undefined` the key has no default
+   * value.
+   */
+  constructor(
+      name: string,
+      {
+        seedKey,
+        byDefault = noop,
+      }: {
+        seedKey?: ContextSeedKey<Src | EventKeeper<Src[]>, AfterEvent<Src[]>>,
+        byDefault?: ContextValueProvider<ContextValues, readonly Src[]>,
+      } = {}) {
+    super(name, seedKey);
+    this.byDefault = byDefault;
+  }
+
+  grow<Ctx extends ContextValues>(
+      opts: ContextValueOpts<Ctx, AfterEvent<Src[]>, EventKeeper<Src[]> | Src, AfterEvent<Src[]>>,
+  ): AfterEvent<Src[]> {
+    return opts.seed.keep.dig((...sources) => {
+      if (sources.length) {
+        // Sources present. Use them.
+        return afterEventOf(...sources);
+      }
+
+      // Sources absent. Attempt to detect the backup value.
+      const backup = opts.byDefault(() => {
+
+        const defaultValue = this.byDefault(opts.context);
+
+        return defaultValue ? afterEventOf(...defaultValue) : afterEventOf();
+      });
+
+      if (backup != null) {
+        return backup; // Backup value found.
+      }
+
+      // Backup value is absent. Construct an error response.
+      return afterEventBy<Src[]>(() => {
+        throw new ContextKeyError(this);
+      });
+    });
+  }
+
+}

src/simple-context-key.spec.ts

@@ -194,44 +194,36 @@ describe('SimpleContextKey', () => {
 
       expect(values.get(key)).toEqual(['value']);
     });
+    it('is associated with fallback value if there is no value provided', () => {
+      expect(values.get(key, { or: ['fallback'] })).toEqual(['fallback']);
+    });
     it('throws if there is no default value', () => {
       expect(() => values.get(new MultiContextKey(key.name, { byDefault: () => null }))).toThrowError();
     });
-    it('is associated with empty array by default', () => {
-      expect(values.get(new MultiContextKey(key.name))).toEqual([]);
-    });
-    it('is associated with default value is there is no value', () => {
-      expect(values.get(new MultiContextKey<string>(key.name), { or: ['default'] }))
-          .toEqual(['default']);
-    });
-    it('is associated with key default value is there is no value', () => {
-      expect(values.get(new MultiContextKey<string>(key.name, { byDefault: () => ['default'] })))
-          .toEqual(['default']);
-    });
     it('prefers fallback value over default one', () => {
       expect(
           values.get(
               new MultiContextKey<string>(
                   key.name,
-                  { byDefault: () => ['key', 'default'] }
+                  { byDefault: () => ['default', 'value'] }
               ),
-              { or: ['explicit', 'default'] }
+              { or: ['fallback', 'value'] },
           )
-      ).toEqual(['explicit', 'default']);
+      ).toEqual(['fallback', 'value']);
     });
     it('prefers `null` fallback value over default one', () => {
       expect(values.get(
-          new MultiContextKey<string>(key.name, { byDefault: () => ['key', 'default'] }),
-          { or: null }
+          new MultiContextKey<string>(key.name, { byDefault: () => ['default', 'value'] }),
+          { or: null },
       )).toBeNull();
     });
     it('prefers `undefined` fallback value over default one', () => {
       expect(
           values.get(new MultiContextKey<string>(
               key.name,
-              { byDefault: () => ['key', 'default'] }
+              { byDefault: () => ['default', 'value'] }
               ),
-              { or: undefined }
+              { or: undefined },
           )
       ).toBeUndefined();
     });