replace linked list implementations with recorder + node

Author: notanengineercom

src/Recorder.ts

@@ -0,0 +1,40 @@
+import { inspect, InspectOptions } from 'util'
+import { SubstituteNodeBase } from './SubstituteNodeBase'
+
+export class Recorder {
+  private _records: SubstituteNodeBase[]
+  private _indexedRecords: Map<PropertyKey, SubstituteNodeBase[]>
+
+  constructor() {
+    this._records = []
+    this._indexedRecords = new Map()
+  }
+
+  public get records(): SubstituteNodeBase[] {
+    return this._records
+  }
+
+  public get indexedRecords(): Map<PropertyKey, SubstituteNodeBase[]> {
+    return this._indexedRecords
+  }
+
+  public addIndexedRecord(node: SubstituteNodeBase): void {
+    const existingNodes = this.indexedRecords.get(node.key)
+    if (typeof existingNodes === 'undefined') this._indexedRecords.set(node.key, [node])
+    else existingNodes.push(node)
+  }
+
+  public addRecord(node: SubstituteNodeBase): void {
+    this._records.push(node)
+  }
+
+  public getSiblingsOf(node: SubstituteNodeBase): SubstituteNodeBase[] {
+    const siblingNodes = this.indexedRecords.get(node.key) ?? []
+    return siblingNodes.filter(siblingNode => siblingNode !== node)
+  }
+
+  public [inspect.custom](_: number, options: InspectOptions): string {
+    const entries = [...this.indexedRecords.entries()]
+    return entries.map(([key, value]) => `\n  ${key.toString()}: {\n${value.map(v => `    ${inspect(v, options)}`).join(',\n')}\n  }`).join()
+  }
+}

src/SubstituteNodeBase.ts

@@ -0,0 +1,73 @@
+import { SubstituteBase } from './SubstituteBase'
+import { Substitute } from './Substitute'
+
+export abstract class SubstituteNodeBase<T extends SubstituteNodeBase = SubstituteNodeBase<any>> extends SubstituteBase {
+  private _parent?: T = undefined
+  private _child?: T
+  private _head: T & { parent: undefined }
+  private _root: Substitute
+
+  constructor(private _key: PropertyKey, caller: T | SubstituteBase) {
+    super()
+
+    if (caller instanceof Substitute) {
+      caller.recorder.addIndexedRecord(this)
+      this._root = caller
+    }
+
+    if (caller instanceof SubstituteNodeBase) {
+      this._parent = caller
+      this._head = caller.head as T & { parent: undefined }
+      caller.child = this
+    }
+
+    this.root.recorder.addRecord(this)
+  }
+
+  get key(): PropertyKey {
+    return this._key
+  }
+
+  set parent(parent: T | undefined) {
+    this._parent = parent
+  }
+
+  get parent(): T | undefined {
+    return this._parent
+  }
+
+  set child(child: T) {
+    this._child = child
+  }
+
+  get child(): T {
+    return this._child
+  }
+
+  get head(): T & { parent: undefined } {
+    return this.isHead() ? this : this._head
+  }
+
+  protected get root(): Substitute {
+    return this.head._root
+  }
+
+  protected isHead(): this is T & { parent: undefined } {
+    return typeof this._parent === 'undefined'
+  }
+
+  protected isIntermediateNode(): this is T & { parent: T } {
+    return !this.isHead()
+  }
+
+  protected getAllSiblings(): T[] {
+    return this.root.recorder.getSiblingsOf(this) as T[]
+  }
+
+  protected getAllSiblingsOfHead(): T[] {
+    return this.root.recorder.getSiblingsOf(this.head) as T[]
+  }
+
+  public abstract read(): void
+  public abstract write(value: any): void
+}