ember-legacy-class-transform
Version:
The default blueprint for ember-cli addons.
380 lines (308 loc) • 38.6 kB
JavaScript
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"); } }
import { clear, move as moveBounds } from '../bounds';
import { ElementStack } from '../builder';
import { Stack, LinkedList, dict } from '@glimmer/util';
import { IteratorSynchronizer,
// Tags
combine, UpdatableTag, combineSlice, CONSTANT_TAG, INITIAL } from '@glimmer/reference';
import { UpdatingOpcode } from '../opcodes';
import VM, { EvaluationStack } from './append';
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 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;
}();
export default UpdatingVM;
export var 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 = 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;
}(UpdatingOpcode);
export var 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 = UpdatableTag.create(CONSTANT_TAG);
return _this2;
}
TryOpcode.prototype.didInitializeChildren = function didInitializeChildren() {
this._tag.inner.update(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 = ElementStack.resume(env, bounds, bounds.reset(env));
var vm = new VM(env, scope, dynamicScope, elementStack);
var updating = new LinkedList();
vm.execute(start, function (vm) {
vm.stack = 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 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) {
moveBounds(entry, reference.firstNode());
} else {
moveBounds(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();
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;
}();
export var 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 = dict();
_this4.lastIterated = INITIAL;
_this4.artifacts = artifacts;
var _tag = _this4._tag = UpdatableTag.create(CONSTANT_TAG);
_this4.tag = 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(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 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 = ElementStack.forInitialRender(this.env, this.bounds.parentElement(), nextSibling);
return new VM(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":";;;;;;;;;;AAAA,SAASA,KAAT,EAAgBC,QAAQC,UAAxB,QAA0C,WAA1C;AACA,SAASC,YAAT,QAA6B,YAA7B;AACA,SAASC,KAAT,EAAgBC,UAAhB,EAA4BC,IAA5B,QAAgD,eAAhD;AACA,SAASC,oBAAT;AACA;AACAC,OAFA,EAESC,YAFT,EAEuBC,YAFvB,EAEqCC,YAFrC,EAEmDC,OAFnD,QAEkE,oBAFlE;AAGA,SAASC,cAAT,QAA+B,YAA/B;AACA,OAAOC,EAAP,IAAaC,eAAb,QAAoC,UAApC;;IACqBC,U;AACjB,wBAAYC,GAAZ,QAA+C;AAAA,yCAA5BC,gBAA4B;AAAA,YAA5BA,gBAA4B,yCAAT,KAAS;;AAAA;;AAC3C,aAAKC,UAAL,GAAkB,IAAIf,KAAJ,EAAlB;AACA,aAAKa,GAAL,GAAWA,GAAX;AACA,aAAKG,SAAL,GAAiBH,IAAII,OAAJ,CAAYD,SAA7B;AACA,aAAKE,GAAL,GAAWL,IAAIM,MAAJ,EAAX;AACA,aAAKL,gBAAL,GAAwBA,gBAAxB;AACH;;yBACDM,O,oBAAQC,O,EAASC,O,EAAS;AAAA,YAChBP,UADgB,GACD,IADC,CAChBA,UADgB;;AAEtB,aAAKQ,GAAL,CAASF,OAAT,EAAkBC,OAAlB;AACA,eAAO,IAAP,EAAa;AACT,gBAAIP,WAAWS,OAAX,EAAJ,EAA0B;AAC1B,gBAAIC,SAAS,KAAKC,KAAL,CAAWC,aAAX,EAAb;AACA,gBAAIF,WAAW,IAAf,EAAqB;AACjB,qBAAKV,UAAL,CAAgBa,GAAhB;AACA;AACH;AACDH,mBAAOI,QAAP,CAAgB,IAAhB;AACH;AACJ,K;;yBAIDC,I,iBAAKC,E,EAAI;AACL,aAAKL,KAAL,CAAWI,IAAX,CAAgBC,EAAhB;AACH,K;;yBACDR,G,iBAAIS,G,EAAKV,O,EAAS;AACd,aAAKP,UAAL,CAAgBkB,IAAhB,CAAqB,IAAIC,eAAJ,CAAoB,IAApB,EAA0BF,GAA1B,EAA+BV,OAA/B,CAArB;AACH,K;;yBACDa,K,qBAAQ;AACJ,aAAKT,KAAL,CAAWU,eAAX;AACA,aAAKrB,UAAL,CAAgBa,GAAhB;AACH,K;;yBACDS,c,2BAAeZ,M,EAAQ;AACnBA,eAAOI,QAAP,CAAgB,IAAhB;AACH,K;;;;yBAfW;AACR,mBAAc,KAAKd,UAAL,CAAgBuB,OAA9B;AACH;;;;;;eAvBgB1B,U;;AAsCrB,WAAa2B,WAAb;AAAA;;AACI,yBAAYC,KAAZ,EAAmBC,KAAnB,EAA0BC,MAA1B,EAAkCC,QAAlC,EAA4C;AAAA;;AAAA,qDACxC,0BADwC;;AAExC,cAAKH,KAAL,GAAaA,KAAb;AACA,cAAKI,IAAL,GAAY,OAAZ;AACA,cAAKC,IAAL,GAAY,IAAZ;AACA,cAAKC,IAAL,GAAY,IAAZ;AALwC,YAMlCjC,GANkC,GAME4B,KANF,CAMlC5B,GANkC;AAAA,YAM7BkC,KAN6B,GAMEN,KANF,CAM7BM,KAN6B;AAAA,YAMtBC,YANsB,GAMEP,KANF,CAMtBO,YANsB;AAAA,YAMRC,KANQ,GAMER,KANF,CAMRQ,KANQ;;AAOxC,cAAKN,QAAL,GAAgBA,QAAhB;AACA,cAAK9B,GAAL,GAAWA,GAAX;AACA,cAAKkC,KAAL,GAAaA,KAAb;AACA,cAAKC,YAAL,GAAoBA,YAApB;AACA,cAAKC,KAAL,GAAaA,KAAb;AACA,cAAKP,MAAL,GAAcA,MAAd;AAZwC;AAa3C;;AAdL,0BAeIQ,aAfJ,4BAeoB;AACZ,eAAO,KAAKR,MAAL,CAAYQ,aAAZ,EAAP;AACH,KAjBL;;AAAA,0BAkBIC,SAlBJ,wBAkBgB;AACR,eAAO,KAAKT,MAAL,CAAYS,SAAZ,EAAP;AACH,KApBL;;AAAA,0BAqBIC,QArBJ,uBAqBe;AACP,eAAO,KAAKV,MAAL,CAAYU,QAAZ,EAAP;AACH,KAvBL;;AAAA,0BAwBIvB,QAxBJ,qBAwBawB,EAxBb,EAwBiB;AACTA,WAAG9B,GAAH,CAAO,KAAKoB,QAAZ,EAAsB,IAAtB;AACH,KA1BL;;AAAA,0BA2BIW,OA3BJ,sBA2Bc;AACN,aAAKZ,MAAL,CAAYY,OAAZ;AACH,KA7BL;;AAAA,0BA8BIC,UA9BJ,yBA8BiB;AACT,aAAK1C,GAAL,CAAS0C,UAAT,CAAoB,KAAKb,MAAzB;AACH,KAhCL;;AAAA,0BAiCIc,MAjCJ,qBAiCa;AACL,YAAIC,UAAUvD,MAAd;AACAuD,gBAAQ,MAAR,SAAqB,KAAKC,KAA1B;AACA,eAAO;AACHC,kBAAM,KAAKD,KADR;AAEHd,kBAAM,KAAKA,IAFR;AAGHa,4BAHG;AAIHd,sBAAU,KAAKA,QAAL,CAAciB,OAAd,GAAwBC,GAAxB,CAA4B;AAAA,uBAAM9B,GAAGyB,MAAH,EAAN;AAAA,aAA5B;AAJP,SAAP;AAMH,KA1CL;;AAAA;AAAA,EAAiC/C,cAAjC;AA4CA,WAAaqD,SAAb;AAAA;;AACI,uBAAYtB,KAAZ,EAAmBC,KAAnB,EAA0BC,MAA1B,EAAkCC,QAAlC,EAA4C;AAAA;;AAAA,sDACxC,wBAAMH,KAAN,EAAaC,KAAb,EAAoBC,MAApB,EAA4BC,QAA5B,CADwC;;AAExC,eAAKC,IAAL,GAAY,KAAZ;AACA,eAAKmB,GAAL,GAAW,OAAKC,IAAL,GAAY3D,aAAa4D,MAAb,CAAoB1D,YAApB,CAAvB;AAHwC;AAI3C;;AALL,wBAMI2D,qBANJ,oCAM4B;AACpB,aAAKF,IAAL,CAAUG,KAAV,CAAgBC,MAAhB,CAAuB9D,aAAa,KAAKqC,QAAlB,CAAvB;AACH,KARL;;AAAA,wBASId,QATJ,qBASawB,EATb,EASiB;AACTA,WAAG9B,GAAH,CAAO,KAAKoB,QAAZ,EAAsB,IAAtB;AACH,KAXL;;AAAA,wBAYIP,eAZJ,8BAYsB;AAAA;;AAAA,YACRvB,GADQ,GACiE,IADjE,CACRA,GADQ;AAAA,YACH6B,MADG,GACiE,IADjE,CACHA,MADG;AAAA,YACKC,QADL,GACiE,IADjE,CACKA,QADL;AAAA,YACeI,KADf,GACiE,IADjE,CACeA,KADf;AAAA,YACsBC,YADtB,GACiE,IADjE,CACsBA,YADtB;AAAA,YACoCR,KADpC,GACiE,IADjE,CACoCA,KADpC;AAAA,YAC2CS,KAD3C,GACiE,IADjE,CAC2CA,KAD3C;AAAA,YACkDH,IADlD,GACiE,IADjE,CACkDA,IADlD;AAAA,YACwDD,IADxD,GACiE,IADjE,CACwDA,IADxD;;AAEdF,iBAAS/C,KAAT;AACA,YAAIyE,eAAetE,aAAauE,MAAb,CAAoBzD,GAApB,EAAyB6B,MAAzB,EAAiCA,OAAO6B,KAAP,CAAa1D,GAAb,CAAjC,CAAnB;AACA,YAAIwC,KAAK,IAAI3C,EAAJ,CAAOG,GAAP,EAAYkC,KAAZ,EAAmBC,YAAnB,EAAiCqB,YAAjC,CAAT;AACA,YAAIG,WAAW,IAAIvE,UAAJ,EAAf;AACAoD,WAAGjC,OAAH,CAAWoB,KAAX,EAAkB,cAAM;AACpBa,eAAGJ,KAAH,GAAWtC,gBAAgB8D,OAAhB,CAAwBxB,KAAxB,CAAX;AACAI,eAAGqB,mBAAH,CAAuBzC,IAAvB,CAA4BuC,QAA5B;AACAnB,eAAGsB,UAAH;AACAtB,eAAGqB,mBAAH,CAAuBzC,IAAvB,CAA4BU,QAA5B;AACH,SALD;AAMA,aAAKG,IAAL,GAAYA,IAAZ;AACA,aAAKD,IAAL,GAAYA,IAAZ;AACH,KA1BL;;AAAA,wBA2BIW,MA3BJ,qBA2Ba;AACL,YAAIoB,OAAO,uBAAMpB,MAAN,WAAX;AACA,YAAIC,UAAUmB,KAAK,SAAL,CAAd;AACA,YAAI,CAACnB,OAAL,EAAc;AACVA,sBAAUmB,KAAK,SAAL,IAAkB,EAA5B;AACH;AACD,eAAO,uBAAMpB,MAAN,WAAP;AACH,KAlCL;;AAAA;AAAA,EAA+BjB,WAA/B;;IAoCMsC,wB;AACF,sCAAYpD,MAAZ,EAAoBqD,MAApB,EAA4B;AAAA;;AACxB,aAAKrD,MAAL,GAAcA,MAAd;AACA,aAAKqD,MAAL,GAAcA,MAAd;AACA,aAAKC,SAAL,GAAiB,KAAjB;AACA,aAAKC,SAAL,GAAiB,KAAjB;AACA,aAAKnB,GAAL,GAAWpC,OAAOoC,GAAlB;AACA,aAAKW,QAAL,GAAgB/C,OAAO,UAAP,CAAhB;AACH;;uCACDwD,M,mBAAOC,G,EAAKC,I,EAAMC,I,EAAMC,M,EAAQ;AAAA,YACtBxB,GADsB,GACI,IADJ,CACtBA,GADsB;AAAA,YACjBpC,MADiB,GACI,IADJ,CACjBA,MADiB;AAAA,YACT+C,QADS,GACI,IADJ,CACTA,QADS;;AAE5B,YAAIc,cAAc,IAAlB;AACA,YAAIC,YAAY,IAAhB;AACA,YAAIF,MAAJ,EAAY;AACRE,wBAAY1B,IAAIwB,MAAJ,CAAZ;AACAC,0BAAcC,UAAU,QAAV,EAAoBpC,SAApB,EAAd;AACH,SAHD,MAGO;AACHmC,0BAAc,KAAKR,MAAnB;AACH;AACD,YAAIzB,KAAK5B,OAAO+D,cAAP,CAAsBF,WAAtB,CAAT;AACA,YAAIG,YAAY,IAAhB;AAX4B,YAYtBjD,KAZsB,GAYZf,MAZY,CAYtBe,KAZsB;;AAa5Ba,WAAGjC,OAAH,CAAWoB,KAAX,EAAkB,cAAM;AACpBqB,gBAAIqB,GAAJ,IAAWO,YAAYpC,GAAGqC,OAAH,CAAWN,IAAX,EAAiBD,IAAjB,CAAvB;AACA9B,eAAGqB,mBAAH,CAAuBzC,IAAvB,CAA4B,IAAIhC,UAAJ,EAA5B;AACAoD,eAAGsB,UAAH,CAAcc,SAAd;AACApC,eAAGqB,mBAAH,CAAuBzC,IAAvB,CAA4BwD,UAAU9C,QAAtC;AACH,SALD;AAMA6B,iBAASmB,YAAT,CAAsBF,SAAtB,EAAiCF,SAAjC;AACA,aAAKR,SAAL,GAAiB,IAAjB;AACH,K;;uCACDa,M,mBAAOC,I,EAAMC,K,EAAOC,K,EAAO,CAAE,C;;uCAC7BlG,I,iBAAKqF,G,EAAKY,K,EAAOC,K,EAAOV,M,EAAQ;AAAA,YACtBxB,GADsB,GACJ,IADI,CACtBA,GADsB;AAAA,YACjBW,QADiB,GACJ,IADI,CACjBA,QADiB;;AAE5B,YAAIwB,QAAQnC,IAAIqB,GAAJ,CAAZ;AACA,YAAIK,YAAY1B,IAAIwB,MAAJ,KAAe,IAA/B;AACA,YAAIA,MAAJ,EAAY;AACRvF,uBAAWkG,KAAX,EAAkBT,UAAUpC,SAAV,EAAlB;AACH,SAFD,MAEO;AACHrD,uBAAWkG,KAAX,EAAkB,KAAKlB,MAAvB;AACH;AACDN,iBAASyB,MAAT,CAAgBD,KAAhB;AACAxB,iBAASmB,YAAT,CAAsBK,KAAtB,EAA6BT,SAA7B;AACH,K;;uCACDW,M,oBAAOhB,G,EAAK;AAAA,YACFrB,GADE,GACM,IADN,CACFA,GADE;;AAER,YAAIpC,SAASoC,IAAIqB,GAAJ,CAAb;AACAzD,eAAO8B,UAAP;AACA3D,cAAM6B,MAAN;AACA,aAAK+C,QAAL,CAAcyB,MAAd,CAAqBxE,MAArB;AACA,eAAOoC,IAAIqB,GAAJ,CAAP;AACA,aAAKF,SAAL,GAAiB,IAAjB;AACH,K;;uCACDmB,I,mBAAO;AACH,aAAK1E,MAAL,CAAYyC,qBAAZ,CAAkC,KAAKa,SAAL,IAAkB,KAAKC,SAAzD;AACH,K;;;;;AAEL,WAAaoB,eAAb;AAAA;;AACI,6BAAY5D,KAAZ,EAAmBC,KAAnB,EAA0BC,MAA1B,EAAkCC,QAAlC,EAA4C0D,SAA5C,EAAuD;AAAA;;AAAA,sDACnD,yBAAM7D,KAAN,EAAaC,KAAb,EAAoBC,MAApB,EAA4BC,QAA5B,CADmD;;AAEnD,eAAKC,IAAL,GAAY,YAAZ;AACA,eAAKiB,GAAL,GAAW3D,MAAX;AACA,eAAKoG,YAAL,GAAoB9F,OAApB;AACA,eAAK6F,SAAL,GAAiBA,SAAjB;AACA,YAAIrC,OAAO,OAAKA,IAAL,GAAY3D,aAAa4D,MAAb,CAAoB1D,YAApB,CAAvB;AACA,eAAKwD,GAAL,GAAW3D,QAAQ,CAACiG,UAAUtC,GAAX,EAAgBC,IAAhB,CAAR,CAAX;AAPmD;AAQtD;;AATL,8BAUIE,qBAVJ,oCAUgD;AAAA,YAAtBqC,aAAsB,uEAAN,IAAM;;AACxC,aAAKD,YAAL,GAAoB,KAAKD,SAAL,CAAetC,GAAf,CAAmByC,KAAnB,EAApB;AACA,YAAID,aAAJ,EAAmB;AACf,iBAAKvC,IAAL,CAAUG,KAAV,CAAgBC,MAAhB,CAAuB9D,aAAa,KAAKqC,QAAlB,CAAvB;AACH;AACJ,KAfL;;AAAA,8BAgBId,QAhBJ,qBAgBawB,EAhBb,EAgBiB;AAAA,YACHgD,SADG,GACyB,IADzB,CACHA,SADG;AAAA,YACQC,YADR,GACyB,IADzB,CACQA,YADR;;AAET,YAAI,CAACD,UAAUtC,GAAV,CAAc0C,QAAd,CAAuBH,YAAvB,CAAL,EAA2C;AAAA,gBACjC5D,MADiC,GACtB,IADsB,CACjCA,MADiC;AAAA,gBAEjCxB,GAFiC,GAEzBmC,EAFyB,CAEjCnC,GAFiC;;AAGvC,gBAAI4D,SAAS5D,IAAIwF,aAAJ,CAAkB,EAAlB,CAAb;AACAxF,gBAAIyF,WAAJ,CAAgBjE,OAAOQ,aAAP,EAAhB,EAAwC4B,MAAxC,EAAuDpC,OAAOU,QAAP,EAAvD;AACA,gBAAIwD,SAAS,IAAI/B,wBAAJ,CAA6B,IAA7B,EAAmCC,MAAnC,CAAb;AACA,gBAAI+B,eAAe,IAAI1G,oBAAJ,CAAyB,EAAEyG,cAAF,EAAUP,oBAAV,EAAzB,CAAnB;AACAQ,yBAAaC,IAAb;AACA,iBAAK5D,aAAL,GAAqB6D,WAArB,CAAiCjC,MAAjC;AACH;AACD;AACA,gCAAMjD,QAAN,YAAewB,EAAf;AACH,KA9BL;;AAAA,8BA+BImC,cA/BJ,2BA+BmBF,WA/BnB,EA+BgC;AAAA,YAClBzE,GADkB,GACW,IADX,CAClBA,GADkB;AAAA,YACbkC,KADa,GACW,IADX,CACbA,KADa;AAAA,YACNC,YADM,GACW,IADX,CACNA,YADM;;AAExB,YAAIqB,eAAetE,aAAaiH,gBAAb,CAA8B,KAAKnG,GAAnC,EAAwC,KAAK6B,MAAL,CAAYQ,aAAZ,EAAxC,EAAqEoC,WAArE,CAAnB;AACA,eAAO,IAAI5E,EAAJ,CAAOG,GAAP,EAAYkC,KAAZ,EAAmBC,YAAnB,EAAiCqB,YAAjC,CAAP;AACH,KAnCL;;AAAA,8BAoCIb,MApCJ,qBAoCa;AACL,YAAIoB,OAAO,wBAAMpB,MAAN,WAAX;AACA,YAAIK,MAAM,KAAKA,GAAf;AACA,YAAIM,QAAQ8C,OAAOC,IAAP,CAAYrD,GAAZ,EAAiBA,GAAjB,CAAqB,eAAO;AACpC,mBAAUsD,KAAKC,SAAL,CAAelC,GAAf,CAAV,UAAkCrB,IAAIqB,GAAJ,EAASxB,KAA3C;AACH,SAFW,EAET2D,IAFS,CAEJ,IAFI,CAAZ;AAGA,YAAI5D,UAAUmB,KAAK,SAAL,CAAd;AACA,YAAI,CAACnB,OAAL,EAAc;AACVA,sBAAUmB,KAAK,SAAL,IAAkB,EAA5B;AACH;AACDnB,gBAAQ,KAAR,UAAqBU,KAArB;AACA,eAAOS,IAAP;AACH,KAhDL;;AAAA;AAAA,EAAqCrC,WAArC;;IAkDML,e;AACF,6BAAYmB,EAAZ,EAAgBrB,GAAhB,EAAqBsF,gBAArB,EAAuC;AAAA;;AACnC,aAAKjE,EAAL,GAAUA,EAAV;AACA,aAAKrB,GAAL,GAAWA,GAAX;AACA,aAAKsF,gBAAL,GAAwBA,gBAAxB;AACA,aAAKjE,EAAL,GAAUA,EAAV;AACA,aAAKrB,GAAL,GAAWA,GAAX;AACA,aAAKM,OAAL,GAAeN,IAAIuF,IAAJ,EAAf;AACH;;8BACDzF,I,iBAAKC,E,EAAI;AACL,aAAKO,OAAL,GAAeP,EAAf;AACH,K;;8BACDJ,a,4BAAgB;AAAA,YACNW,OADM,GACW,IADX,CACNA,OADM;AAAA,YACGN,GADH,GACW,IADX,CACGA,GADH;;AAEZ,YAAIM,OAAJ,EAAa,KAAKA,OAAL,GAAeN,IAAIwF,QAAJ,CAAalF,OAAb,CAAf;AACb,eAAOA,OAAP;AACH,K;;8BACDF,e,8BAAkB;AACd,YAAI,KAAKkF,gBAAT,EAA2B;AACvB,iBAAKA,gBAAL,CAAsBlF,eAAtB;AACH;AACJ,K","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}"]}