ember-material-icons
Version:
Google Material icons for your ember-cli app
394 lines • 30 kB
JavaScript
import { isSafeString, isNode, isString, cautiousInsert, trustingInsert } from '../../upsert';
import { isComponentDefinition } from '../../component/interfaces';
import { UpdatingOpcode } from '../../opcodes';
import { CompiledArgs } from '../expressions';
import { TryOpcode } from '../../vm/update';
import { ReferenceCache, UpdatableTag, isModified, isConst, map } from '@glimmer/reference';
import { LinkedList, expect } from '@glimmer/util';
import { Cursor, clear } from '../../bounds';
import { Fragment } from '../../builder';
import OpcodeBuilderDSL from './builder';
import { ConditionalReference } from '../../references';
import { UpdatableBlockTracker } from '../../builder';
import { APPEND_OPCODES } from '../../opcodes';
APPEND_OPCODES.add(31 /* DynamicContent */, (vm, { op1: append }) => {
let opcode = vm.constants.getOther(append);
opcode.evaluate(vm);
});
function isEmpty(value) {
return value === null || value === undefined || typeof value['toString'] !== 'function';
}
export function normalizeTextValue(value) {
if (isEmpty(value)) {
return '';
}
return String(value);
}
function normalizeTrustedValue(value) {
if (isEmpty(value)) {
return '';
}
if (isString(value)) {
return value;
}
if (isSafeString(value)) {
return value.toHTML();
}
if (isNode(value)) {
return value;
}
return String(value);
}
function normalizeValue(value) {
if (isEmpty(value)) {
return '';
}
if (isString(value)) {
return value;
}
if (isSafeString(value) || isNode(value)) {
return value;
}
return String(value);
}
export class AppendDynamicOpcode {
evaluate(vm) {
let reference = vm.frame.getOperand();
let normalized = this.normalize(reference);
let value, cache;
if (isConst(reference)) {
value = normalized.value();
}
else {
cache = new ReferenceCache(normalized);
value = cache.peek();
}
let stack = vm.stack();
let upsert = this.insert(vm.env.getAppendOperations(), stack, value);
let bounds = new Fragment(upsert.bounds);
stack.newBounds(bounds);
if (cache /* i.e. !isConst(reference) */) {
vm.updateWith(this.updateWith(vm, reference, cache, bounds, upsert));
}
}
}
export class GuardedAppendOpcode extends AppendDynamicOpcode {
constructor(expression, symbolTable) {
super();
this.expression = expression;
this.symbolTable = symbolTable;
this.start = -1;
this.end = -1;
}
evaluate(vm) {
if (this.start === -1) {
vm.evaluateOperand(this.expression);
let value = vm.frame.getOperand().value();
if (isComponentDefinition(value)) {
this.deopt(vm.env);
vm.pushEvalFrame(this.start, this.end);
}
else {
super.evaluate(vm);
}
}
else {
vm.pushEvalFrame(this.start, this.end);
}
}
deopt(env) {
// At compile time, we determined that this append callsite might refer
// to a local variable/property lookup that resolves to a component
// definition at runtime.
//
// We could have eagerly compiled this callsite into something like this:
//
// {{#if (is-component-definition foo)}}
// {{component foo}}
// {{else}}
// {{foo}}
// {{/if}}
//
// However, in practice, there might be a large amout of these callsites
// and most of them would resolve to a simple value lookup. Therefore, we
// tried to be optimistic and assumed that the callsite will resolve to
// appending a simple value.
//
// However, we have reached here because at runtime, the guard conditional
// have detected that this callsite is indeed referring to a component
// definition object. Since this is likely going to be true for other
// instances of the same callsite, it is now appropiate to deopt into the
// expanded version that handles both cases. The compilation would look
// like this:
//
// PutValue(expression)
// Test(is-component-definition)
// Enter(BEGIN, END)
// BEGIN: Noop
// JumpUnless(VALUE)
// PutDynamicComponentDefinitionOpcode
// OpenComponent
// CloseComponent
// Jump(END)
// VALUE: Noop
// OptimizedAppend
// END: Noop
// Exit
//
// Keep in mind that even if we *don't* reach here at initial render time,
// it is still possible (although quite rare) that the simple value we
// encounter during initial render could later change into a component
// definition object at update time. That is handled by the "lazy deopt"
// code on the update side (scroll down for the next big block of comment).
let dsl = new OpcodeBuilderDSL(this.symbolTable, env);
dsl.putValue(this.expression);
dsl.test(IsComponentDefinitionReference.create);
dsl.labelled(null, (dsl, _BEGIN, END) => {
dsl.jumpUnless('VALUE');
dsl.putDynamicComponentDefinition();
dsl.openComponent(CompiledArgs.empty());
dsl.closeComponent();
dsl.jump(END);
dsl.label('VALUE');
dsl.dynamicContent(new this.AppendOpcode());
});
this.start = dsl.start;
this.end = dsl.end;
// From this point on, we have essentially replaced ourselves with a new set
// of opcodes. Since we will always be executing the new/deopted code, it's
// a good idea (as a pattern) to null out any unneeded fields here to avoid
// holding on to unneeded/stale objects:
// QUESTION: Shouldn't this whole object be GCed? If not, why not?
this.expression = null;
return dsl.start;
}
}
class IsComponentDefinitionReference extends ConditionalReference {
static create(inner) {
return new IsComponentDefinitionReference(inner);
}
toBool(value) {
return isComponentDefinition(value);
}
}
class UpdateOpcode extends UpdatingOpcode {
constructor(cache, bounds, upsert) {
super();
this.cache = cache;
this.bounds = bounds;
this.upsert = upsert;
this.tag = cache.tag;
}
evaluate(vm) {
let value = this.cache.revalidate();
if (isModified(value)) {
let { bounds, upsert } = this;
let { dom } = vm;
if (!this.upsert.update(dom, value)) {
let cursor = new Cursor(bounds.parentElement(), clear(bounds));
upsert = this.upsert = this.insert(vm.env.getAppendOperations(), cursor, value);
}
bounds.update(upsert.bounds);
}
}
toJSON() {
let { _guid: guid, type, cache } = this;
return {
guid,
type,
details: { lastValue: JSON.stringify(cache.peek()) }
};
}
}
class GuardedUpdateOpcode extends UpdateOpcode {
constructor(reference, cache, bounds, upsert, appendOpcode, state) {
super(cache, bounds, upsert);
this.reference = reference;
this.appendOpcode = appendOpcode;
this.state = state;
this.deopted = null;
this.tag = this._tag = new UpdatableTag(this.tag);
}
evaluate(vm) {
if (this.deopted) {
vm.evaluateOpcode(this.deopted);
}
else {
if (isComponentDefinition(this.reference.value())) {
this.lazyDeopt(vm);
}
else {
super.evaluate(vm);
}
}
}
lazyDeopt(vm) {
// Durign initial render, we know that the reference does not contain a
// component definition, so we optimistically assumed that this append
// is just a normal append. However, at update time, we discovered that
// the reference has switched into containing a component definition, so
// we need to do a "lazy deopt", simulating what would have happened if
// we had decided to perform the deopt in the first place during initial
// render.
//
// More concretely, we would have expanded the curly into a if/else, and
// based on whether the value is a component definition or not, we would
// have entered either the dynamic component branch or the simple value
// branch.
//
// Since we rendered a simple value during initial render (and all the
// updates up until this point), we need to pretend that the result is
// produced by the "VALUE" branch of the deopted append opcode:
//
// Try(BEGIN, END)
// Assert(IsComponentDefinition, expected=false)
// OptimizedUpdate
//
// In this case, because the reference has switched from being a simple
// value into a component definition, what would have happened is that
// the assert would throw, causing the Try opcode to teardown the bounds
// and rerun the original append opcode.
//
// Since the Try opcode would have nuked the updating opcodes anyway, we
// wouldn't have to worry about simulating those. All we have to do is to
// execute the Try opcode and immediately throw.
let { bounds, appendOpcode, state } = this;
let env = vm.env;
let deoptStart = appendOpcode.deopt(env);
let enter = expect(env.program.opcode(deoptStart + 8), 'hardcoded deopt location');
let { op1: start, op2: end } = enter;
let tracker = new UpdatableBlockTracker(bounds.parentElement());
tracker.newBounds(this.bounds);
let children = new LinkedList();
state.frame.condition = IsComponentDefinitionReference.create(expect(state.frame['operand'], 'operand should be populated'));
let deopted = this.deopted = new TryOpcode(start, end, state, tracker, children);
this._tag.update(deopted.tag);
vm.evaluateOpcode(deopted);
vm.throw();
// From this point on, we have essentially replaced ourselve with a new
// opcode. Since we will always be executing the new/deopted code, it's a
// good idea (as a pattern) to null out any unneeded fields here to avoid
// holding on to unneeded/stale objects:
// QUESTION: Shouldn't this whole object be GCed? If not, why not?
this._tag = null;
this.reference = null;
this.cache = null;
this.bounds = null;
this.upsert = null;
this.appendOpcode = null;
this.state = null;
}
toJSON() {
let { _guid: guid, type, deopted } = this;
if (deopted) {
return {
guid,
type,
deopted: true,
children: [deopted.toJSON()]
};
}
else {
return super.toJSON();
}
}
}
export class OptimizedCautiousAppendOpcode extends AppendDynamicOpcode {
constructor() {
super(...arguments);
this.type = 'optimized-cautious-append';
}
normalize(reference) {
return map(reference, normalizeValue);
}
insert(dom, cursor, value) {
return cautiousInsert(dom, cursor, value);
}
updateWith(_vm, _reference, cache, bounds, upsert) {
return new OptimizedCautiousUpdateOpcode(cache, bounds, upsert);
}
}
class OptimizedCautiousUpdateOpcode extends UpdateOpcode {
constructor() {
super(...arguments);
this.type = 'optimized-cautious-update';
}
insert(dom, cursor, value) {
return cautiousInsert(dom, cursor, value);
}
}
export class GuardedCautiousAppendOpcode extends GuardedAppendOpcode {
constructor() {
super(...arguments);
this.type = 'guarded-cautious-append';
this.AppendOpcode = OptimizedCautiousAppendOpcode;
}
normalize(reference) {
return map(reference, normalizeValue);
}
insert(dom, cursor, value) {
return cautiousInsert(dom, cursor, value);
}
updateWith(vm, reference, cache, bounds, upsert) {
return new GuardedCautiousUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());
}
}
class GuardedCautiousUpdateOpcode extends GuardedUpdateOpcode {
constructor() {
super(...arguments);
this.type = 'guarded-cautious-update';
}
insert(dom, cursor, value) {
return cautiousInsert(dom, cursor, value);
}
}
export class OptimizedTrustingAppendOpcode extends AppendDynamicOpcode {
constructor() {
super(...arguments);
this.type = 'optimized-trusting-append';
}
normalize(reference) {
return map(reference, normalizeTrustedValue);
}
insert(dom, cursor, value) {
return trustingInsert(dom, cursor, value);
}
updateWith(_vm, _reference, cache, bounds, upsert) {
return new OptimizedTrustingUpdateOpcode(cache, bounds, upsert);
}
}
class OptimizedTrustingUpdateOpcode extends UpdateOpcode {
constructor() {
super(...arguments);
this.type = 'optimized-trusting-update';
}
insert(dom, cursor, value) {
return trustingInsert(dom, cursor, value);
}
}
export class GuardedTrustingAppendOpcode extends GuardedAppendOpcode {
constructor() {
super(...arguments);
this.type = 'guarded-trusting-append';
this.AppendOpcode = OptimizedTrustingAppendOpcode;
}
normalize(reference) {
return map(reference, normalizeTrustedValue);
}
insert(dom, cursor, value) {
return trustingInsert(dom, cursor, value);
}
updateWith(vm, reference, cache, bounds, upsert) {
return new GuardedTrustingUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());
}
}
class GuardedTrustingUpdateOpcode extends GuardedUpdateOpcode {
constructor() {
super(...arguments);
this.type = 'trusting-update';
}
insert(dom, cursor, value) {
return trustingInsert(dom, cursor, value);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content.js","sourceRoot":"","sources":["../../../../../lib/compiled/opcodes/content.ts"],"names":[],"mappings":"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"}