@glimmer/runtime/dist/commonjs/es2017/lib/vm/update.js

Minimal runtime needed to render Glimmer templates

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ListBlockOpcode = exports.ListItemOpcode = exports.TryOpcode = exports.BlockOpcode = exports.ResumableVMStateImpl = exports.default = void 0;

var _env = require("@glimmer/env");

var _reference = require("@glimmer/reference");

var _destroyable = require("@glimmer/destroyable");

var _util = require("@glimmer/util");

var _validator = require("@glimmer/validator");

var _bounds = require("../bounds");

var _elementBuilder = require("./element-builder");

class UpdatingVMImpl {
  constructor(env, {
    alwaysRevalidate = false
  }) {
    this.frameStack = new _util.Stack();
    this.env = env;
    this.dom = env.getDOM();
    this.alwaysRevalidate = alwaysRevalidate;
  }

  execute(opcodes, handler) {
    if (_env.DEBUG) {
      let hasErrored = true;

      try {
        (0, _validator.runInTrackingTransaction)(() => this._execute(opcodes, handler), '- While rendering:'); // using a boolean here to avoid breaking ergonomics of "pause on uncaught exceptions"
        // which would happen with a `catch` + `throw`

        hasErrored = false;
      } finally {
        if (hasErrored) {
          // eslint-disable-next-line no-console
          console.error(`\n\nError occurred:\n\n${(0, _validator.resetTracking)()}\n\n`);
        }
      }
    } else {
      this._execute(opcodes, handler);
    }
  }

  _execute(opcodes, handler) {
    let {
      frameStack
    } = this;
    this.try(opcodes, handler);

    while (true) {
      if (frameStack.isEmpty()) break;
      let opcode = this.frame.nextStatement();

      if (opcode === undefined) {
        frameStack.pop();
        continue;
      }

      opcode.evaluate(this);
    }
  }

  get frame() {
    return this.frameStack.current;
  }

  goto(index) {
    this.frame.goto(index);
  }

  try(ops, handler) {
    this.frameStack.push(new UpdatingVMFrame(ops, handler));
  }

  throw() {
    this.frame.handleException();
    this.frameStack.pop();
  }

}

exports.default = UpdatingVMImpl;

class ResumableVMStateImpl {
  constructor(state, resumeCallback) {
    this.state = state;
    this.resumeCallback = resumeCallback;
  }

  resume(runtime, builder) {
    return this.resumeCallback(runtime, this.state, builder);
  }

}

exports.ResumableVMStateImpl = ResumableVMStateImpl;

class BlockOpcode {
  constructor(state, runtime, bounds, children) {
    this.state = state;
    this.runtime = runtime;
    this.children = children;
    this.bounds = bounds;
  }

  parentElement() {
    return this.bounds.parentElement();
  }

  firstNode() {
    return this.bounds.firstNode();
  }

  lastNode() {
    return this.bounds.lastNode();
  }

  evaluate(vm) {
    vm.try(this.children, null);
  }

}

exports.BlockOpcode = BlockOpcode;

class TryOpcode extends BlockOpcode {
  constructor() {
    super(...arguments);
    this.type = 'try';
  }

  evaluate(vm) {
    vm.try(this.children, this);
  }

  handleException() {
    let {
      state,
      bounds,
      runtime
    } = this;
    (0, _destroyable.destroyChildren)(this);

    let elementStack = _elementBuilder.NewElementBuilder.resume(runtime.env, bounds);

    let vm = state.resume(runtime, elementStack);
    let updating = [];
    let children = this.children = [];
    let result = vm.execute(vm => {
      vm.pushUpdating(updating);
      vm.updateWith(this);
      vm.pushUpdating(children);
    });
    (0, _destroyable.associateDestroyableChild)(this, result.drop);
  }

}

exports.TryOpcode = TryOpcode;

class ListItemOpcode extends TryOpcode {
  constructor(state, runtime, bounds, key, memo, value) {
    super(state, runtime, bounds, []);
    this.key = key;
    this.memo = memo;
    this.value = value;
    this.retained = false;
    this.index = -1;
  }

  updateReferences(item) {
    this.retained = true;
    (0, _reference.updateRef)(this.value, item.value);
    (0, _reference.updateRef)(this.memo, item.memo);
  }

  shouldRemove() {
    return !this.retained;
  }

  reset() {
    this.retained = false;
  }

}

exports.ListItemOpcode = ListItemOpcode;

class ListBlockOpcode extends BlockOpcode {
  constructor(state, runtime, bounds, children, iterableRef) {
    super(state, runtime, bounds, children);
    this.iterableRef = iterableRef;
    this.type = 'list-block';
    this.opcodeMap = new Map();
    this.marker = null;
    this.lastIterator = (0, _reference.valueForRef)(iterableRef);
  }

  initializeChild(opcode) {
    opcode.index = this.children.length - 1;
    this.opcodeMap.set(opcode.key, opcode);
  }

  evaluate(vm) {
    let iterator = (0, _reference.valueForRef)(this.iterableRef);

    if (this.lastIterator !== iterator) {
      let {
        bounds
      } = this;
      let {
        dom
      } = vm;
      let marker = this.marker = dom.createComment('');
      dom.insertAfter(bounds.parentElement(), marker, bounds.lastNode());
      this.sync(iterator);
      this.parentElement().removeChild(marker);
      this.marker = null;
      this.lastIterator = iterator;
    } // Run now-updated updating opcodes


    super.evaluate(vm);
  }

  sync(iterator) {
    let {
      opcodeMap: itemMap,
      children
    } = this;
    let currentOpcodeIndex = 0;
    let seenIndex = 0;
    this.children = this.bounds.boundList = [];

    while (true) {
      let item = iterator.next();
      if (item === null) break;
      let opcode = children[currentOpcodeIndex];
      let {
        key
      } = item; // Items that have already been found and moved will already be retained,
      // we can continue until we find the next unretained item

      while (opcode !== undefined && opcode.retained === true) {
        opcode = children[++currentOpcodeIndex];
      }

      if (opcode !== undefined && opcode.key === key) {
        this.retainItem(opcode, item);
        currentOpcodeIndex++;
      } else if (itemMap.has(key)) {
        let itemOpcode = itemMap.get(key); // The item opcode was seen already, so we should move it.

        if (itemOpcode.index < seenIndex) {
          this.moveItem(itemOpcode, item, opcode);
        } else {
          // Update the seen index, we are going to be moving this item around
          // so any other items that come before it will likely need to move as
          // well.
          seenIndex = itemOpcode.index;
          let seenUnretained = false; // iterate through all of the opcodes between the current position and
          // the position of the item's opcode, and determine if they are all
          // retained.

          for (let i = currentOpcodeIndex + 1; i < seenIndex; i++) {
            if (children[i].retained === false) {
              seenUnretained = true;
              break;
            }
          } // If we have seen only retained opcodes between this and the matching
          // opcode, it means that all the opcodes in between have been moved
          // already, and we can safely retain this item's opcode.


          if (seenUnretained === false) {
            this.retainItem(itemOpcode, item);
            currentOpcodeIndex = seenIndex + 1;
          } else {
            this.moveItem(itemOpcode, item, opcode);
            currentOpcodeIndex++;
          }
        }
      } else {
        this.insertItem(item, opcode);
      }
    }

    for (let i = 0; i < children.length; i++) {
      let opcode = children[i];

      if (opcode.retained === false) {
        this.deleteItem(opcode);
      } else {
        opcode.reset();
      }
    }
  }

  retainItem(opcode, item) {
    if (false
    /* LOCAL_DEBUG */
    ) {
        (0, _util.logStep)('list-updates', ['retain', item.key]);
      }

    let {
      children
    } = this;
    (0, _reference.updateRef)(opcode.memo, item.memo);
    (0, _reference.updateRef)(opcode.value, item.value);
    opcode.retained = true;
    opcode.index = children.length;
    children.push(opcode);
  }

  insertItem(item, before) {
    if (false
    /* LOCAL_DEBUG */
    ) {
        (0, _util.logStep)('list-updates', ['insert', item.key]);
      }

    let {
      opcodeMap,
      bounds,
      state,
      runtime,
      children
    } = this;
    let {
      key
    } = item;
    let nextSibling = before === undefined ? this.marker : before.firstNode();

    let elementStack = _elementBuilder.NewElementBuilder.forInitialRender(runtime.env, {
      element: bounds.parentElement(),
      nextSibling
    });

    let vm = state.resume(runtime, elementStack);
    vm.execute(vm => {
      vm.pushUpdating();
      let opcode = vm.enterItem(item);
      opcode.index = children.length;
      children.push(opcode);
      opcodeMap.set(key, opcode);
      (0, _destroyable.associateDestroyableChild)(this, opcode);
    });
  }

  moveItem(opcode, item, before) {
    let {
      children
    } = this;
    (0, _reference.updateRef)(opcode.memo, item.memo);
    (0, _reference.updateRef)(opcode.value, item.value);
    opcode.retained = true;
    let currentSibling, nextSibling;

    if (before === undefined) {
      (0, _bounds.move)(opcode, this.marker);
    } else {
      currentSibling = opcode.lastNode().nextSibling;
      nextSibling = before.firstNode(); // Items are moved throughout the algorithm, so there are cases where the
      // the items already happen to be siblings (e.g. an item in between was
      // moved before this move happened). Check to see if they are siblings
      // first before doing the move.

      if (currentSibling !== nextSibling) {
        (0, _bounds.move)(opcode, nextSibling);
      }
    }

    opcode.index = children.length;
    children.push(opcode);

    if (false
    /* LOCAL_DEBUG */
    ) {
        let type = currentSibling && currentSibling === nextSibling ? 'move-retain' : 'move';
        (0, _util.logStep)('list-updates', [type, item.key]);
      }
  }

  deleteItem(opcode) {
    if (false
    /* LOCAL_DEBUG */
    ) {
        (0, _util.logStep)('list-updates', ['delete', opcode.key]);
      }

    (0, _destroyable.destroy)(opcode);
    (0, _bounds.clear)(opcode);
    this.opcodeMap.delete(opcode.key);
  }

}

exports.ListBlockOpcode = ListBlockOpcode;

class UpdatingVMFrame {
  constructor(ops, exceptionHandler) {
    this.ops = ops;
    this.exceptionHandler = exceptionHandler;
    this.current = 0;
  }

  goto(index) {
    this.current = index;
  }

  nextStatement() {
    return this.ops[this.current++];
  }

  handleException() {
    if (this.exceptionHandler) {
      this.exceptionHandler.handleException();
    }
  }

}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../packages/@glimmer/runtime/lib/vm/update.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEBUG } from '@glimmer/env';\nimport {\n  Bounds,\n  DynamicScope,\n  ElementBuilder,\n  Environment,\n  ExceptionHandler,\n  GlimmerTreeChanges,\n  LiveBlock,\n  Option,\n  RuntimeContext,\n  Scope,\n  UpdatableBlock,\n  UpdatingVM,\n  UpdatingOpcode,\n} from '@glimmer/interfaces';\nimport { LOCAL_DEBUG } from '@glimmer/local-debug-flags';\nimport {\n  OpaqueIterationItem,\n  OpaqueIterator,\n  Reference,\n  updateRef,\n  valueForRef,\n} from '@glimmer/reference';\nimport { associateDestroyableChild, destroy, destroyChildren } from '@glimmer/destroyable';\nimport { expect, Stack, logStep } from '@glimmer/util';\nimport { resetTracking, runInTrackingTransaction } from '@glimmer/validator';\nimport { SimpleComment } from '@simple-dom/interface';\nimport { clear, move as moveBounds } from '../bounds';\nimport { InternalVM, VmInitCallback } from './append';\nimport { LiveBlockList, NewElementBuilder } from './element-builder';\n\nexport default class UpdatingVMImpl implements UpdatingVM {\n  public env: Environment;\n  public dom: GlimmerTreeChanges;\n  public alwaysRevalidate: boolean;\n\n  private frameStack: Stack<UpdatingVMFrame> = new Stack<UpdatingVMFrame>();\n\n  constructor(env: Environment, { alwaysRevalidate = false }) {\n    this.env = env;\n    this.dom = env.getDOM();\n    this.alwaysRevalidate = alwaysRevalidate;\n  }\n\n  execute(opcodes: UpdatingOpcode[], handler: ExceptionHandler) {\n    if (DEBUG) {\n      let hasErrored = true;\n      try {\n        runInTrackingTransaction!(() => this._execute(opcodes, handler), '- While rendering:');\n\n        // using a boolean here to avoid breaking ergonomics of \"pause on uncaught exceptions\"\n        // which would happen with a `catch` + `throw`\n        hasErrored = false;\n      } finally {\n        if (hasErrored) {\n          // eslint-disable-next-line no-console\n          console.error(`\\n\\nError occurred:\\n\\n${resetTracking()}\\n\\n`);\n        }\n      }\n    } else {\n      this._execute(opcodes, handler);\n    }\n  }\n\n  private _execute(opcodes: UpdatingOpcode[], handler: ExceptionHandler) {\n    let { frameStack } = this;\n\n    this.try(opcodes, handler);\n\n    while (true) {\n      if (frameStack.isEmpty()) break;\n\n      let opcode = this.frame.nextStatement();\n\n      if (opcode === undefined) {\n        frameStack.pop();\n        continue;\n      }\n\n      opcode.evaluate(this);\n    }\n  }\n\n  private get frame() {\n    return expect(this.frameStack.current, 'bug: expected a frame');\n  }\n\n  goto(index: number) {\n    this.frame.goto(index);\n  }\n\n  try(ops: UpdatingOpcode[], handler: Option<ExceptionHandler>) {\n    this.frameStack.push(new UpdatingVMFrame(ops, handler));\n  }\n\n  throw() {\n    this.frame.handleException();\n    this.frameStack.pop();\n  }\n}\n\nexport interface VMState {\n  readonly pc: number;\n  readonly scope: Scope;\n  readonly dynamicScope: DynamicScope;\n  readonly stack: unknown[];\n}\n\nexport interface ResumableVMState {\n  resume(runtime: RuntimeContext, builder: ElementBuilder): InternalVM;\n}\n\nexport class ResumableVMStateImpl implements ResumableVMState {\n  constructor(readonly state: VMState, private resumeCallback: VmInitCallback) {}\n\n  resume(runtime: RuntimeContext, builder: ElementBuilder): InternalVM {\n    return this.resumeCallback(runtime, this.state, builder);\n  }\n}\n\nexport abstract class BlockOpcode implements UpdatingOpcode, Bounds {\n  public children: UpdatingOpcode[];\n\n  protected readonly bounds: LiveBlock;\n\n  constructor(\n    protected state: ResumableVMState,\n    protected runtime: RuntimeContext,\n    bounds: LiveBlock,\n    children: UpdatingOpcode[]\n  ) {\n    this.children = children;\n    this.bounds = bounds;\n  }\n\n  parentElement() {\n    return this.bounds.parentElement();\n  }\n\n  firstNode() {\n    return this.bounds.firstNode();\n  }\n\n  lastNode() {\n    return this.bounds.lastNode();\n  }\n\n  evaluate(vm: UpdatingVMImpl) {\n    vm.try(this.children, null);\n  }\n}\n\nexport class TryOpcode extends BlockOpcode implements ExceptionHandler {\n  public type = 'try';\n\n  protected bounds!: UpdatableBlock; // Hides property on base class\n\n  evaluate(vm: UpdatingVMImpl) {\n    vm.try(this.children, this);\n  }\n\n  handleException() {\n    let { state, bounds, runtime } = this;\n\n    destroyChildren(this);\n\n    let elementStack = NewElementBuilder.resume(runtime.env, bounds);\n    let vm = state.resume(runtime, elementStack);\n\n    let updating: UpdatingOpcode[] = [];\n    let children = (this.children = []);\n\n    let result = vm.execute((vm) => {\n      vm.pushUpdating(updating);\n      vm.updateWith(this);\n      vm.pushUpdating(children);\n    });\n\n    associateDestroyableChild(this, result.drop);\n  }\n}\n\nexport class ListItemOpcode extends TryOpcode {\n  public retained = false;\n  public index = -1;\n\n  constructor(\n    state: ResumableVMState,\n    runtime: RuntimeContext,\n    bounds: UpdatableBlock,\n    public key: unknown,\n    public memo: Reference,\n    public value: Reference\n  ) {\n    super(state, runtime, bounds, []);\n  }\n\n  updateReferences(item: OpaqueIterationItem) {\n    this.retained = true;\n    updateRef(this.value, item.value);\n    updateRef(this.memo, item.memo);\n  }\n\n  shouldRemove(): boolean {\n    return !this.retained;\n  }\n\n  reset() {\n    this.retained = false;\n  }\n}\n\nexport class ListBlockOpcode extends BlockOpcode {\n  public type = 'list-block';\n  public children!: ListItemOpcode[];\n\n  private opcodeMap = new Map<unknown, ListItemOpcode>();\n  private marker: SimpleComment | null = null;\n  private lastIterator: OpaqueIterator;\n\n  protected readonly bounds!: LiveBlockList;\n\n  constructor(\n    state: ResumableVMState,\n    runtime: RuntimeContext,\n    bounds: LiveBlockList,\n    children: ListItemOpcode[],\n    private iterableRef: Reference<OpaqueIterator>\n  ) {\n    super(state, runtime, bounds, children);\n    this.lastIterator = valueForRef(iterableRef);\n  }\n\n  initializeChild(opcode: ListItemOpcode) {\n    opcode.index = this.children.length - 1;\n    this.opcodeMap.set(opcode.key, opcode);\n  }\n\n  evaluate(vm: UpdatingVMImpl) {\n    let iterator = valueForRef(this.iterableRef);\n\n    if (this.lastIterator !== iterator) {\n      let { bounds } = this;\n      let { dom } = vm;\n\n      let marker = (this.marker = dom.createComment(''));\n      dom.insertAfter(\n        bounds.parentElement(),\n        marker,\n        expect(bounds.lastNode(), \"can't insert after an empty bounds\")\n      );\n\n      this.sync(iterator);\n\n      this.parentElement().removeChild(marker);\n      this.marker = null;\n      this.lastIterator = iterator;\n    }\n\n    // Run now-updated updating opcodes\n    super.evaluate(vm);\n  }\n\n  private sync(iterator: OpaqueIterator) {\n    let { opcodeMap: itemMap, children } = this;\n\n    let currentOpcodeIndex = 0;\n    let seenIndex = 0;\n\n    this.children = this.bounds.boundList = [];\n\n    while (true) {\n      let item = iterator.next();\n\n      if (item === null) break;\n\n      let opcode = children[currentOpcodeIndex];\n      let { key } = item;\n\n      // Items that have already been found and moved will already be retained,\n      // we can continue until we find the next unretained item\n      while (opcode !== undefined && opcode.retained === true) {\n        opcode = children[++currentOpcodeIndex];\n      }\n\n      if (opcode !== undefined && opcode.key === key) {\n        this.retainItem(opcode, item);\n        currentOpcodeIndex++;\n      } else if (itemMap.has(key)) {\n        let itemOpcode = itemMap.get(key)!;\n\n        // The item opcode was seen already, so we should move it.\n        if (itemOpcode.index < seenIndex) {\n          this.moveItem(itemOpcode, item, opcode);\n        } else {\n          // Update the seen index, we are going to be moving this item around\n          // so any other items that come before it will likely need to move as\n          // well.\n          seenIndex = itemOpcode.index;\n\n          let seenUnretained = false;\n\n          // iterate through all of the opcodes between the current position and\n          // the position of the item's opcode, and determine if they are all\n          // retained.\n          for (let i = currentOpcodeIndex + 1; i < seenIndex; i++) {\n            if (children[i].retained === false) {\n              seenUnretained = true;\n              break;\n            }\n          }\n\n          // If we have seen only retained opcodes between this and the matching\n          // opcode, it means that all the opcodes in between have been moved\n          // already, and we can safely retain this item's opcode.\n          if (seenUnretained === false) {\n            this.retainItem(itemOpcode, item);\n            currentOpcodeIndex = seenIndex + 1;\n          } else {\n            this.moveItem(itemOpcode, item, opcode);\n            currentOpcodeIndex++;\n          }\n        }\n      } else {\n        this.insertItem(item, opcode);\n      }\n    }\n\n    for (let i = 0; i < children.length; i++) {\n      let opcode = children[i];\n\n      if (opcode.retained === false) {\n        this.deleteItem(opcode);\n      } else {\n        opcode.reset();\n      }\n    }\n  }\n\n  private retainItem(opcode: ListItemOpcode, item: OpaqueIterationItem) {\n    if (LOCAL_DEBUG) {\n      logStep!('list-updates', ['retain', item.key]);\n    }\n\n    let { children } = this;\n\n    updateRef(opcode.memo, item.memo);\n    updateRef(opcode.value, item.value);\n    opcode.retained = true;\n\n    opcode.index = children.length;\n    children.push(opcode);\n  }\n\n  private insertItem(item: OpaqueIterationItem, before: ListItemOpcode) {\n    if (LOCAL_DEBUG) {\n      logStep!('list-updates', ['insert', item.key]);\n    }\n\n    let { opcodeMap, bounds, state, runtime, children } = this;\n    let { key } = item;\n    let nextSibling = before === undefined ? this.marker : before.firstNode();\n\n    let elementStack = NewElementBuilder.forInitialRender(runtime.env, {\n      element: bounds.parentElement(),\n      nextSibling,\n    });\n\n    let vm = state.resume(runtime, elementStack);\n\n    vm.execute((vm) => {\n      vm.pushUpdating();\n      let opcode = vm.enterItem(item);\n\n      opcode.index = children.length;\n      children.push(opcode);\n      opcodeMap.set(key, opcode);\n      associateDestroyableChild(this, opcode);\n    });\n  }\n\n  private moveItem(opcode: ListItemOpcode, item: OpaqueIterationItem, before: ListItemOpcode) {\n    let { children } = this;\n\n    updateRef(opcode.memo, item.memo);\n    updateRef(opcode.value, item.value);\n    opcode.retained = true;\n\n    let currentSibling, nextSibling;\n\n    if (before === undefined) {\n      moveBounds(opcode, this.marker);\n    } else {\n      currentSibling = opcode.lastNode().nextSibling;\n      nextSibling = before.firstNode();\n\n      // Items are moved throughout the algorithm, so there are cases where the\n      // the items already happen to be siblings (e.g. an item in between was\n      // moved before this move happened). Check to see if they are siblings\n      // first before doing the move.\n      if (currentSibling !== nextSibling) {\n        moveBounds(opcode, nextSibling);\n      }\n    }\n\n    opcode.index = children.length;\n    children.push(opcode);\n\n    if (LOCAL_DEBUG) {\n      let type = currentSibling && currentSibling === nextSibling ? 'move-retain' : 'move';\n      logStep!('list-updates', [type, item.key]);\n    }\n  }\n\n  private deleteItem(opcode: ListItemOpcode) {\n    if (LOCAL_DEBUG) {\n      logStep!('list-updates', ['delete', opcode.key]);\n    }\n\n    destroy(opcode);\n    clear(opcode);\n    this.opcodeMap.delete(opcode.key);\n  }\n}\n\nclass UpdatingVMFrame {\n  private current = 0;\n\n  constructor(private ops: UpdatingOpcode[], private exceptionHandler: Option<ExceptionHandler>) {}\n\n  goto(index: number) {\n    this.current = index;\n  }\n\n  nextStatement(): UpdatingOpcode | undefined {\n    return this.ops[this.current++];\n  }\n\n  handleException() {\n    if (this.exceptionHandler) {\n      this.exceptionHandler.handleException();\n    }\n  }\n}\n"],"sourceRoot":""}