ember-legacy-class-transform
Version:
The default blueprint for ember-cli addons.
138 lines • 5.47 kB
JavaScript
import { combine, CONSTANT_TAG, isConst, ReferenceCache } from '@glimmer/reference';
import { APPEND_OPCODES, UpdatingOpcode } from '../../opcodes';
import ARGS from '../../vm/arguments';
import { ComponentElementOperations } from './dom';
import { Assert } from './vm';
APPEND_OPCODES.add(56 /* PushComponentManager */, (vm, { op1: _definition }) => {
let definition = vm.constants.getOther(_definition);
let stack = vm.stack;
stack.push({ definition, manager: definition.manager, component: null });
});
APPEND_OPCODES.add(57 /* PushDynamicComponentManager */, vm => {
let stack = vm.stack;
let reference = stack.pop();
let cache = isConst(reference) ? undefined : new ReferenceCache(reference);
let definition = cache ? cache.peek() : reference.value();
stack.push({ definition, manager: definition.manager, component: null });
if (cache) {
vm.updateWith(new Assert(cache));
}
});
APPEND_OPCODES.add(58 /* PushArgs */, (vm, { op1: synthetic }) => {
let stack = vm.stack;
ARGS.setup(stack, !!synthetic);
stack.push(ARGS);
});
APPEND_OPCODES.add(59 /* PrepareArgs */, (vm, { op1: _state }) => {
let stack = vm.stack;
let { definition, manager } = vm.fetchValue(_state);
let args = stack.pop();
let preparedArgs = manager.prepareArgs(definition, args);
if (preparedArgs) {
args.clear();
let { positional, named } = preparedArgs;
let positionalCount = positional.length;
for (let i = 0; i < positionalCount; i++) {
stack.push(positional[i]);
}
stack.push(positionalCount);
let names = Object.keys(named);
let namedCount = names.length;
let atNames = [];
for (let i = 0; i < namedCount; i++) {
let value = named[names[i]];
let atName = `@${names[i]}`;
stack.push(value);
atNames.push(atName);
}
stack.push(atNames);
args.setup(stack, false);
}
stack.push(args);
});
APPEND_OPCODES.add(60 /* CreateComponent */, (vm, { op1: flags, op2: _state }) => {
let definition;
let manager;
let args = vm.stack.pop();
let dynamicScope = vm.dynamicScope();
let state = ({ definition, manager } = vm.fetchValue(_state));
let hasDefaultBlock = flags & 1;
let component = manager.create(vm.env, definition, args, dynamicScope, vm.getSelf(), !!hasDefaultBlock);
state.component = component;
vm.updateWith(new UpdateComponentOpcode(args.tag, definition.name, component, manager, dynamicScope));
});
APPEND_OPCODES.add(61 /* RegisterComponentDestructor */, (vm, { op1: _state }) => {
let { manager, component } = vm.fetchValue(_state);
let destructor = manager.getDestructor(component);
if (destructor) vm.newDestroyable(destructor);
});
APPEND_OPCODES.add(65 /* BeginComponentTransaction */, vm => {
vm.beginCacheGroup();
vm.elements().pushSimpleBlock();
});
APPEND_OPCODES.add(62 /* PushComponentOperations */, vm => {
vm.stack.push(new ComponentElementOperations(vm.env));
});
APPEND_OPCODES.add(67 /* DidCreateElement */, (vm, { op1: _state }) => {
let { manager, component } = vm.fetchValue(_state);
let action = 'DidCreateElementOpcode#evaluate';
manager.didCreateElement(component, vm.elements().expectConstructing(action), vm.elements().expectOperations(action));
});
APPEND_OPCODES.add(63 /* GetComponentSelf */, (vm, { op1: _state }) => {
let state = vm.fetchValue(_state);
vm.stack.push(state.manager.getSelf(state.component));
});
APPEND_OPCODES.add(64 /* GetComponentLayout */, (vm, { op1: _state }) => {
let { manager, definition, component } = vm.fetchValue(_state);
vm.stack.push(manager.layoutFor(definition, component, vm.env));
});
APPEND_OPCODES.add(68 /* DidRenderLayout */, (vm, { op1: _state }) => {
let { manager, component } = vm.fetchValue(_state);
let bounds = vm.elements().popBlock();
manager.didRenderLayout(component, bounds);
vm.env.didCreate(component, manager);
vm.updateWith(new DidUpdateLayoutOpcode(manager, component, bounds));
});
APPEND_OPCODES.add(66 /* CommitComponentTransaction */, vm => vm.commitCacheGroup());
export class UpdateComponentOpcode extends UpdatingOpcode {
constructor(tag, name, component, manager, dynamicScope) {
super();
this.name = name;
this.component = component;
this.manager = manager;
this.dynamicScope = dynamicScope;
this.type = 'update-component';
let componentTag = manager.getTag(component);
if (componentTag) {
this.tag = combine([tag, componentTag]);
} else {
this.tag = tag;
}
}
evaluate(_vm) {
let { component, manager, dynamicScope } = this;
manager.update(component, dynamicScope);
}
toJSON() {
return {
args: [JSON.stringify(this.name)],
guid: this._guid,
type: this.type
};
}
}
export class DidUpdateLayoutOpcode extends UpdatingOpcode {
constructor(manager, component, bounds) {
super();
this.manager = manager;
this.component = component;
this.bounds = bounds;
this.type = 'did-update-layout';
this.tag = CONSTANT_TAG;
}
evaluate(vm) {
let { manager, component, bounds } = this;
manager.didUpdateLayout(component, bounds);
vm.env.didUpdate(component, manager);
}
}