ember-material-icons/.node_modules.ember-try/@glimmer/runtime/dist/commonjs/lib/compiled/opcodes/content.js

Google Material icons for your ember-cli app

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const upsert_1 = require("../../upsert");
const interfaces_1 = require("../../component/interfaces");
const opcodes_1 = require("../../opcodes");
const expressions_1 = require("../expressions");
const update_1 = require("../../vm/update");
const reference_1 = require("@glimmer/reference");
const util_1 = require("@glimmer/util");
const bounds_1 = require("../../bounds");
const builder_1 = require("../../builder");
const builder_2 = require("./builder");
const references_1 = require("../../references");
const builder_3 = require("../../builder");
const opcodes_2 = require("../../opcodes");
opcodes_2.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';
}
function normalizeTextValue(value) {
    if (isEmpty(value)) {
        return '';
    }
    return String(value);
}
exports.normalizeTextValue = normalizeTextValue;
function normalizeTrustedValue(value) {
    if (isEmpty(value)) {
        return '';
    }
    if (upsert_1.isString(value)) {
        return value;
    }
    if (upsert_1.isSafeString(value)) {
        return value.toHTML();
    }
    if (upsert_1.isNode(value)) {
        return value;
    }
    return String(value);
}
function normalizeValue(value) {
    if (isEmpty(value)) {
        return '';
    }
    if (upsert_1.isString(value)) {
        return value;
    }
    if (upsert_1.isSafeString(value) || upsert_1.isNode(value)) {
        return value;
    }
    return String(value);
}
class AppendDynamicOpcode {
    evaluate(vm) {
        let reference = vm.frame.getOperand();
        let normalized = this.normalize(reference);
        let value, cache;
        if (reference_1.isConst(reference)) {
            value = normalized.value();
        }
        else {
            cache = new reference_1.ReferenceCache(normalized);
            value = cache.peek();
        }
        let stack = vm.stack();
        let upsert = this.insert(vm.env.getAppendOperations(), stack, value);
        let bounds = new builder_1.Fragment(upsert.bounds);
        stack.newBounds(bounds);
        if (cache /* i.e. !isConst(reference) */) {
            vm.updateWith(this.updateWith(vm, reference, cache, bounds, upsert));
        }
    }
}
exports.AppendDynamicOpcode = AppendDynamicOpcode;
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 (interfaces_1.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 builder_2.default(this.symbolTable, env);
        dsl.putValue(this.expression);
        dsl.test(IsComponentDefinitionReference.create);
        dsl.labelled(null, (dsl, _BEGIN, END) => {
            dsl.jumpUnless('VALUE');
            dsl.putDynamicComponentDefinition();
            dsl.openComponent(expressions_1.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;
    }
}
exports.GuardedAppendOpcode = GuardedAppendOpcode;
class IsComponentDefinitionReference extends references_1.ConditionalReference {
    static create(inner) {
        return new IsComponentDefinitionReference(inner);
    }
    toBool(value) {
        return interfaces_1.isComponentDefinition(value);
    }
}
class UpdateOpcode extends opcodes_1.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 (reference_1.isModified(value)) {
            let { bounds, upsert } = this;
            let { dom } = vm;
            if (!this.upsert.update(dom, value)) {
                let cursor = new bounds_1.Cursor(bounds.parentElement(), bounds_1.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 reference_1.UpdatableTag(this.tag);
    }
    evaluate(vm) {
        if (this.deopted) {
            vm.evaluateOpcode(this.deopted);
        }
        else {
            if (interfaces_1.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 = util_1.expect(env.program.opcode(deoptStart + 8), 'hardcoded deopt location');
        let { op1: start, op2: end } = enter;
        let tracker = new builder_3.UpdatableBlockTracker(bounds.parentElement());
        tracker.newBounds(this.bounds);
        let children = new util_1.LinkedList();
        state.frame.condition = IsComponentDefinitionReference.create(util_1.expect(state.frame['operand'], 'operand should be populated'));
        let deopted = this.deopted = new update_1.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();
        }
    }
}
class OptimizedCautiousAppendOpcode extends AppendDynamicOpcode {
    constructor() {
        super(...arguments);
        this.type = 'optimized-cautious-append';
    }
    normalize(reference) {
        return reference_1.map(reference, normalizeValue);
    }
    insert(dom, cursor, value) {
        return upsert_1.cautiousInsert(dom, cursor, value);
    }
    updateWith(_vm, _reference, cache, bounds, upsert) {
        return new OptimizedCautiousUpdateOpcode(cache, bounds, upsert);
    }
}
exports.OptimizedCautiousAppendOpcode = OptimizedCautiousAppendOpcode;
class OptimizedCautiousUpdateOpcode extends UpdateOpcode {
    constructor() {
        super(...arguments);
        this.type = 'optimized-cautious-update';
    }
    insert(dom, cursor, value) {
        return upsert_1.cautiousInsert(dom, cursor, value);
    }
}
class GuardedCautiousAppendOpcode extends GuardedAppendOpcode {
    constructor() {
        super(...arguments);
        this.type = 'guarded-cautious-append';
        this.AppendOpcode = OptimizedCautiousAppendOpcode;
    }
    normalize(reference) {
        return reference_1.map(reference, normalizeValue);
    }
    insert(dom, cursor, value) {
        return upsert_1.cautiousInsert(dom, cursor, value);
    }
    updateWith(vm, reference, cache, bounds, upsert) {
        return new GuardedCautiousUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());
    }
}
exports.GuardedCautiousAppendOpcode = GuardedCautiousAppendOpcode;
class GuardedCautiousUpdateOpcode extends GuardedUpdateOpcode {
    constructor() {
        super(...arguments);
        this.type = 'guarded-cautious-update';
    }
    insert(dom, cursor, value) {
        return upsert_1.cautiousInsert(dom, cursor, value);
    }
}
class OptimizedTrustingAppendOpcode extends AppendDynamicOpcode {
    constructor() {
        super(...arguments);
        this.type = 'optimized-trusting-append';
    }
    normalize(reference) {
        return reference_1.map(reference, normalizeTrustedValue);
    }
    insert(dom, cursor, value) {
        return upsert_1.trustingInsert(dom, cursor, value);
    }
    updateWith(_vm, _reference, cache, bounds, upsert) {
        return new OptimizedTrustingUpdateOpcode(cache, bounds, upsert);
    }
}
exports.OptimizedTrustingAppendOpcode = OptimizedTrustingAppendOpcode;
class OptimizedTrustingUpdateOpcode extends UpdateOpcode {
    constructor() {
        super(...arguments);
        this.type = 'optimized-trusting-update';
    }
    insert(dom, cursor, value) {
        return upsert_1.trustingInsert(dom, cursor, value);
    }
}
class GuardedTrustingAppendOpcode extends GuardedAppendOpcode {
    constructor() {
        super(...arguments);
        this.type = 'guarded-trusting-append';
        this.AppendOpcode = OptimizedTrustingAppendOpcode;
    }
    normalize(reference) {
        return reference_1.map(reference, normalizeTrustedValue);
    }
    insert(dom, cursor, value) {
        return upsert_1.trustingInsert(dom, cursor, value);
    }
    updateWith(vm, reference, cache, bounds, upsert) {
        return new GuardedTrustingUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());
    }
}
exports.GuardedTrustingAppendOpcode = GuardedTrustingAppendOpcode;
class GuardedTrustingUpdateOpcode extends GuardedUpdateOpcode {
    constructor() {
        super(...arguments);
        this.type = 'trusting-update';
    }
    insert(dom, cursor, value) {
        return upsert_1.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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"}