refactor recorder and recordsSet

Author: notanengineercom

src/Recorder.ts

@@ -1,46 +1,55 @@
 import { inspect, InspectOptions } from 'util'
-import { SubstituteNodeBase } from './SubstituteNodeBase'
+
+import { FilterFunction } from './Types'
 import { RecordsSet } from './RecordsSet'
 
-export class Recorder {
-  private _records: RecordsSet<SubstituteNodeBase>
-  private _indexedRecords: Map<PropertyKey, RecordsSet<SubstituteNodeBase>>
+export class Recorder<TRecord> {
+  private _identity: PropertyKey
+  private _records: RecordsSet<TRecord>
+  private _indexedRecords: Map<PropertyKey, RecordsSet<TRecord>>
 
-  constructor() {
+  private constructor(identity: PropertyKey) {
+    this._identity = identity
     this._records = new RecordsSet()
     this._indexedRecords = new Map()
   }
 
-  public get records(): RecordsSet<SubstituteNodeBase> {
+  public static withIdentityProperty<TRecord>(identity: keyof TRecord): Recorder<TRecord> {
+    return new this(identity)
+  }
+
+  public get records(): RecordsSet<TRecord> {
     return this._records
   }
 
-  public get indexedRecords(): Map<PropertyKey, RecordsSet<SubstituteNodeBase>> {
+  public get indexedRecords(): Map<PropertyKey, RecordsSet<TRecord>> {
     return this._indexedRecords
   }
 
-  public addIndexedRecord(node: SubstituteNodeBase): void {
-    this.addRecord(node)
-    const existingNodes = this.indexedRecords.get(node.key)
-    if (typeof existingNodes === 'undefined') this.indexedRecords.set(node.key, new RecordsSet([node]))
-    else existingNodes.add(node)
+  public addIndexedRecord(record: TRecord): void {
+    const id = this.getIdentity(record)
+    this.addRecord(record)
+    const existingNodes = this.indexedRecords.get(id)
+    if (typeof existingNodes === 'undefined') this.indexedRecords.set(id, new RecordsSet([record]))
+    else existingNodes.add(record)
   }
 
-  public addRecord(node: SubstituteNodeBase): void {
-    this._records.add(node)
+  public addRecord(record: TRecord): void {
+    this._records.add(record)
   }
 
-  public getSiblingsOf(node: SubstituteNodeBase): RecordsSet<SubstituteNodeBase> {
-    const siblingNodes = this.indexedRecords.get(node.key) ?? new RecordsSet()
-    return siblingNodes.filter(siblingNode => siblingNode !== node)
+  public getSiblingsOf(record: TRecord): RecordsSet<TRecord> {
+    const siblings = this.indexedRecords.get(this.getIdentity(record)) ?? new RecordsSet()
+    return siblings.filter(sibling => sibling !== record)
   }
 
-  public clearRecords(filterFunction: (node: SubstituteNodeBase) => boolean) {
+  public clearRecords(filterFunction: FilterFunction<TRecord>) {
     const recordsToRemove = this.records.filter(filterFunction)
     for (const record of recordsToRemove) {
-      const indexedRecord = this.indexedRecords.get(record.key)
+      const id = this.getIdentity(record)
+      const indexedRecord = this.indexedRecords.get(id)
       indexedRecord.delete(record)
-      if (indexedRecord.size === 0) this.indexedRecords.delete(record.key)
+      if (indexedRecord.size === 0) this.indexedRecords.delete(id)
       this.records.delete(record)
     }
   }
@@ -51,4 +60,8 @@ export class Recorder {
       ([key, value]) => `\n  ${key.toString()}: {\n${[...value.map(v => `    ${inspect(v, options)}`)].join(',\n')}\n  }`
     ).join()
   }
-}
+
+  private getIdentity(record: TRecord): PropertyKey {
+    return record[this._identity as keyof TRecord] as PropertyKey
+  }
+}

src/RecordsSet.ts

@@ -1,14 +1,16 @@
-type FilterFunction<T> = (item: T) => boolean
+import { FilterFunction } from './Types'
+
 type MapperFunction<T, R> = (item: T) => R
-type Transformer<T, R> = { type: 'filter', fnc: FilterFunction<T> } | { type: 'mapper', fnc: MapperFunction<T, R> }
+type Transformer<T, R> = { type: 'filter', predicate: FilterFunction<T> } | { type: 'mapper', predicate: MapperFunction<T, R> }
 
 export class RecordsSet<T> extends Set<T> {
   private _transformer: Transformer<any, any>
   private readonly _prevIter?: RecordsSet<T>
 
   constructor(value?: Iterable<T> | readonly T[]) {
-    super(value instanceof RecordsSet ? undefined : value)
-    if (value instanceof RecordsSet) this._prevIter = value
+    const isRecordSet = value instanceof RecordsSet
+    super(isRecordSet ? undefined : value)
+    if (isRecordSet) this._prevIter = value
   }
 
   get size(): number {
@@ -17,15 +19,15 @@ export class RecordsSet<T> extends Set<T> {
     return currentSize
   }
 
-  filter(predicate: (item: T) => boolean): RecordsSet<T> {
-    const newInstance = new RecordsSet<T>(this)
-    newInstance._transformer = { type: 'filter', fnc: predicate }
+  filter(predicate: FilterFunction<T>): RecordsSet<T> {
+    const newInstance = new RecordsSet<T>(this as RecordsSet<T>)
+    newInstance._transformer = { type: 'filter', predicate }
     return newInstance
   }
 
-  map<R>(predicate: (item: T) => R): RecordsSet<R> {
+  map<R>(predicate: MapperFunction<T, R>): RecordsSet<R> {
     const newInstance = new RecordsSet<R | T>(this)
-    newInstance._transformer = { type: 'mapper', fnc: predicate }
+    newInstance._transformer = { type: 'mapper', predicate }
     return newInstance as RecordsSet<R>
   }
 
@@ -41,7 +43,10 @@ export class RecordsSet<T> extends Set<T> {
   }
 
   clear() {
-    Object.defineProperty(this, '_prevIter', { value: undefined })
+    if (this._prevIter instanceof RecordsSet) {
+      this._prevIter.clear()
+      Object.defineProperty(this, '_prevIter', { value: undefined })
+    }
     super.clear()
   }
 
@@ -54,12 +59,17 @@ export class RecordsSet<T> extends Set<T> {
     yield* this.applyTransform(super.values())
   }
 
-  private *applyTransform(itarable: Iterable<T>): IterableIterator<T> {
+  private * applyTransform(itarable: Iterable<T>): IterableIterator<T> {
     const transform = this._transformer
     if (typeof transform === 'undefined') return yield* itarable
     for (const value of itarable) {
-      if (transform.type === 'mapper') yield transform.fnc(value)
-      if (transform.type === 'filter' && transform.fnc(value)) yield value
+      switch (transform.type) {
+        case 'filter':
+          if (transform.predicate(value)) yield value
+          break
+        case 'mapper': yield transform.predicate(value)
+          break
+      }
     }
   }
 }