ember-legacy-class-transform/.node_modules.ember-try/@glimmer/runtime/dist/commonjs/es5/lib/vm/update.js

The default blueprint for ember-cli addons.

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.ListBlockOpcode = exports.TryOpcode = exports.BlockOpcode = undefined;

var _bounds = require("../bounds");

var _builder = require("../builder");

var _util = require("@glimmer/util");

var _reference = require("@glimmer/reference");

var _opcodes = require("../opcodes");

var _append = require("./append");

var _append2 = _interopRequireDefault(_append);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defaults(obj, defaults) {
    var keys = Object.getOwnPropertyNames(defaults);for (var i = 0; i < keys.length; i++) {
        var key = keys[i];var value = Object.getOwnPropertyDescriptor(defaults, key);if (value && value.configurable && obj[key] === undefined) {
            Object.defineProperty(obj, key, value);
        }
    }return obj;
}

var _createClass = function () {
    function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
        }
    }return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
    };
}();

function _possibleConstructorReturn(self, call) {
    if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }return call && (typeof call === "object" || typeof call === "function") ? call : self;
}

function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass);
}

function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}

var UpdatingVM = function () {
    function UpdatingVM(env, _ref) {
        var _ref$alwaysRevalidate = _ref.alwaysRevalidate,
            alwaysRevalidate = _ref$alwaysRevalidate === undefined ? false : _ref$alwaysRevalidate;

        _classCallCheck(this, UpdatingVM);

        this.frameStack = new _util.Stack();
        this.env = env;
        this.constants = env.program.constants;
        this.dom = env.getDOM();
        this.alwaysRevalidate = alwaysRevalidate;
    }

    UpdatingVM.prototype.execute = function execute(opcodes, handler) {
        var frameStack = this.frameStack;

        this.try(opcodes, handler);
        while (true) {
            if (frameStack.isEmpty()) break;
            var opcode = this.frame.nextStatement();
            if (opcode === null) {
                this.frameStack.pop();
                continue;
            }
            opcode.evaluate(this);
        }
    };

    UpdatingVM.prototype.goto = function goto(op) {
        this.frame.goto(op);
    };

    UpdatingVM.prototype.try = function _try(ops, handler) {
        this.frameStack.push(new UpdatingVMFrame(this, ops, handler));
    };

    UpdatingVM.prototype.throw = function _throw() {
        this.frame.handleException();
        this.frameStack.pop();
    };

    UpdatingVM.prototype.evaluateOpcode = function evaluateOpcode(opcode) {
        opcode.evaluate(this);
    };

    _createClass(UpdatingVM, [{
        key: 'frame',
        get: function () {
            return this.frameStack.current;
        }
    }]);

    return UpdatingVM;
}();

exports.default = UpdatingVM;
var BlockOpcode = exports.BlockOpcode = function (_UpdatingOpcode) {
    _inherits(BlockOpcode, _UpdatingOpcode);

    function BlockOpcode(start, state, bounds, children) {
        _classCallCheck(this, BlockOpcode);

        var _this = _possibleConstructorReturn(this, _UpdatingOpcode.call(this));

        _this.start = start;
        _this.type = "block";
        _this.next = null;
        _this.prev = null;
        var env = state.env,
            scope = state.scope,
            dynamicScope = state.dynamicScope,
            stack = state.stack;

        _this.children = children;
        _this.env = env;
        _this.scope = scope;
        _this.dynamicScope = dynamicScope;
        _this.stack = stack;
        _this.bounds = bounds;
        return _this;
    }

    BlockOpcode.prototype.parentElement = function parentElement() {
        return this.bounds.parentElement();
    };

    BlockOpcode.prototype.firstNode = function firstNode() {
        return this.bounds.firstNode();
    };

    BlockOpcode.prototype.lastNode = function lastNode() {
        return this.bounds.lastNode();
    };

    BlockOpcode.prototype.evaluate = function evaluate(vm) {
        vm.try(this.children, null);
    };

    BlockOpcode.prototype.destroy = function destroy() {
        this.bounds.destroy();
    };

    BlockOpcode.prototype.didDestroy = function didDestroy() {
        this.env.didDestroy(this.bounds);
    };

    BlockOpcode.prototype.toJSON = function toJSON() {
        var details = (0, _util.dict)();
        details["guid"] = '' + this._guid;
        return {
            guid: this._guid,
            type: this.type,
            details: details,
            children: this.children.toArray().map(function (op) {
                return op.toJSON();
            })
        };
    };

    return BlockOpcode;
}(_opcodes.UpdatingOpcode);
var TryOpcode = exports.TryOpcode = function (_BlockOpcode) {
    _inherits(TryOpcode, _BlockOpcode);

    function TryOpcode(start, state, bounds, children) {
        _classCallCheck(this, TryOpcode);

        var _this2 = _possibleConstructorReturn(this, _BlockOpcode.call(this, start, state, bounds, children));

        _this2.type = "try";
        _this2.tag = _this2._tag = _reference.UpdatableTag.create(_reference.CONSTANT_TAG);
        return _this2;
    }

    TryOpcode.prototype.didInitializeChildren = function didInitializeChildren() {
        this._tag.inner.update((0, _reference.combineSlice)(this.children));
    };

    TryOpcode.prototype.evaluate = function evaluate(vm) {
        vm.try(this.children, this);
    };

    TryOpcode.prototype.handleException = function handleException() {
        var _this3 = this;

        var env = this.env,
            bounds = this.bounds,
            children = this.children,
            scope = this.scope,
            dynamicScope = this.dynamicScope,
            start = this.start,
            stack = this.stack,
            prev = this.prev,
            next = this.next;

        children.clear();
        var elementStack = _builder.ElementStack.resume(env, bounds, bounds.reset(env));
        var vm = new _append2.default(env, scope, dynamicScope, elementStack);
        var updating = new _util.LinkedList();
        vm.execute(start, function (vm) {
            vm.stack = _append.EvaluationStack.restore(stack);
            vm.updatingOpcodeStack.push(updating);
            vm.updateWith(_this3);
            vm.updatingOpcodeStack.push(children);
        });
        this.prev = prev;
        this.next = next;
    };

    TryOpcode.prototype.toJSON = function toJSON() {
        var json = _BlockOpcode.prototype.toJSON.call(this);
        var details = json["details"];
        if (!details) {
            details = json["details"] = {};
        }
        return _BlockOpcode.prototype.toJSON.call(this);
    };

    return TryOpcode;
}(BlockOpcode);

var ListRevalidationDelegate = function () {
    function ListRevalidationDelegate(opcode, marker) {
        _classCallCheck(this, ListRevalidationDelegate);

        this.opcode = opcode;
        this.marker = marker;
        this.didInsert = false;
        this.didDelete = false;
        this.map = opcode.map;
        this.updating = opcode['children'];
    }

    ListRevalidationDelegate.prototype.insert = function insert(key, item, memo, before) {
        var map = this.map,
            opcode = this.opcode,
            updating = this.updating;

        var nextSibling = null;
        var reference = null;
        if (before) {
            reference = map[before];
            nextSibling = reference['bounds'].firstNode();
        } else {
            nextSibling = this.marker;
        }
        var vm = opcode.vmForInsertion(nextSibling);
        var tryOpcode = null;
        var start = opcode.start;

        vm.execute(start, function (vm) {
            map[key] = tryOpcode = vm.iterate(memo, item);
            vm.updatingOpcodeStack.push(new _util.LinkedList());
            vm.updateWith(tryOpcode);
            vm.updatingOpcodeStack.push(tryOpcode.children);
        });
        updating.insertBefore(tryOpcode, reference);
        this.didInsert = true;
    };

    ListRevalidationDelegate.prototype.retain = function retain(_key, _item, _memo) {};

    ListRevalidationDelegate.prototype.move = function move(key, _item, _memo, before) {
        var map = this.map,
            updating = this.updating;

        var entry = map[key];
        var reference = map[before] || null;
        if (before) {
            (0, _bounds.move)(entry, reference.firstNode());
        } else {
            (0, _bounds.move)(entry, this.marker);
        }
        updating.remove(entry);
        updating.insertBefore(entry, reference);
    };

    ListRevalidationDelegate.prototype.delete = function _delete(key) {
        var map = this.map;

        var opcode = map[key];
        opcode.didDestroy();
        (0, _bounds.clear)(opcode);
        this.updating.remove(opcode);
        delete map[key];
        this.didDelete = true;
    };

    ListRevalidationDelegate.prototype.done = function done() {
        this.opcode.didInitializeChildren(this.didInsert || this.didDelete);
    };

    return ListRevalidationDelegate;
}();

var ListBlockOpcode = exports.ListBlockOpcode = function (_BlockOpcode2) {
    _inherits(ListBlockOpcode, _BlockOpcode2);

    function ListBlockOpcode(start, state, bounds, children, artifacts) {
        _classCallCheck(this, ListBlockOpcode);

        var _this4 = _possibleConstructorReturn(this, _BlockOpcode2.call(this, start, state, bounds, children));

        _this4.type = "list-block";
        _this4.map = (0, _util.dict)();
        _this4.lastIterated = _reference.INITIAL;
        _this4.artifacts = artifacts;
        var _tag = _this4._tag = _reference.UpdatableTag.create(_reference.CONSTANT_TAG);
        _this4.tag = (0, _reference.combine)([artifacts.tag, _tag]);
        return _this4;
    }

    ListBlockOpcode.prototype.didInitializeChildren = function didInitializeChildren() {
        var listDidChange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        this.lastIterated = this.artifacts.tag.value();
        if (listDidChange) {
            this._tag.inner.update((0, _reference.combineSlice)(this.children));
        }
    };

    ListBlockOpcode.prototype.evaluate = function evaluate(vm) {
        var artifacts = this.artifacts,
            lastIterated = this.lastIterated;

        if (!artifacts.tag.validate(lastIterated)) {
            var bounds = this.bounds;
            var dom = vm.dom;

            var marker = dom.createComment('');
            dom.insertAfter(bounds.parentElement(), marker, bounds.lastNode());
            var target = new ListRevalidationDelegate(this, marker);
            var synchronizer = new _reference.IteratorSynchronizer({ target: target, artifacts: artifacts });
            synchronizer.sync();
            this.parentElement().removeChild(marker);
        }
        // Run now-updated updating opcodes
        _BlockOpcode2.prototype.evaluate.call(this, vm);
    };

    ListBlockOpcode.prototype.vmForInsertion = function vmForInsertion(nextSibling) {
        var env = this.env,
            scope = this.scope,
            dynamicScope = this.dynamicScope;

        var elementStack = _builder.ElementStack.forInitialRender(this.env, this.bounds.parentElement(), nextSibling);
        return new _append2.default(env, scope, dynamicScope, elementStack);
    };

    ListBlockOpcode.prototype.toJSON = function toJSON() {
        var json = _BlockOpcode2.prototype.toJSON.call(this);
        var map = this.map;
        var inner = Object.keys(map).map(function (key) {
            return JSON.stringify(key) + ': ' + map[key]._guid;
        }).join(", ");
        var details = json["details"];
        if (!details) {
            details = json["details"] = {};
        }
        details["map"] = '{' + inner + '}';
        return json;
    };

    return ListBlockOpcode;
}(BlockOpcode);

var UpdatingVMFrame = function () {
    function UpdatingVMFrame(vm, ops, exceptionHandler) {
        _classCallCheck(this, UpdatingVMFrame);

        this.vm = vm;
        this.ops = ops;
        this.exceptionHandler = exceptionHandler;
        this.vm = vm;
        this.ops = ops;
        this.current = ops.head();
    }

    UpdatingVMFrame.prototype.goto = function goto(op) {
        this.current = op;
    };

    UpdatingVMFrame.prototype.nextStatement = function nextStatement() {
        var current = this.current,
            ops = this.ops;

        if (current) this.current = ops.nextNode(current);
        return current;
    };

    UpdatingVMFrame.prototype.handleException = function handleException() {
        if (this.exceptionHandler) {
            this.exceptionHandler.handleException();
        }
    };

    return UpdatingVMFrame;
}();
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["lib/vm/update.js"],"names":["clear","move","moveBounds","ElementStack","Stack","LinkedList","dict","IteratorSynchronizer","combine","UpdatableTag","combineSlice","CONSTANT_TAG","INITIAL","UpdatingOpcode","VM","EvaluationStack","UpdatingVM","env","alwaysRevalidate","frameStack","constants","program","dom","getDOM","execute","opcodes","handler","try","isEmpty","opcode","frame","nextStatement","pop","evaluate","goto","op","ops","push","UpdatingVMFrame","throw","handleException","evaluateOpcode","current","BlockOpcode","start","state","bounds","children","type","next","prev","scope","dynamicScope","stack","parentElement","firstNode","lastNode","vm","destroy","didDestroy","toJSON","details","_guid","guid","toArray","map","TryOpcode","tag","_tag","create","didInitializeChildren","inner","update","elementStack","resume","reset","updating","restore","updatingOpcodeStack","updateWith","json","ListRevalidationDelegate","marker","didInsert","didDelete","insert","key","item","memo","before","nextSibling","reference","vmForInsertion","tryOpcode","iterate","insertBefore","retain","_key","_item","_memo","entry","remove","delete","done","ListBlockOpcode","artifacts","lastIterated","listDidChange","value","validate","createComment","insertAfter","target","synchronizer","sync","removeChild","forInitialRender","Object","keys","JSON","stringify","join","exceptionHandler","head","nextNode"],"mappings":"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","file":"lib/vm/update.js","sourcesContent":["import { clear, move as moveBounds } from '../bounds';\nimport { ElementStack } from '../builder';\nimport { Stack, LinkedList, dict, expect } from '@glimmer/util';\nimport { IteratorSynchronizer,\n// Tags\ncombine, UpdatableTag, combineSlice, CONSTANT_TAG, INITIAL } from '@glimmer/reference';\nimport { UpdatingOpcode } from '../opcodes';\nimport VM, { EvaluationStack } from './append';\nexport default class UpdatingVM {\n    constructor(env, { alwaysRevalidate = false }) {\n        this.frameStack = new Stack();\n        this.env = env;\n        this.constants = env.program.constants;\n        this.dom = env.getDOM();\n        this.alwaysRevalidate = alwaysRevalidate;\n    }\n    execute(opcodes, handler) {\n        let { frameStack } = this;\n        this.try(opcodes, handler);\n        while (true) {\n            if (frameStack.isEmpty()) break;\n            let opcode = this.frame.nextStatement();\n            if (opcode === null) {\n                this.frameStack.pop();\n                continue;\n            }\n            opcode.evaluate(this);\n        }\n    }\n    get frame() {\n        return expect(this.frameStack.current, 'bug: expected a frame');\n    }\n    goto(op) {\n        this.frame.goto(op);\n    }\n    try(ops, handler) {\n        this.frameStack.push(new UpdatingVMFrame(this, ops, handler));\n    }\n    throw() {\n        this.frame.handleException();\n        this.frameStack.pop();\n    }\n    evaluateOpcode(opcode) {\n        opcode.evaluate(this);\n    }\n}\nexport class BlockOpcode extends UpdatingOpcode {\n    constructor(start, state, bounds, children) {\n        super();\n        this.start = start;\n        this.type = \"block\";\n        this.next = null;\n        this.prev = null;\n        let { env, scope, dynamicScope, stack } = state;\n        this.children = children;\n        this.env = env;\n        this.scope = scope;\n        this.dynamicScope = dynamicScope;\n        this.stack = stack;\n        this.bounds = bounds;\n    }\n    parentElement() {\n        return this.bounds.parentElement();\n    }\n    firstNode() {\n        return this.bounds.firstNode();\n    }\n    lastNode() {\n        return this.bounds.lastNode();\n    }\n    evaluate(vm) {\n        vm.try(this.children, null);\n    }\n    destroy() {\n        this.bounds.destroy();\n    }\n    didDestroy() {\n        this.env.didDestroy(this.bounds);\n    }\n    toJSON() {\n        let details = dict();\n        details[\"guid\"] = `${this._guid}`;\n        return {\n            guid: this._guid,\n            type: this.type,\n            details,\n            children: this.children.toArray().map(op => op.toJSON())\n        };\n    }\n}\nexport class TryOpcode extends BlockOpcode {\n    constructor(start, state, bounds, children) {\n        super(start, state, bounds, children);\n        this.type = \"try\";\n        this.tag = this._tag = UpdatableTag.create(CONSTANT_TAG);\n    }\n    didInitializeChildren() {\n        this._tag.inner.update(combineSlice(this.children));\n    }\n    evaluate(vm) {\n        vm.try(this.children, this);\n    }\n    handleException() {\n        let { env, bounds, children, scope, dynamicScope, start, stack, prev, next } = this;\n        children.clear();\n        let elementStack = ElementStack.resume(env, bounds, bounds.reset(env));\n        let vm = new VM(env, scope, dynamicScope, elementStack);\n        let updating = new LinkedList();\n        vm.execute(start, vm => {\n            vm.stack = EvaluationStack.restore(stack);\n            vm.updatingOpcodeStack.push(updating);\n            vm.updateWith(this);\n            vm.updatingOpcodeStack.push(children);\n        });\n        this.prev = prev;\n        this.next = next;\n    }\n    toJSON() {\n        let json = super.toJSON();\n        let details = json[\"details\"];\n        if (!details) {\n            details = json[\"details\"] = {};\n        }\n        return super.toJSON();\n    }\n}\nclass ListRevalidationDelegate {\n    constructor(opcode, marker) {\n        this.opcode = opcode;\n        this.marker = marker;\n        this.didInsert = false;\n        this.didDelete = false;\n        this.map = opcode.map;\n        this.updating = opcode['children'];\n    }\n    insert(key, item, memo, before) {\n        let { map, opcode, updating } = this;\n        let nextSibling = null;\n        let reference = null;\n        if (before) {\n            reference = map[before];\n            nextSibling = reference['bounds'].firstNode();\n        } else {\n            nextSibling = this.marker;\n        }\n        let vm = opcode.vmForInsertion(nextSibling);\n        let tryOpcode = null;\n        let { start } = opcode;\n        vm.execute(start, vm => {\n            map[key] = tryOpcode = vm.iterate(memo, item);\n            vm.updatingOpcodeStack.push(new LinkedList());\n            vm.updateWith(tryOpcode);\n            vm.updatingOpcodeStack.push(tryOpcode.children);\n        });\n        updating.insertBefore(tryOpcode, reference);\n        this.didInsert = true;\n    }\n    retain(_key, _item, _memo) {}\n    move(key, _item, _memo, before) {\n        let { map, updating } = this;\n        let entry = map[key];\n        let reference = map[before] || null;\n        if (before) {\n            moveBounds(entry, reference.firstNode());\n        } else {\n            moveBounds(entry, this.marker);\n        }\n        updating.remove(entry);\n        updating.insertBefore(entry, reference);\n    }\n    delete(key) {\n        let { map } = this;\n        let opcode = map[key];\n        opcode.didDestroy();\n        clear(opcode);\n        this.updating.remove(opcode);\n        delete map[key];\n        this.didDelete = true;\n    }\n    done() {\n        this.opcode.didInitializeChildren(this.didInsert || this.didDelete);\n    }\n}\nexport class ListBlockOpcode extends BlockOpcode {\n    constructor(start, state, bounds, children, artifacts) {\n        super(start, state, bounds, children);\n        this.type = \"list-block\";\n        this.map = dict();\n        this.lastIterated = INITIAL;\n        this.artifacts = artifacts;\n        let _tag = this._tag = UpdatableTag.create(CONSTANT_TAG);\n        this.tag = combine([artifacts.tag, _tag]);\n    }\n    didInitializeChildren(listDidChange = true) {\n        this.lastIterated = this.artifacts.tag.value();\n        if (listDidChange) {\n            this._tag.inner.update(combineSlice(this.children));\n        }\n    }\n    evaluate(vm) {\n        let { artifacts, lastIterated } = this;\n        if (!artifacts.tag.validate(lastIterated)) {\n            let { bounds } = this;\n            let { dom } = vm;\n            let marker = dom.createComment('');\n            dom.insertAfter(bounds.parentElement(), marker, expect(bounds.lastNode(), \"can't insert after an empty bounds\"));\n            let target = new ListRevalidationDelegate(this, marker);\n            let synchronizer = new IteratorSynchronizer({ target, artifacts });\n            synchronizer.sync();\n            this.parentElement().removeChild(marker);\n        }\n        // Run now-updated updating opcodes\n        super.evaluate(vm);\n    }\n    vmForInsertion(nextSibling) {\n        let { env, scope, dynamicScope } = this;\n        let elementStack = ElementStack.forInitialRender(this.env, this.bounds.parentElement(), nextSibling);\n        return new VM(env, scope, dynamicScope, elementStack);\n    }\n    toJSON() {\n        let json = super.toJSON();\n        let map = this.map;\n        let inner = Object.keys(map).map(key => {\n            return `${JSON.stringify(key)}: ${map[key]._guid}`;\n        }).join(\", \");\n        let details = json[\"details\"];\n        if (!details) {\n            details = json[\"details\"] = {};\n        }\n        details[\"map\"] = `{${inner}}`;\n        return json;\n    }\n}\nclass UpdatingVMFrame {\n    constructor(vm, ops, exceptionHandler) {\n        this.vm = vm;\n        this.ops = ops;\n        this.exceptionHandler = exceptionHandler;\n        this.vm = vm;\n        this.ops = ops;\n        this.current = ops.head();\n    }\n    goto(op) {\n        this.current = op;\n    }\n    nextStatement() {\n        let { current, ops } = this;\n        if (current) this.current = ops.nextNode(current);\n        return current;\n    }\n    handleException() {\n        if (this.exceptionHandler) {\n            this.exceptionHandler.handleException();\n        }\n    }\n}"]}