add and unify custom factory for sub-states on and on deep states

Author: loreanvictor

src/agent/deep.ts

@@ -1,8 +1,9 @@
 import { KeyFunc } from "../util/keyed-array-diff";
 
 import { State } from "./state";
-import { SimpleDeep } from "./simple-deep";
+import { SimpleDeep, DeepChildFactory, DeepAccessor } from "./simple-deep";
 import { KeyedDeep } from "./keyed-deep";
+import { EqualityFunc } from ".";
 
 
 export function deep(state: State): SimpleDeep;
@@ -24,4 +25,18 @@ export function deep(state: State, key?: KeyFunc): SimpleDeep | KeyedDeep {
 }
 
 
+/**
+ *
+ * Returns a deep child factory that creates [keyed deep](https://connective.dev/docs/deep#keyed-deep) sub-states
+ * with given key function. Pass this to `.sub()` or `.key()` on [deep states](https://connective.dev/docs/deep)
+ * to have keyed sub-states.
+ *
+ * @param keyfunc the key function to be used
+ *
+ */
+export function keyed(keyfunc: KeyFunc): DeepChildFactory<KeyedDeep> {
+  return (accessor: DeepAccessor, compare: EqualityFunc) => new KeyedDeep(accessor, keyfunc, compare);
+}
+
+
 export default deep;

src/agent/index.ts

@@ -23,8 +23,8 @@ import { composition } from './inline-composition';
 
 import { KeyFunc, ChangeMap, AdditionList, DeletionList, MoveList } from '../util/keyed-array-diff';
 import { KeyedDeep } from './keyed-deep';
-import { SimpleDeep } from './simple-deep';
-import { deep } from './deep';
+import { SimpleDeep, DeepAccessor, DeepChildFactory } from './simple-deep';
+import { deep, keyed } from './deep';
 
 import { ChildNotDefined } from './errors/child-not-defined.error';
 import { ChildIsNotAgent, ChildIsNotPin } from './errors/child-type-mismatch.error';
@@ -44,6 +44,7 @@ export {
   exec, call, singleton, sampler,
   ChildIsNotAgent, ChildIsNotPin, ChildNotDefined,
   InsufficientInputs, InputNotInSignature, OutputNotInSignature,
-  deep, SimpleDeep, KeyedDeep,
+  deep, keyed, SimpleDeep, KeyedDeep,
+  DeepAccessor, DeepChildFactory,
   KeyFunc, ChangeMap, AdditionList, MoveList, DeletionList,
 }

src/agent/keyed-deep.ts

@@ -10,7 +10,7 @@ import { value } from "../pin/value";
 import { pipe } from "../pin/pipe";
 import { PinLike } from "../pin/pin-like";
 
-import { SimpleDeep, DeepAccessor } from "./simple-deep";
+import { SimpleDeep, DeepAccessor, DeepChildFactory } from "./simple-deep";
 import { State, EqualityFunc } from "./state";
 
 
@@ -40,21 +40,22 @@ export class KeyedDeep extends SimpleDeep {
   }
 
   public key(key: string | number): SimpleDeep;
-  public key(key: string | number, subkeyfunc: KeyFunc): KeyedDeep;
+  public key<T extends SimpleDeep>(key: string | number, factory: DeepChildFactory<T>): T;
   /**
    *
    * Creates a sub-state bound to entity identified by given key. Entity `x` is
    * said to be identified by key `k` if `state.keyfunc(x) === k`.
    *
    * @param key the identifier of the entity to track
-   * @param subkeyfunc a key function for the sub-state. provide IF the sub-state also needs to be keyed.
+   * @param factory the factory function to be used to construct the sub-state
    *
    */
-  public key(key: string | number, subkeyfunc?: KeyFunc): SimpleDeep | KeyedDeep {
+  public key<T extends SimpleDeep>(key: string | number, factory?: DeepChildFactory<T>): SimpleDeep | T {
     let initialized = false;
     let _this = this;
+    let _factory = factory || ((accessor: DeepAccessor, compare: EqualityFunc) => new SimpleDeep(accessor, compare));
 
-    let accessor: DeepAccessor = {
+    return _factory({
       initial: (_this._keyMap[key] || {item: undefined}).item
               || (Object.values(this.value) || []).find((i: any) => this.keyfunc(i) == key),
       get: group(_this.changes, _this.reemit).to(map(() => (_this._keyMap[key] || {item: undefined}).item)),
@@ -79,10 +80,7 @@ export class KeyedDeep extends SimpleDeep {
         } catch (err) {}
       }),
       bind() { return this.set.subscribe(); },
-    }
-
-    if (subkeyfunc) return new KeyedDeep(accessor, subkeyfunc, this.state.compare);
-    else return new SimpleDeep(accessor, this.state.compare);
+    }, this.state.compare);
   }
 
   /**

src/agent/simple-deep.ts

@@ -21,6 +21,8 @@ export interface DeepAccessor {
 }
 
 
+export type DeepChildFactory<T extends SimpleDeep> = (accessor: DeepAccessor, compare: EqualityFunc) => T;
+
 /**
  *
  * Represents non-keyed (simple) [deep states](https://connective.dev/docs/deep).
@@ -78,19 +80,23 @@ export class SimpleDeep extends Agent {
     }
   }
 
+  public sub(index: string | number): SimpleDeep;
+  public sub<T extends SimpleDeep>(index: string | number, factory: DeepChildFactory<T>): T;
   /**
    *
    * Creates a sub-state for given index/property.
    * [Read this](https://connective.dev/docs/deep) for more details
    *
    * @param index
+   * @param factory the factory function to be used to construct the sub-state
    *
    */
-  public sub(index: string | number): SimpleDeep {
+  public sub<T extends SimpleDeep>(index: string | number, factory?: DeepChildFactory<T>): SimpleDeep | T {
     let initialized = false;
     let _this = this;
+    let _factory = factory || ((accessor: DeepAccessor, compare: EqualityFunc) => new SimpleDeep(accessor, compare));
 
-    return new SimpleDeep({
+    return _factory({
       initial: (_this.value || [])[index],
       get: _this.output.to(map((v: any) => (v || [])[index])),
       set: sink((v, context) => {