@glimmer/runtime
Version:
Minimal runtime needed to render Glimmer templates
885 lines (779 loc) • 90.2 kB
JavaScript
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 */
, (vm, {
op1: handle
}) => {
let definition = vm[CONSTANTS].getValue(handle);
(false && assert(!!definition, `Missing component for ${handle}`));
let {
manager,
capabilities
} = definition;
let instance = {
definition,
manager,
capabilities,
state: null,
handle: null,
table: null,
lookup: null
};
vm.stack.push(instance);
});
APPEND_OPCODES.add(80
/* ResolveDynamicComponent */
, (vm, {
op1: _isStrict
}) => {
let stack = vm.stack;
let component = valueForRef(stack.pop());
let constants = vm[CONSTANTS];
let owner = vm.getOwner();
let isStrict = constants.getValue(_isStrict);
vm.loadValue($t1, null); // Clear the temp register
let 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.`);
}
let 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 */
, vm => {
let stack = vm.stack;
let ref = stack.pop();
let value = valueForRef(ref);
let constants = vm[CONSTANTS];
let 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 */
, vm => {
let {
stack
} = vm;
let definition = stack.pop();
let capabilities, manager;
if (isCurriedValue(definition)) {
manager = capabilities = null;
} else {
manager = definition.manager;
capabilities = definition.capabilities;
}
stack.push({
definition,
capabilities,
manager,
state: null,
handle: null,
table: null
});
});
APPEND_OPCODES.add(82
/* PushArgs */
, (vm, {
op1: _names,
op2: _blockNames,
op3: flags
}) => {
let stack = vm.stack;
let names = vm[CONSTANTS].getArray(_names);
let positionalCount = flags >> 4;
let atNames = flags & 0b1000;
let blockNames = flags & 0b0111 ? vm[CONSTANTS].getArray(_blockNames) : EMPTY_STRING_ARRAY;
vm[ARGS].setup(stack, names, blockNames, positionalCount, !!atNames);
stack.push(vm[ARGS]);
});
APPEND_OPCODES.add(83
/* PushEmptyArgs */
, vm => {
let {
stack
} = vm;
stack.push(vm[ARGS].empty(stack));
});
APPEND_OPCODES.add(86
/* CaptureArgs */
, vm => {
let stack = vm.stack;
let args = stack.pop();
let capturedArgs = args.capture();
stack.push(capturedArgs);
});
APPEND_OPCODES.add(85
/* PrepareArgs */
, (vm, {
op1: _state
}) => {
let stack = vm.stack;
let instance = vm.fetchValue(_state);
let args = stack.pop();
let {
definition
} = instance;
if (isCurriedType(definition, 0
/* Component */
)) {
(false && assert(!definition.manager, "If the component definition was curried, we don't yet have a manager"));
let constants = vm[CONSTANTS];
let {
definition: resolvedDefinition,
owner,
resolved,
positional,
named
} = resolveCurriedValue(definition);
if (resolved === true) {
definition = resolvedDefinition;
} else if (typeof resolvedDefinition === 'string') {
let 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({}, ...named));
}
if (positional !== undefined) {
args.realloc(positional.length);
args.positional.prepend(positional);
}
let {
manager
} = definition;
(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);
}
let {
manager,
state
} = definition;
let capabilities = instance.capabilities;
if (!managerHasCapability(manager, capabilities, 4
/* PrepareArgs */
)) {
stack.push(args);
return;
}
let blocks = args.blocks.values;
let blockNames = args.blocks.names;
let preparedArgs = manager.prepareArgs(state, args);
if (preparedArgs) {
args.clear();
for (let i = 0; i < blocks.length; i++) {
stack.push(blocks[i]);
}
let {
positional,
named
} = preparedArgs;
let positionalCount = positional.length;
for (let i = 0; i < positionalCount; i++) {
stack.push(positional[i]);
}
let names = Object.keys(named);
for (let i = 0; i < names.length; i++) {
stack.push(named[names[i]]);
}
args.setup(stack, names, blockNames, positionalCount, false);
}
stack.push(args);
});
APPEND_OPCODES.add(87
/* CreateComponent */
, (vm, {
op1: flags,
op2: _state
}) => {
let instance = vm.fetchValue(_state);
let {
definition,
manager,
capabilities
} = instance;
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;
}
let dynamicScope = null;
if (managerHasCapability(manager, capabilities, 64
/* DynamicScope */
)) {
dynamicScope = vm.dynamicScope();
}
let hasDefaultBlock = flags & 1;
let args = null;
if (managerHasCapability(manager, capabilities, 8
/* CreateArgs */
)) {
args = vm.stack.peek();
}
let self = null;
if (managerHasCapability(manager, capabilities, 128
/* CreateCaller */
)) {
self = vm.getSelf();
}
let 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 */
, (vm, {
op1: _state
}) => {
let {
manager,
state,
capabilities
} = vm.fetchValue(_state);
let 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 */
, (vm, {
op1: _state
}) => {
var _a;
let name;
if (DEBUG) {
let {
definition,
manager
} = vm.fetchValue(_state);
name = (_a = definition.resolvedName) !== null && _a !== void 0 ? _a : manager.getDebugName(definition.state);
}
vm.beginCacheGroup(name);
vm.elements().pushSimpleBlock();
});
APPEND_OPCODES.add(89
/* PutComponentOperations */
, vm => {
vm.loadValue($t0, new ComponentElementOperations());
});
APPEND_OPCODES.add(53
/* ComponentAttr */
, (vm, {
op1: _name,
op2: _trusting,
op3: _namespace
}) => {
let name = vm[CONSTANTS].getValue(_name);
let trusting = vm[CONSTANTS].getValue(_trusting);
let reference = vm.stack.pop();
let namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
vm.fetchValue($t0).setAttribute(name, reference, trusting, namespace);
});
APPEND_OPCODES.add(105
/* StaticComponentAttr */
, (vm, {
op1: _name,
op2: _value,
op3: _namespace
}) => {
let name = vm[CONSTANTS].getValue(_name);
let value = vm[CONSTANTS].getValue(_value);
let namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
vm.fetchValue($t0).setStaticAttribute(name, value, namespace);
});
export class ComponentElementOperations {
constructor() {
this.attributes = dict();
this.classes = [];
this.modifiers = [];
}
setAttribute(name, value, trusting, namespace) {
let deferred = {
value,
namespace,
trusting
};
if (name === 'class') {
this.classes.push(value);
}
this.attributes[name] = deferred;
}
setStaticAttribute(name, value, namespace) {
let deferred = {
value,
namespace
};
if (name === 'class') {
this.classes.push(value);
}
this.attributes[name] = deferred;
}
addModifier(modifier) {
this.modifiers.push(modifier);
}
flush(vm) {
let type;
let attributes = this.attributes;
for (let name in this.attributes) {
if (name === 'type') {
type = attributes[name];
continue;
}
let 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;
}
}
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 (let i = 0; i < classes.length; i++) {
if (typeof classes[i] !== 'string') {
return false;
}
}
return true;
}
function setDeferredAttr(vm, name, value, namespace, trusting = false) {
if (typeof value === 'string') {
vm.elements().setStaticAttribute(name, value, namespace);
} else {
let 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 */
, (vm, {
op1: _state
}) => {
let {
definition,
state
} = vm.fetchValue(_state);
let {
manager
} = definition;
let operations = vm.fetchValue($t0);
manager.didCreateElement(state, vm.elements().constructing, operations);
});
APPEND_OPCODES.add(90
/* GetComponentSelf */
, (vm, {
op1: _state,
op2: _names
}) => {
var _a;
let instance = vm.fetchValue(_state);
let {
definition,
state
} = instance;
let {
manager
} = definition;
let selfRef = manager.getSelf(state);
if (vm.env.debugRenderTree !== undefined) {
let instance = vm.fetchValue(_state);
let {
definition,
manager
} = instance;
let args;
if (vm.stack.peek() === vm[ARGS]) {
args = vm[ARGS].capture();
} else {
let names = vm[CONSTANTS].getArray(_names);
vm[ARGS].setup(vm.stack, names, [], 0, true);
args = vm[ARGS].capture();
}
let moduleName;
let compilable = definition.compilable;
if (compilable === null) {
(false && assert(managerHasCapability(manager, instance.capabilities, 1
/* DynamicLayout */
), 'BUG: No template was found for this component, and the component did not have the dynamic layout capability'));
compilable = manager.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(manager)) {
let nodes = manager.getDebugCustomRenderTree(instance.definition.state, instance.state, args, moduleName);
nodes.forEach(node => {
let {
bucket
} = node;
vm.env.debugRenderTree.create(bucket, node);
registerDestructor(instance, () => {
var _a;
(_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.willDestroy(bucket);
});
vm.updateWith(new DebugRenderTreeUpdateOpcode(bucket));
});
} else {
let name = (_a = definition.resolvedName) !== null && _a !== void 0 ? _a : manager.getDebugName(definition.state);
vm.env.debugRenderTree.create(instance, {
type: 'component',
name,
args,
template: moduleName,
instance: valueForRef(selfRef)
});
vm.associateDestroyable(instance);
registerDestructor(instance, () => {
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 */
, (vm, {
op1: _state
}) => {
let {
definition,
state
} = vm.fetchValue(_state);
let {
manager
} = definition;
let 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 */
, (vm, {
op1: _state
}) => {
let instance = vm.fetchValue(_state);
let {
manager,
definition
} = instance;
let {
stack
} = vm;
let {
compilable
} = definition;
if (compilable === null) {
let {
capabilities
} = instance;
(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();
}
}
}
let handle = compilable.compile(vm.context);
stack.push(compilable.symbolTable);
stack.push(handle);
});
APPEND_OPCODES.add(75
/* Main */
, (vm, {
op1: register
}) => {
let definition = vm.stack.pop();
let invocation = vm.stack.pop();
let {
manager,
capabilities
} = definition;
let state = {
definition,
manager,
capabilities,
state: null,
handle: invocation.handle,
table: invocation.symbolTable,
lookup: null
};
vm.loadValue(register, state);
});
APPEND_OPCODES.add(95
/* PopulateLayout */
, (vm, {
op1: _state
}) => {
let {
stack
} = vm; // In DEBUG handles could be ErrHandle objects
let handle = stack.pop();
let table = stack.pop();
let state = vm.fetchValue(_state);
state.handle = handle;
state.table = table;
});
APPEND_OPCODES.add(38
/* VirtualRootScope */
, (vm, {
op1: _state
}) => {
let {
table,
manager,
capabilities,
state
} = vm.fetchValue(_state);
let 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 */
, (vm, {
op1: _state
}) => {
let state = vm.fetchValue(_state);
if (state.table.hasEval) {
let lookup = state.lookup = dict();
vm.scope().bindEvalScope(lookup);
}
});
APPEND_OPCODES.add(17
/* SetNamedVariables */
, (vm, {
op1: _state
}) => {
let state = vm.fetchValue(_state);
let scope = vm.scope();
let args = vm.stack.peek();
let callerNames = args.named.atNames;
for (let i = callerNames.length - 1; i >= 0; i--) {
let atName = callerNames[i];
let symbol = state.table.symbols.indexOf(callerNames[i]);
let 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) {
let symbol = state.table.symbols.indexOf(symbolName);
let 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 */
, (vm, {
op1: _state
}) => {
let state = vm.fetchValue(_state);
let {
blocks
} = vm.stack.peek();
for (let 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 */
, (vm, {
op1: _state
}) => {
let state = vm.fetchValue(_state);
vm.call(state.handle);
});
APPEND_OPCODES.add(100
/* DidRenderLayout */
, (vm, {
op1: _state
}) => {
let instance = vm.fetchValue(_state);
let {
manager,
state,
capabilities
} = instance;
let bounds = vm.elements().popBlock();
if (vm.env.debugRenderTree !== undefined) {
if (hasCustomDebugRenderTreeLifecycle(manager)) {
let nodes = manager.getDebugCustomRenderTree(instance.definition.state, state, EMPTY_ARGS);
nodes.reverse().forEach(node => {
let {
bucket
} = node;
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 */
)) {
let mgr = manager;
mgr.didRenderLayout(state, bounds);
vm.env.didCreate(instance);
vm.updateWith(new DidUpdateLayoutOpcode(instance, bounds));
}
});
APPEND_OPCODES.add(98
/* CommitComponentTransaction */
, vm => {
vm.commitCacheGroup();
});
export class UpdateComponentOpcode {
constructor(component, manager, dynamicScope) {
this.component = component;
this.manager = manager;
this.dynamicScope = dynamicScope;
}
evaluate(_vm) {
let {
component,
manager,
dynamicScope
} = this;
manager.update(component, dynamicScope);
}
}
export class DidUpdateLayoutOpcode {
constructor(component, bounds) {
this.component = component;
this.bounds = bounds;
}
evaluate(vm) {
let {
component,
bounds
} = this;
let {
manager,
state
} = component;
manager.didUpdateLayout(state, bounds);
vm.env.didUpdate(component);
}
}
class DebugRenderTreeUpdateOpcode {
constructor(bucket) {
this.bucket = bucket;
}
evaluate(vm) {
var _a;
(_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.update(this.bucket);
}
}
class DebugRenderTreeDidRenderOpcode {
constructor(bucket, bounds) {
this.bucket = bucket;
this.bounds = bounds;
}
evaluate(vm) {
var _a;
(_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.didRender(this.bucket, this.bounds);
}
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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