@glimmer/runtime/dist/modules/es5/lib/compiled/opcodes/component.js

Minimal runtime needed to render Glimmer templates

import { DEBUG } from '@glimmer/env';
import { isConstRef, valueForRef } from '@glimmer/reference';
import { assert, assign, debugToString, dict, EMPTY_STRING_ARRAY, unwrapTemplate } from '@glimmer/util';
import { $t0, $t1 } from '@glimmer/vm';
import { registerDestructor } from '@glimmer/destroyable';
import { managerHasCapability } from '@glimmer/manager';
import { resolveComponent } from '../../component/resolve';
import { hasCustomDebugRenderTreeLifecycle } from '../../component/interfaces';
import { APPEND_OPCODES } from '../../opcodes';
import createClassListRef from '../../references/class-list';
import { ARGS, CONSTANTS } from '../../symbols';
import { EMPTY_ARGS } from '../../vm/arguments';
import { UpdateDynamicAttributeOpcode } from './dom';
import { isCurriedType, isCurriedValue, resolveCurriedValue } from '../../curried-value';
APPEND_OPCODES.add(78
/* PushComponentDefinition */
, function (vm, _ref) {
  var handle = _ref.op1;
  var definition = vm[CONSTANTS].getValue(handle);
  false && assert(!!definition, "Missing component for " + handle);
  var manager = definition.manager,
      capabilities = definition.capabilities;
  var instance = {
    definition: definition,
    manager: manager,
    capabilities: capabilities,
    state: null,
    handle: null,
    table: null,
    lookup: null
  };
  vm.stack.push(instance);
});
APPEND_OPCODES.add(80
/* ResolveDynamicComponent */
, function (vm, _ref2) {
  var _isStrict = _ref2.op1;
  var stack = vm.stack;
  var component = valueForRef(stack.pop());
  var constants = vm[CONSTANTS];
  var owner = vm.getOwner();
  var isStrict = constants.getValue(_isStrict);
  vm.loadValue($t1, null); // Clear the temp register

  var definition;

  if (typeof component === 'string') {
    if (DEBUG && isStrict) {
      throw new Error("Attempted to resolve a dynamic component with a string definition, `" + component + "` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly.");
    }

    var resolvedDefinition = resolveComponent(vm.runtime.resolver, constants, component, owner);
    definition = resolvedDefinition;
  } else if (isCurriedValue(component)) {
    definition = component;
  } else {
    definition = constants.component(component, owner);
  }

  stack.push(definition);
});
APPEND_OPCODES.add(81
/* ResolveCurriedComponent */
, function (vm) {
  var stack = vm.stack;
  var ref = stack.pop();
  var value = valueForRef(ref);
  var constants = vm[CONSTANTS];
  var definition;

  if (DEBUG && !(typeof value === 'function' || typeof value === 'object' && value !== null)) {
    throw new Error("Expected a component definition, but received " + value + ". You may have accidentally done <" + ref.debugLabel + ">, where \"" + ref.debugLabel + "\" was a string instead of a curried component definition. You must either use the component definition directly, or use the {{component}} helper to create a curried component definition when invoking dynamically.");
  }

  if (isCurriedValue(value)) {
    definition = value;
  } else {
    definition = constants.component(value, vm.getOwner(), true);

    if (DEBUG && definition === null) {
      throw new Error("Expected a dynamic component definition, but received an object or function that did not have a component manager associated with it. The dynamic invocation was `<" + ref.debugLabel + ">` or `{{" + ref.debugLabel + "}}`, and the incorrect definition is the value at the path `" + ref.debugLabel + "`, which was: " + debugToString(value));
    }
  }

  stack.push(definition);
});
APPEND_OPCODES.add(79
/* PushDynamicComponentInstance */
, function (vm) {
  var stack = vm.stack;
  var definition = stack.pop();
  var capabilities, manager;

  if (isCurriedValue(definition)) {
    manager = capabilities = null;
  } else {
    manager = definition.manager;
    capabilities = definition.capabilities;
  }

  stack.push({
    definition: definition,
    capabilities: capabilities,
    manager: manager,
    state: null,
    handle: null,
    table: null
  });
});
APPEND_OPCODES.add(82
/* PushArgs */
, function (vm, _ref3) {
  var _names = _ref3.op1,
      _blockNames = _ref3.op2,
      flags = _ref3.op3;
  var stack = vm.stack;
  var names = vm[CONSTANTS].getArray(_names);
  var positionalCount = flags >> 4;
  var atNames = flags & 8;
  var blockNames = flags & 7 ? vm[CONSTANTS].getArray(_blockNames) : EMPTY_STRING_ARRAY;
  vm[ARGS].setup(stack, names, blockNames, positionalCount, !!atNames);
  stack.push(vm[ARGS]);
});
APPEND_OPCODES.add(83
/* PushEmptyArgs */
, function (vm) {
  var stack = vm.stack;
  stack.push(vm[ARGS].empty(stack));
});
APPEND_OPCODES.add(86
/* CaptureArgs */
, function (vm) {
  var stack = vm.stack;
  var args = stack.pop();
  var capturedArgs = args.capture();
  stack.push(capturedArgs);
});
APPEND_OPCODES.add(85
/* PrepareArgs */
, function (vm, _ref4) {
  var _state = _ref4.op1;
  var stack = vm.stack;
  var instance = vm.fetchValue(_state);
  var args = stack.pop();
  var definition = instance.definition;

  if (isCurriedType(definition, 0
  /* Component */
  )) {
    false && assert(!definition.manager, "If the component definition was curried, we don't yet have a manager");
    var constants = vm[CONSTANTS];

    var _resolveCurriedValue = resolveCurriedValue(definition),
        resolvedDefinition = _resolveCurriedValue.definition,
        owner = _resolveCurriedValue.owner,
        resolved = _resolveCurriedValue.resolved,
        positional = _resolveCurriedValue.positional,
        named = _resolveCurriedValue.named;

    if (resolved === true) {
      definition = resolvedDefinition;
    } else if (typeof resolvedDefinition === 'string') {
      var resolvedValue = vm.runtime.resolver.lookupComponent(resolvedDefinition, owner);
      definition = constants.resolvedComponent(resolvedValue, resolvedDefinition);
    } else {
      definition = constants.component(resolvedDefinition, owner);
    }

    if (named !== undefined) {
      args.named.merge(assign.apply(void 0, [{}].concat(named)));
    }

    if (positional !== undefined) {
      args.realloc(positional.length);
      args.positional.prepend(positional);
    }

    var _definition = definition,
        _manager = _definition.manager;
    false && assert(instance.manager === null, 'component instance manager should not be populated yet');
    false && assert(instance.capabilities === null, 'component instance manager should not be populated yet');
    instance.definition = definition;
    instance.manager = _manager;
    instance.capabilities = definition.capabilities; // Save off the owner that this component was curried with. Later on,
    // we'll fetch the value of this register and set it as the owner on the
    // new root scope.

    vm.loadValue($t1, owner);
  }

  var _definition2 = definition,
      manager = _definition2.manager,
      state = _definition2.state;
  var capabilities = instance.capabilities;

  if (!managerHasCapability(manager, capabilities, 4
  /* PrepareArgs */
  )) {
    stack.push(args);
    return;
  }

  var blocks = args.blocks.values;
  var blockNames = args.blocks.names;
  var preparedArgs = manager.prepareArgs(state, args);

  if (preparedArgs) {
    args.clear();

    for (var i = 0; i < blocks.length; i++) {
      stack.push(blocks[i]);
    }

    var _positional = preparedArgs.positional,
        _named = preparedArgs.named;
    var positionalCount = _positional.length;

    for (var _i = 0; _i < positionalCount; _i++) {
      stack.push(_positional[_i]);
    }

    var names = Object.keys(_named);

    for (var _i2 = 0; _i2 < names.length; _i2++) {
      stack.push(_named[names[_i2]]);
    }

    args.setup(stack, names, blockNames, positionalCount, false);
  }

  stack.push(args);
});
APPEND_OPCODES.add(87
/* CreateComponent */
, function (vm, _ref5) {
  var flags = _ref5.op1,
      _state = _ref5.op2;
  var instance = vm.fetchValue(_state);
  var definition = instance.definition,
      manager = instance.manager,
      capabilities = instance.capabilities;

  if (!managerHasCapability(manager, capabilities, 512
  /* CreateInstance */
  )) {
    // TODO: Closure and Main components are always invoked dynamically, so this
    // opcode may run even if this capability is not enabled. In the future we
    // should handle this in a better way.
    return;
  }

  var dynamicScope = null;

  if (managerHasCapability(manager, capabilities, 64
  /* DynamicScope */
  )) {
    dynamicScope = vm.dynamicScope();
  }

  var hasDefaultBlock = flags & 1;
  var args = null;

  if (managerHasCapability(manager, capabilities, 8
  /* CreateArgs */
  )) {
    args = vm.stack.peek();
  }

  var self = null;

  if (managerHasCapability(manager, capabilities, 128
  /* CreateCaller */
  )) {
    self = vm.getSelf();
  }

  var state = manager.create(vm.getOwner(), definition.state, args, vm.env, dynamicScope, self, !!hasDefaultBlock); // We want to reuse the `state` POJO here, because we know that the opcodes
  // only transition at exactly one place.

  instance.state = state;

  if (managerHasCapability(manager, capabilities, 256
  /* UpdateHook */
  )) {
    vm.updateWith(new UpdateComponentOpcode(state, manager, dynamicScope));
  }
});
APPEND_OPCODES.add(88
/* RegisterComponentDestructor */
, function (vm, _ref6) {
  var _state = _ref6.op1;

  var _vm$fetchValue = vm.fetchValue(_state),
      manager = _vm$fetchValue.manager,
      state = _vm$fetchValue.state,
      capabilities = _vm$fetchValue.capabilities;

  var d = manager.getDestroyable(state);

  if (DEBUG && !managerHasCapability(manager, capabilities, 2048
  /* WillDestroy */
  ) && d !== null && typeof 'willDestroy' in d) {
    throw new Error('BUG: Destructor has willDestroy, but the willDestroy capability was not enabled for this component. Pre-destruction hooks must be explicitly opted into');
  }

  if (d) vm.associateDestroyable(d);
});
APPEND_OPCODES.add(97
/* BeginComponentTransaction */
, function (vm, _ref7) {
  var _state = _ref7.op1;

  var _a;

  var name;

  if (DEBUG) {
    var _vm$fetchValue2 = vm.fetchValue(_state),
        definition = _vm$fetchValue2.definition,
        manager = _vm$fetchValue2.manager;

    name = (_a = definition.resolvedName) !== null && _a !== void 0 ? _a : manager.getDebugName(definition.state);
  }

  vm.beginCacheGroup(name);
  vm.elements().pushSimpleBlock();
});
APPEND_OPCODES.add(89
/* PutComponentOperations */
, function (vm) {
  vm.loadValue($t0, new ComponentElementOperations());
});
APPEND_OPCODES.add(53
/* ComponentAttr */
, function (vm, _ref8) {
  var _name = _ref8.op1,
      _trusting = _ref8.op2,
      _namespace = _ref8.op3;
  var name = vm[CONSTANTS].getValue(_name);
  var trusting = vm[CONSTANTS].getValue(_trusting);
  var reference = vm.stack.pop();
  var namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
  vm.fetchValue($t0).setAttribute(name, reference, trusting, namespace);
});
APPEND_OPCODES.add(105
/* StaticComponentAttr */
, function (vm, _ref9) {
  var _name = _ref9.op1,
      _value = _ref9.op2,
      _namespace = _ref9.op3;
  var name = vm[CONSTANTS].getValue(_name);
  var value = vm[CONSTANTS].getValue(_value);
  var namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
  vm.fetchValue($t0).setStaticAttribute(name, value, namespace);
});
export var ComponentElementOperations = /*#__PURE__*/function () {
  function ComponentElementOperations() {
    this.attributes = dict();
    this.classes = [];
    this.modifiers = [];
  }

  var _proto = ComponentElementOperations.prototype;

  _proto.setAttribute = function setAttribute(name, value, trusting, namespace) {
    var deferred = {
      value: value,
      namespace: namespace,
      trusting: trusting
    };

    if (name === 'class') {
      this.classes.push(value);
    }

    this.attributes[name] = deferred;
  };

  _proto.setStaticAttribute = function setStaticAttribute(name, value, namespace) {
    var deferred = {
      value: value,
      namespace: namespace
    };

    if (name === 'class') {
      this.classes.push(value);
    }

    this.attributes[name] = deferred;
  };

  _proto.addModifier = function addModifier(modifier) {
    this.modifiers.push(modifier);
  };

  _proto.flush = function flush(vm) {
    var type;
    var attributes = this.attributes;

    for (var name in this.attributes) {
      if (name === 'type') {
        type = attributes[name];
        continue;
      }

      var attr = this.attributes[name];

      if (name === 'class') {
        setDeferredAttr(vm, 'class', mergeClasses(this.classes), attr.namespace, attr.trusting);
      } else {
        setDeferredAttr(vm, name, attr.value, attr.namespace, attr.trusting);
      }
    }

    if (type !== undefined) {
      setDeferredAttr(vm, 'type', type.value, type.namespace, type.trusting);
    }

    return this.modifiers;
  };

  return ComponentElementOperations;
}();

function mergeClasses(classes) {
  if (classes.length === 0) {
    return '';
  }

  if (classes.length === 1) {
    return classes[0];
  }

  if (allStringClasses(classes)) {
    return classes.join(' ');
  }

  return createClassListRef(classes);
}

function allStringClasses(classes) {
  for (var i = 0; i < classes.length; i++) {
    if (typeof classes[i] !== 'string') {
      return false;
    }
  }

  return true;
}

function setDeferredAttr(vm, name, value, namespace, trusting) {
  if (trusting === void 0) {
    trusting = false;
  }

  if (typeof value === 'string') {
    vm.elements().setStaticAttribute(name, value, namespace);
  } else {
    var attribute = vm.elements().setDynamicAttribute(name, valueForRef(value), trusting, namespace);

    if (!isConstRef(value)) {
      vm.updateWith(new UpdateDynamicAttributeOpcode(value, attribute, vm.env));
    }
  }
}

APPEND_OPCODES.add(99
/* DidCreateElement */
, function (vm, _ref10) {
  var _state = _ref10.op1;

  var _vm$fetchValue3 = vm.fetchValue(_state),
      definition = _vm$fetchValue3.definition,
      state = _vm$fetchValue3.state;

  var manager = definition.manager;
  var operations = vm.fetchValue($t0);
  manager.didCreateElement(state, vm.elements().constructing, operations);
});
APPEND_OPCODES.add(90
/* GetComponentSelf */
, function (vm, _ref11) {
  var _state = _ref11.op1,
      _names = _ref11.op2;

  var _a;

  var instance = vm.fetchValue(_state);
  var definition = instance.definition,
      state = instance.state;
  var manager = definition.manager;
  var selfRef = manager.getSelf(state);

  if (vm.env.debugRenderTree !== undefined) {
    var _instance = vm.fetchValue(_state);

    var _definition3 = _instance.definition,
        _manager2 = _instance.manager;
    var args;

    if (vm.stack.peek() === vm[ARGS]) {
      args = vm[ARGS].capture();
    } else {
      var names = vm[CONSTANTS].getArray(_names);
      vm[ARGS].setup(vm.stack, names, [], 0, true);
      args = vm[ARGS].capture();
    }

    var moduleName;
    var compilable = _definition3.compilable;

    if (compilable === null) {
      false && assert(managerHasCapability(_manager2, _instance.capabilities, 1
      /* DynamicLayout */
      ), 'BUG: No template was found for this component, and the component did not have the dynamic layout capability');
      compilable = _manager2.getDynamicLayout(state, vm.runtime.resolver);

      if (compilable !== null) {
        moduleName = compilable.moduleName;
      } else {
        moduleName = '__default__.hbs';
      }
    } else {
      moduleName = compilable.moduleName;
    } // For tearing down the debugRenderTree


    vm.associateDestroyable(_instance);

    if (hasCustomDebugRenderTreeLifecycle(_manager2)) {
      var nodes = _manager2.getDebugCustomRenderTree(_instance.definition.state, _instance.state, args, moduleName);

      nodes.forEach(function (node) {
        var bucket = node.bucket;
        vm.env.debugRenderTree.create(bucket, node);
        registerDestructor(_instance, function () {
          var _a;

          (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.willDestroy(bucket);
        });
        vm.updateWith(new DebugRenderTreeUpdateOpcode(bucket));
      });
    } else {
      var name = (_a = _definition3.resolvedName) !== null && _a !== void 0 ? _a : _manager2.getDebugName(_definition3.state);
      vm.env.debugRenderTree.create(_instance, {
        type: 'component',
        name: name,
        args: args,
        template: moduleName,
        instance: valueForRef(selfRef)
      });
      vm.associateDestroyable(_instance);
      registerDestructor(_instance, function () {
        var _a;

        (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.willDestroy(_instance);
      });
      vm.updateWith(new DebugRenderTreeUpdateOpcode(_instance));
    }
  }

  vm.stack.push(selfRef);
});
APPEND_OPCODES.add(91
/* GetComponentTagName */
, function (vm, _ref12) {
  var _state = _ref12.op1;

  var _vm$fetchValue4 = vm.fetchValue(_state),
      definition = _vm$fetchValue4.definition,
      state = _vm$fetchValue4.state;

  var manager = definition.manager;
  var tagName = manager.getTagName(state); // User provided value from JS, so we don't bother to encode

  vm.stack.push(tagName);
}); // Dynamic Invocation Only

APPEND_OPCODES.add(92
/* GetComponentLayout */
, function (vm, _ref13) {
  var _state = _ref13.op1;
  var instance = vm.fetchValue(_state);
  var manager = instance.manager,
      definition = instance.definition;
  var stack = vm.stack;
  var compilable = definition.compilable;

  if (compilable === null) {
    var capabilities = instance.capabilities;
    false && assert(managerHasCapability(manager, capabilities, 1
    /* DynamicLayout */
    ), 'BUG: No template was found for this component, and the component did not have the dynamic layout capability');
    compilable = manager.getDynamicLayout(instance.state, vm.runtime.resolver);

    if (compilable === null) {
      if (managerHasCapability(manager, capabilities, 1024
      /* Wrapped */
      )) {
        compilable = unwrapTemplate(vm[CONSTANTS].defaultTemplate).asWrappedLayout();
      } else {
        compilable = unwrapTemplate(vm[CONSTANTS].defaultTemplate).asLayout();
      }
    }
  }

  var handle = compilable.compile(vm.context);
  stack.push(compilable.symbolTable);
  stack.push(handle);
});
APPEND_OPCODES.add(75
/* Main */
, function (vm, _ref14) {
  var register = _ref14.op1;
  var definition = vm.stack.pop();
  var invocation = vm.stack.pop();
  var manager = definition.manager,
      capabilities = definition.capabilities;
  var state = {
    definition: definition,
    manager: manager,
    capabilities: capabilities,
    state: null,
    handle: invocation.handle,
    table: invocation.symbolTable,
    lookup: null
  };
  vm.loadValue(register, state);
});
APPEND_OPCODES.add(95
/* PopulateLayout */
, function (vm, _ref15) {
  var _state = _ref15.op1;
  var stack = vm.stack; // In DEBUG handles could be ErrHandle objects

  var handle = stack.pop();
  var table = stack.pop();
  var state = vm.fetchValue(_state);
  state.handle = handle;
  state.table = table;
});
APPEND_OPCODES.add(38
/* VirtualRootScope */
, function (vm, _ref16) {
  var _state = _ref16.op1;

  var _vm$fetchValue5 = vm.fetchValue(_state),
      table = _vm$fetchValue5.table,
      manager = _vm$fetchValue5.manager,
      capabilities = _vm$fetchValue5.capabilities,
      state = _vm$fetchValue5.state;

  var owner;

  if (managerHasCapability(manager, capabilities, 4096
  /* HasSubOwner */
  )) {
    owner = manager.getOwner(state);
    vm.loadValue($t1, null); // Clear the temp register
  } else {
    // Check the temp register to see if an owner was resolved from currying
    owner = vm.fetchValue($t1);

    if (owner === null) {
      // If an owner wasn't found, default to using the current owner. This
      // will happen for normal dynamic component invocation,
      // e.g. <SomeClassicEmberComponent/>
      owner = vm.getOwner();
    } else {
      // Else the owner was found, so clear the temp register. This will happen
      // if we are loading a curried component, e.g. <@someCurriedComponent/>
      vm.loadValue($t1, null);
    }
  }

  vm.pushRootScope(table.symbols.length + 1, owner);
});
APPEND_OPCODES.add(94
/* SetupForEval */
, function (vm, _ref17) {
  var _state = _ref17.op1;
  var state = vm.fetchValue(_state);

  if (state.table.hasEval) {
    var lookup = state.lookup = dict();
    vm.scope().bindEvalScope(lookup);
  }
});
APPEND_OPCODES.add(17
/* SetNamedVariables */
, function (vm, _ref18) {
  var _state = _ref18.op1;
  var state = vm.fetchValue(_state);
  var scope = vm.scope();
  var args = vm.stack.peek();
  var callerNames = args.named.atNames;

  for (var i = callerNames.length - 1; i >= 0; i--) {
    var atName = callerNames[i];
    var symbol = state.table.symbols.indexOf(callerNames[i]);
    var value = args.named.get(atName, true);
    if (symbol !== -1) scope.bindSymbol(symbol + 1, value);
    if (state.lookup) state.lookup[atName] = value;
  }
});

function bindBlock(symbolName, blockName, state, blocks, vm) {
  var symbol = state.table.symbols.indexOf(symbolName);
  var block = blocks.get(blockName);
  if (symbol !== -1) vm.scope().bindBlock(symbol + 1, block);
  if (state.lookup) state.lookup[symbolName] = block;
}

APPEND_OPCODES.add(18
/* SetBlocks */
, function (vm, _ref19) {
  var _state = _ref19.op1;
  var state = vm.fetchValue(_state);

  var _vm$stack$peek = vm.stack.peek(),
      blocks = _vm$stack$peek.blocks;

  for (var i = 0; i < blocks.names.length; i++) {
    bindBlock(blocks.symbolNames[i], blocks.names[i], state, blocks, vm);
  }
}); // Dynamic Invocation Only

APPEND_OPCODES.add(96
/* InvokeComponentLayout */
, function (vm, _ref20) {
  var _state = _ref20.op1;
  var state = vm.fetchValue(_state);
  vm.call(state.handle);
});
APPEND_OPCODES.add(100
/* DidRenderLayout */
, function (vm, _ref21) {
  var _state = _ref21.op1;
  var instance = vm.fetchValue(_state);
  var manager = instance.manager,
      state = instance.state,
      capabilities = instance.capabilities;
  var bounds = vm.elements().popBlock();

  if (vm.env.debugRenderTree !== undefined) {
    if (hasCustomDebugRenderTreeLifecycle(manager)) {
      var nodes = manager.getDebugCustomRenderTree(instance.definition.state, state, EMPTY_ARGS);
      nodes.reverse().forEach(function (node) {
        var bucket = node.bucket;
        vm.env.debugRenderTree.didRender(bucket, bounds);
        vm.updateWith(new DebugRenderTreeDidRenderOpcode(bucket, bounds));
      });
    } else {
      vm.env.debugRenderTree.didRender(instance, bounds);
      vm.updateWith(new DebugRenderTreeDidRenderOpcode(instance, bounds));
    }
  }

  if (managerHasCapability(manager, capabilities, 512
  /* CreateInstance */
  )) {
    var mgr = manager;
    mgr.didRenderLayout(state, bounds);
    vm.env.didCreate(instance);
    vm.updateWith(new DidUpdateLayoutOpcode(instance, bounds));
  }
});
APPEND_OPCODES.add(98
/* CommitComponentTransaction */
, function (vm) {
  vm.commitCacheGroup();
});
export var UpdateComponentOpcode = /*#__PURE__*/function () {
  function UpdateComponentOpcode(component, manager, dynamicScope) {
    this.component = component;
    this.manager = manager;
    this.dynamicScope = dynamicScope;
  }

  var _proto2 = UpdateComponentOpcode.prototype;

  _proto2.evaluate = function evaluate(_vm) {
    var component = this.component,
        manager = this.manager,
        dynamicScope = this.dynamicScope;
    manager.update(component, dynamicScope);
  };

  return UpdateComponentOpcode;
}();
export var DidUpdateLayoutOpcode = /*#__PURE__*/function () {
  function DidUpdateLayoutOpcode(component, bounds) {
    this.component = component;
    this.bounds = bounds;
  }

  var _proto3 = DidUpdateLayoutOpcode.prototype;

  _proto3.evaluate = function evaluate(vm) {
    var component = this.component,
        bounds = this.bounds;
    var manager = component.manager,
        state = component.state;
    manager.didUpdateLayout(state, bounds);
    vm.env.didUpdate(component);
  };

  return DidUpdateLayoutOpcode;
}();

var DebugRenderTreeUpdateOpcode = /*#__PURE__*/function () {
  function DebugRenderTreeUpdateOpcode(bucket) {
    this.bucket = bucket;
  }

  var _proto4 = DebugRenderTreeUpdateOpcode.prototype;

  _proto4.evaluate = function evaluate(vm) {
    var _a;

    (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.update(this.bucket);
  };

  return DebugRenderTreeUpdateOpcode;
}();

var DebugRenderTreeDidRenderOpcode = /*#__PURE__*/function () {
  function DebugRenderTreeDidRenderOpcode(bucket, bounds) {
    this.bucket = bucket;
    this.bounds = bounds;
  }

  var _proto5 = DebugRenderTreeDidRenderOpcode.prototype;

  _proto5.evaluate = function evaluate(vm) {
    var _a;

    (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.didRender(this.bucket, this.bounds);
  };

  return DebugRenderTreeDidRenderOpcode;
}();
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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