targetj 1.0.256 → 1.0.258

package/build/StateUtil.js

@@ -0,0 +1,600 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { TUtil } from "./TUtil.js";
+var TMODEL_REF_KEY = "__targetjsTModelRef";
+
+/*
+ * These fields are reconstructed separately or must be connected to the
+ * current DOM rather than copied from the old tree.
+ */
+var EXCLUDED_RUNTIME_FIELDS = new Set(["_state", "targets", "targetDefinitions", "restoringRuntime", "restoredUsesExistingDom", "type", "oid", "oidNum", "originalId", "parent", "allChildrenList", "allChildrenMap", "$dom", "viewport", "visibilityStatus", "currentStatus", "dirtyLayout", "originWindowEpoch", "hasDomNow", "isNowVisible", "domHeightTimestamp", "domWidthTimestamp", "lastBatch", "waapiBatch", "finalKeyframe", "finalRawFrame"]);
+var CHILD_OPERATION_FIELDS = ["addedChildren", "deletedChildren", "movedChildren"];
+var RUNTIME_TIMESTAMP_FIELDS = new Set(["lastUpdate", "scheduleTimeStamp", "completeTime", "creationTime", "activationTime", "catchupAt", "startTime", "lastResizeHandledTime"]);
+var TARGET_RUNTIME_FIELDS = ["originalTargetName", "originalTModel", "invokerTargetName", "invokerTModel", "fetchAction", "childAction", "addChildAction"];
+
+/**
+ * Creates and restores in-memory TargetJS runtime snapshots.
+ *
+ * The snapshot is not JSON serialization. Functions and non-plain class
+ * instances remain shared references.
+ */
+var StateUtil = /*#__PURE__*/function () {
+  function StateUtil() {
+    _classCallCheck(this, StateUtil);
+  }
+  return _createClass(StateUtil, null, [{
+    key: "rebaseRuntimeTimes",
+    value: function rebaseRuntimeTimes(value, offset) {
+      var seen = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakSet();
+      if (!value || _typeof(value) !== "object" || offset === 0 || StateUtil.isTModel(value) || seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+      if (value instanceof Map) {
+        var _iterator = _createForOfIteratorHelper(value.values()),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var mapValue = _step.value;
+            StateUtil.rebaseRuntimeTimes(mapValue, offset, seen);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        return;
+      }
+      if (value instanceof Set) {
+        var _iterator2 = _createForOfIteratorHelper(value),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var item = _step2.value;
+            StateUtil.rebaseRuntimeTimes(item, offset, seen);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        return;
+      }
+      for (var _i = 0, _Object$keys = Object.keys(value); _i < _Object$keys.length; _i++) {
+        var key = _Object$keys[_i];
+        var propertyValue = value[key];
+        if (RUNTIME_TIMESTAMP_FIELDS.has(key) && Number.isFinite(propertyValue) && propertyValue > 0) {
+          value[key] = propertyValue + offset;
+          continue;
+        }
+        StateUtil.rebaseRuntimeTimes(propertyValue, offset, seen);
+      }
+    }
+  }, {
+    key: "isPlainObject",
+    value: function isPlainObject(value) {
+      if (!value || _typeof(value) !== "object") {
+        return false;
+      }
+      var prototype = Object.getPrototypeOf(value);
+      return prototype === Object.prototype || prototype === null;
+    }
+  }, {
+    key: "cloneUnboundTargets",
+    value: function cloneUnboundTargets(targets) {
+      var cloned = TUtil.cloneTargetDefinition(targets);
+      for (var _i2 = 0, _Object$values = Object.values(cloned); _i2 < _Object$values.length; _i2++) {
+        var target = _Object$values[_i2];
+        if (!StateUtil.isPlainObject(target)) {
+          continue;
+        }
+        for (var _i3 = 0, _Object$keys2 = Object.keys(target); _i3 < _Object$keys2.length; _i3++) {
+          var key = _Object$keys2[_i3];
+          var value = target[key];
+          if (typeof value === "function" && value.__isBoundTargetMethod) {
+            target[key] = value.__targetjsSource || value;
+          }
+        }
+      }
+      return cloned;
+    }
+  }, {
+    key: "isTModel",
+    value: function isTModel(value) {
+      return Boolean(value && _typeof(value) === "object" && typeof value.oid === "string" && value.targets && typeof value.state === "function" && typeof value.getChildren === "function");
+    }
+  }, {
+    key: "isTModelReference",
+    value: function isTModelReference(value) {
+      return Boolean(StateUtil.isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, TMODEL_REF_KEY));
+    }
+  }, {
+    key: "createTModelReference",
+    value: function createTModelReference(tmodel) {
+      return _defineProperty({}, TMODEL_REF_KEY, tmodel.oid);
+    }
+  }, {
+    key: "encodeValue",
+    value: function encodeValue(value) {
+      var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new WeakMap();
+      if (value === null || value === undefined || _typeof(value) !== "object") {
+        return value;
+      }
+      if (StateUtil.isTModel(value)) {
+        return StateUtil.createTModelReference(value);
+      }
+      if (seen.has(value)) {
+        return seen.get(value);
+      }
+      if (value instanceof Date) {
+        return new Date(value.getTime());
+      }
+      if (value instanceof Map) {
+        var _copy = new Map();
+        seen.set(value, _copy);
+        var _iterator3 = _createForOfIteratorHelper(value),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _step3$value = _slicedToArray(_step3.value, 2),
+              key = _step3$value[0],
+              mapValue = _step3$value[1];
+            _copy.set(StateUtil.encodeValue(key, seen), StateUtil.encodeValue(mapValue, seen));
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+        return _copy;
+      }
+      if (value instanceof Set) {
+        var _copy2 = new Set();
+        seen.set(value, _copy2);
+        var _iterator4 = _createForOfIteratorHelper(value),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var item = _step4.value;
+            _copy2.add(StateUtil.encodeValue(item, seen));
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+        return _copy2;
+      }
+      if (Array.isArray(value)) {
+        var _copy3 = [];
+        seen.set(value, _copy3);
+        var _iterator5 = _createForOfIteratorHelper(value),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var _item = _step5.value;
+            _copy3.push(StateUtil.encodeValue(_item, seen));
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+        return _copy3;
+      }
+      if (!StateUtil.isPlainObject(value)) {
+        return value;
+      }
+      var copy = {};
+      seen.set(value, copy);
+      for (var _i4 = 0, _Object$entries = Object.entries(value); _i4 < _Object$entries.length; _i4++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i4], 2),
+          _key = _Object$entries$_i[0],
+          propertyValue = _Object$entries$_i[1];
+        copy[_key] = StateUtil.encodeValue(propertyValue, seen);
+      }
+      return copy;
+    }
+  }, {
+    key: "decodeValue",
+    value: function decodeValue(value, tmodelIdMap) {
+      var seen = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakMap();
+      if (value === null || value === undefined || _typeof(value) !== "object") {
+        return value;
+      }
+      if (StateUtil.isTModelReference(value)) {
+        return tmodelIdMap[value[TMODEL_REF_KEY]];
+      }
+      if (seen.has(value)) {
+        return seen.get(value);
+      }
+      if (value instanceof Date) {
+        return new Date(value.getTime());
+      }
+      if (value instanceof Map) {
+        var _copy4 = new Map();
+        seen.set(value, _copy4);
+        var _iterator6 = _createForOfIteratorHelper(value),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var _step6$value = _slicedToArray(_step6.value, 2),
+              key = _step6$value[0],
+              mapValue = _step6$value[1];
+            _copy4.set(StateUtil.decodeValue(key, tmodelIdMap, seen), StateUtil.decodeValue(mapValue, tmodelIdMap, seen));
+          }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+        return _copy4;
+      }
+      if (value instanceof Set) {
+        var _copy5 = new Set();
+        seen.set(value, _copy5);
+        var _iterator7 = _createForOfIteratorHelper(value),
+          _step7;
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var item = _step7.value;
+            _copy5.add(StateUtil.decodeValue(item, tmodelIdMap, seen));
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+        return _copy5;
+      }
+      if (Array.isArray(value)) {
+        var _copy6 = [];
+        seen.set(value, _copy6);
+        var _iterator8 = _createForOfIteratorHelper(value),
+          _step8;
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var _item2 = _step8.value;
+            _copy6.push(StateUtil.decodeValue(_item2, tmodelIdMap, seen));
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+        return _copy6;
+      }
+      if (!StateUtil.isPlainObject(value)) {
+        return value;
+      }
+      var copy = {};
+      seen.set(value, copy);
+      for (var _i5 = 0, _Object$entries2 = Object.entries(value); _i5 < _Object$entries2.length; _i5++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i5], 2),
+          _key2 = _Object$entries2$_i[0],
+          propertyValue = _Object$entries2$_i[1];
+        copy[_key2] = StateUtil.decodeValue(propertyValue, tmodelIdMap, seen);
+      }
+      return copy;
+    }
+  }, {
+    key: "resolveTModelReferencesInPlace",
+    value: function resolveTModelReferencesInPlace(value, tmodelIdMap) {
+      var seen = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakSet();
+      if (value === null || value === undefined || _typeof(value) !== "object") {
+        return value;
+      }
+      if (StateUtil.isTModelReference(value)) {
+        return tmodelIdMap[value[TMODEL_REF_KEY]];
+      }
+      if (seen.has(value)) {
+        return value;
+      }
+      seen.add(value);
+      if (value instanceof Date) {
+        return value;
+      }
+      if (value instanceof Map) {
+        var entries = _toConsumableArray(value.entries());
+        value.clear();
+        var _iterator9 = _createForOfIteratorHelper(entries),
+          _step9;
+        try {
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            var _step9$value = _slicedToArray(_step9.value, 2),
+              key = _step9$value[0],
+              mapValue = _step9$value[1];
+            value.set(StateUtil.resolveTModelReferencesInPlace(key, tmodelIdMap, seen), StateUtil.resolveTModelReferencesInPlace(mapValue, tmodelIdMap, seen));
+          }
+        } catch (err) {
+          _iterator9.e(err);
+        } finally {
+          _iterator9.f();
+        }
+        return value;
+      }
+      if (value instanceof Set) {
+        var _entries = _toConsumableArray(value);
+        value.clear();
+        var _iterator10 = _createForOfIteratorHelper(_entries),
+          _step10;
+        try {
+          for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+            var item = _step10.value;
+            value.add(StateUtil.resolveTModelReferencesInPlace(item, tmodelIdMap, seen));
+          }
+        } catch (err) {
+          _iterator10.e(err);
+        } finally {
+          _iterator10.f();
+        }
+        return value;
+      }
+      if (Array.isArray(value)) {
+        for (var index = 0; index < value.length; index++) {
+          value[index] = StateUtil.resolveTModelReferencesInPlace(value[index], tmodelIdMap, seen);
+        }
+        return value;
+      }
+      if (!StateUtil.isPlainObject(value)) {
+        return value;
+      }
+      for (var _i6 = 0, _Object$keys3 = Object.keys(value); _i6 < _Object$keys3.length; _i6++) {
+        var _key3 = _Object$keys3[_i6];
+        value[_key3] = StateUtil.resolveTModelReferencesInPlace(value[_key3], tmodelIdMap, seen);
+      }
+      return value;
+    }
+  }, {
+    key: "clearMaterializedChildOperations",
+    value: function clearMaterializedChildOperations(state) {
+      if (!state) {
+        return;
+      }
+      for (var _i7 = 0, _CHILD_OPERATION_FIEL = CHILD_OPERATION_FIELDS; _i7 < _CHILD_OPERATION_FIEL.length; _i7++) {
+        var key = _CHILD_OPERATION_FIEL[_i7];
+        if (Array.isArray(state[key])) {
+          state[key].length = 0;
+        } else {
+          state[key] = [];
+        }
+      }
+      if (!state.lastChildrenUpdate) {
+        state.lastChildrenUpdate = {
+          additions: [],
+          deletions: []
+        };
+        return;
+      }
+      state.lastChildrenUpdate.additions = [];
+      state.lastChildrenUpdate.deletions = [];
+    }
+  }, {
+    key: "exportRuntimeState",
+    value: function exportRuntimeState(tmodel) {
+      var fields = {};
+      for (var _i8 = 0, _Object$keys4 = Object.keys(tmodel); _i8 < _Object$keys4.length; _i8++) {
+        var key = _Object$keys4[_i8];
+        if (EXCLUDED_RUNTIME_FIELDS.has(key)) {
+          continue;
+        }
+        fields[key] = tmodel[key];
+      }
+      var runtime = StateUtil.encodeValue({
+        state: tmodel.state(),
+        fields: fields
+      });
+      StateUtil.clearMaterializedChildOperations(runtime.state);
+      return runtime;
+    }
+  }, {
+    key: "importRuntimeState",
+    value: function importRuntimeState(tmodel, runtime, tmodelIdMap) {
+      var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+        _ref2$timeOffset = _ref2.timeOffset,
+        timeOffset = _ref2$timeOffset === void 0 ? 0 : _ref2$timeOffset;
+      var restored = StateUtil.decodeValue(runtime, tmodelIdMap);
+      StateUtil.rebaseRuntimeTimes(restored, timeOffset);
+      tmodel._state = restored.state || {};
+      for (var _i9 = 0, _Object$entries3 = Object.entries(restored.fields || {}); _i9 < _Object$entries3.length; _i9++) {
+        var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i9], 2),
+          key = _Object$entries3$_i[0],
+          value = _Object$entries3$_i[1];
+        if (EXCLUDED_RUNTIME_FIELDS.has(key)) {
+          continue;
+        }
+        tmodel[key] = value;
+      }
+      StateUtil.clearMaterializedChildOperations(tmodel._state);
+
+      /*
+       * The child tree has already been reconstructed directly.
+       */
+      tmodel.childrenUpdateFlag = false;
+
+      /*
+       * DOM and Web Animation objects belong to the old runtime.
+       */
+      tmodel.$dom = null;
+      tmodel.viewport = undefined;
+      tmodel.hasDomNow = false;
+      tmodel.lastBatch = undefined;
+      tmodel.waapiBatch = undefined;
+      tmodel.finalKeyframe = undefined;
+      tmodel.finalRawFrame = undefined;
+      return tmodel;
+    }
+  }, {
+    key: "createRuntimeSnapshot",
+    value: function createRuntimeSnapshot(tmodel) {
+      var _tmodel$oidNum, _tmodel$targets, _tmodel$targets2, _tmodel$originalTarge;
+      var children = _toConsumableArray(tmodel.getChildren());
+      var targetDefinitions = TUtil.cloneTargetDefinition(tmodel.targetDefinitions);
+      return {
+        oid: tmodel.oid,
+        oidNum: (_tmodel$oidNum = tmodel.oidNum) !== null && _tmodel$oidNum !== void 0 ? _tmodel$oidNum : 0,
+        originalId: tmodel.originalId,
+        type: tmodel.type,
+        usesExistingDom: ((_tmodel$targets = tmodel.targets) === null || _tmodel$targets === void 0 ? void 0 : _tmodel$targets.domIsland) === true || ((_tmodel$targets2 = tmodel.targets) === null || _tmodel$targets2 === void 0 ? void 0 : _tmodel$targets2.reuseDomDefinition) === true || ((_tmodel$originalTarge = tmodel.originalTargetNames) === null || _tmodel$originalTarge === void 0 ? void 0 : _tmodel$originalTarge.includes('$dom')),
+        targets: StateUtil.encodeValue(targetDefinitions),
+        targetRuntime: StateUtil.exportTargetRuntime(tmodel),
+        runtime: StateUtil.exportRuntimeState(tmodel),
+        children: children.map(function (child) {
+          return StateUtil.createRuntimeSnapshot(child);
+        })
+      };
+    }
+  }, {
+    key: "createWithIdentity",
+    value: function createWithIdentity(snapshot, TModelClass) {
+      var _snapshot$oidNum;
+      if (typeof TModelClass !== "function") {
+        throw new TypeError("A TModel constructor is required.");
+      }
+      var targets = StateUtil.encodeValue(snapshot.targets);
+      var tmodel = new TModelClass(snapshot.type, targets, snapshot.oid, {
+        restoringRuntime: true,
+        usesExistingDom: snapshot.usesExistingDom === true
+      });
+      tmodel.type = snapshot.type;
+      tmodel.oid = snapshot.oid;
+      tmodel.oidNum = (_snapshot$oidNum = snapshot.oidNum) !== null && _snapshot$oidNum !== void 0 ? _snapshot$oidNum : 0;
+      if (snapshot.originalId !== undefined) {
+        tmodel.originalId = snapshot.originalId;
+      } else {
+        delete tmodel.originalId;
+      }
+
+      /*
+       * Tree relationships are restored without using addChild().
+       */
+      tmodel.parent = undefined;
+      tmodel.allChildrenList = [];
+      tmodel.allChildrenMap = {};
+      return tmodel;
+    }
+  }, {
+    key: "attachRestoredChild",
+    value: function attachRestoredChild(parent, child) {
+      child.parent = parent;
+      parent.allChildrenList.push(child);
+      parent.allChildrenMap[child.oid] = child;
+      return child;
+    }
+  }, {
+    key: "fromRuntimeSnapshot",
+    value: function fromRuntimeSnapshot(snapshot, TModelClass) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      if (!snapshot) {
+        throw new TypeError("A runtime snapshot is required.");
+      }
+      var tmodelIdMap = {};
+      var models = [];
+      var imports = [];
+      var _buildTree = function buildTree(modelSnapshot, parent) {
+        var tmodel = StateUtil.createWithIdentity(modelSnapshot, TModelClass);
+        tmodelIdMap[tmodel.oid] = tmodel;
+        models.push(tmodel);
+        if (parent) {
+          StateUtil.attachRestoredChild(parent, tmodel);
+        }
+        imports.push({
+          tmodel: tmodel,
+          runtime: modelSnapshot.runtime,
+          targetRuntime: modelSnapshot.targetRuntime
+        });
+        var _iterator11 = _createForOfIteratorHelper(modelSnapshot.children || []),
+          _step11;
+        try {
+          for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+            var childSnapshot = _step11.value;
+            _buildTree(childSnapshot, tmodel);
+          }
+        } catch (err) {
+          _iterator11.e(err);
+        } finally {
+          _iterator11.f();
+        }
+        return tmodel;
+      };
+      var root = _buildTree(snapshot, undefined);
+      for (var _i10 = 0, _models = models; _i10 < _models.length; _i10++) {
+        var tmodel = _models[_i10];
+        StateUtil.resolveTModelReferencesInPlace(tmodel.targets, tmodelIdMap);
+      }
+      for (var _i11 = 0, _imports = imports; _i11 < _imports.length; _i11++) {
+        var _imports$_i = _imports[_i11],
+          _tmodel = _imports$_i.tmodel,
+          targetRuntime = _imports$_i.targetRuntime;
+        StateUtil.applyTargetRuntime(_tmodel, targetRuntime, tmodelIdMap);
+      }
+      for (var _i12 = 0, _imports2 = imports; _i12 < _imports2.length; _i12++) {
+        var _imports2$_i = _imports2[_i12],
+          _tmodel2 = _imports2$_i.tmodel,
+          runtime = _imports2$_i.runtime;
+        StateUtil.importRuntimeState(_tmodel2, runtime, tmodelIdMap, options);
+      }
+      return {
+        root: root,
+        tmodelIdMap: tmodelIdMap,
+        models: models
+      };
+    }
+  }, {
+    key: "exportTargetRuntime",
+    value: function exportTargetRuntime(tmodel) {
+      var result = {};
+      for (var _i13 = 0, _Object$entries4 = Object.entries(tmodel.targets); _i13 < _Object$entries4.length; _i13++) {
+        var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i13], 2),
+          targetName = _Object$entries4$_i[0],
+          target = _Object$entries4$_i[1];
+        if (!StateUtil.isPlainObject(target)) {
+          continue;
+        }
+        var runtime = {};
+        for (var _i14 = 0, _TARGET_RUNTIME_FIELD = TARGET_RUNTIME_FIELDS; _i14 < _TARGET_RUNTIME_FIELD.length; _i14++) {
+          var field = _TARGET_RUNTIME_FIELD[_i14];
+          if (Object.prototype.hasOwnProperty.call(target, field)) {
+            runtime[field] = target[field];
+          }
+        }
+        if (Object.keys(runtime).length) {
+          result[targetName] = StateUtil.encodeValue(runtime);
+        }
+      }
+      return result;
+    }
+  }, {
+    key: "applyTargetRuntime",
+    value: function applyTargetRuntime(tmodel, encodedTargetRuntime, tmodelIdMap) {
+      for (var _i15 = 0, _Object$entries5 = Object.entries(encodedTargetRuntime || {}); _i15 < _Object$entries5.length; _i15++) {
+        var _Object$entries5$_i = _slicedToArray(_Object$entries5[_i15], 2),
+          targetName = _Object$entries5$_i[0],
+          encodedRuntime = _Object$entries5$_i[1];
+        var target = tmodel.targets[targetName];
+        if (!target) {
+          continue;
+        }
+        var runtime = StateUtil.decodeValue(encodedRuntime, tmodelIdMap);
+        Object.assign(target, runtime);
+      }
+    }
+  }]);
+}();
+export { StateUtil };

package/build/TModel.js

@@ -28,6 +28,7 @@ import { SearchUtil } from "./SearchUtil.js";
 import { TargetUtil } from "./TargetUtil.js";
 import { TModelUtil } from "./TModelUtil.js";
 import { DomInit } from "./DomInit.js";
+import { StateUtil } from "./StateUtil.js";
 
 /**
  * It provides the base class for all objects in an app where targets are defined. 
@@ -36,8 +37,9 @@ import { DomInit } from "./DomInit.js";
 var TModel = /*#__PURE__*/function (_BaseModel) {
   function TModel(type, targets, oid) {
     var _this;
+    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     _classCallCheck(this, TModel);
-    _this = _callSuper(this, TModel, [type, targets, oid]);
+    _this = _callSuper(this, TModel, [type, targets, oid, options]);
     _this.allChildrenList = [];
     _this.allChildrenMap = {};
     _this.childrenUpdateFlag = false;
@@ -61,6 +63,7 @@ var TModel = /*#__PURE__*/function (_BaseModel) {
     _this.dirtyLayout = false;
     _this.originWindowEpoch = -1;
     _this.initTargets();
+    _this.restoringRuntime = false;
     return _this;
   }
   _inherits(TModel, _BaseModel);
@@ -127,8 +130,8 @@ var TModel = /*#__PURE__*/function (_BaseModel) {
       this.removeFromActiveChildren(child);
       this.removeFromAnimatingChildren(child);
       this.childrenUpdateFlag = true;
-      getLocationManager().calcChildren(this);
       this.markLayoutDirty('removeChild');
+      getLocationManager().calcChildren(this);
       getRunScheduler().schedule(1, 'removeChild-' + child.oid);
       return this;
     }
@@ -1157,6 +1160,11 @@ var TModel = /*#__PURE__*/function (_BaseModel) {
     value: function reuseDomDefinition() {
       return this.val('reuseDomDefinition');
     }
+  }, {
+    key: "createRuntimeSnapshot",
+    value: function createRuntimeSnapshot() {
+      return StateUtil.createRuntimeSnapshot(this);
+    }
   }]);
 }(BaseModel);
 export { TModel };