Class MapBuilder

src/map.ts:17–155

    | ["remap", number, PropertyPath, ["import", number][], MapInstruction[]]

class MapBuilder implements Exporter {
  private context:
    | {parent: undefined, captures: StubHook[], subject: StubHook, path: PropertyPath}
    | {parent: MapBuilder, captures: number[], subject: number, path: PropertyPath};
  private captureMap: Map<StubHook, number> = new Map();

  private instructions: MapInstruction[] = [];

  constructor(subject: StubHook, path: PropertyPath) {
    if (currentMapBuilder) {
      this.context = {
        parent: currentMapBuilder,
        captures: [],
        subject: currentMapBuilder.capture(subject),
        path
      };
    } else {
      this.context = {
        parent: undefined,
        captures: [],
        subject,
        path
      };
    }

    currentMapBuilder = this;
  }

  unregister() {
    currentMapBuilder = this.context.parent;
  }

  makeInput(): MapVariableHook {
    return new MapVariableHook(this, 0);
  }

  makeOutput(result: RpcPayload): StubHook {
    let devalued: unknown;
    try {
      devalued = Devaluator.devaluate(result.value, undefined, this, result);
    } finally {
      result.dispose();
    }

    // The result is the final instruction. This doesn't actually fit our MapInstruction type
    // signature, so we cheat a bit.
    this.instructions.push(<any>devalued);

    if (this.context.parent) {
      this.context.parent.instructions.push(
        ["remap", this.context.subject, this.context.path,
                  this.context.captures.map(cap => ["import", cap]),
                  this.instructions]
      );
      return new MapVariableHook(this.context.parent, this.context.parent.instructions.length);
    } else {
      return this.context.subject.map(this.context.path, this.context.captures, this.instructions);
    }